Dictionary sa Python (dict): paggawa, mga method, pag-ikot, pag-aayos, at frozendict

Ang dictionary sa Python (dict) ay koleksiyon ng mga pares na "key — value", kung saan halos agad na nahahanap ang halaga sa pamamagitan ng key, gaano man karami ang laman nito. Kapag kailangan mong bilangin ang mga gastos ayon sa kategorya, mag-imbak ng mga setting, o mabilis na maghanap ng user ayon sa id, dictionary ang ginagamit. Narito ang lahat ng kailangan para sa python dict: paggawa, mga method, pag-ikot, pag-aayos, pagsasama, at ang bagong sangkap ng 3.15 — ang frozendict.

Ano ang dictionary sa Python

Nag-iimbak ang dictionary ng mga pares na natatangi ang key: kapag nagsulat ka ng halaga sa umiiral nang key, papalitan ang lumang halaga. Sa loob, hash table ito, kaya ang paghahanap, pagdaragdag, at pagtanggal ayon sa key ay gumagana sa karaniwang constant time, hindi sa pag-iikot.

Hashable na object lang ang puwedeng maging key: string, numero, o tuple ng mga hindi nababagong halaga. Hindi maaaring gawing key ang list — makakakuha ka ng TypeError: unhashable type: 'list'. Maaaring anuman ang halaga, kasama ang iba pang dictionary at list.

Mula Python 3.7, tiyak na naaalala ng dictionary ang pagkakasunod ng pagpasok: sa pag-ikot, makukuha mo ang mga key ayon sa pagkakadagdag nito.

Paano gumawa ng dictionary

Maraming paraan para gumawa ng dictionary, at lahat ay makikita sa totoong code.

spent = {"Pagkain": 1200, "Taksi": 450}       # literal
empty = {}                                    # walang laman na dictionary
also_empty = dict()                           # pareho, gamit ang function na dict
user = dict(name="Anna", age=30)              # keyword argument
pairs = dict([("a", 1), ("b", 2)])            # mula sa listahan ng mga pares
keys = dict.fromkeys(["x", "y"], 0)           # {'x': 0, 'y': 0}

Pansinin: ang walang laman na curly brace na {} ay gumagawa ng walang laman na dictionary, hindi ng set. Ang walang laman na set ay gawa lang ng set().

Maginhawang paraan para gumawa ng dictionary mula sa dalawang listahan ang zip:

names = ["Pagkain", "Taksi", "Sine"]
sums = [1200, 450, 600]
spent = dict(zip(names, sums))
print(spent)   # {'Pagkain': 1200, 'Taksi': 450, 'Sine': 600}

Pag-access gamit ang key: d[k] at get

Binabasa ang halaga gamit ang square bracket. Kapag wala ang key, magtataas ang Python ng KeyError. Para maiwasan ang error, gamitin ang method na get: magbabalik ito ng None o ng default na halaga.

spent = {"Pagkain": 1200}
print(spent["Pagkain"])        # 1200
print(spent.get("Sine"))       # None
print(spent.get("Sine", 0))    # 0
spent["Sine"]                  # KeyError: 'Sine'

Para suriin kung nasa dictionary ang isang key, gamitin ang operator na in: ang "Pagkain" in spent ay magbabalik ng True. Mga key ang tinitingnan nito, hindi mga value. Para sa mga value, isulat ang 1200 in spent.values().

Pagdaragdag, pagbabago, at pagtanggal

Isang linya lang ng assignment ang kailangan para magdagdag o mag-update ng entry. Sa mga pagbibilang, napakagaling ang kombinasyon nito sa get:

spent = {}
for category, amount in [("Pagkain", 250), ("Taksi", 300), ("Pagkain", 400)]:
    spent[category] = spent.get(category, 0) + amount
print(spent)   # {'Pagkain': 650, 'Taksi': 300}

Maaaring magtanggal ng key gamit ang del d[k] (magtataas ng KeyError kapag wala ang key), o d.pop(k, default), na ibinabalik din ang halaga. Para linisin ang buong dictionary, gamitin ang d.clear(). Ang haba ng dictionary, ibig sabihin ang bilang ng mga pares, ay len(d).

Mga method ng dictionary: buod

setdefault: punan ang dictionary ng mga list

Nakatutulong ang setdefault kapag list ang mga value at kailangang pagpangkatin ang datos:

groups = {}
for item, cat in [("kape", "Pagkain"), ("metro", "Transportasyon"), ("pizza", "Pagkain")]:
    groups.setdefault(cat, []).append(item)
print(groups)   # {'Pagkain': ['kape', 'pizza'], 'Transportasyon': ['metro']}

update: i-update ang dictionary

Binabago ng update ang dictionary sa mismong lugar: idinadagdag ang mga bagong key, at pinapalitan ang mga magkaparehong key.

