30 Trik Python Keren untuk Kode yang Lebih Baik Disertai Contoh

Keterampilan pemrograman Python semakin diminati dalam beberapa tahun terakhir. Untuk membantu Anda mengembangkan keterampilan pemrograman Python, kami mengkurasi 30 trik Python keren yang bisa Anda gunakan untuk meningkatkan kode Anda. Cobalah pelajari satu setiap hari selama 30 hari ke depan, dan lihat juga postingan praktik terbaik Python kami untuk memastikan kode Anda kelas atas. 

Jika keterampilan Python Anda masih belum mantap, Anda juga dapat mengasahnya dengan jalur keterampilan Python Programming kami.

Trik Urutan & Struktur Data

#1 Slicing

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

Slicing adalah fitur di Python yang bergantung pada pengindeksan untuk memungkinkan pengguna mengakses subset dari suatu urutan. Indeks hanyalah posisi suatu elemen dalam urutan. Jika tipe urutan dapat diubah (mutable), Anda dapat menggunakan slicing untuk mengekstrak dan memodifikasi data. 

Catatan: Kita juga bisa menggunakan slicing pada urutan yang tidak dapat diubah (immutable), tetapi mencoba memodifikasi slice akan memunculkan TypeError. 

Format penerapan slice adalah: sequence[start:stop:step]. Jika tidak ada nilai yang ditentukan pada parameter start, stop, dan step, maka urutan akan menggunakan nilai baku. Nilai bakunya adalah: 

• "start" baku ke 0 
• "stop" baku ke panjang urutan
• "step" baku ke 1 jika tidak ditentukan. 

Ketika diberikan sequence[start:stop] elemen yang dikembalikan akan dari indeks awal hingga stop - 1 (indeks stop tidak termasuk). 

Kita juga dapat memasukkan indeks negatif, yang bisa digunakan untuk membalik urutan. Misalnya, pada daftar dengan 4 elemen, indeks ke-0 juga merupakan indeks -4, dan indeks terakhir juga -1. Pada contoh kode di atas, pemahaman ini diterapkan pada parameter step dari urutan. Akibatnya, string dicetak terbalik, mulai dari akhir urutan hingga indeks 0.   

#2 Pertukaran in-place / penugasan simultan

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

Jika kesan awal Anda adalah nilai b akan 7 alih-alih 12, Anda terjebak oleh pertukaran in-place. 

Di Python, kita dapat membongkar iterable ke variabel dalam satu penugasan menggunakan otomatisasi unpacking. Misalnya: 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

Kita juga dapat mengumpulkan beberapa nilai ke satu variabel menggunakan * – trik Python ini disebut packing. Berikut contoh packing.  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

Menggabungkan packing dan unpacking otomatis melahirkan teknik yang dikenal sebagai penugasan simultan. Kita dapat menggunakan penugasan simultan untuk menetapkan serangkaian nilai ke serangkaian variabel.

#3 List vs. tuple 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""

Kebanyakan programmer Python akrab dengan struktur data list. Hal yang sama tidak bisa dikatakan untuk tuple. Keduanya iterable, memungkinkan pengindeksan, dan dapat menyimpan tipe data heterogen. Namun ada situasi di mana penggunaan tuple lebih disukai daripada list. 

Pertama, list bersifat mutable, artinya kita bisa memodifikasinya sesuka hati: 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

Tuple, di sisi lain, bersifat immutable, artinya mencoba memodifikasinya akan memunculkan TypeError. 

Karena alasan ini, tuple lebih efisien memori karena Python dapat mengalokasikan blok memori yang tepat sesuai kebutuhan data. Sebaliknya, pada list, memori tambahan harus dialokasikan jika sewaktu-waktu kita memperluasnya - ini disebut alokasi memori dinamis. 

Singkatnya; Dalam skenario di mana Anda tidak ingin data berubah, maka struktur data tuple lebih disukai daripada list karena alasan memori. Tuple juga lebih cepat daripada list. 

