Ciri-ciri Terkini Python

Artikel ini menerangkan ciri-ciri terkini Python.

Kami akan menerangkan secara berperingkat ciri-ciri terpenting Python generasi 3.12 hingga 3.13 dari sudut pandangan aplikasi yang 'terus boleh digunakan'.

YouTube Video

Ciri-ciri Terkini Python

Sejak beberapa tahun kebelakangan ini, Python telah berkembang dengan memberi penekanan bukan sahaja kepada 'kemudahan penulisan' tetapi juga 'kekuatan, kepantasan dan kebolehbacaan'. Di bawah, kami perkenalkan ciri-ciri utama dari generasi Python 3.12 hingga 3.13.

Penambahbaikan Ketara pada Mesej Ralat (Python 3.12)

Dalam Python 3.12, mesej ralat kini dipaparkan secara lebih jelas dan visual. Anda boleh segera mengenal pasti di mana kesilapan berlaku dan mengurangkan masa penyahpepijatan dengan ketara.

1def calc_total(price, tax):
2    return price + price * tax
3
4result = calc_total(100, )

• Argumen yang hilang akan dipaparkan bersama baris dan kedudukan yang berkaitan, jadi anda tidak akan keliru semasa mengenal pasti punca ralat.

Penggunaan Praktikal Pernyataan 'match' (Pencocokan Corak Struktural)

Pernyataan 'match' membolehkan anda menghuraikan cabang syarat yang kompleks dan diskriminasi struktur data secara deklaratif. Pengendalian kamus (dictionary) dan struktur bersarang menjadi lebih mudah dibaca.

1user = {"status": "active", "name": "Alice"}
2
3match user:
4    case {"status": "active", "name": name}:
5        print(f"Welcome back, {name}!")
6    case {"status": "inactive"}:
7        print("Please activate your account.")
8    case _:
9        print("Unknown user status.")

• Kerana anda boleh membuat cabang syarat dan pengekstrakan data secara serentak, penggunaan if bersarang menjadi tidak perlu.

Pencocokan corak yang intuitif untuk mengendalikan data bersarang

Pernyataan 'match' juga berkesan untuk data berstruktur seperti respons JSON atau API.

1data = {"user": {"name": "Bob", "age": 25}}
2
3match data:
4    case {"user": {"name": name, "age": age}}:
5        print(f"{name} is {age} years old.")

• Anda boleh mengekstrak hanya elemen yang diperlukan dengan selamat, sekaligus mengurangkan keperluan kod pertahanan.

