Pinakabagong Mga Tampok ng Python

Ipinaliliwanag ng artikulong ito ang pinakabagong mga tampok ng Python.

Ipapaliwanag namin ang mga kapansin-pansing tampok mula Python 3.12 hanggang 3.13 na henerasyon, hakbang-hakbang mula sa praktikal na pananaw ng 'agad magagamit' na mga aplikasyon.

YouTube Video

Pinakabagong Mga Tampok ng Python

Sa mga nagdaang taon, ang Python ay umunlad na hindi lamang binibigyang-diin ang 'kadaling isulat' kundi pati ang 'kalakasan, bilis, at nababasang code'. Sa ibaba, ipakikilala namin ang mga kapansin-pansing tampok mula sa Python 3.12 hanggang 3.13 na mga henerasyon.

Malaking Pagpapabuti sa Mga Mensahe ng Error (Python 3.12)

Sa Python 3.12, ang mga error ay ipinapakita na ngayon sa mas malinaw at biswal na paraan. Mabibigyang-daan kang kaagad makita kung saan nagkamali at malaki ang mababawas sa oras ng pag-debug.

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

• Ang mga kulang na argumento ay ipinapakita kasabay ng kaukulang linya at lokasyon, kaya hindi ka na malilito sa paghahanap ng sanhi.

Praktikal na Paggamit ng 'match' Statement (Structural Pattern Matching)

Pinapayagan ng 'match' statement na maipahayag mo ng madaling basahin ang mga komplikadong sangay ng kundisyon at pagkakaiba ng istraktura ng datos. Mas madaling mabasa ang paghawak sa mga dictionary at mga nested na istruktura.

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.")

• Dahil sabay mong magagawa ang pag-branch ng kundisyon at pagkuha ng datos, hindi na kailangan ang nested na mga if statement.

Intuwitibong pattern matching para sa paghawak ng nested na datos

Epektibo rin ang 'match' statement para sa mga structured na datos gaya ng JSON o API responses.

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

• Maaari mong kunin ang kinakailangang elemento nang ligtas, kaya nababawasan ang pangangailangan sa malalabong code para sa depensa.