Pelajari lebih lanjut tentang Struktur Data Python dalam tutorial ini. 

#4 Generator

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

List comprehension adalah cara pythonic untuk membuat list dari iterable lain - ini jauh lebih cepat daripada menggunakan for loop. Namun apa yang terjadi jika Anda tidak sengaja mengubah kurung dari [] menjadi ()? Anda mendapatkan objek generator.

Di Python, kurung bulat dengan logika list comprehension membuat apa yang dikenal sebagai objek generator. Generator adalah jenis iterable khusus. Tidak seperti list, mereka tidak menyimpan itemnya. Sebagai gantinya, mereka menyimpan instruksi untuk menghasilkan setiap elemen secara berurutan dan status iterasi saat ini.

Setiap elemen hanya dihasilkan saat diminta menggunakan teknik yang disebut lazy evaluation. Manfaat utama dari tip Python ini menggunakan generator adalah penggunaan memori lebih sedikit karena seluruh urutan tidak dibangun sekaligus. 

#5 Aliasing 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python adalah bahasa pemrograman berorientasi objek - semuanya adalah objek. Jadi, menetapkan sebuah objek ke sebuah pengenal berarti membuat referensi ke objek tersebut. 

Ketika kita menetapkan satu pengenal ke pengenal lain, kita mendapatkan dua pengenal yang mereferensikan objek yang sama. Ini adalah konsep yang dikenal sebagai aliasing. Perubahan pada satu alias akan memengaruhi yang lain. Terkadang perilaku ini diinginkan, tetapi sering kali membuat kita lengah. 

Salah satu cara mengatasinya adalah menghindari aliasing saat menggunakan objek mutable. Solusi lain bisa dengan membuat klon dari objek asli alih-alih referensi. 

Cara paling sederhana untuk membuat klon adalah memanfaatkan slicing: 

b = a[:] 

Ini akan membuat referensi baru ke objek list pada pengenal b. 

Anda bisa membuat banyak solusi lain, seperti memanggil list(a) saat menetapkan data ke pengenal lain dan menggunakan metode copy(). 

#6 Operator ‘not’

a = []
print(not a)

"""
True
"""

Tip Python berikutnya adalah cara termudah untuk memeriksa apakah struktur data Anda kosong dengan menggunakan operator not. not bawaan Python adalah operator logika yang mengembalikan True jika ekspresi tidak benar, atau sebaliknya akan mengembalikan False – operator ini membalik nilai kebenaran ekspresi Boolean dan objek.  

Cara lain penggunaannya yang sering Anda lihat adalah dalam pernyataan if: 

if not a:
    # do something... 

Saat a bernilai True maka operator not akan mengembalikan False, dan sebaliknya. 

Agak bikin pusing di awal, jadi silakan coba sendiri.

Trik String & Output

#7 F-strings

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

Sesekali, kita perlu memformat objek string; Python 3.6 memperkenalkan fitur keren bernama f-strings untuk menyederhanakan proses ini. Ada baiknya memahami bagaimana string diformat sebelum rilis baru agar lebih menghargai metode baru ini. 

Begini cara string dulu diformat: 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

Pada dasarnya, cara baru ini lebih cepat, lebih mudah dibaca, lebih ringkas, dan lebih sulit untuk salah.

Kegunaan lain f-strings adalah mencetak nama pengenal beserta nilainya. Ini diperkenalkan di Python 3.8.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Lihat tutorial tentang Pemformatan F-string di Python untuk mempelajari lebih lanjut. 

#8 Parameter ‘end’ pada fungsi print()

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

Cukup umum menggunakan pernyataan print tanpa mendefinisikan parameter opsionalnya. Akibatnya, banyak Pythonista tidak sadar bahwa Anda dapat mengontrol output sampai taraf tertentu.

Salah satu parameter opsional yang bisa kita ubah adalah end. Parameter end menentukan apa yang harus ditampilkan di akhir pemanggilan pernyataan print. 