cfg = {"debug": False, "lang": "tl"}
cfg.update({"debug": True, "theme": "dark"})
print(cfg)   # {'debug': True, 'lang': 'tl', 'theme': 'dark'}

defaultdict: dictionary na may default na halaga

Ang collections.defaultdict ay subclass ng dict na kusang gumagawa ng halaga gamit ang factory kapag may hinanap na wala pang key. Dahil dito, nagiging mas maikli ang code ng pagbibilang at pagpapangkat.

from collections import defaultdict

spent = defaultdict(int)
for cat, amount in [("Pagkain", 250), ("Taksi", 300), ("Pagkain", 400)]:
    spent[cat] += amount
print(dict(spent))   # {'Pagkain': 650, 'Taksi': 300}

groups = defaultdict(list)
groups["Pagkain"].append("kape")

Para sa simpleng pagbibilang, mayroon ding collections.Counter: ang Counter(["a", "b", "a"]) ay magbibigay ng Counter({'a': 2, 'b': 1}).

Pag-ikot sa dictionary: loop na for

Sa loop na for, ang default na pag-ikot sa dictionary ay sa mga key. Para makuha agad ang key at value, dumaan sa items() — ito ang pinakakaraniwang paraan.

spent = {"Pagkain": 650, "Taksi": 300}

for cat in spent:                    # mga key
    print(cat)

for amount in spent.values():        # mga value
    print(amount)

for cat, amount in spent.items():    # mga pares
    print(f"{cat}: {amount} ₱")

Hindi maaaring baguhin ang laki ng dictionary habang dumadaan dito — magkakaroon ng RuntimeError: dictionary changed size during iteration. Kung kailangang magtanggal ng ilang key, dumaan sa kopya: for k in list(d):.

Pag-print ng dictionary sa screen

Ang print(d) ay nagpi-print ng dictionary sa isang linya. Para sa malaki o nested na dictionary, mas maginhawa ang module na pprint o ang json.dumps(d, ensure_ascii=False, indent=2) — ipinapakita nito ang datos na may indentation at tamang Unicode na walang escape.

Pag-aayos ng dictionary

Hindi naaayos sa mismong lugar ang dictionary; walang method na sort dito. Ang pag-aayos ng dictionary ay paggawa ng bagong dictionary mula sa mga pares na inayos gamit ang sorted.

spent = {"Taksi": 300, "Pagkain": 650, "Sine": 120}

by_key = dict(sorted(spent.items()))
print(by_key)    # {'Pagkain': 650, 'Sine': 120, 'Taksi': 300}

by_value = dict(sorted(spent.items(), key=lambda p: p[1], reverse=True))
print(by_value)  # {'Pagkain': 650, 'Taksi': 300, 'Sine': 120}

Kung kailangan lang ang nangungunang N kategorya, huwag na itong ibalik sa dictionary: ang sorted(spent.items(), key=lambda p: p[1], reverse=True)[:2] ay magbabalik ng listahan ng mga pares.

Maaaring ayusin ang listahan ng mga dictionary ayon sa field: sorted(users, key=lambda u: u["age"]).

Pagsasama at pagdaragdag ng dictionary

Mula Python 3.9, pinagsasama ang mga dictionary gamit ang operator na |, at ina-update ng |= ang dictionary sa mismong lugar. Kapag nagkapareho ang key, mananaig ang kanang operand.

a = {"x": 1, "y": 2}
b = {"y": 20, "z": 3}
print(a | b)          # {'x': 1, 'y': 20, 'z': 3}
print({**a, **b})     # pareho, gamit ang unpacking
a |= b                # katulad ng a.update(b)

Pansinin: hindi gumagana ang a + b para sa dictionary — magkakaroon ng TypeError. Kung ang layunin ay pagdagdagin ang mga value ng magkaparehong key, gamitin ang Counter: Counter(a) + Counter(b).

Unpacking ng dictionary

Ang dalawang asterisk na ** ay nag-u-unpack ng dictionary bilang mga keyword argument ng function o papunta sa ibang dictionary:

def greet(name, city):
    return f"{name} mula sa {city}"

data = {"name": "Anna", "city": "Cebu"}
print(greet(**data))   # Anna mula sa Cebu

Dict comprehension

Gumagawa ng dictionary sa isang linya mula sa anumang sunod-sunod na datos ang dict comprehension:

squares = {n: n * n for n in range(5)}
print(squares)   # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

big = {k: v for k, v in spent.items() if v > 200}

inverted = {v: k for k, v in {"a": 1, "b": 2}.items()}
print(inverted)  # {1: 'a', 2: 'b'}

Ang huling halimbawa ay paraan para baligtarin ang dictionary, palitan ang mga key at value. Gumagana lang ito kapag natatangi at hashable ang mga value; kung hindi, mawawala ang ilang pares.