Pinahusay na f-string Debug Output (=` notation / Python 3.8 pataas, mas maginhawang gamitin)

Sa f-strings, maaari mo nang idagdag ang = para ipakita ang parehong ekspresyon at ang kinalabasan nito. Ang tampok na ito ay partikular para sa debugging at napaka-kapaki-pakinabang kapag nais mong mabilisang makita ang laman ng isang variable.

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

• Dahil ipinapakita nang sabay ang pangalan ng variable at halaga nito, mas madaling maintindihan ang pansamantalang debugging gamit ang mga print().
• Maaari kang magsulat ng log outputs at verification code nang mas maikli at mas malinaw.

Pinadaling Type Hints at 'type' Alias (Python 3.12: Bagong Sintaks ng Type Alias)

Sa Python 3.12, ipinakilala ang tanging sintaks para sa pagdeklara ng type alias — ang type statement. Nagpapahintulot ito na ang type hints ay hindi lang pansuportang impormasyon kundi isang elemento ng wika upang malinaw na ipahayag ang layunin ng disenyo.

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

• Sa pagbibigay ng sariling kahulugan sa UserId o UserName, naipapaliwanag ang pinagkaiba ng bawat papel kahit magkapareho ng uri tulad ng int o str.
• Nagiging mas simple ang mga kahulugan ng type, kaya bumababa ang kahirapan sa pag-intindi kapag nagrereview o nagme-maintenance ng code.
• Dati, ang type alias tulad ng UserId = int ay ginagawa lang sa pamamagitan ng assignment, ngunit gamit ang type statement ay maliwanag na ipinapakita na 'ito ay isang type definition'. Epektibo ito lalo na sa pagpapaganda ng nababasang disenyo ng code sa mga medium hanggang malaking codebase.

Natural na Type Annotations Gamit ang Built-in Types (Pinadaling Generics mula Python 3.9 pataas)

Mula Python 3.9 pataas, maaari mo nang gamitin ang built-in types gaya ng list o dict direkta bilang generics.

Pinapadali nitong magsulat ng madaling intindihin at mabasang type hints nang hindi nag-iimport mula sa typing module.

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

• Ang type hints ay gumaganap hindi bilang 'limitasyon' kundi bilang 'dokumentasyon na naglalarawan ng nilalaman ng proseso'.

Ligtas na Method Chaining gamit ang Self Type (Python 3.11 pataas)

Simula Python 3.11, maaari mo nang tukuyin ang Self bilang uri ng resulta para sa mga method na bumabalik ng sariling klase.

Nagbibigay-daan ito na makapagsulat ka ng method chaining nang hindi nawawala ang impormasyon ng type.

 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)

• Kahit para sa mga metodong bumabalik ng self, mananatili ang tamang return type.
• Ang mga IDE at type checker ay mas tumpak na mauunawaan ang method chaining.

Mas Malinaw na String Manipulation (removeprefix / removesuffix | Python 3.9 pataas)

Mula Python 3.9, nadagdag ang mga espesyal na method na str.removeprefix() at str.removesuffix() para ligtas na matanggal ang mga prefix at suffix sa string. Sa mga ito, malinaw mong maipapahayag sa code ang layunin ng 'pagtanggal lamang sa simula o dulo'.

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

• Tatanggalin lamang ang tinukoy na string kung ito ay nasa simula o dulo, kaya naiiwasan ang hindi inaasahang pagpalit.
• Mas nababasa at ligtas ang pamamaraang ito kaysa sa paggamit ng replace() o slicing.
• Lalo na sa paghawak ng 'strings na may nakatakdang format', tulad ng mga filename o URL preprocessing, ang paggamit ng mga method na ito ay malaki ang nababawas sa panganib ng bugs.

Matatag na Paghahambing ng String para sa Internationalization (str.casefold() | Unicode Support)

Ang str.casefold() sa Python ay isang method para sa paghahambing na walang kaso na isinasaalang-alang ang Unicode. Hindi tulad ng simpleng lower() o upper(), ito ay nagno-normalize ng strings, kabilang ang pagbabago ng karakter batay sa wika.

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

• Kaya nitong hawakan ang mga pagkakaibang batay sa wika gaya ng German ß at ss.
• Mahalagang teknik ito para sa mga aplikasyon na nangangailangan ng multilingual support o internationalization.

Pamantayang Suporta para sa TOML (tomllib | Python 3.11 pataas)

Simula Python 3.11, ang tomllib module para sa pagbasa ng mga TOML configuration file ay kasama na sa standard library. Magagawa mo nang pamahalaan ang mga configuration gamit lamang ang Python, nang hindi umaasa sa panlabas na library.

 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 ]

• Hindi na kailangan ng mga external package tulad ng toml, kaya mas simple ang mga dependency mo.
• Standardisado na ang paglo-load ng configuration file, kaya mas madali ang distribusyon, operasyon, at pag-set up ng CI.

Exception Handling para sa Panahon ng Parallel Processing (ExceptionGroup / except* | Python 3.11 pataas)

Ipinakilala sa Python 3.11 ang ExceptionGroup para pagsabay-sabay na hawakan ang maraming exception at ang except* syntax para ligtas na masangay ang kanilang paghawak. Ito ay bagong tampok para sa paghawak ng 'sabay-sabay na error' na lumalabas sa asynchronous o parallel processing.

 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)

• Maari nang i-raise at i-classify ang maraming exception sa isang operasyon.
• Solusyon ito sa problema ng asynchronous processing kung saan una lang na error ang nakikita dati.
• Sa mga operasyon tulad ng asyncio.gather() o parallel batch processing, maaaring sabay-sabay ang iba't ibang sanhi ng pagkabigo. Ang paggamit ng ExceptionGroup ay nagpapadali sa pag-oorganisa ng error collection, logging, at retry strategies.

Umuusbong ang Performance sa Simpleng Pag-update sa Pinakabagong Bersyon

Simula Python 3.11, mas mabilis ang maraming proseso dahil sa mga internal na optimization.

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))

• Ang malaking bentahe ay pwede kang bumilis nang hindi kinakailangang palitan ang code mo.

Pagkontrol ng Garbage Collection (Manwal na Pamamahala gamit ang gc Module)

Sa Python, gamit ang gc module ay pwede mong panandaliang i-disable o mano-mano paandarin ang garbage collection. Mabisa itong teknik ng optimization para sa mga senaryo tulad ng batch processing ng malalaking datos o mga operasyong kritikal sa performance.

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

• Sa pagpigil ng hindi kailangang garbage collection, nababalangkas ang oras ng pagproseso.
• Maari kang mag-manual collect sa pagtatapos ng mga process, mas madali ring masusundan ang paggamit ng memorya.
• Gayunpaman, hindi dapat gamitin ito bilang default na optimization kundi ikonsidera lang kung ang profiling ay nagpapakitang GC ang bottleneck. Sa karamihan ng mga application, pinaka-ligtas pa ring umasa sa awtomatikong garbage collection ng Python.

Buod

Dahil sa pagpapabuti ng error messages at pag-evolve ng type hints mula Python 3.12 hanggang 3.13, mas madali at mas magaan nang unawain at panatilihin ang code kaysa dati. Bukod pa dito, ang mga enhancement gaya ng mas mahusay na debugging at performance mula sa mga panloob na optimization ay tuloy-tuloy na nagbibigay ng direktang ambag sa produktibidad sa aktwal na paggamit. Hindi mo kailangang gamitin ang lahat ng bagong tampok agad-agad; mas mainam na magsimula sa pinakabagong bersyon ng Python at dahan-dahang idagdag ang mga tampok kung kinakailangan. Ang unti-unting pagtanggap ng mga ito ay nagreresulta sa mas nababasang at mas matibay na Python code.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video