Bawaan dari end adalah "\n" yang memberi tahu Python untuk memulai baris baru. Pada kode di atas, kami mengubahnya menjadi spasi. Jadi, output mengembalikan semua elemen daftar kami dicetak pada baris yang sama.

#9 Menambahkan ke tuple

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

Kita sudah tahu tuple bersifat immutable – lihat trik Python #3 List vs. Tuple. Mencoba mengubah keadaan tuple akan menimbulkan TypeError. Namun, jika Anda memandang objek tuple sebagai urutan nama dengan keterikatan (binding) ke objek yang tidak dapat diubah, Anda mungkin melihatnya secara berbeda.

Dua elemen pertama dari tuple kita adalah bilangan bulat - mereka immutable. Elemen terakhir dari tuple kita adalah list, sebuah objek mutable di Python.

Jika kita menganggap list kita sebagai nama lain dalam urutan dengan binding ke objek yang tidak dapat diubah, maka kita akan menyadari bahwa list tersebut masih dapat dimodifikasi dari dalam tuple.

Apakah kami menyarankan Anda melakukannya dalam praktik? Mungkin tidak, tetapi ini adalah salah satu hal yang bagus untuk diketahui!

#10 Menggabungkan dictionary

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

Di Python 3.9 ke atas, memungkinkan untuk menggabungkan dictionary menggunakan | (bitwise OR). Tidak banyak lagi yang perlu dikatakan tentang trik Python yang satu ini selain bahwa ini jauh lebih mudah dibaca! 

Trik Gaya Kode & Sintaks

#11 Operator ternary / ekspresi kondisi 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

Pada kode di atas, Anda melihat apa yang dikenal sebagai operator ternary - juga disebut ekspresi kondisional. Kita menggunakan operator ternary untuk mengevaluasi sesuatu berdasarkan apakah suatu kondisi bernilai True atau False.

Cara lain kita bisa menulis kode di atas adalah sebagai berikut:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Meskipun kedua potongan kode menghasilkan output yang sama, perhatikan bagaimana ternary conditional memungkinkan kita menulis kode yang jauh lebih pendek dan jelas. Inilah yang akan disebut para Pythonista sebagai cara menulis kode yang lebih 'Pythonic'. 

#12 Menghapus duplikasi dari list

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

"""
[1, 2, 3, 4, 5, 6, 7]
"""

Cara paling sederhana untuk menghapus elemen duplikat dari list adalah mengonversi list tersebut menjadi set (lalu kembali ke list jika diinginkan).

Berdasarkan kemutabilan, set dan list cukup mirip di Python. Kita dapat menambah dan menghapus elemen dari kedua struktur data tersebut sesuka hati, namun tetap sangat berbeda.

List terurut, berindeks berbasis nol, dan mutable. Set tidak terurut dan tidak berindeks. Elemen dalam set harus bertipe immutable, meskipun set itu sendiri mutable - mencoba mengambil elemen melalui indeks atau memodifikasi elemen akan memunculkan error.

Perbedaan kunci lainnya antara set dan list adalah set tidak dapat berisi duplikasi. Inilah yang membantu kita menghapus elemen duplikat dari list kita.

#13 Garis bawah tunggal 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

Garis bawah (_) adalah pengenal yang sah di Python, sehingga memungkinkan menggunakannya untuk mereferensikan objek. Tetapi garis bawah juga punya tanggung jawab lain: menyimpan hasil evaluasi terakhir.

Dokumentasi menyatakan bahwa "interpreter interaktif membuat hasil evaluasi terakhir tersedia dalam variabel _. (Disimpan di modul builtins, bersama fungsi bawaan seperti print)."

Karena kita tidak menetapkan objek ke garis bawah sebelum memanggilnya pada baris pertama, kita mendapat error. Namun, ketika kita menghitung hasil 1 + 2, interpreter interaktif menyimpan hasilnya pada pengenal _ untuk kita. 

#14 Garis bawah untuk mengabaikan nilai

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