Nested na dictionary

Maaaring dictionary din ang value — ganito inilalarawan ang mga istrukturang gaya ng JSON response ng API o dictionary ng mga dictionary ng user.

users = {
    101: {"name": "Anna", "skills": ["python", "sql"]},
    102: {"name": "Oscar", "skills": ["go"]},
}
print(users[101]["skills"][0])            # python
print(users.get(103, {}).get("name"))     # None, walang KeyError

Pagkopya ng dictionary: kopya at pangalawang pangalan

Hindi kinokopya ng b = a ang dictionary; naglalagay lang ito ng pangalawang pangalan sa iisang object. Kapag binago mo sa pamamagitan ng b, makikita rin ang pagbabago sa a. Ganoon din kapag ipinasa ang dictionary sa function: tumatanggap ito ng reference sa iisang object at maaaring tahimik itong masira.

import copy

a = {"limits": [0, 500]}
b = a.copy()              # shallow copy
b["limits"].append(1000)  # nakabahagi ang nested na list!
print(a)                  # {'limits': [0, 500, 1000]}

c = copy.deepcopy(a)      # ganap na hiwalay na kopya

Paghahambing ng mga dictionary

Inihahambing ng operator na == ang mga dictionary ayon sa laman: magkapareho kapag magkapareho ang lahat ng pares. Hindi isinasaalang-alang ang pagkakasunod ng mga key: ang {"a": 1, "b": 2} == {"b": 2, "a": 1} ay True. Para hanapin ang magkakaparehong key, gamitin ang mga operasyon ng set sa mga view: a.keys() & b.keys().

Typed na dictionary: annotation

Isinusulat ang annotation ng dictionary bilang dict[str, int]. Kapag nakapirmi ang set ng mga field na magkakaiba ang uri, kapaki-pakinabang ang TypedDict mula sa module na typing:

from typing import TypedDict

class User(TypedDict):
    name: str
    age: int

u: User = {"name": "Anna", "age": 30}

Hindi sinusuri ang mga annotation habang tumatakbo; binabasa ang mga ito ng IDE at ng mga analyzer gaya ng mypy.

Hindi nababagong dictionary: frozendict sa Python 3.15

Sa Python 3.15, may built-in na uring frozendict (PEP 814): walang kailangang i-import, at ang pagtatangkang baguhin ito ay agad na nagtatapos sa TypeError. Dati, ginagaya ang hindi nababagong dictionary gamit ang wrapper mula sa module na types o gamit ang third-party package. Ito mismo ang kailangan para sa mga shared na setting na hindi dapat tahimik na mabago ng kahit anong function.

config = frozendict(min_amount=0, max_amount=500)
config["max_amount"] = 1000
# TypeError: 'frozendict' object does not support item assignment

strict = config | {"max_amount": 300}   # bagong frozendict, buo pa ang orihinal
cache = {config: "ulat para sa Mayo"}   # hashable — puwedeng gawing key

Mahalagang malaman, ayon sa mga materyal ng kurso:

• Nagmamana ang frozendict mula sa object, hindi mula sa dict, kaya magbabalik ng False ang isinstance(cfg, dict). Para tingnan ang "anumang dictionary", gamitin ang collections.abc.Mapping o isinstance(x, (dict, frozendict)).
• Hashable lang ito kapag hashable ang mga key at value: nagagawa ang frozendict(a=[1]), pero babagsak ang hash(). Shallow ang hindi pagkakabago, gaya ng tuple.
• Nananatili ang pagkakasunod, pero hindi ito isinasaalang-alang ng ==.
• Nauunawaan ng json.dumps, pickle, at copy ang frozendict.

Karaniwang pagkakamali

• KeyError sa pagbasa — gamitin ang get o ang pagsusuring in.
• List bilang key — gawin itong tuple: d[tuple(lst)].
• Pagbabago ng dictionary sa loob ng loop — dumaan sa list(d).
• Pag-asa sa kopya mula sa assignment — gumawa ng copy() o deepcopy.
• {} bilang walang laman na set — dictionary ito.

Buod

Ang python dict ang pangunahing istruktura ng datos ng wika: mabilis na paghahanap ayon sa key, napananatiling pagkakasunod ng pagpasok, at maginhawang mga method na get, setdefault, at update, pag-ikot gamit ang items(), pag-aayos gamit ang sorted, at pagsasama gamit ang |. Tandaan ang pagkopya at ang mga hashable na key, at para sa mga setting sa Python 3.15, gamitin ang frozendict. Ang mga dictionary, list, tuple, at set ay tinalakay nang praktikal sa kursong "Python 3.15: mula baguhan hanggang propesyonal", gamit ang tagasubaybay ng gastos bilang halimbawa.