Output Penyahpepijatan f-string yang Ditingkatkan (notasi =` / Python 3.8 ke atas, kebolehgunaan lebih baik)

Dengan f-string, anda kini boleh menambah = untuk memaparkan kedua-dua ungkapan dan hasil penilaiannya serentak. Ciri ini dikhaskan untuk penyahpepijatan dan amat berguna bila anda mahu menyemak kandungan pembolehubah dengan pantas.

1x = 10
2y = 20
3print(f"{x=}, {y=}, {x+y=}")

• Kerana nama dan nilai pembolehubah dipaparkan bersama, penyahpepijatan sementara menggunakan pernyataan print() menjadi lebih mudah dibaca.
• Anda boleh menulis output log dan kod pengesahan dengan lebih ringkas dan ekspresif.

Petunjuk Jenis dan Alias 'type' yang Dipermudahkan (Python 3.12: Sintaks Alias Jenis Baharu)

Dalam Python 3.12, sintaks khusus untuk mendefinisikan alias jenis—pernyataan type—telah diperkenalkan. Ini membolehkan petunjuk jenis berperanan bukan sekadar maklumat tambahan, malah sebagai elemen bahasa untuk menjelaskan maksud rekaan dengan lebih jelas.

1type UserId = int
2type UserName = str
3
4def greet(user_id: UserId, name: UserName) -> str:
5    return f"Hello, {name} (id={user_id})"

• Dengan memberikan makna kepada UserId atau UserName, perbezaan peranan dapat diperjelas walaupun kedua-duanya menggunakan jenis int atau str yang sama.
• Definisi jenis menjadi lebih ringkas, mengurangkan kos pemahaman semasa semakan kod dan penyelenggaraan.
• Sebelum ini, alias jenis seperti UserId = int diwujudkan dengan tugasan, tetapi menggunakan pernyataan type menjadikan 'ini ialah definisi jenis' lebih jelas. Ciri ini amat berkesan bagi memperbaiki kebolehbacaan reka bentuk dalam kod bersaiz sederhana dan besar.

Annotasi Jenis Semula Jadi Menggunakan Jenis Terbina (Generik Dipermudahkan dari Python 3.9+)

Sejak Python 3.9, anda boleh menggunakan jenis terbina seperti list atau dict secara langsung sebagai generik.

Ini membolehkan anda menulis petunjuk jenis yang intuitif dan mudah dibaca tanpa perlu mengimport jenis dari modul typing.

1def sum_numbers(numbers: list[int]) -> int:
2    return sum(numbers)
3
4print(sum_numbers([1, 2, 3, 4]))

• Petunjuk jenis berfungsi bukan sebagai 'sekatan', tetapi sebagai 'dokumentasi yang menerangkan kandungan pemprosesan'.

Rantaian Kaedah Selamat dengan Jenis Self (Python 3.11 ke atas)

Bermula Python 3.11, anda boleh menentukan Self sebagai jenis pulangan untuk kaedah yang memulangkan objek kelas itu sendiri.

Ini membolehkan anda menulis kod rantaian kaedah dengan selamat tanpa kehilangan maklumat jenis.

 1from typing import Self
 2
 3class Counter:
 4    def __init__(self, value: int = 0) -> None:
 5        self.value = value
 6
 7    def increment(self) -> Self:
 8        self.value += 1
 9        return self
10
11counter = Counter()
12counter.increment().increment()
13print(counter.value)

• Walaupun untuk kaedah yang memulangkan self, jenis pulangan yang betul tetap dikekalkan.
• IDE dan pemeriksa jenis boleh memahami rantaian kaedah dengan tepat.

Manipulasi Rentetan Lebih Jelas (removeprefix / removesuffix | Python 3.9 ke atas)

Bermula Python 3.9, kaedah khusus str.removeprefix() dan str.removesuffix() telah ditambah untuk membuang awalan dan akhiran daripada rentetan dengan selamat. Dengan kaedah ini, anda boleh dengan tepat menyatakan maksud 'membuang hanya permulaan atau pengakhiran' dalam kod anda.

1filename = "report_2026.txt"
2
3clean_name = filename.removeprefix("report_")
4name_without_ext = clean_name.removesuffix(".txt")
5
6print(name_without_ext)

• Rentetan yang ditetapkan akan dibuang hanya jika ia wujud di permulaan atau di penghujung, sekali gus mengelakkan penggantian tidak disengajakan.
• Pendekatan ini memberikan kebolehbacaan dan keselamatan yang lebih baik berbanding penggunaan replace() atau menghiris rentetan.
• Terutamanya untuk mengendalikan 'rentetan dengan format tertentu', seperti nama fail atau prapemprosesan URL, penggunaan kaedah ini boleh mengurangkan risiko pepijat dengan ketara.

Perbandingan Rentetan Kukuh untuk Internasionalisasi (str.casefold() | Sokongan Unicode)

str.casefold() dalam Python ialah kaedah untuk perbandingan tanpa mengira huruf besar kecil yang mengambil kira Unicode. Tidak seperti lower() atau upper() yang biasa, ia menormalkan rentetan termasuk penukaran aksara khusus bahasa.

1text1 = "Stra\u00dfe"
2text2 = "strasse"
3
4print(text1)
5print(text2)
6
7print(f"Comparison Result: {text1.casefold() == text2.casefold()}")

• Ia boleh mengatasi perbezaan bergantung kepada bahasa seperti ß dan ss dalam bahasa Jerman.
• Ini adalah teknik penting untuk aplikasi yang memerlukan sokongan pelbagai bahasa atau internasionalisasi.

Sokongan TOML Standard (tomllib | Python 3.11 ke atas)

Mulai Python 3.11, modul tomllib untuk membaca fail konfigurasi TOML telah ditambah ke pustaka standard. Pengurusan konfigurasi kini boleh dilakukan sepenuhnya dalam Python tanpa bergantung pada pustaka luaran.

 1import tomllib
 2
 3with open("config.toml", "rb") as f:
 4    config = tomllib.load(f)
 5
 6print(config["database"]["host"])
 7
 8# config.toml
 9# title = "TOML Example"
10# [database]
11# host = "192.168.1.1"
12# ports = [ 8001, 8001, 8002 ]

• Pakej luaran seperti toml tidak lagi diperlukan, sekali gus memudahkan pengurusan kebergantungan anda.
• Pemuatan fail konfigurasi kini telah distandardkan, menjadikan taburan, operasi dan persekitaran CI lebih mudah diurus.

Pengendalian Pengecualian untuk Era Pemprosesan Selari (ExceptionGroup / except* | Python 3.11 ke atas)

Python 3.11 memperkenalkan ExceptionGroup untuk mengendalikan pelbagai pengecualian serentak dan sintaks except* untuk menguruskannya dengan selamat dalam cabang. Ini ialah ciri baharu untuk mengendalikan 'ralat serentak' yang muncul semasa pemprosesan asinkron atau selari.

 1def process(values):
 2    errors = []
 3    for v in values:
 4        if v < 0:
 5            errors.append(ValueError(f"Negative value: {v}"))
 6    if errors:
 7        raise ExceptionGroup("Invalid values", errors)
 8
 9try:
10    process([1, -2, -3])
11except* ValueError as e:
12    print("Handled:", e)

• Pelbagai pengecualian kini boleh dibangkitkan dan dikelaskan dalam satu operasi.
• Ini menyelesaikan masalah dalam pemprosesan asinkron di mana hanya ralat pertama dapat dikesan.
• Dalam operasi seperti asyncio.gather() atau pemprosesan kelompok selari, pelbagai faktor kegagalan boleh berlaku serentak. Menggunakan ExceptionGroup memudahkan organisasi pengumpulan ralat, pembalakan dan strategi percubaan semula.

Prestasi Meningkat Hanya Dengan Mengemaskini ke Versi Terkini

Sejak Python 3.11, banyak proses telah dipercepatkan melalui pengoptimuman dalaman.

1def count_up(n):
2    total = 0
3    for i in range(n):
4        total += i
5    return total
6
7print(count_up(1_000_000))

• Kelebihan utamanya ialah peningkatan kelajuan boleh dicapai tanpa perlu menulis semula kod anda.

Kawalan Pengumpulan Sampah (Pengurusan Eksplisit melalui Modul gc)

Dalam Python, menggunakan modul gc standard membolehkan anda mematikan sementara atau menjalankan kutipan sampah secara manual. Ini ialah teknik pengoptimuman yang berkesan untuk situasi seperti pemprosesan kelompok set data besar atau operasi kritikal prestasi.

1import gc
2
3gc.disable()
4# heavy batch processing
5gc.enable()
6gc.collect()

• Menyekat pencetus kutipan sampah yang tidak perlu boleh mengurangkan turun naik masa pemprosesan.
• Anda boleh menjalankan kutipan secara eksplisit pada selang tertentu, menjadikan penggunaan memori lebih mudah dipantau.
• Bagaimanapun, teknik ini tidak wajar digunakan sebagai pengoptimuman lalai tetapi pertimbangkan hanya jika profil menunjukkan GC menjadi penghalang. Untuk kebanyakan aplikasi, adalah paling selamat untuk bergantung pada kutipan sampah automatik Python.

Ringkasan

Dengan penambahbaikan mesej ralat dan evolusi petunjuk jenis dalam generasi Python 3.12 hingga 3.13, pemahaman dan penyelenggaraan kod kini lebih mudah berbanding sebelum ini. Di samping itu, penambahbaikan seperti pengalaman penyahpepijatan lebih baik dan peningkatan prestasi melalui pengoptimuman dalaman secara berterusan menyumbang kepada peningkatan produktiviti dalam praktik. Anda tidak perlu menggunakan semua ciri baharu ini serentak; adalah praktikal untuk bermula dengan versi Python terkini dan memasukkan ciri mengikut keperluan secara berperingkat. Penggunaan beransur-ansur ini membawa kepada kod Python yang lebih mudah dibaca dan kukuh.

Anda boleh mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Sila lihat juga saluran YouTube kami.

YouTube Video