Pada tip Python #13, kita mengetahui interpreter interaktif menyediakan hasil terakhir evaluasi pada pengenal garis bawah (_), tetapi itu bukan satu-satunya kasus penggunaan.

Kita juga dapat menggunakannya untuk mewakili objek yang tidak kita pedulikan atau tidak akan digunakan di kemudian hari dalam program. Ini penting karena menggunakan pengenal alih-alih garis bawah (_) akan memunculkan error F841 saat kita mencoba melakukan linting pada program. Error F841 menyatakan bahwa nama variabel lokal telah ditetapkan tetapi tidak digunakan dalam program, yang merupakan praktik buruk.

#15 Garis bawah di akhir

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

Melanjutkan dari dua trik sebelumnya tentang penggunaan garis bawah (_) di Python, tujuan lainnya adalah untuk menghindari konflik dengan kata kunci Python. 

PEP 8 menyebutkan bahwa garis bawah di akhir sebaiknya "digunakan secara konvensi untuk menghindari konflik dengan kata kunci Python." PEP 8 juga menyatakan bahwa "secara umum lebih baik menambahkan satu garis bawah di akhir daripada menggunakan singkatan atau pengubahan ejaan. Jadi list_ lebih baik daripada lst."

#16 Garis bawah di awal

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

Sering kali Anda akan menemukan programmer Python berpengalaman cenderung menambahkan garis bawah sebagai awalan pada nama pengenal atau metode - dan ada alasannya.

Garis bawah yang diawali pada pengenal atau metode punya makna tersirat: variabel atau metode ini hanya untuk penggunaan internal. Intinya, ini adalah disclaimer untuk programmer lain yang telah didefinisikan dalam PEP 8 namun tidak dipaksakan oleh Python. Jadi, garis bawah awal adalah indikator yang lemah.

Tidak seperti Java, Python tidak memiliki pembedaan kuat antara variabel privat dan publik. Dengan kata lain, ini hanya bermakna karena komunitas Python menyepakatinya. Keberadaannya tidak memengaruhi perilaku program Anda.

#17 Garis bawah sebagai pemisah visual

Inilah tip terakhir tentang garis bawah; Sejauh ini, kita telah membahas tiga kasus penggunaan berbeda untuk garis bawah, tetapi Anda bisa melihat tutorial kami untuk mempelajari lebih lanjut tentang Peran Garis Bawah (_) di Python. 

number = 1_500_000
print(number)

"""
15000000
"""

Cara lain kita bisa menggunakan garis bawah adalah sebagai pemisah visual untuk pengelompokan digit pada literal bilangan bulat, floating-point, dan kompleks – ini diperkenalkan di Python 3.6. 

Gagasannya adalah untuk membantu keterbacaan literal yang panjang, atau literal yang nilainya seharusnya jelas dipisahkan ke beberapa bagian – Anda dapat membacanya lebih lanjut di PEP 515.

Trik Gaya Kode & Sintaks

#18 __name__ == “__main__” 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

Kemungkinan besar Anda pernah melihat sintaks ini di beberapa program Python; Python menggunakan nama khusus "__main__" dan menetapkannya ke pengenal bernama __name__ jika file Python yang dijalankan adalah program utama.

Jika kita memutuskan untuk mengimpor modul yang ditampilkan pada tangkapan layar ke modul lain (file Python) dan menjalankan file tersebut, kebenaran ekspresi pada kode kita akan bernilai salah. Ini karena saat kita mengimpor dari modul lain, pengenal __name__ diatur ke nama modul (file Python). 

#19 Metode ‘setdefault’ 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""

Anda mungkin ingin menetapkan nilai untuk berbagai key dalam dictionary. Misalnya, saat Anda melacak jumlah kata dalam sebuah korpus. Cara umum untuk melakukannya adalah sebagai berikut: 

1. Periksa apakah key ada dalam dictionary
2. Jika ada, naikkan nilainya sebesar 1.
3. Jika tidak ada, tambahkan dan tetapkan nilainya ke 1.

