.jpeg)
n sebagai argument method
update() dalam bentuk dictionary.
◉ Menghapus item dictionary
Method pop() digunakan untuk menghapus item dictionary berdasarkan key.
profile = {
"name": "mario",
}
print("len:", len(profile), "data:", profile)
# output ➜ len: 1 data: {'name': 'mario'}
profile["favourite_color"] = "red"
print("len:", len(profile), "data:", profile)
# output ➜ len: 2 data: {'name': 'mario', 'favourite_color': 'red'}
profile.update({"race": "italian"})
print("len:", len(profile), "data:", profile)
# output ➜ len: 3 data: {'name': 'mario', 'favourite_color': 'red',
'race': 'italian'}
profile.pop("hobbies")
print(profile)
Keyword del juga bisa difungsikan untuk operasi yang sama. Contoh:
◉ Pengaksesan dictionary keys
Method keys() digunakan untuk mengakses semua keys dictionary, hasilnya
yaitu tipe data view objects dict_keys . Dari nilai tersebut bungkus
memakai list() untuk mendapatkan nilainya dalam bentuk list.
◉ Pengaksesan dictionary values
Method values() digunakan untuk mengakses semua value dictionary,
hasilnya yaitu tipe data view objects dict_values . Gunakan fungsi list()
untuk mengkonversinya ke bentuk list.
del profile["id"]
print(profile)
profile = {
"id": 2,
"name": "mario",
"hobbies": ("playing with luigi", "saving the mushroom kingdom"),
"is_female": False,
}
print(list(profile.keys()))
# output ➜ ['id', 'name', 'hobbies', 'is_female']
profile = {
"id": 2,
"name": "mario",
"hobbies": ("playing with luigi", "saving the mushroom kingdom"),
"is_female": False,
◉ Method items() dictionary
Digunakan untuk mengakses semua item dictionary. Nilai baliknya bertipe view
objects dict_items yang strukturnya cukup mirip seperti list berisi tuple.
Untuk mengkonversinya ke bentuk list, gunakan fungsi list() .
◉ Copy dictionary
Method copy() digunakan untuk meng-copy dictionary, hasilnya data
dictionary baru.
profile = {
"id": 2,
"name": "mario",
"hobbies": ("playing with luigi", "saving the mushroom kingdom"),
"is_female": False,
}
print(list(profile.items()))
# output ➜ [('id', 2), ('name', 'mario'), ('hobbies', ('playing with
luigi', 'saving the mushroom kingdom')), ('is_female', False)]
p1 = {
"id": 2,
"name": "mario",
"is_female": False,
}
print(p1)
# output ➜ {'id': 2, 'name': 'mario', 'is_female': False}
p2 = p1.copy()
print(p2)
Pada contoh di atas, statement p1.copy() menghasilkan data baru dengan isi
sama seperti isi p1 , data tersebut kemudian ditampung oleh variabel p2 .
Operasi copy disini jenisnya yaitu shallow copy.
Lebih detailnya mengenai shallow copy vs deep copy dibahas pada
chapter terpisah.
◉ Mengosongkan isi dictionary
Method clear() berguna untuk menghapus isi dictionary.
Catatan chapter 📑📑
◉ Source code praktik
github.com/novalagung/dasarpemrogramanpython-example/../dictionary
profile = {
"id": 2,
"name": "mario",
"is_female": False,
}
print("len:", len(profile), "data:", profile)
# output ➜ len: 3 data: {'id': 2, 'name': 'mario', 'is_female': False}
profile.clear()
print("len:", len(profile), "data:", profile)
# output ➜ len: 0 data: {}
◉ Chapter relevan lainnya
• OOP ➜ Class & Object
◉ Referensi
• https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
A.17. Python String
String (atau str ) merupakan kumpulan data char atau karakter yang
tersimpan secara urut (text sequence). String di Python mengadopsi standar
Unicode dengan default encoding yaitu UTF-8 .
A.17.1. Pengenalan String
Python mendesain tipe data string dalam bentuk yang sangat sederhana dan
mudah digunakan. Untuk membuat string cukup tulis saja text yang diinginkan
dengan diapit tanda petik satu atau petik dua. Contoh:
◉ Multiline string
Untuk string multiline atau lebih dari satu baris, cara penulisannya bisa
dengan:
• memakai karakter spesial \n :
text = "hello python"
print(text)
# output ➜ hello python
text = 'hello python'
print(text)
# output ➜ hello python
text = "a multiline string\nin python"
print(text)
• Atau memakai tanda """ atau ''' untuk mengapit text. Contoh:
Teknik penulisan string memakai tanda """ atau ''' selain
digunakan untuk membuat multiline string, juga bisa dimanfaatkan
untuk hal lain yaitu pembuatan docstring.
Lebih detailnya mengenai docstring dibahas di chapter DocString.
◉ Escape character
Python mengenal escape character umum yang ada di banyak bahasa
pemrograman, contohnya seperti \" digunakan untuk menuliskan karakter
" (pada string yang dibuat memakai literal " " ). Penambahan karakter
\ yaitu penting agar karakter " terdeteksi sebagai penanda string.
Sebagai contoh, dua statement berikut yaitu ekuivalen:
text = """a multiline string
in python"""
print(text)
# output ↓
#
# a multiline string
# in python
text = 'this is a "string" in python'
print(text)
# output ➜ this is a "string" in python
text = "this is a \"string\" in python"
A.17.2. String special characters
Di atas telah dicontohkan bagaimana cara menulis karakter newline atau baris
baru memakai \n , dan karakter petik dua memakai \" . Dua
karakter tersebut yaitu contoh dari special characters.
Python mengenal banyak special characters yang masing-masing memiliki
kegunaan yang cukup spesifik. Agar lebih jelas silakan lihat tabel berikut:
Special character Kegunaan
\\ karakter backslash (\)
\' tanda petik satu (')
\" tanda kutip (petik dua) (")
\a bunyi beeb (ASCII BEL)
\b backspace (ASCII BS)
\f page separator / formfeed (ASCII FF)
\n karakter baris baru linefeed (ASCII LF)
\r karakter baris baru carriage return (ASCII CR)
\t horizontal tab (ASCII TAB)
Special character Kegunaan
\v vertical tab (ASCII VT)
\{oktal} nilai oktal, contoh: \122 , \004 , \024
\x{hex} nilai heksadesimal, contoh: \xA4 , \x5B
Tambahan contoh penggunaan salah satu special character \t (horizontal
tab):
Program di atas menghasilkan output berikut:
Syntax 0xC548 yaitu salah satu penulisan numerik berbasis
hexadecimal. Pembahasan detailnya ada di chapter Number.
print("Nama\t\t| Umur\t| Gender")
print("--------------------------------")
print("Bruce Wayne\t| 34\t| laki-laki")
print("Cassandra Cain\t| 22\t| perempuan")
A.17.3. String formatting
String formatting yaitu teknik untuk mem-format string agar menghasilkan
text sesuai dengan format yang diinginkan.
Cara termudah melakukan string formatting yaitu dengan memakai f-
strings (atau formatted string literals). Tulis string seperti biasa tapi diawali
dengan huruf f atau F sebelum penulisan " " .
Pada contoh berikut, sebuah string dibuat dimana dua bagian string
didalamnya datanya bersumber dari variabel string lain.
Penjelasan:
• String dibuat dengan metode f-strings, dimana struktur text yaitu hello,
my name is {name}, I'm an {occupation} .
• Text {name} di dalam string di-replace oleh nilai variable name , yang
pada konteks ini nilainya Aiden Pearce .
• Text {occupation} di dalam string di-replace oleh nilai variable
occupation , yang pada konteks ini nilainya IT support .
• f-strings di atas menghasilkan text hello, my name is Aiden Pearce,
I'm an IT support .
name = "Aiden Pearce"
occupation = "IT support"
text = f"hello, my name is {name}, I'm an {occupation}"
print(text)
# output ➜ hello, my name is Aiden Pearce, I'm an IT support
Pada penerapan metode f-strings, isi dari {} tidak harus data string,
tetapi tipe data lainnya juga bisa digunakan asalkan printable atau bisa
di-print.
Selain memakai metode di atas, ada beberapa alternatif cara lain yang
bisa digunakan, diantaranya:
Semua metode string formatting yang telah dipelajari menghasilkan nilai balik
yang sama, yaitu hello, my name is Aiden Pearce, I'm an IT support .
Mana yang lebih baik? Silakan pilih saja metode yang sesuai selera.
A.17.4. Penggabungan string & split
string
◉ Penggabungan string (concatenation)
Ada beberapa metode yang bisa digunakan untuk string concatenation atau
operasi penggabungan string.
text = "hello, my name is {name}, I'm an {occupation}".format(name =
name, occupation = occupation)
print(text)
# output ➜ hello, my name is Aiden Pearce, I'm an IT support
text = "hello, my name is {0}, I'm an {1}".format(name, occupation)
print(text)
# output ➜ hello, my name is Aiden Pearce, I'm an IT support
text = "hello, my name is {}, I'm an {}".format(name, occupation)
print(text)
# output ➜ hello, my name is Aiden Pearce, I'm an IT support
• memakai teknik penulisan string literal sebaris.
Caranya dengan langsung tulis saja semua string-nya memakai
separator karakter spasi.
• memakai operator + .
Operator + jika diterapkan pada string menghasilkan penggabungan
string.
Untuk data non-string jika ingin digabung harus dibungkus dengan fungsi
str() terlebih dahulu. Fungsi str() digunakan untuk mengkonversi
segala jenis data ke bentuk string.
text = "hello " "python"
print(text)
# output ➜ hello python
text_one = "hello"
text_two = "python"
text = text_one + " " + text_two
print(text)
# output ➜ hello python
text = "hello"
number = 123
yes = True
message = text + " " + str(number) + " " + str(yes)
print(message)
• memakai method join() milik string.
Pada penerapannya, karakter pembatas atau separator ditulis terlebih
dahulu, kemudian di-chain dengan method join dengan isi argument
yaitu list yang ingin digabung.
◉ Split string
Split string yaitu operasi pemisahan karakter string menjadi list dengan
element berisi string. Operasi ini merupakan kebalikan dari penggabungan
string.
Cara penggunaannya yaitu dengan mengakses method split() langsung
dari data string. Pemanggilan method tersebut perlu disertai argument berisi
separator atau karakter pemisah string.
Pada contoh berikut, string hello python 12345 di split memakai
karakter spasi ( ).
Parameter method split() boleh untuk tidak diisi apapun, dengan efek
text = " ".join(["hello", "python"])
print(text)
# output ➜ hello python
```
text = "hello python 12345"
res = text.split(" ")
print(res)
# output ➜ ['hello', 'python', '12345']
yaitu string menjadi di-split memakai separator \n , \r , \t ,
\f atau spasi ( ).
A.17.5. Operasi sequence pada string
String masih termasuk kategori tipe data sequence, yang artinya bisa
digunakan pada operasi standar sequence, contoh seperti perulangan,
pengaksesan elemen, dan slicing.
◉ Mengecek jumlah karakter string
Fungsi len() ketika digunakan pada tipe data string mengembalikan
informasi jumlah karakter string.
◉ Mengakses element string
Setiap elemen string bisa diakses memakai index. Penulisan notasi
pengaksesannya sama seperti pada tipe data sequence lainnya, yaitu
memakai string[index] .
text = "hello python"
print("text:", text)
# output ➜ hello python
print("length:", len(text))
# output ➜ 12
text = "hello python"
print(text[0])
Selain via index, keyword perulangan for bisa dimanfaatkan untuk
mengiterasi elemen string. Contoh:
Contoh lain memakai range() :
Output:
DANGER
Pengaksesan elemen memakai index di-luar kapasitas data akan
menghasilkan error.
Sebagai contoh, string text = "hello" , jika diakses index ke-5-nya
for c in text:
print(c)
for i in range(0, len(text)):
print(text[i])
misalnya ( text[5] ) hasilnya yaitu error.
◉ Slicing string
Teknik slicing bisa diterapkan pada data string. Contoh:
Pembahasan detail mengenai slice ada di chapter Slice
A.17.6. Operasi character & case
Tipe data string memiliki beberapa method yang berguna untuk keperluan
operasi string yang berhubungan dengan character & case
◉ Pengecekan karakter alfabet dan angka
• Method isalpha() digunakan untuk mengecek apakah string berisi
karakter alfabet atau tidak. Nilai kembaliannya True jika semua karakter
dalam string yaitu alfabet.
text = "hello python"
print(text[1:5])
# output ➜ ello
print(text[7:])
# output ➜ ython
print(text[:4])
# output ➜ hell
• Method isdigit() digunakan untuk mengecek apakah string berisi
karakter digit atau tidak. Nilai kembaliannya True jika semua karakter
dalam string yaitu angka numerik (termasuk pangkat).
• Method isdecimal() digunakan untuk mengecek apakah string berisi
print("abcdef".isalpha())
# output ➜ True, karena abcdef yaitu alfabet
print("abc123".isalpha())
# output ➜ False, karena ada karakter 123 yang bukan merupakan alfabet
print("زوم".isalpha())
# output ➜ True, karena زوم yaitu abjad arabic
print("⯑⯑⯑".isalpha())
# output ➜ True, karena ⯑⯑⯑ yaitu karakter jepang
print("123456".isdigit())
# output ➜ True, karena 123456 yaitu digit
print("123abc".isdigit())
# output ➜ False, karena ada karakter abc yang bukan merupakan digit
print('2⅓'.isdigit())
# output ➜ False, karena bilangan pecahan memiliki karakter `/` yang
tidak termasuk dalam kategori digit
print('4²'.isdigit())
# output ➜ True, karena 4² yaitu bilangan pangkat
print('٢٨'.isdigit())
# output ➜ True, karena ٢٨ yaitu digit arabic
print('𝟜'.isdigit())
# output ➜ True, karena 𝟜 yaitu digit
karakter desimal atau tidak. Nilai kembaliannya True jika semua karakter
dalam string yaitu angka numerik desimal.
• Method isnumeric() digunakan untuk mengecek apakah string berisi
karakter desimal atau tidak. Nilai kembaliannya True jika semua karakter
dalam string yaitu angka numerik (termasuk pecahan, pangkat, dan
angka numerik lainnya).
print("123456".isdecimal())
# output ➜ True, karena 123456 yaitu angka desimal
print("123abc".isdecimal())
# output ➜ False, karena ada karakter abc yang bukan merupakan angka
desimal
print('2⅓'.isdecimal())
# output ➜ False, karena bilangan pecahan memiliki karakter `/` yang
tidak termasuk dalam kategori angka desimal
print('4²'.isdecimal())
# output ➜ False, karena bilangan pangkat yang tidak termasuk dalam
kategori angka desimal
print('٢٨'.isdecimal())
# output ➜ True, karena ٢٨ yaitu angka desimal arabic
print('𝟜'.isdecimal())
# output ➜ True, karena 𝟜 yaitu angka desimal
print("123456".isnumeric())
# output ➜ True, karena 123456 yaitu angka numerik
print("123abc".isnumeric())
# output ➜ False, karena ada karakter abc yang bukan merupakan numerik
• Method isalnum() digunakan untuk mengecek apakah string berisi
setidaknya karakter alfabet atau digit, atau tidak keduanya. Nilai
kembaliannya True jika semua karakter dalam string yaitu alfabet atau
angka numerik.
◉ Pengecekan karakter whitespace
Method isspace() digunakan untuk mengecek apakah string berisi karakter
whitespace.
print("123abc".isalnum())
# output ➜ True, karena 123 yaitu digit dan abc yaitu alfabet
print("12345⅓".isalnum())
# output ➜ True, karena 12345⅓ yaitu digit
print("abcdef".isalnum())
# output ➜ True, karena abcdef yaitu alfabet
print("abc 12".isalnum())
# output ➜ False, karena ada karakter spasi yang bukan merupakan
karakter digit ataupun alfabet
print("زوم".isalnum())
# output ➜ True, karena زوم yaitu abjad arabic
print("⯑⯑⯑".isalnum())
# output ➜ True, karena ⯑⯑⯑ yaitu karakter jepang
print(" ".isspace())
# output ➜ True, karena string berisi karakter spasi
print("\n".isspace())
# output ➜ True, karena string berisi karakter newline
◉ Pengecekan karakter case
• Method islower() digunakan untuk mengecek apakah semua karakter
string yaitu ditulis dalam huruf kecil (lower case), jika kondisi tersebut
terpenuhi maka nilai kembaliannya yaitu True .
• Method istitle() digunakan untuk mengecek apakah kata dalam string
yaitu ditulis dengan awalan huruf besar (title case), jika kondisi tersebut
terpenuhi maka nilai kembaliannya yaitu True .
• Method isupper() digunakan untuk mengecek apakah semua karakter
string yaitu ditulis dalam huruf besar (upper case), jika kondisi tersebut
terpenuhi maka nilai kembaliannya yaitu True .
print("hello python".islower())
# output ➜ True
print("Hello Python".islower())
# output ➜ False
print("HELLO PYTHON".islower())
# output ➜ False
print("hello python".istitle())
# output ➜ False
print("Hello Python".istitle())
# output ➜ True
print("HELLO PYTHON".istitle())
# output ➜ False
◉ Mengubah karakter case
Beberapa method yang bisa digunakan untuk mengubah case suatu string:
• Method capitalize() berfungsi untuk mengubah penulisan karakter
pertama string menjadi huruf besar (capitalize).
• Method title() berfungsi untuk mengubah penulisan kata dalam string
diawali dengan huruf besar (title case).
• Method upper() berfungsi untuk mengubah penulisan semua karakter
string menjadi huruf besar (upper case).
• Method lower() berfungsi untuk mengubah penulisan semua karakter
string menjadi huruf kecil (lower case).
• Method swapcase() berfungsi untuk membalik penulisan case karakter
string. Untuk karakter yang awalnya huruf kecil menjadi huruf besar, dan
sebaliknya.
print("hello python".isupper())
# output ➜ False
print("Hello Python".isupper())
# output ➜ False
print("HELLO PYTHON".isupper())
# output ➜ True
print("hello python".capitalize())
# output ➜ Hello python
print("hello python".title())
# output ➜ Hello Python
print("hello python".upper())
A.17.7. Operasi pencarian string &
substring
◉ Pengecekan string memakai keyword in
Keyword in bisa digunakan untuk mengecek apakah suatu string merupakan
bagian dari string lain. Nilai balik statement yaitu boolean. Contoh:
Teknik tersebut bisa dikombinasikan dengan seleksi kondisi if :
◉ Pengecekan substring
Ada beberapa Method yang bisa digunakan untuk keperluan pengecekan
substring, apakah suatu string merupakan bagian dari string lain.
• memakai method startswith() untuk mengecek apakah suatu
string diawali dengan huruf/kata tertentu.
text = "hello world"
print("ello" in text)
# output ➜ True
text = "hello world"
if "ello" in text:
print(f"py is in {text}")
# output ➜ py is in hello world
print("hello world".startswith("hell"))
# output ➜ True
• memakai method endswith() untuk mengecek apakah suatu string
diakhiri dengan huruf/kata tertentu.
• memakai method count() untuk mengecek apakah suatu string
merupakan bagian dari string lain.
Method ini mengembalikan jumlah huruf/kata yang ditemukan. Jika
kebutuhannya yaitu mencari tau apakah suatu substring ada atau tidak,
maka gunakan operasi logika lebih dari 0 (atau n > 0 ).
◉ Pencarian index substring
Method-method berikut sebenarnya kegunaannya mirip seperti method untuk
pengecekan substring, perbedaannya yaitu nilai balik pemanggilan method
berupa index substring.
• Method count() mengembalikan jumlah substring yang ditemukan sesuai
kata kunci yang dicari.
print("hello world".endswith("orld"))
# output ➜ True
print("hello world".endswith("worl"))
# output ➜ False
print("hello world".count("ello"))
# output ➜ 1
print("hello world".count("ello") > 0)
# output ➜ True
• Method index() mengembalikan index substring pertama yang
ditemukan sesuai kata kunci yang dicari. Jika substring tidak ditemukan,
method ini menghasilkan error.
• Method rindex() mengembalikan index substring pertama yang
ditemukan sesuai kata kunci yang dicari dengan urutan pencarian yaitu
dari kanan. Jika substring tidak ditemukan, method ini menghasilkan error.
• Method find() mengembalikan index substring pertama yang ditemukan
sesuai kata kunci yang dicari. Jika substring tidak ditemukan, method ini
menghasilkan nilai -1 .
• Method rfind() mengembalikan index substring pertama yang
ditemukan sesuai kata kunci yang dicari dengan urutan pencarian yaitu
dari kanan. Jika substring tidak ditemukan, method ini menghasilkan nilai
text = "hello world hello world"
print(text.count("ello"))
# output ➜ 2
text = "hello world hello world"
print(text.index("worl"))
# output ➜ 6
text = "hello world hello world"
print(text.rindex("worl"))
# output ➜ 18
text = "hello world hello world"
print(text.find("worl"))
# output ➜ 6
-1 .
A.17.8. Operasi string lainnya
◉ Replace substring
Method replace() digunakan untuk me-replace suatu substring dengan
string lain. Contoh penggunaan:
◉ Trim / strip
Metode trimming/stripping digunakan untuk menghapus whitespace yang
diantaranya yaitu baris baru dan juga spasi.
Sebelum kita mulai, coba perhatikan kode berikut. String text dideklarasikan
memakai """ """ yang dalam penerapannya tidak akan meng-escape
whitespace.
text = "hello world hello world"
print(text.rfind("worl"))
# output ➜ 18
str_old = "hello world"
str_new = str_old.replace("world", "python")
print(str_new)
# output ➜ hello python
text = """
hello python
"""
Bisa dilihat saat di print kelihatan newline atau baris barunya pada awal string
dan juga akhir string.
Dengan memakai teknik trimming, whitespace bisa dihilangkan. Ada
beberapa method yang bisa digunakan, diantaranya:
• Method lstrip() untuk trim whitespace karakter di awal atau sebelah
kiri string.
• Method rstrip() untuk trim whitespace karakter di akhir atau sebelah
kanan string.
• Method strip() untuk trim whitespace karakter di awal dan akhir string.
text = """
hello python
"""
print(f"--{text.lstrip()}--")
# output ↓
#
# --hello python
# --
text = """
hello python
"""
print(f"--{text.rstrip()}--")
# output ↓
#
# --
# hello python--
◉ Join string
Method join() berguna untuk menggabungkan list berisi element string.
String yang digunakan untuk memanggil method ini menjadi separator operasi
join.
◉ Konversi data ke string
Ada beberapa metode konversi tipe data ke string, diantaranya:
• memakai fungsi str() .
Fungsi ini bisa digunakan untuk mengkonversi data bertipe apapun ke
bentuk string. Contoh penerapan:
text = """
hello python
"""
print(f"--{text.strip()}--")
# output ➜ --hello python--
data = ["hello", "world", "abcdef"]
res = "-".join(data)
print(res)
# output ➜ hello-world-abcdef
number = 24
string1 = str(number)
print(string1)
# output ➜ 24
• memakai teknik string formatting. Contoh:
Catatan chapter 📑📑
◉ Source code praktik
github.com/novalagung/dasarpemrogramanpython-example/../string
◉ Chapter relevan lainnya
• String ➜ Unicode
number = 24
string1 = f"{number}"
print(string1)
# output ➜ 24
items = [1, 2, 3, 4]
string2 = f"{items}"
print(string2)
# output ➜ [1, 2, 3, 4]
obj = {
"name": "AMD Ryzen 5600g",
"type": "processor",
"igpu": True,
}
string3 = f"{obj}"
print(string3)
# output ➜ {'name': 'AMD Ryzen 5600g', 'type': 'processor', 'igpu':
True}
• Slice
◉ TBA
• Bytes
• Konversi tipe data ke string
◉ Referensi
• https://docs.python.org/3/library/string.html
• https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
• https://docs.python.org/3/reference/lexical_analysis.html#f-strings
A.18. Python Unicode String
Python mengadopsi aturan standar Unicode dalam pengelolaan karakter pada string. Benefitnya Python mendukung
dan mengenali berbagai macam jenis karakter, termasuk diantaranya yaitu huruf Arab, Jepang, emoji, symbol, dan
banyak jenis karakter lainnya.
Unicode sendiri yaitu suatu aturan standar untuk encoding text yang di-maintain oleh Unicode Consortium.
Standarisasi ini diciptakan untuk mendukung semua jenis penulisan yang ada di bumi.
Pada chapter ini kita akan membahas tentang bagaimana implementasi Unicode di Python.
A.18.1. Pengenalan Unicode String
Dalam dunia per-Unicode-an, ada yang disebut dengan code point yaitu suatu angka numerik (bisa desimal maupun
hexadecimal) yang merepresentasikan karakter tertentu. Jadi bisa diibaratkan identifier dari suatu karakter. Semua
karakter ada code point-nya, termasuk huruf A, B, C, maupun karakter lainnya (angka, tulisan romawi, symbol, dll).
Cara penulisan karakter unicode sendiri bisa dengan langsung menuliskan karakternya, atau bisa juga dengan
menuliskan code point dalam notasi tertentu.
• Contoh penulisan text dengan langsung menuliskan karakternya:
• memakai notasi special character \uXXXX , dimana XXXX diisi dengan code point dalam encoding 16-bit.
◦ Code point 16-bit C548 merepresentasikan karakter ⯑
◦ Code point 16-bit B155 merepresentasikan karakter ⯑
◦ Code point 16-bit D558 merepresentasikan karakter ⯑
◦ Code point 16-bit C548 merepresentasikan karakter ⯑
◦ Code point 16-bit C694 merepresentasikan karakter ⯑
Untuk memunculkan emoji memakai kode encoding 16-bit butuh tambahan effort karena code point emoji
tidak cukup jika direpresentasikan oleh code point yang lebarnya hanya 16-bit.
• memakai notasi special character \UXXXXXXXX , dimana XXXXXXXX diisi code point dalam encoding 32-bit.
message = "⯑⯑⯑⯑⯑ 😀"print(message)# output ➜ ⯑⯑⯑⯑⯑ 😀
message = "\uC548\uB155\uD558\uC138\uC694"print(message)# output ➜ ⯑⯑⯑⯑⯑
message = "\U0000C548\U0000B155\U0000D558\U0000C138\U0000C694 \U0001F600"print(message)
◦ Code point 32-bit 0000C548 merepresentasikan karakter ⯑
◦ Code point 32-bit 0000B155 merepresentasikan karakter ⯑
◦ Code point 32-bit 0000D558 merepresentasikan karakter ⯑
◦ Code point 32-bit 0000C138 merepresentasikan karakter ⯑
◦ Code point 32-bit 0000C694 merepresentasikan karakter ⯑
◦ Code point 32-bit 0001F600 merepresentasikan emoji 😀
• Atau memakai notasi special character \N{NAME} , dimana NAME diisi dengan nama karakter unicode
dalam huruf besar.
◦ Nama karakter Unicode HANGUL SYLLABLE AN merepresentasikan karakter ⯑
◦ Nama karakter Unicode HANGUL SYLLABLE NYEONG merepresentasikan karakter ⯑
◦ Nama karakter Unicode GRINNING FACE merepresentasikan emoji 😀
Salah satu website yang berguna untuk mencari informasi nama dan code point karakter Unicode:
https://www.compart.com/en/unicode/
A.18.2. Fungsi utilitas pada Unicode
◉ Fungsi ord()
Fungsi ord() digunakan untuk mengambil nilai code point dari suatu karakter. Nilai baliknya yaitu numerik
berbasis desimal.
Untuk menampilkan code point dalam notasi heksadesimal, cukup bungkus memakai fungsi hex() .
message = "\N{HANGUL SYLLABLE AN}\N{HANGUL SYLLABLE NYEONG} \N{GRINNING FACE}"print(message)# output ➜ ⯑⯑ 😀
text = "N"codePoint = ord(text)print(f'code point of {text} in decimal: {codePoint}')# output ➜ code point of N in decimal: 78
text = "⯑"codePoint = ord(text)print(f'code point of {text} in decimal: {codePoint}')# output ➜ code point of ⯑ in decimal: 50504
text = "⯑"codePoint = ord(text)
print(f'code point of {text} in decimal: {codePoint}')# output ➜ code point of ⯑ in decimal: 50504
Bisa dilihat dari program di atas, unicode code point dari karakter ⯑ dalam bentuk heksadesimal yaitu c548 . Jika
dicek pada praktek sebelumnya, kode heksadesimal yang sama kita gunakan juga dalam penulisan karakter unicode
memakai notasi \uXXXX (yaitu \uc548 ).
◉ Fungsi chr()
Fungsi chr() yaitu kebalikan dari fungsi ord() , kegunaannya yaitu untuk menampilkan string sesuai code
point.
Pada contoh dibawah ini fungsi chr() digunakan untuk memunculkan karakter dengan code point desimal 50504
dan juga heksadesimal C548 , yang keduanya yaitu merepresentasikan karakter yang sama, yaitu ⯑ .
Catatan chapter 📑📑
◉ Source code praktik
github.com/novalagung/dasarpemrogramanpython-example/../unicode
◉ Chapter relevan lainnya
• String
◉ Referensi
• https://docs.python.org/3/howto/
unicode.html#:~:text=Python's%20string%20type%20uses%20the,character%20its%20own%20unique%20code.
• https://docs.python.org/3/howto/unicode.html?highlight=unicode%20howto#the-string-type
codePoint = chr(50504)print(codePoint)# output ➜ ⯑
codePoint = chr(0xC548)print(codePoint)# output ➜ ⯑
A.19. Number/Bilangan di Python
Sedikit mengulang tentang pembahasan chapter Tipe Data ➜ numerik, telah dijelaskan bahwa Python
mengenal 3 jenis tipe data numerik, yaitu int , float , dan complex .
Pada chapter ini kita akan belajar lebih dalam tentang ketiganya.
A.19.1. Integer
Bilangan bulat direpresentasikan oleh tipe data int (kependekan dari integer). Cara deklarasi nilai
bertipe data ini yaitu memakai literal integer dimana angka ditulis langsung. Contoh:
INFO
Ada yang unik dengan deklarasi bilangan bulat di Python. Diperbolehkan untuk menambahkan
karakter underscore ( _ ) di sela-sela angka. Misalnya:
Variabel angka3 di atas nilainya yaitu sama dengan literal 1002345123 .
Literal integer default-nya yaitu berbasis 10, contohnya seperti 24 dan 13 di atas keduanya yaitu
berbasis 10. Dan umumnya bahasa pemrograman lain juga sama.
A.19.2. Hexadecimal, Octal, Binary
Selain basis 10, bilangan bulat bisa dituliskan memakai basis lain, misalnya heksadesimal/oktal/biner,
caranya dengan memanfaatkan prefix atau suatu awalan saat penulisan literalnya.
• Prefix literal untuk heksadesimal: 0x
• Prefix literal untuk oktal: 0o
• Prefix literal untuk biner: 0b
angka1 = 24angka2 = 13total = angka1 + angka2print(f"angka: {total}")# output ➜ angka: 37
angka3 = 100_2_345_123
print(f"angka3: {angka3}")# output ➜ angka3: 1002345123
Nilai numerik (tanpa melihat basis deklarasinya) ketika di-print pasti dimunculkan dalam basis 10. Python
otomatis meng-handle proses konversi antar basisnya. Pembuktiannya bisa dilihat pada output program di
atas.
Dari perbandingan source code dan output, terlihat bahwa angka 8c heksadesimal yaitu sama dengan
214 oktal dan 10001100 biner.
Sedangkan untuk memunculkan angka-angka tersebut sesuai basisnya caranya yaitu dengan
memakai metode string formatting, dengan menambahkan suffix dalam penulisan variabel. Contoh:
angka = 140angka_heksadesimal = 0x8cangka_oktal = 0o214angka_biner = 0b10001100
print(f"angka: {angka}")# output ➜ angka: 140
print(f"heksadesimal: {angka_heksadesimal}")# output ➜ heksadesimal: 140
print(f"oktal: {angka_oktal}")# output ➜ oktal: 140
print(f"biner: {angka_biner}")# output ➜ biner: 140
angka = 140angka_heksadesimal = 0x8cangka_oktal = 0o214angka_biner = 0b10001100
print(f"angka: {angka:d}")# output ➜ angka: 140
print(f"heksadesimal: {angka_heksadesimal:x}")# output ➜ heksadesimal: 8c
print(f"oktal: {angka_oktal:o}")# output ➜ oktal: 214
print(f"biner: {angka_biner:b}")
Output program:
Perbedaan lengkap tentang prefix dan suffix tiap basis bilangan bisa dicek pada tabel berikut:
Nama Basis
Deklarasi String formatting
Prefix Contoh Suffix Contoh
Decimal 10 -
d
atau
tanpa
suffix
Hexadecimal 16 0x x
Octal 8 0o o
Binary 2 0b b
Lebih detailnya mengenai string formatting dibahas pada chapter String Formatting
◉ Operasi perbandingan antar basis
Nilai bilangan integer meskipun dideklarasikan dengan basis biner, heksadesimal, atau oktal, nilai tersebut
disimpan di variabel oleh Python dalam satu tipe data, yaitu int . Dari sifat tersebut, maka operasi logika
perbandingan bisa dilakukan tanpa melihat basis numerik-nya, karena kesemuanya pasti bertipe int .
angka1 = 24angka2 = 13 print(f"angka1: {angka1}")print(f"angka2: {angka2:d}")
hex1 = 0x8chex2 = 0xff00c0 print(f"hex1: {hex1:x}")print(f"hex2: {hex2:x}")
oct1 = 0o214oct2 = 0o605 print(f"oct1: {oct1:o}")print(f"oct2: {oct2:o}")
bin1 = 0b1010bin2 = 0b110 print(f"bin1: {bin1:b}")print(f"bin2: {bin2:b}")
angka = 140
Output program:
◉ Print nilai numerik dalam basis tertentu memakai suffix
Angka numerik bisa di-print dalam basis apapun tanpa melihat deklarasinya memakai basis apa.
Contohnya bisa dilihat pada program berikut, nilai oktal 214 di-print dalam 4 basis berbeda dengan
memanfaatkan suffix tiap-tiap basis.
◉ Operasi aritmatika antar basis
Operasi aritmatika, apapun itu, juga bisa dilakukan antar basis. Contoh:
Output program:
angka_oktal = 0o214
print(f"angka: {angka_oktal:d}")# output ➜ angka 140
print(f"heksadesimal: {angka_oktal:x}")# output ➜ heksadesimal: 8c
print(f"oktal: {angka_oktal:o}")# output ➜ oktal: 214
print(f"biner: {angka_oktal:b}")# output ➜ biner: 10001100
angka = 140angka_heksadesimal = 0x8cangka_oktal = 0o214angka_biner = 0b10001100
total = angka + angka_heksadesimal + angka_oktal + angka_binerprint(f"total: {total} (hex: {total:x}, oct: {total:o}, bin: {total:b})")
◉ Print nilai numerik dalam basis tertentu memakai fungsi
• Fungsi oct() digunakan untuk memunculkan nilai numerik dalam basis oktal dalam tipe data string.
• Fungsi hex() digunakan untuk memunculkan nilai numerik dalam basis heksadesimal dalam tipe
data string.
• Fungsi bin() digunakan untuk memunculkan nilai numerik dalam basis biner dalam tipe data string.
◉ Fungsi int()
Fungsi int() digunakan untuk mengkonversi data string berisi angka numerik berbasis apapun (selama
basisnya 0 hingga 36) ke tipe data integer.
int1 = oct(140)print(f"int1: {int1}")# output ➜ int1: 0o214
int2 = oct(0x8c)print(f"int2: {int2}")# output ➜ int2: 0o214
int3 = hex(140)print(f"int3: {int3}")# output ➜ int3: 0x8c
int4 = hex(0b10001100)print(f"int4: {int4}")# output ➜ int4: 0x8c
int5 = bin(140)print(f"int5: {int5}")# output ➜ int5: 0b10001100
int6 = bin(0o214)print(f"int6: {int6}")# output ➜ int6: 0b10001100
int1 = int("0b10001100", base=2)print(f"int1: {int1}")# output ➜ int1: 140
int2 = int("0x8c", base=16)print(f"int2: {int2}")
A.19.3. Floating point (float)
Bilangan float yaitu bilangan yang memiliki angka dibelakang koma (atau titik untuk sistem angka luar
negeri), misalnya angka 3.14 (yang di negara kita biasa ditulis dengan 3,14 ).
Umumnya bilangan ini dikenal dengan nama bilangan desimal. Namun penulis tidak
memakai istilah ini karena kata desimal pada chapter ini tidak selalu berarti bilangan dengan
nilai dibelakang koma.
Penulis memilih memakai istilah bilangan float.
Untuk mendeklarasikan bilangan float, langsung saja tulis angka yang diinginkan dengan penanda
dibelakang koma yaitu tanda titik. Misalnya:
Khusus untuk bilangan float yang nilai belakang komanya yaitu 0 bisa dituliskan dengan tanpa
menuliskan angka 0 -nya. Contoh:
◉ Pembulatan / rounding
Pembulatan nilai di belakang koma dilakukan memakai fungsi round() . Panggil fungsi tersebut,
sisipkan data float yang ingin dibulatkan sebagai argument pertama fungsi dan jumlah digit belakang
koma sebagai argument ke-dua.
Selain fungsi round() ada juga 2 fungsi milik module math yang cukup berguna untuk keperluan
angka_float = 3.141592653589print(f"angka float: {angka_float}")# output ➜ angka float: 3.141592653589
angka_float = 3.print(f"angka float: {angka_float}")# output ➜ angka float: 3.0
pi = 3.141592653589
n1 = round(pi, 2)print(f"n1: {n1}")# output ➜ n1: 3.14
n2 = round(pi, 5)print(f"n2: {n2}")# output ➜ n2: 3.14159
pembulatan ke-bawah atau ke-atas.
• Pembulatan ke-bawah.
• Pembulatan ke-atas
Kedua fungsi di atas menghasilkan nilai balik bertipe int , tidak seperti fungsi round() yang
mengembalikan nilai float.
◉ Pembulatan float dengan string formatting
Fungsi round() , math.floor() , dan math.ceil() menerima data float sebagai argument pemanggilan
fungsi dan mengembalikan nilai baru setelah dibulatkan.
Jika pembulatan hanya diperlukan saat printing saja, lebih efektif memakai metode string formatting.
Caranya, tulis variabel dalam string formatting lalu tambahkan suffix :.{n}f dimana n diisi dengan
jumlah digit belakang koma. Sebagai contoh, suffix :.2f menghasilkan string berisi data float dengan 2
digit dibelakang koma.
Contoh versi lebih lengkap:
import math
n3 = math.floor(pi)print(f"n3: {n3}")# output ➜ n3: 3
import math
n4 = math.ceil(pi)print(f"n4: {n4}")# output ➜ n4: 4
angka_float = -3.141592653589
print(f"angka float: {angka_float:.2f}")# output ➜ angka float: -3.14
print(f"angka float: {angka_float:.3f}")# output ➜ angka float: -3.142
print(f"angka float: {angka_float:.4f}")# output ➜ angka float: -3.1416
◉ Karakteristik floating point
Hampir di semua bahasa pemrograman yang ada, tipe data float (atau sejenisnya) memiliki satu sifat unik
dimana angka belakang koma tidak tersimpan secara pasti informasinya digitnya.
Agar lebih jelas, silakan run program berikut:
Ajaib bukan? Operasi aritmatika 3.14 + 2.8 menghasilkan output 5.9399999999999995 .
Namun tidak usah khawatir, ini bukan error. Di belakang layar, komputer memang selalu menyimpan
informasi angka belakang koma float secara tidak pasti (tidak fixed).
Untuk menampilkan angka fixed-nya, gunakan suffix :f . Contoh:
Manfaatkan suffix :{n}f untuk menampilkan jumlah digit belakang koma ( n ) sesuai keinginan.
Misalnya:
Lebih detailnya mengenai string formatting dibahas pada chapter String Formatting
◉ Konversi tipe data via fungsi float()
Fungsi float() digunakan untuk mengkonversi suatu nilai menjadi float.
n = 3.14 + 2.8print(f"3.14 + 2.8: {n}")
n = 3.14 + 2.8
print(f"3.14 + 2.8: {n:f}")# output ➜ 3.14 + 2.8: 5.940000
n = 3.14 + 2.8print(f"3.14 + 2.8: {n:.2f}")# output ➜ 3.14 + 2.8: 5.94
number = 278885float_num1 = float(number)
Fungsi ini cukup berguna untuk dipergunakan dalam kebutuhan konversi tipe data, misalnya dari string ke
float.
◉ Notasi float exponential
Deklarasi nilai float bisa ditulis memakai literal float dengan notasi exponsensial, yaitu {f}e{n} atau
{f}e+{n} dimana literal tersebut menghasilkan angka f * (10 ^ n) .
Agar lebih jelas, langsung ke praktek saja.
Penjelasan:
• Notasi 2e0 artinya yaitu 2.0 * (10 ^ 0) . Nilai tersebut ekuivalen dengan 2.0
• Notasi 577e2 artinya yaitu 577.0 * (10 ^ 2) . Nilai tersebut ekuivalen dengan 57700.0
• Notasi 68277e+6 artinya yaitu 68277.0 * (10 ^ 6) . Nilai tersebut ekuivalen dengan
68277000000.0
Nilai n setelah huruf e jika diisi dengan nilai negatif menghasilkan output dengan formula f / (10 ^
n) . Contoh:
A.19.4. Bilangan complex
Bilangan complex yaitu bilangan yang isinya merupakan kombinasi bilangan real dan bilangan imajiner,
text = '278885.666'float_num2 = float(text)print(f"float_num2: {float_num2}")# output ➜ float_num: 278885.666
float1 = 2e0print(f"float1: {float1}")# output ➜ float1: 2.0
float2 = 577e2print(f"float2: {float2}")# output ➜ float2: 57700.0
float3 = 68277e+6print(f"float3: {float3}")# output ➜ float3: 68277000000.0
float4 = 6e-3print(f"float4: {float4}")# output ➜ float4: 0.006
contohnya seperti 120+3j .
Informasi bilangan real pada complex number bisa dimunculkan memakai property real sedangkan
informasi bilangan imajinernya memakai property imag . Contoh:
◉ Fungsi complex()
Fungsi complex() yaitu digunakan sebagai alternatif cara membuat bilangan kompleks.
Sebagai contoh, bilangan 120+3j jika dituliskan memakai fungsi complex() maka penulisannya
seperti berikut:
◉ Operasi aritmatika bilangan complex
Seperti wajarnya suatu bilangan, nilai complex bisa dimasukan dalam operasi matematika standar,
misalnya:
angka_complex = 120+3jprint(f"angka complex: {angka_complex}")# output ➜ angka complex: (120+3j)
r = angka_complex.realprint(f"angka real: {r}")# output ➜ angka real: 120.0
i = angka_complex.imagprint(f"angka imajiner: {i}")# output ➜ angka imajiner: 3.0
angka_complex = complex(120, 3)print(f"angka complex: {angka_complex}")# output ➜ angka complex: (120+3j)
cmp1 = 120-2jcmp2 = -19+4j
res = cmp1 + cmp2print(f"angka complex: {res}")# output ➜ angka complex: (101+2j)
res = cmp1 + cmp2 + 23print(f"angka complex: {res}")# output ➜ angka complex: (124+2j)
res = (cmp1 + cmp2 + 23) / 0.5print(f"angka complex: {res}")
Penjelasan:
• Operasi antar bilangan kompleks akan melakukan perhitungan terhadap bilangan real dan juga
bilangan imajinernya.
• Operasi antara bilangan kompleks vs. bilangan real, menghasilkan dua operasi aritmatika:
◦ Menghitung bilangan real bilangan complex vs bilangan real
◦ Dan juga menghitung bilangan imajiner vs bilangan real
Catatan chapter 📑📑
◉ Source code praktik
github.com/novalagung/dasarpemrogramanpython-example/../number-bilangan
◉ Chapter relevan lainnya
• Variabel
• Tipe Data
• String ➜ formatting
◉ TBA
• nan
• inf
◉ Referensi
• https://pythondev.readthedocs.io/numbers.html
• https://note.nkmk.me/en/python-nan-usage/
• https://note.nkmk.me/en/python-inf-usage/
A.20. Python Slice (Data
Sequence Slicing)
Pada chapter ini kita akan belajar tentang penerapan teknik slice pada data
sequence.
A.20.1. Pengenalan slice
Teknik slice atau slicing digunakan untuk mengakses sekumpulan element/item
dari data sequence sesuai dengan index yang diinginkan. Data sequence
sendiri yaitu klasifikasi tipe data yang berisi kumpulan data terurut atau
sekuensial. Yang termasuk dalam tipe data sequence yaitu list, range, tuple,
dan string.
Operasi slice mengembalikan data bertipe sama seperti data aslinya,
sedangkan isi sesuai dengan index yang ditentukan.
Salah satu penerapan slice yaitu dengan memanfaatkan notasi
data[start:end] atau data[start:end:step] .
• start yaitu index awal slicing. Misalkan index start yaitu 2 maka
slicing dimulai dari element index ke-2.
• end yaitu index akhir slicing. Misalkan index end yaitu 5 maka
slicing berakhir sebelum element index ke-5 (yang berarti element ke-4).
• step by default nilainya 1 , kegunaannya untuk menentukan apakah
element yang dikembalikan yaitu setiap step index.
Lanjut praktek. Pada contoh berikut disiapkan variabel data_str berisi string
hello world yang kemudian akan di-slice datanya.
Variabel data_str visualisasinya dalam bentuk sequence kurang lebih seperti
ini. Lebar element data yaitu 11 dengan index awal 0 dan index akhir 10 .
Ok, sekarang kita coba slice data_str :
• Slicing element index ke-0 hingga ke-2, maka notasinya yaitu
data_str[0:3] . Perlu diketahui bahwa end diisi dengan nilai index-1 ,
jadi jika ingin mengambil element hingga index ke-2 maka nilai end
yaitu 3 .
• Slicing element index ke-2 hingga ke-7, maka notasinya yaitu
data_str = "hello world"
print(data_str)
# output ➜ hello world
data_str = "hello world"
slice1 = data_str[0:3]
print(slice1)
# output ➜ hel
data_str[2:8] .
• Slicing element hingga index ke-4, maka notasinya yaitu data_str[:5] .
Nilai start jika tidak diisi maka default-nya yaitu 0 . Notasi tersebut
yaitu ekuivalen dengan data_str[0:5] .
• Slicing element dimulai index ke-4, maka notasinya yaitu data_str[4:] .
Nilai end jika tidak diisi maka default-nya yaitu nilai jumlah element
data (ekuivalen dengan notasi data_str[4:len(data_str)] ).
slice2 = data_str[2:8]
print(slice2)
# output ➜ llo wo
slice3 = data_str[:5]
print(slice3)
# output ➜ hello
slice4 = data_str[4:]
• Slicing element dimulai index ke-3 hingga ke-6 dengan element yang
dikembalikan yaitu setiap 1 element, maka notasinya yaitu
data_str[3:7:1] .
• Slicing element dimulai index ke-2 hingga ke-8 dengan ketentuan element
yang dikembalikan yaitu setiap 2 element, notasinya: data_str[2:9:2] .
slice5 = data_str[3:7:1]
print(slice5)
# output ➜ lo w
slice6 = data_str[2:9:2]
print(slice6)
# output ➜ lowr
• Slicing seluruh element bisa dilakukan dengan notasi data_str[:] . Notasi
tersebut yaitu ekuivalen dengan data_str[0:len(data_str)] .
• Slicing seluruh element dengan ketentuan element yang dikembalikan
yaitu setiap 2 element, ditulis dengan notasi data_str[::2] . Notasi
tersebut yaitu ekuivalen dengan data_str[0:len(data_str):2] .
slice7 = data_str[:]
print(slice7)
# output ➜ hello world
slice8 = data_str[::2]
print(slice8)
# output ➜ hlowrd
◉ Tentang slicing seluruh element
Slicing seluruh element bisa dilakukan dengan notasi data[0:len(data)]
atau data[0:len(data):1] . Sebagai contoh, 3 statement printing tuple
berikut memunculkan output yang sama meskipun data tuple yang
ditampilkan yaitu dari variabel yang berbeda.
Ok, lalu kenapa harus memakai teknik ini? padahal operasi assignment
data tuple ke variabel baru jauh lebih mudah, misalnya:
data_tuple = (1, 3, 5, 7, 9, 11, 13, 14)
print(data_tuple)
# output ➜ (1, 3, 5, 7, 9, 11, 13, 14)
tuple1 = data_tuple[0:len(data_tuple)]
print(tuple1)
# output ➜ (1, 3, 5, 7, 9, 11, 13, 14)
tuple2 = data_tuple[0:len(data_tuple):1]
print(tuple2)
# output ➜ (1, 3, 5, 7, 9, 11, 13, 14)
tuple3 = data_tuple
print(tuple3)
# output ➜ (1, 3, 5, 7, 9, 11, 13, 14)
Statement assignment tuple3 di atas isinya yaitu sama dengan data hasil
operasi slicing tuple1 dan tuple2 , namun reference-nya yaitu berbeda.
Pembahasan detail mengenai reference ada di chapter Object ID &
Reference
A.20.2. Fungsi slice()
Notasi penulisan slice bisa disimpan pada suatu variabel dengan
memanfaatkan fungsi slice() . Nilai start , end , dan step dijadikan
argument pemanggilan fungsi tersebut dengan notasi slice(start, end)
atau slice(start, end, step) .
Pada contoh berikut, perhatikan bagaimana perbedaan slicing pada list1 ,
list2 , dan list3 :
data_list = [2, 4, 6, 7, 9, 11, 13]
print(data_list)
# output ➜ [2, 4, 6, 7, 9, 11, 13]
list1 = data_list[2:6:1]
print(list1)
# output ➜ [6, 7, 9, 11]
list2 = data_list[slice(2, 6, 1)]
print(list2)
# output ➜ [6, 7, 9, 11]
sl = slice(2, 6)
list3 = data_list[sl]
print(list3)
# output ➜ [6, 7, 9, 11]
Catatan chapter 📑📑
◉ Source code praktik
github.com/novalagung/dasarpemrogramanpython-example/../slice
◉ Chapter relevan lainnya
• List
• Tuple
• String
• Object ID & Reference
◉ TBA
• Negative index slicing
◉ Referensi
• https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-
range
• https://python-reference.readthedocs.io/en/latest/docs/functions/slice.html
• https://stackoverflow.com/questions/509211/how-slicing-in-python-works
A.21. Python Object ID &
Reference
Pada chapter ini kita akan belajar tentang beberapa hal yang berhubungan
dengan object/data dan reference, diantaranya:
• Apa itu identifier data (object ID)
• Bagaimana Python mengelola data
• Apa yang terjadi sewaktu data di-assign ke variabel lain
• Dan juga peran ID dalam data reference dan operasi slicing
A.21.1. Object ID
Di Python, semua object atau data memiliki identifier, yaitu angka unik yang
merepresentasikan data tersebut. Sebagai contoh, pada kode berikut nilai
numerik 24 tersimpan pada variabel number , ID nya yaitu
140728206353928 .
Output program di atas jika di-run:
number = 24
print("data:", number)
# output ➜ data: 24
identifier = id(number)
print("id:", identifier)
# output ➜ id: 140728206353928
Object ID dialokasikan oleh Python saat program dijalankan, dan nilainya bisa
saja berbeda setiap eksekusi program.
◉ Fungsi id()
Fungsi id() digunakan untuk melihat ID suatu data. Cara penggunaannya
cukup mudah, tulis fungsi lalu sisipkan data yang ingin dicek ID-nya sebagai
parameter pemanggilan fungsi.
A.21.2. Reference / alamat memori data
Perlu diketahui bahwa Identifier merupakan metadata informasi yang
menempel pada data atau object, bukan menempel ke variabel. Data yang
sama jika di-assign ke banyak variabel, maka pengecekan ID pada semua
variabel tersebut mengembalikan ID yang sama.
Reference pada konteks programming artinya yaitu referensi suatu
data ke alamat memori.
Coba pelajari kode berikut. Variabel message1 berisi string hello world .
String tersebut kemudian di-assign ke message2 . Selain itu ada juga variabel
message3 berisi string yang sama persis tapi dari deklarasi literal berbeda.
message1 = "hello world"
message2 = message1
Jalankan program, lalu perhatikan id -nya:
Penjelasan program:
• Ketiga variabel di atas berisi data string yang sama persis, yaitu hello
world .
• Identifier data string pada variabel message1 dan message2 yaitu
sama. Hal ini wajar karena memang variabel message2 mendapatkan data
dari message1 . Yang terjadi di belakang layar, kedua variabel tersebut
menampung nilai yang tersimpan di alamat memori yang sama
(reference-nya sama).
• Identifier data string pada variabel message3 yaitu berbeda
dibandingkan message1 maupun message2 , hal ini karena meskipun isi
string ketiga variabel sama, dua diantaranya yaitu tersimpan di alamat
memory yang berbeda.
Ilustrasi dalam bentuk grafiknya kurang lebih seperti ini:
Variabel hanya merupakan media untuk pengaksesan data. Data sendiri
tersimpan-nya yaitu di memory. Sangat mungkin ada situasi dimana satu
data direpresentasikan oleh lebih dari 1 variabel. Contohnya seperti message1
dan message2 .
A.21.3. Operasi logika via keyword is
Kita sudah cukup sering memakai operator == dan operator logika
lainnya untuk membandingkan dua buah nilai. Dalam penerapannya, operator-
operator tersebut akan membandingkan isi data, bukan identifier-nya.
Pada kode berikut ini, 3 variabel yang telah dibuat sebelumnya digunakan
pada statement perbandingan.
Hasil dari ke-3 statement perbandingan yaitu True , karena memang isi
data-nya yaitu sama, yaitu string hello world .
Selanjutnya coba bandingkan dengan satement operator perbandingan
memakai keyword is . Keyword is akan melakukan pengecekan
apakah identifier suatu data yaitu sama dengan yang dibandingkan (yang di-
cek yaitu identifier-nya, bukan isi datanya).
message1 = "hello world"
message2 = message1
message3 = "hello world"
print(f"message1 ({id(message1)}) == message2 ({id(message2)}) ➡
{message1 == message2}")
# output ➜ message1 (2131034204400) == message2 (2131034204400) ➡ True
print(f"message1 ({id(message1)}) == message3 ({id(message3)}) ➡
{message1 == message3}")
# output ➜ message1 (2131034204400) == message3 (2131034205616) ➡ True
print(f"message2 ({id(message2)}) == message3 ({id(message3)}) ➡
{message2 == message3}")
# output ➜ message2 (2131034204400) == message3 (2131034205616) ➡ True
message1 = "hello world"
message2 = message1
message3 = "hello world"
print(f"message1 ({id(message1)}) is message2 ({id(message2)}) ➡
{message1 is message2}")
# output ➜ message1 (2131034204400) is message2 (2131034204400) ➡ True
print(f"message1 ({id(message1)}) is message3 ({id(message3)}) ➡
{message1 is message3}")
# output ➜ message1 (2131034204400) is message3 (2131034205616) ➡ False
Hasilnya:
• Statement message1 is message2 menghasilkan True karena kedua
variabel tersebut merepresentasikan satu data yang sama (tersimpan di
alamat memory yang sama).
• Statement perbandingan lainnya menghasilkan False karena identifier
data yaitu berbeda meskipun isi data yaitu sama.
◉ Lebih dalam mengenai korelasi operasi assignment
dan object ID
Mari kita modifikasi lagi kode sebelumnya agar lebih terlihat jelas efek dari
operasi assignment ke object ID.
Pada kode berikut, kita coba tampilkan hasil operasi perbandingan
memakai keyword is . Kemudian nilai variabel message2 diubah dan
dibandingkan ulang. Setelah itu, nilai message3 diubah untuk diisi dengan
nilai dari message2 .
message1 = "hello world"
message2 = message1
message3 = "hello world"
print(f"message1 ({id(message1)}) is message2 ({id(message2)}) ➜
{message1 is message2}")
print(f"message1 ({id(message1)}) is message3 ({id(message3)}) ➜
{message1 is message3}")
print(f"message2 ({id(message2)}) is message3 ({id(message3)}) ➜
{message2 is message3}")
message2 = "hello world"
print(f"message1 ({id(message1)}) is message2 ({id(message2)}) ➜
{message1 is message2}")
Output program:
Bisa dilihat, pada bagian akhir, statement message2 is message3
menghasilkan nilai True karena pada baris tersebut isi data message3 sudah
diganti dengan data dari message2 , menjadikan kedua variabel menampung
satu data yang sama, dan tersimpan di alamat memory yang sama.
Ilustrasi perubahan data pada program di atas dalam bentuk grafik bisa dilihat
pada penjelasan berikut:
• Fase 1:
message1 = "hello world" # statement 1
message2 = message1 # statement 2
message3 = "hello world" # statement 3
• Fase 2:
message1 = "hello world" # statement 1
message2 = message1 # statement 2
message3 = "hello world" # statement 3
message2 = "hello world" # statement 4
• Fase 3:
message1 = "hello world" # statement 1
message2 = message1 # statement 2
message3 = "hello world" # statement 3
message2 = "hello world" # statement 4
message3 = message2 # statement 5
A.21.4. Reference data sequence
Data sequence (entah itu list, string, ataupun lainnya) kalau dilihat dari segi
manajemen memory-nya yaitu berbeda dibandingkan dengan bagaimana
data dalam array di-manage di bahasa lain.
List di Python tersimpan pada satu alamat memory. Tidak seperti slice/array
pada bahasa Go (misalnya), yang setiap element-nya merupakan reference.
Perhatikan kode berikut, variabel numbers1 berikut di-assign ke variabel
bernama numbers2 , maka identifier kedua variabel yaitu sama karena
mengarah ke satu data yang sama.
Perlu diingat bahwa data sequence bukan data atomic seperti int yang isinya
sangat spesifik, yaitu nilai numerik. Data sequence merupakan data kolektif
dengan isi banyak element. Data sequence isi-isi element-nya bisa dimutasi
atau diubah tanpa men-trigger alokasi alamat memory baru (identifier-nya
yaitu tetap).
Sebagai contoh, pada program berikut, variabel numbers1 dan numbers2
reference-nya yaitu sama. Apa yang akan terjadi ketika ada penambahan
element baru di salah satu variabel?
Output program:
numbers1 = [1, 2, 3, 4]
print("numbers1", id(numbers1), numbers1)
# output ➜ numbers1 2269649131136 [1, 2, 3, 4]
numbers2 = numbers1
print("numbers1", id(numbers1), numbers1)
# output ➜ numbers1 2269649131136 [1, 2, 3, 4]
print("numbers2", id(numbers2), numbers2)
# output ➜ numbers2 2269649131136 [1, 2, 3, 4]
import sys
numbers1 = [1, 2, 3, 4]
print("numbers1", numbers1, id(numbers1), sys.getsizeof(numbers1))
numbers2 = numbers1
numbers2.append(9)
print("numbers1", numbers1, id(numbers1), sys.getsizeof(numbers1))
print("numbers2", numbers1, id(numbers2), sys.getsizeof(numbers2))
Dari output eksekusi program terlihat bahwa data numbers1 ikut berubah
setelah numbers2 diubah lewat penambahan element baru (via method
append() ). perubahan di kedua variabel terjadi karena memang keduanya
merepresentasikan satu data yang sama, reference-nya yaitu sama.
Terlihat juga ID kedua variabel juga tetap meskipun setelah isi element-nya di-
ubah.
◉ Fungsi sys.getsizeof()
Fungsi getsizeof() tersedia dalam module sys , kegunaannya untuk
melihat ukuran data dalam byte.
A.21.5. Reference pada data hasil slicing
Bagaimana dengan slicing, apakah ada efeknya ke object ID dan reference
data? Yap, ada. Coba saja test program berikut:
numbers1 = [1, 2, 3, 4]
numbers2 = numbers1
numbers3 = numbers1[:]
print("numbers1", numbers1, id(numbers1)) # statement 1
print("numbers2", numbers2, id(numbers2)) # statement 2
print("numbers3", numbers3, id(numbers3)) # statement 3
Kemudian lihat hasilnya:
Penjelasan:
• Ketika suatu data sequence di assign dari satu variabel ke variabel lain,
maka keduanya memiliki reference yang sama.
• Namun, jika assignment tersebut merupakan hasil operasi slice, maka data
hasil slicing merupakan data baru yang tersimpan di alamat memory baru.
Jadi ID-nya sudah pasti berbeda.
Ilustrasi yang terjadi pada saat statement 1, 2, 3 dieksekusi:
Lalu setelah angka 9 di-append ke numbers2 :
A.21.6. Catatan tambahan tentang object
ID
Ada hal unik/spesial yang berhubungan dengan object ID yang wajib untuk
diketahui, diantaranya:
◉ Object ID data numerik
Python meng-cache informasi data numerik integer -5 hingga 256 , karena
alasan ini terkadang ID suatu data numerik integer yaitu sama (meskipun
tidak selalu).
n1 = 12
n2 = 12
◉ Object ID data string
Python meng-cache informasi data string a hingga Z , karena alasan ini
terkadang ID suatu data string yaitu sama (meskipun tidak selalu).
Catatan chapter 📑📑
◉ Source code praktik
github.com/novalagung/dasarpemrogramanpython-example/../object-id-
reference
◉ Chapter relevan lainnya
• Slice
◉ TBA
• Hashable
str1 = 'Indonesia'
str2 = "Indonesia"
print(f"id str1: {id(str1)}, id str2: {id(str2)}")
# output ➜ id str1: 133983722110320, id str2: 133983722110320
print(f"str1 == str2: {str1 == str2}")
# output ➜ str1 == str2: True
print(f"str1 is str2: {str1 is str2}")
# output ➜ str1 is str2: True
◉ Referensi
• https://stackoverflow.com/questions/45335809/python-pass-by-reference-
and-slice-assignment
• https://stackoverflow.com/a/15172182/1467988
A.22. Python Function /
Fungsi
Penerapan fungsi di Python cukup mudah dan pada chapter ini kita akan
memulai untuk mempelajarinya.
O iya, chapter ini merupakan chapter pembuka pembahasan topik fungsi. Ada
banyak hal yang perlu dipelajari, oleh karena itu penulis memutuskan untuk
memecah chapter menjadi beberapa bagian.
A.22.1. Pengenalan Fungsi
Function atau fungsi yaitu kode program yang terisolasi dalam satu blok
kode, yang bisa dipanggil sewaktu-waktu. Fungsi memiliki beberapa atribut
seperti nama fungsi, isi fungsi, parameter/argument, dan nilai balik.
Pembuatan fungsi dilakukan dengan keyword def diikuti dengan nama fungsi,
lalu di bawahnya ditulis body/isi fungsi. Sebagai contoh pada kode berikut
fungsi say_hello() dideklarasikan dengan isi yaitu sebuah statement yang
menampilkan text hello .
Setelah di deklarasikan, fungsi bisa dipanggil berkali-kali. Misalnya pada
contoh berikut fungsi say_hello() dipanggil 3x.
def say_hello():
print("hello")
def say_hello():
Output program sewaktu di-run:
Suatu fungsi hanya bisa diakses atau dipanggil setelah fungsi tersebut
dideklarasikan (statement pemanggilan fungsi harus dibawah statement
deklarasi fungsi). Jika fungsi dipaksa digunakan sebelum dideklarasikan
hasilnya error.
Pada contoh di atas, selain say_hello() sebenarnya ada satu buah fungsi
lagi yang digunakan pada contoh, yaitu print() . Fungsi print()
dideklarasikan dalam Python Standard Library (stdlib). Sewaktu program
dijalankan fungsi-fungsi dalam stdlib otomatis ter-import dan bisa digunakan.
Lebih detailnya mengenai Python Standard Library dibahas pada chapter
Python Standard Library
Untuk tambahan latihan, buat satu fungsi lagi, lalu isi dengan banyak
statement. Misalnya:
Output program:
Penulisan isi fungsi (statement-statement dalam fungsi) harus disertai dengan
indentation yang benar. Isi statement posisinya tidak boleh sejejar dengan blok
deklarasi fungsi (secara vertikal). Isi fungsi harus lebih menjorok ke kanan.
Sebagai contoh, penulisan statement berikut yaitu tidak valid dan
menghasilkan error sewaktu di-run:
def print_something():
print("hello")
today = "Thursday"
print(f"happy {today}")
for i in range(5):
print(f"i: {i}")
print_something()
A.22.2. Parameter dan argument fungsi
Fungsi bisa memiliki parameter. Dengan adanya parameter, suatu nilai bisa di-
sisipkan ke dalam fungsi secara dinamis saat pemanggilannya.
Parameter sendiri merupakan istilah untuk variabel yang menempel pada
fungsi, yang mengharuskan kita untuk menyisipkan nilai pada parameter
tersebut saat pemanggilan fungsi.
Contoh:
Penjelasan:
• Fungsi calculate_circle_area() dideklarasikan memiliki parameter
bernama r .
• Notasi penulisan parameter fungsi ada diantara penulisan kurung () milik
def print_something():
print("hello")
today = "Thursday"
print(f"happy {today}")
for i in range(5):
print(f"i: {i}")
def calculate_circle_area(r):
area = 3.14 * (r ** 2)
print("area of circle:", area)
calculate_circle_area(788)
# output ➜ area of circle: 1949764.1600000001
blok deklarasi fungsi.
• Tugas fungsi calculate_circle_area() yaitu menghitung luas lingkaran
dengan nilai jari-jari didapat dari parameter r . Nilai luas lingkaran
kemudian di-print.
• Setelah blok deklarasi fungsi, ada statement pemanggilan fungsi
calculate_circle_area() . Nilai numerik 788 digunakan sebagai
argument parameter r pemanggilan fungsi tersebut.
INFO
Catatan:
• Parameter yaitu istilah untuk variabel yang menempel di fungsi.
• Argument yaitu isitilah untuk nilai yang disisipkan saat pemanggilan
fungsi (yang ditampung oleh parameter).
Dewasa ini, kedua istilah tersebut dimaknai sama, jadi tidak usah bingung.
Parameter by default bisa menerima segala jenis tipe data. Untuk memaksa
suatu parameter agar hanya bisa menerima data tertentu, maka tulis tipe data
yang diinginkan dengan notasi penulisan sama seperti deklarasi variabel.
Perhatikan contoh berikut agar lebih jelas. Fungsi calculate_circle_area()
di atas di-refactor menjadi fungsi dengan 2 parameter yaitu message bertipe
string dan r bertipe int .
def calculate_circle_area(message: str, r: int):
area = 3.14 * (r ** 2)
print(message, area)
calculate_circle_area("area of circle:", 788)
Fungsi bisa tidak memiliki parameter, satu parameter, atau bisa lebih dari
satu, tidak ada batasan.
Python memiliki args dan kwargs, pembahasan detailnya ada di
chapter Function ➜ Args & Kwargs
O iya, argument fungsi bisa dituliskan secara horizontal maupun vertikal.
Misalnya:
• Penulisan argument secara horizontal
• Penulisan argument secara vertikal
Penulisan argument secara vertikal umumnya cukup berguna pada situasi
dimana fungsi yang dipanggil memiliki cukup banyak parameter yang harus
diisi.
A.22.3. Naming convention fungsi &
parameter
Mengacu ke dokumentasi PEP 8 – Style Guide for Python Code, nama fungsi
dianjurkan untuk ditulis memakai snake_case .
calculate_circle_area("area of circle:", 788)
calculate_circle_area(
"area of circle:",
788
)
Sedangkan aturan penulisan nama parameter/argument yaitu sama seperti
nama variabel, yaitu memakai snake_case juga. Misalnya:
A.22.4. Nilai balik fungsi (return value)
Fungsi bisa memiliki return value atau nilai balik. Data apapun bisa dijadikan
sebagai nilai balik fungsi, caranya dengan dengan memanfaatkan keyword
return , tulis keyword tersebut di dalam isi fungsi diikuti dengan data yang
ingin dikembalikan.
Mari coba praktekan, coba jalankan kode berikut:
def say_hello():
print("hello")
def say_hello(the_message):
print(the_message)
def calculate_circle_area(r: int):
area = 3.14 * (r ** 2)
return area
def calculate_circle_circumference(r: int):
return 2 * 3.14 * r
area = calculate_circle_area(788)
print(f"area: {area:.2f}")
# output ➜ area: 1949764.16
circumference = calculate_circle_circumference(788)
print(f"circumference: {circumference:.2f}")
# output ➜ circumference: 4948.64
Penjelasan:
• Notasi penulisan parameter fungsi ada dalam kurung () milik blok
deklarasi fungsi.
• Fungsi calculate_circle_area() dideklarasikan memiliki parameter
bernama r .
◦ Tugas fungsi ini yaitu menghitung luas lingkaran dengan nilai jari-jari
didapat dari parameter r . Hasil perhitungan disimpan di variabel
area .
◦ Di akhir isi fungsi, nilai variabel area dikembalikan memakai
keyword return .
• Fungsi calculate_circle_circumference() mirip seperti fungsi
sebelumnya, hanya saja fungsi ini memiliki tugas yang berbeda yaitu
untuk menghitung keliling lingkaran.
◦ Fungsi ini melakukan perhitungan 2 * 3.14 * r kemudian hasilnya
dijadikan nilai balik.
• Setelah blok deklarasi fungsi, ada statement pemanggilan fungsi
calculate_circle_area() . Nilai 788 digunakan sebagai argument
parameter r pemanggilan fungsi tersebut.
• Kemudian ada lagi statement pemanggilan fungsi
calculate_circle_circumference() . Nilai 788 digunakan sebagai
argument parameter r pemanggilan fungsi tersebut.
• Nilai balik kedua pemanggilan fungsi di atas masing-masing di-print.
O iya, fungsi yang didalamnya tidak memiliki statement return sebenarnya
juga mengembalikan nilai balik, yaitu None .
Pembahasan detail mengenai tipe data None ada di chapter None
A.22.5. Tipe data nilai balik fungsi
(return type)
Python mendukung type hinting yaitu penentuan tipe data nilai balik fungsi
yang ditulis secara eksplisit. Penerapannya bisa dilihat pada kode berikut
dimana fungsi calculate_circle_area() dan
calculate_circle_circumference() tipe data nilai baliknya ditulis secara
jelas.
Notasi penulisan type hinting yaitu dengan menuliskan tanda -> setelah
deklarasi fungsi diikuti dengan tipe datanya.
def calculate_circle_area(r: int) -> float:
area = 3.14 * (r ** 2)
return area
def calculate_circle_circumference(r: int) -> float:
return 2 * 3.14 * r
area = calculate_circle_area(788)
print(f"area: {area:.2f}")
# output ➜ area: 1949764.16
circumference = calculate_circle_circumference(788)
print(f"circumference: {circumference:.2f}")
# output ➜ circumference: 4948.64
def <function_name>() -> <data_type>:
return <data>
Penerapan type hinting mewajibkan fungsi untuk selalu memiliki nilai balik
berupa data bertipe sesuai.
Jika nilai balik tipe datanya berbeda dengan yang ditulis di deklarasi fungsi,
warning akan muncul.
Khusus untuk tipe data nilai balik None tidak wajib diikuti statement return .
Contoh:
• Fungsi dengan return type None diikuti statement return :
• Fungsi dengan return type None tanpa diikuti statement return :
• Fungsi dengan tanpa return type maupun return statement:
def say_hello() -> None:
print("hello world")
return None
def say_hello() -> None:
print("hello world")
def say_hello():
print("hello world")
A.22.6. Keyword pass
Keyword pass secara fungsional umumnya tidak terlalu berguna, kecuali
untuk beberapa situasi. Misalnya untuk dipergunakan sebagai isi pada fungsi
yang masih belum selesai dikerjakan. Daripada fungsi isinya kosong dan akan
menghasilkan error kalau di-run, lebih baik diisi pass .
Sebagai contoh, penulis berencana membuat fungsi bernama
transpose_matrix() , namun fungsi tersebut tidak akan di-coding sekarang
karena suatu alasan. Jadi yang penulis lakukan yaitu mendeklarasikan fungsi
tersebut, kemudian diisi hanya statement pass .
Dari blok kode di atas, nantinya engineer akan tau bahwa fungsi tersebut akan
dibuat tapi belum selesai pengerjaannya.
Catatan chapter 📑📑
◉ Source code praktik
github.com/novalagung/dasarpemrogramanpython-example/../function
# need to complete sometime later
def transpose_matrix(matrix):
pass
◉ Chapter relevan lainnya
• Function ➜ Positional, Optional, Keyword Arguments
• Function ➜ Args & Kwargs
• Function ➜ Closure
• Function ➜ Lambda
◉ Referensi
• https://docs.python.org/3/tutorial/controlflow.html#defining-functions
• https://peps.python.org/pep-3102/
• https://peps.python.org/pep-0484/
A.23. Python Function
Argument (Positional,
Optional, Keyword
Argument)
Pada chapter ini kita akan belajar tentang apa itu positional argument, optional
argument, dan keyword arguments, serta bagaimana penerapannya di Python.
A.23.1. Positional argument
Positional argument yaitu istilah untuk urutan parameter/argument fungsi.
Pengisian argument saat pemanggilan fungsi harus urut sesuai dengan
deklarasi parameternya.
Silakan perhatikan kode berikut:
def create_sorcerer(name, age, race, era):
return {
"name": name,
"age": age,
"race": race,
"era": era,
}
obj1 = create_sorcerer("Sukuna", 1000, "incarnation", "heian")
print(obj1)
# output ➜ {'name': 'Sukuna', 'age': 1000, 'race': 'incarnation', 'era':
'heian'}
Coba lakukan sedikit experiment dengan mengubah urutan pengisian data
contohnya seperti ini. Hasilnya: program tidak error, namun data yang
dihasilkan yaitu tidak sesuai harapan.
Saat pemanggilan fungsi dengan argument, pastikan untuk selalu menyisipkan
argument sesuai dengan parameter yang dideklarasikan. Gunakan penamaan
parameter yang sesuai agar lebih mudah untuk mengetahui parameter harus
diisi dengan data apa.
A.23.2. Keyword argument
Keyword argument atau named argument yaitu metode pengisian argument
pemanggilan fungsi disertai nama parameter yang ditulis secara jelas
(eksplisit).
Pada kode berikut dibuat 3 buah statement pemanggilan fungsi
create_sorcerer() . Ketiganya memiliki perbedaan satu sama lain pada
bagian bagaimana argument disisipkan ke fungsi.
obj4 = create_sorcerer("400 year ago", 400, "human", "Hajime Kashimo")
print(obj3)
# output ➜ {'name': '400 year ago', 'age': 400, 'race': 'human', 'era':
'Hajime Kashimo'}
obj5 = create_sorcerer("Sukuna", 1000, "incarnation", "heian")
print(obj5)
# output ➜ {'name': 'Sukuna', 'age': 1000, 'race': 'incarnation', 'era':
'heian'}
obj6 = create_sorcerer(name="Kenjaku", age=1000, race="human", era="1000+
year ago")
print(obj6)
Penjelasan:
• Pada statement obj5 , fungsi dipanggil dengan nilai argument disisipkan
seperti biasa.
• Pada statement obj6 , fungsi dipanggil dengan nilai argument disisipkan
disertai nama parameter.
• Pada statement obj7 , argument pertama dan ke-2 ditulis tanpa nama
parameter, sedangkan argument ke-3 dan ke-4 ditulis disertai nama
parameternya.
Kombinasi penulisan argument seperti pada statement obj7 yaitu
diperbolehkan, dengan catatan: untuk argument yang tidak disertai nama
parameter harus diletakkan di kiri sebelum penulisan argument parameter
lainnya yang mengadopsi metode keyword argument.
Salah satu benefit dari penerapan keyword argument: pada argument
pemanggilan fungsi yang disertai nama parameter, urutan penulisan argument
boleh di-ubah. Contohnya seperti ini:
Pada statement obj8 semua argument pemanggilan fungsi ditulis
memakai metode keyword argument dan urutannya diubah total.
obj8 = create_sorcerer(era="1000+ year ago", age=1000, name="Kenjaku",
race="human")
print(obj8)
# output ➜ {'name': 'Kenjaku', 'age': 1000, 'race': 'human', 'era':
'1000+ year ago'}
obj9 = create_sorcerer("Hajime Kashimo", 400, era="400 year ago",
race="human")
print(obj9)
# output ➜ {'name': 'Hajime Kashimo', 'age': 400, 'race': 'human', 'era':
'400 year ago'}
Sewaktu di-print, hasilnya tetap valid. Sedangkan pada statement obj9 ,
hanya argument parameter era dan race yang ditulis memakai
metode keyword argument dengan urutan diubah. Sisanya (yaitu name dan
age ) ditulis memakai metode positional argument secara urut.
Kesimpulannya:
• Penulisan argument pemanggilan fungsi by default harus urut (sesuai
dengan aturan positional argument), dengan pengecualian jika argument
ditulis memakai keyword argument maka boleh diubah urutannya.
• Jika suatu pemanggilan fungsi pada bagian penulisan argument-nya
menerapkan kombinasi positional argument dan keyword argument maka
untuk argument yang ditulis tanpa keyword harus berada di bagian kiri dan
dituliskan secara urut.
A.23.3. Optional argument
Suatu parameter bisa ditentukan nilai default-nya saat deklarasi fungsi.
Efeknya, saat pemanggilan fungsi diperbolehkan untuk tidak mengisi nilai
argument karena nilai default sudah ditentukan.
Sebagai contoh, pada fungsi print_matrix() berikut, parameter matrix di-
set nilai default-nya yaitu list kosong [] . Fungsi print_matrix() dipanggil
2x, pemanggilan pertama dengan tanpa argument, dan yang kedua dengan
argument matrix [[1, 2], [5, 6]] .
def print_matrix(matrix=[]):
if len(matrix) == 0:
print("[]")
for el in matrix:
Silakan run program di atas, dan perhatikan outpunya. Error tidak muncul saat
eksekusi statement print_matrix() pertama yang padahal tidak ada data
yang disisipkan saat pemanggilan fungsi. Hal ini karena fungsi tersebut pada
parameter matrix sudah ada nilai default-nya.
A.23.4. Kombinasi positional argument,
keyword argument, dan optional
argument
Parameter fungsi bisa berisi nilai default (seperti pada contoh sebelumnya)
atau tidak, atau bisa juga kombinasi keduanya.
Kode program berikut yaitu contoh pengaplikasiannya. Fungsi
matrix_multiply_scalar() memiliki 2 buah parameter yaitu matrix yang
tidak memiliki default value dan scalar yang default value-nya yaitu 1 .
def matrix_multiply_scalar(matrix, scalar = 1):
res = []
for row in matrix:
res.append([cell * scalar for cell in row])
Pada kode di atas fungsi matrix_multiply_scalar() dipanggil beberapa kali:
• Pemanggilan ke-1: nilai parameter scalar tidak diisi, efeknya maka
default value digunakan.
• Pemanggilan ke-2: nilai parameter scalar ditentukan yaitu 3 .
• Pemanggilan ke-3: nilai parameter scalar ditentukan yaitu 2
memakai metode keyword argument diterapkan.
• Pemanggilan ke-4: nilai parameter matrix dan scalar dituliskan
memakai metode keyword argument diterapkan.
• Pemanggilan ke-5: nilai parameter matrix dan scalar dituliskan
memakai metode keyword argument diterapkan dengan posisi
penulisan argument diubah.
Argument pemanggilan fungsi yang ditulis memakai metode keyword
argument harus selalu diposisikan di sebelah kanan, setelah penulisan
argument yang memakai metode positional argument. Jika dipaksa ditulis
terbalik, maka menghasilkan error. Contohnya seperti pada gambar berikut:
Catatan chapter 📑📑
◉ Source code praktik
github.com/novalagung/dasarpemrogramanpython-
example/../positional-optional-keyword-argument
◉ Chapter relevan lainnya
• Function
• Function ➜ Args & Kwargs
• Function ➜ Closure
• Function ➜ Lambda
◉ Referensi
• https://docs.python.org/3/tutorial/controlflow.html#defining-functions
A.24. Python Args &
Kwargs
Pada chapter ini kita akan belajar tentang penerapan args dan kwargs pada
fungsi di Python.
A.24.1. Pengenalan Args
Args (atau yang umumnya ditulis sebagai *args) merupakan notasi penulisan
parameter spesial dengan kapabilitas bisa menampung banyak positional
argument untuk ditampung dalam 1 parameter saja.
Agar lebih jelas tentang kegunaan args, mari pelajari terlebih dahulu kode
berikut:
Fungsi sum_then_print() menerima 5 buah argument numerik yang dari nilai
tersebut kemudian dihitung totalnya lalu ditampilkan.
Fungsi tersebut memiliki limitasi yaitu hanya bisa menerima 5 buah data
numerik. Untuk membuatnya bisa menampung sejumlah data, solusinya bisa
dengan cukup memakai 1 parameter saja dengan data argument yang
disisipkan harus dalam tipe data sequence seperti list, atau solusi alternatif
def sum_then_print(n1, n2, n3, n4, n5):
total = n1 + n2 + n3 + n4 + n5
print(total)
sum_then_print(2, 3, 4, 5, 4)
# output ➜ 18
lainnya bisa dengan memakai *args yang di bawah ini dibahas.
Implementasi args cukup mudah, pada deklarasi fungsi tulis saja parameter
dengan nama apapun bebas, tetapi pada penulisannya diawali karakter
asterisk atau *, contohnya seperti parameter numbers berikut:
Fungsi di atas parameter numbers -nya ditulis memakai notasi *args,
maka parameter tersebut akan menampung semua argument yang disisipkan
saat pemanggilan fungsi. Nilai argument disimpan oleh parameter numbers
dalam bentuk tuple. Variabel numbers di-iterasi nilainya lalu dihitung
totalnya.
◉ Args untuk argument dengan tipe data bervariasi
Metode *args ini mampu menampung segala jenis argument tanpa
meghiraukan tipe datanya. Contohnya bisa dilihat pada program berikut ini:
def sum_then_print(*numbers):
total = 0
for n in numbers:
total = total + n
print(total)
sum_then_print(2, 3, 4, 5, 4)
# output ➜ 18
def print_data(*params):
print(f"type: {type(params)}, data: {params}")
for i in range(len(params)):
print(f"param {i}: {params[i]}")
print_data("hello python", 123, [5, True, ("yesn't")], {"iwak", "peyek"})
# output ↓
◉ Kombinasi positional argument dan args
Args sebenarnya tidak benar-benar menangkap semua argument pemanggilan
fungsi, melainkan hanya argument yang ditulis sesuai posisi parameter hingga
posisi setelahnya. Misalnya, sebuah fungsi memiliki 2 parameter dimana
parameter pertama menampung string dan parameter kedua yaitu *args,
maka pada contoh ini parameter *args hanya menampung argument ke-2 dan
setelahnya. Contoh:
Bisa dilihat, pada kode di atas parameter message menampung argument
ke-1 yaitu string total nilai: , dan parameter numbers menampung
argument ke-2 hingga seterusnya (yaitu data 2 , 3 , 4 , 5 , 4 ).
Perlu diketahui dalam penerapan kombinasi positional argument dan args,
positional argument harus selalu ditulis sebelum parameter *args.
◉ Kombinasi positional argument, args, dan keyword
argument
Keyword argument bisa digunakan bebarengan dengan positional argument
dan *args, dengan syarat harus dituliskan di akhir setelah *args.
def sum_then_print(message, *numbers):
total = 0
for n in numbers:
total = total + n
print(f"{message} {total}")
sum_then_print("total nilai:", 2, 3, 4, 5, 4)
# output ➜ total nilai: 18
A.24.2. Pengenalan Kwargs
Kwargs (atau yang umumnya ditulis sebagai **kwargs atau keyword
arguments) merupakan notasi penulisan parameter spesial dengan
kapabilitas bisa menampung banyak keyword argument pemanggilan fungsi
dalam 1 parameter saja.
def sum_then_print(message, *numbers, suffix_message):
total = 0
for n in numbers:
total = total + n
print(f"{message} {total} {suffix_message}")
sum_then_print("total nilai:", 2, 3, 4, 5, 4, suffix_message="selesai!")
# output ➜ total nilai: 18 selesai!
def print_data(**data):
print(f"type: {type(data)}")
print(f"data: {data}")
for key in data:
print(f"param: {key}, value: {data[key]}")
print_data(phone="nokia 3310", discontinue=False, year=2000,
networks=["GSM", "TDMA"])
# output ↓
#
# type: <class 'dict'>
# data: {'phone': 'nokia 3310', 'discontinue': False, 'year': 2000,
'networks': ['GSM', 'TDMA']}
#
# param: phone, value: nokia 3310
# param: discontinue, value: False
# param: year, value: 2000
Argument yang ditampung oleh parameter **kwargs datanya tersimpan
dalam bentuk dictionary dengan key yaitu nama parameter dan value yaitu
nilai argument.
◉ Kombinasi positional argument dan kwargs
Kwargs sebenarnya hanya menampung semua argument mulai dari argument
ke- n hingga seterusnya dimana n yaitu nomor/posisi **kwargs ditulis.
Contohnya pada kode berikut, parameter data hanya akan menampung
argument nomor ke-3 hingga seterusnya. Argument pertama ditampung oleh
parameter message sedangkan argument ke-2 oleh parameter number .
Dalam penerapannya, positional argument harus selalu ditulis sebelum
parameter **kwargs.
def print_data(message, number, **data):
print(f"message: {message}")
print(f"number: {number}")
print()
for key in data:
print(f"param: {key}, value: {data[key]}")
print_data("sesuk prei", 2023, phone="nokia 3315", networks=["GSM",
"TDMA"])
# output ↓
#
# message: sesuk prei
# number: 2023
#
# param: phone, value: nokia 3310
# param: networks, value: ['GSM', 'TDMA']
◉ Kombinasi positional argument, args dan kwargs
Kombinasi antara positional argument, *args, dan **kwargs juga bisa
dilakukan dengan ketentuan semua positional argument ditulis terlebih dahulu,
kemudian diikuti *args, lalu **kwargs.
Contoh penerapannya:
Python secara cerdas mengidentifikasi argument mana yang akan disimpan
pada positional parameter, *args, dan **kwargs. Pada kode di atas, mapping
antara arguments dengan parameter yaitu seperti ini:
• Argument hello world ditampung parameter message .
• Argument 1 , True ,dan ("yesn't", "nope") ditampung parameter
params .
• Keyword argument name="nokia 3310" , discontinued=True , dan
year_released=2000 ditampung parameter others .
◉ Kombinasi positional argument, args, keyword
def print_all(message, *params, **others):
print(f"message: {message}")
print(f"params: {params}")
print(f"others: {others}")
print_all("hello world", 1, True, ("yesn't", "nope"), name="nokia 3310",
discontinued=True, year_released=2000)
# output ↓
#
# message: hello world
# params: (1, True, ("yesn't", 'nope'))
# others: {'name': 'nokia 3310', 'discontinued': True, 'year_released':
2000}
argument, dan kwargs
Keyword argument bisa dituliskan diantara *args, dan **kwargs, diluar itu
menghasilkan error.
Catatan chapter 📑📑
◉ Source code praktik
github.com/novalagung/dasarpemrogramanpython-example/../args-
kwargs
◉ Chapter relevan lainnya
• Function
def print_all(message, *params, say_something, **others):
print(f"message: {message}")
print(f"params: {params}")
print(f"say_something: {say_something}")
print(f"others: {others}")
print_all("hello world", 1, True, ("yesn't", "nope"), say_something="how
are you", name="nokia 3310", discontinued=True, year_released=2000)
# output ↓
#
# message: hello world
# params: (1, True, ("yesn't", 'nope'))
# say_something: how are you
# others: {'name': 'nokia 3310', 'discontinued': True, 'year_released':
2000}
• Function ➜ Positional, Optional, Keyword Arguments
• Function ➜ Closure
• Function ➜ Lambda
◉ Referensi
• https://docs.python.org/3/tutorial/controlflow.html#arbitrary-argument-lists
A.25. Python Closure
Closure yaitu istilah umum dalam programming untuk deklarasi fungsi yang
berada di dalam fungsi (nested function). Pada chapter ini kita akan
mempelajari cara implementasinya.
A.25.1. Pengenalan Closure
Di Python, fungsi bisa dideklarasikan di-dalam suatu fungsi. Penerapannya
cukup berguna pada kasus dimana ada blok kode yang perlu di-eksekusi lebih
dari satu kali tetapi eksekusinya hanya di dalam fungsi tertentu, atau
eksekusinya setelah pemanggilan fungsi tertentu.
Permisalan ada fungsi inner() yang dideklarasikan di dalam fungsi
outer() , maka:
• Fungsi inner() bisa diakses dari dalam fungsi outer()
• Fungsi inner() juga bisa diakses dari luar fungsi outer() asalkan fungsi
inner() tersebut dijadikan sebagai nilai balik fungsi outer() (untuk
kemudian ditampung ke dalam variabel lalu dieksekusi)
Program berikut berisi contoh praktis tentang fungsi inner() dan outer() .
Silakan pelajari dan praktekan.
def outer_func(numbers = []):
print(f"numbers: {numbers}")
def inner_func():
print(f"max: {max(numbers)}")
print(f"min: {min(numbers)}")
Output program:
Program di atas jika di-breakdown sesuai urutan eksekusi statement-nya
kurang lebih seperti ini:
• Tahap 1: eksekusi statement print("call outer_func()")
• Tahap 2: eksekusi statement print(f"numbers: {numbers}")
• Tahap 3: eksekusi statement print("call inner_func() within
outer_func()")
• Tahap 4: eksekusi statement inner_func()
◦ Tahap 4.A. eksekusi statement print(f"max: {max(numbers)}")
◦ Tahap 4.B. eksekusi statement print(f"min: {min(numbers)}")
• Tahap 5: eksekusi statement print("call inner_func() outside of
outer_func()")
• Tahap 6: eksekusi statement inner_func() via f() dari luar fungsi
outer_func()
◦ Tahap 6.A. eksekusi statement print(f"max: {max(numbers)}")
◦ Tahap 6.B. eksekusi statement print(f"min: {min(numbers)}")
Jika di-flatten semua statement-nya maka programnya menjadi seperti ini:
◉ Fungsi min() & max()
Kedua fungsi ini digunakan untuk menghitung agregasi data numerik.
• Fungsi min() untuk pencarian nilai minimum dari data list yang berisi
elemen data numerik.
Contoh min([3, 4, 1, 2, 3, 4]) menghasilkan data 1 .
• Fungsi max() untuk pencarian nilai maksimum dari data list yang berisi
elemen data numerik.
Contoh max([3, 4, 1, 2, 3, 4]) menghasilkan data 4 .
A.25.2. Menampung fungsi dalam
variabel
Pada contoh sebelumnya, fungsi inner_func() ditampung ke variabel
bernama f via nilai balik pemanggilan fungsi outer_func() . Dari sini terlihat
bahwa closure bisa disimpan ke variabel.
Tidak hanya closure, fungsi biasa-pun juga bisa disimpan dalam variabel,
print("call outer_func()")
numbers = [1, 2, 3, 4]
print(f"numbers: {numbers}")
print("call inner_func() within outer_func()")
print(f"max: {max(numbers)}")
print(f"min: {min(numbers)}")
print("call inner_func() outside of outer_func()")
print(f"max: {max(numbers)}")
print(f"min: {min(numbers)}")
contohnya ada pada fungsi print_all() berikut yang disimpan pada variabel
display untuk kemudian di-eksekusi.
A.25.3. Fungsi sebagai argument
parameter
Selain disimpan dalam variabel, fungsi/closure bisa juga dijadikan sebagai nilai
argument suatu parameter fungsi. Metode seperti ini cukup sering digunakan
terutama pada operasi data sequence atau agregasi data numerik.
Contoh penerapan fungsi/closure sebagai argument pemanggilan fungsi bisa
dilihat pada kode berikut ini. Silakan coba dan pelajari, penjelasannya ada
dibawah kode.
def print_all(message, *numbers, **others):
print(f"message: {message}")
print(f"numbers: {numbers}")
print(f"others: {others}")
display = print_all
display("hello world", 1, 2, 3, 4, name="nokia 3310", discontinued=True,
year_released=2000)
# output ↓
#
# message: hello world
# numbers: (1, 2, 3, 4)
# others: {'name': 'nokia 3310', 'discontinued': True, 'year_released':
2000}
def aggregate(message, numbers, f):
res = f(numbers)
print(f"{message} is {res}")
Fungsi aggregate() dideklarasikan memiliki 3 buah parameter yaitu
message , numbers , dan f dimana f yaitu akan diisi dengan fungsi/
closure. Di dalam fungsi aggregate() , fungsi f dipanggil dengan disisipkan
argument yaitu numbers dalam pemanggilannya.
Ada juga fungsi sum() dideklarasikan dengan tugas untuk menghitung total
dari data list numerik numbers . Dan fungsi avg() untuk nilai rata-rata dari
data numbers .
Kemudian di bawahnya ada 4 buah statement pemanggilan fungsi
aggregate() :
• Pemanggilan ke-1 yaitu perhitungan nilai total numbers . Fungsi sum
yang telah dideklarasikan sebelumnya dijadikan sebagai argument
pemanggilan fungsi aggregate() untuk ditampung di parameter f .
• Pemanggilan ke-2 yaitu perhitungan nilai rata-rata dimana fungsi avg
yang telah dideklarasikan dijadikan sebagai argument pemanggilan fungsi
aggregate() ..
• Pemanggilan ke-3 yaitu perhitungan nilai maksimum. Fungsi max yang
merupakan fungsi bawaan Python digunakan sebagai argument
pemanggilan fungsi aggregate() .
• Pemanggilan ke-1 yaitu perhitungan nilai minimum. Fungsi min yang
merupakan fungsi bawaan Python digunakan sebagai argument
pemanggilan fungsi aggregate() .
Dari contoh terlihat bagaimana contoh penerapan closure sebagai nilai
argument parameter fungsi. Fungsi atau closure bisa digunakan sebagai nilai
argument, dengan catatan skema parameter-nya harus disesuaikan dengan
kebutuhan.
Di dalam fungsi aggregate() , closure f diharapkan untuk memiliki
parameter yang bisa menampung data list numbers . Selama fungsi/closure
memenuhi kriteria ini maka penggunaannya tidak menghasilkan error.
Catatan chapter 📑📑
◉ Source code praktik
github.com/novalagung/dasarpemrogramanpython-example/../args-
kwargs
◉ Chapter relevan lainnya
• Function
• Function ➜ Positional, Optional, Keyword Arguments
• Function ➜ Args & Kwargs
• Function ➜ Lambda
◉ Referensi
• https://docs.python.org/3/library/stdtypes.html#functions
A.26. Python Lambda
Pada chapter ini kita
.jpeg&description=Python 4){kind=link}