Beginilah tampilannya dalam kode:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Cara yang lebih ringkas adalah menggunakan metode setdefault() pada objek dictionary Anda.

Argumen pertama yang diberikan ke metode adalah key yang ingin kita periksa. Argumen kedua adalah nilai untuk menetapkan key tersebut jika key belum ada di dictionary - jika key sudah ada, maka metode akan mengembalikan nilai key tersebut. Jadi, nilainya tidak akan diubah.

Trik Struktur Program

#20 Pencocokan regex

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

Regular expression memungkinkan Anda menentukan pola teks untuk dicari; Mayoritas orang tahu kita dapat mencari sesuatu menggunakan CTRL + F (Windows), tetapi jika Anda tidak tahu persis apa yang Anda cari, bagaimana cara menemukannya? Jawabannya adalah mencari pola.  

Misalnya, nomor telepon Inggris mengikuti pola serupa: diawali nol diikuti sepuluh angka atau +44 menggantikan nol diikuti sepuluh angka – contoh kedua menunjukkan format internasional. 

Regular expression sangat menghemat waktu. Jika kita membuat aturan untuk menangkap contoh pada gambar alih-alih regex, itu bisa memakan hingga 10+ baris kode. 

Mempelajari cara kerja regular expression penting bahkan jika Anda tidak menulis kode. Sebagian besar editor teks dan pengolah kata modern memungkinkan Anda menggunakan regular expression untuk fitur temukan dan ganti.

#21 Pipe pada regex

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

Regular expression memiliki karakter khusus bernama pipe (|) yang memungkinkan Anda mencocokkan salah satu dari banyak ekspresi, dan dapat digunakan di mana saja. Ini sangat berguna saat Anda memiliki beberapa pola yang mirip.

Misalnya, 'Superman', 'Superwoman', dan 'Superhuman' semuanya memiliki awalan yang sama. Maka, Anda bisa memanfaatkan pipe untuk mempertahankan bagian pola yang berulang dan mengubah bagian yang perlu berbeda. Sekali lagi, menghemat waktu berharga Anda.

Waspadai jebakannya: jika semua ekspresi yang ingin Anda cocokkan muncul dalam teks yang sama, kemunculan pertama teks yang cocok akan dikembalikan - mis., "An example text containing Superwoman, Superman, Superhuman," akan mengembalikan Superwoman.

#22 Parameter ‘sep’ pada fungsi print()

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""

Banyaknya programmer Python yang tidak mengetahui kemampuan penuh fungsi print() cukup mengkhawatirkan; Jika “Hello World” adalah program pertama Anda, fungsi print() mungkin salah satu fungsi bawaan pertama yang Anda pelajari saat mempelajari Python. Kita menggunakan print() untuk menampilkan pesan terformat di layar, tetapi ada banyak hal lain dari fungsi print(). 

Pada kode di atas, kami menunjukkan berbagai cara untuk menampilkan pesan terformat. Parameter sep adalah argumen opsional pada fungsi print() yang memungkinkan kita menentukan bagaimana objek dipisahkan jika kita menyertakan lebih dari satu. 

Bawaannya dipisahkan dengan spasi, tetapi kami mengubah fungsionalitas ini dengan pernyataan print kami - satu di mana sep disetel ke "" dan satu lagi di mana sep disetel ke ".".

#23 Fungsi lambda 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

Fungsi lambda membawa Anda ke hal-hal tingkat menengah-lanjutan yang bisa Anda lakukan dengan Python – pelajari Intermediate Python dengan kursus ini. Sekilas terlihat rumit, tetapi sebenarnya cukup sederhana.

Pada contoh kode kami, kami hanya menggunakan satu argumen, tetapi kami juga bisa menggunakan beberapa argumen jika diinginkan:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

Pada intinya, kata kunci lambda memungkinkan kita membuat fungsi kecil, terbatas, dan anonim dalam satu baris. Perilakunya sama seperti fungsi biasa yang dideklarasikan dengan kata kunci def, kecuali fungsi-fungsi ini tidak memiliki nama.

#24 Metode ‘swapcase’

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

Metode swapcase() diterapkan pada objek string untuk memungkinkan kita mengubah huruf besar menjadi kecil dan sebaliknya dalam satu baris kode. Tidak banyak kasus penggunaan untuk metode swapcase(), tetapi bagus untuk diketahui.

#25 Metode ‘isalnum’

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Misalkan kita membuat program yang mengharuskan pengguna memasukkan kata sandi, tetapi harus memiliki kombinasi angka dan huruf. Kita dapat melakukannya dalam satu baris kode dengan memanggil isalnum() pada instance string.

Metode ini memeriksa apakah semua karakter merupakan bagian dari alfabet (A-Za-z) dan numerik (0-9). Spasi atau simbol (!#%$&? dll.) akan mengembalikan False.

#26 Penanganan exception

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""

Program Python akan berhenti saat menemui error.

Terkadang, kita tidak menginginkan perilaku ini, seperti saat ada pengguna akhir yang berinteraksi dengan kode kita. Seberapa buruk jika kode kita berhenti sebelum waktunya dalam kasus seperti itu?

Ada beberapa cara berpikir dalam menangani kasus eksepsional. Kebanyakan programmer Python biasanya menganut pemikiran bahwa lebih mudah untuk meminta maaf daripada meminta izin. Artinya mereka lebih suka menangkap error yang muncul dengan menyediakan konteks di sekitarnya yang mampu menangani exception. Gagasan di balik pemikiran ini adalah tidak ada gunanya menghabiskan waktu mencoba mengamankan semua kasus eksepsional yang mungkin.

Tetapi ini hanya berlaku ketika ada mekanisme untuk mengatasi masalah setelah terjadi.

#27 Mengidentifikasi perbedaan pada list

list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

Berikut tiga metode berbeda untuk membandingkan perbedaan antara dua list di Python. 

Catatan: Kecuali Anda tahu bahwa list_1 adalah subset dari list_2, maka solusi 1 tidak sama dengan dua solusi lainnya.

#28 Args & kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

Kita menggunakan *args dan **kwargs sebagai parameter fungsi saat kita tidak mengetahui jumlah variabel yang harus diharapkan fungsi kita. 

Parameter *args memungkinkan kita mengoper sejumlah parameter variabel ke fungsi ketika tidak ber-keyword (yaitu parameter yang kita oper tidak memerlukan nama terkait). Di sisi lain, parameter **kwargs memungkinkan kita mengoper sejumlah parameter ber-keyword secara sewenang-wenang ke fungsi.

Sebenarnya, kata *args dan **kwargs tidak terlalu ajaib: yang benar-benar ajaib adalah tanda bintang (*). Ini berarti kita bisa menggunakan kata apa pun setelah tanda bintang, tetapi penggunaan args dan kwargs adalah praktik umum, dan diberlakukan di antara pengembang Python. 

#29 Ellipsis

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Ellipsis adalah objek Python yang dapat dipanggil dengan memberikan urutan tiga titik (...) atau memanggil objek itu sendiri (Ellipsis).

Penggunaannya yang paling terkenal adalah untuk mengakses dan melakukan slicing pada array multidimensi di NumPy, misalnya:

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

Namun penggunaan lain Ellipsis adalah sebagai placeholder dalam fungsi yang belum diimplementasikan. 

Ini berarti Anda bisa menuliskan Ellipsis, ..., atau pass, dan semuanya tetap valid.

#30 List comprehension

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Trik Python terakhir kita adalah list comprehension, yang merupakan cara elegan untuk membuat list dari urutan lain. Mereka memungkinkan Anda melakukan logika dan penyaringan yang canggih seperti yang kita lakukan pada kode di atas.

Ada cara lain untuk mencapai tujuan yang sama; misalnya, kita bisa menggunakan fungsi lambda seperti berikut:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Tetapi banyak Pythonista akan berpendapat solusi ini jauh lebih sulit dibaca daripada list comprehension.