Szótárak ebben a kurzusban:

A(z) Szótárak fogalomról

A Pythonban a szótár (dict) olyan adatszerkezet, amely hash-elhető kulcsokat rendel értékekhez, és más programozási nyelvekben átméretezhető hash-táblaként, hashmapként vagy asszociatív tömbként ismert. A szótárak a Python egyetlen beépített leképezéstípusai.

A keys kulcsoknak hash-elhetőnek kell lenniük, és a szótáron belül egyedinek. A kulcsok típusa lehet number, str vagy tuple (megváltoztathatatlan értékekből). Nem tartalmazhatnak változtatható adatszerkezeteket, például list, dict vagy set. A Python 3.7 óta a dict kulcsainak sorrendje garantáltan a bejegyzések beszúrásának sorrendje.

A values értékek bármilyen adattípusúak vagy szerkezetűek lehetnek. Az értékek tetszőlegesen egymásba ágyazhatók, így tartalmazhatnak listák listáit, alszótárakat és más egyéni vagy összetett adatszerkezeteket.

Egy key megadásával a szótárak (átlagosan) konstans idő alatt ki tudják olvasni a hozzá tartozó value értéket (függetlenül a bejegyzések számától). Ha egy értéket egy list-en vagy array-en belül keresünk (az index pozíció ismerete nélkül), ahhoz képest a dict lényegesen több memóriát használ, de a visszakeresés nagyon gyors.

A szótárak különösen hasznosak olyan helyzetekben, amikor az elemek gyűjteménye nagy, és gyakran kell hozzáférni és frissíteni.

Szótár létrehozása

A szótárakat sokféleképpen létre lehet hozni, például:

• A fromkeys() osztálymetódussal.
• Szótár-komprehenziókkal.
• Két szótár összefésülésével kicsomagolás (**) segítségével.
• Szótárak összefésülésével a | (update) operátorral.
• Ciklus használatával, hogy egy korábban létrehozott üres dict-hez iteratívan adjunk bejegyzéseket.

A két legegyszerűbb módszer a szótár konstruktora és a szótár literálja.

A szótárkonstruktor

A dict() (a dict osztály konstruktora) bármilyen key, value párokból álló iterálhatóval használható. dict() hívható egy sor <name>=<value> argumentummal is:

# Passing a list of key,value tuples.
>>> wombat = dict([('name', 'Wombat'),
...              ('speed', 23),
...              ('land_animal', True)])
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Using key=value arguments.
>>> bear = dict(name="Black Bear",
...             speed=40,
...             land_animal=True)
{'name': 'Black Bear', 'speed': 40, 'land_animal': True}

A dict-ek dokumentációja további változatokat és lehetőségeket mutat be a konstruktor használatához.

Szótárliterálok

Egy szótár közvetlenül is megadható szótárliterálként, kapcsos zárójelek ({}) segítségével, amelyek key : value párokat zárnak közre. A {} közé zárt bejegyzések külön sorokban is szerepelhetnek:

>>> whale = {"name": "Blue Whale", 
             "speed": 35, 
             "land_animal": False}
{'name': 'Blue Whale', 'speed': 35, 'land_animal': False}

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle'}

>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'color': 'Brindle'}

Egymásba ágyazott szótárak

A szótárak tetszőleges mélységig egymásba ágyazhatók:

animals = {
    "Real" : {
        "Winged" : {
            "Sparrow" : {'name': 'sparrow','speed': 12, 'land_animal': True},
            "Kestrel" : {'name': 'kestrel', 'speed': 15, 'land_animal': True}
           },
        "Legged" : {
            "Wombat" : {'name': 'Wombat', 'speed': 23, 'land_animal': True},
            "Black Bear": {'name': 'Black Bear', 'speed': 40, 'land_animal': True},
            "Polecat" : {'name': 'Polecat', 'speed': 15, 'land_animal': True}
           },
        "Other" :  {
            "Whale" : {'name': 'Blue Whale', 'speed': 35, 'land_animal': False},
            "Orca" : {'name': 'Orca', 'speed': 45, 'land_animal': False},
            "Snake" : {'name': 'Python', 'speed': 25, 'land_animal': True}
            }
        },
        
    "Imaginary": {
        "Winged" : {
            "Dragon" : {'name': 'Fire Dragon','speed': 100, 'land_animal': True},
            "Phoenix" : {'name': 'Phoenix', 'speed': 1500, 'land_animal': True}
            },
        "Legged" : {
            "Sphinx" : {'name': 'Sphinx','speed': 10, 'land_animal': True},
            "Minotaur" : {'name': 'Minotaur', 'speed': 5, 'land_animal': True}
            },
        "Other" :  {}
        }
   }

Értékek elérése egy dict-ben

Egy szótárban lévő value értéket egy kulcs segítségével érhetsz el szögletes zárójelben. Ha egy kulcs nem létezik a szótárban, KeyError keletkezik:

>>> bear["speed"]
40

>>> bear["color"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'color'

Ha egy bejegyzést a get(<key>, <default value>) metódussal érsz el, elkerülheted a KeyError-t:

>>> bear.get("color", 'not found')
'not found'

Egymásba ágyazott szótárbejegyzések elérése

Az egymásba ágyazott szótárak bejegyzéseinek eléréséhez egymás után több zárójelet használj. Ha egy adott kulcs hiányzik, a szokásos KeyError dobódik:

# Using the animals nested dictionary.
>>> animals["Real"]["winged"]["Kestrel"]["speed"]
15

>>> animals["Imaginary"]["winged"]["Kestrel"]["speed"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Kestrel'

A KeyError elkerüléséhez a .get() használható, de a .get() hívásokat láncolni kell:

# Using the animals nested dictionary.
# Note the use of parenthesis to enable placing the 
# .get() calls on separate lines.
>>> (animals.get("Imaginary", {})
            .get("Legged", {})
            .get("Sphinx", {})
            .get("Color", "I have no idea!"))
'I have no idea!'

Szótárértékek módosítása vagy hozzáadása

Egy bejegyzés value értékét úgy módosíthatod, hogy értéket rendelsz a kulcsához:

# Assigning the value "Grizzly Bear" to the name key.
>>> bear["name"] = "Grizzly Bear"
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True}

>>> whale["speed"] = 25
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False}

Új key:value párok ugyanígy adhatók hozzá:

# Adding a new "color" key with a new "tawney" value.
>>> bear["color"] = 'tawney'
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True, 'color': 'tawney'}

>>> whale["blowholes"] = 1
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False, 'blowholes': 1}

Szótárbejegyzések eltávolítása (pop és del)

A <dict>.pop(<key>) metódussal törölhetsz egy szótárbejegyzést. A <dict>.pop() eltávolítja a (key, value) párt, és visszaadja a value értéket használatra. A <dict>.get()-hez hasonlóan a <dict>.pop(<key>) elfogad egy második argumentumot (<dict>.pop(<key>, <default value>)), amelyet akkor ad vissza, ha a key nem található. Ez meggátolja, hogy KeyError keletkezzen:

# Using .pop() removes both the key and value, returning the value.
>>> bear.pop("name")
'Grizzly Bear'


# The "name" key is now removed from the dictionary.
# Attempting .pop() a second time will throw a KeyError.
>>> bear.pop("name")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name'


# Using a default argument with .pop() will 
# prevent a KeyError from a missing key.
>>> bear.pop("name", "Unknown")
'Unknown'

A del utasítással egy vagy több bejegyzést is eltávolíthatsz. Ha az eltávolítandó bejegyzés nem található a szótárban, KeyError keletkezik:

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle',
              'talent': 'Singing',
              'size': 'small'}

# Remove a single entry from the dictionary.
>>> del wombat["color"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'talent': 'Singing', 'size': 'small'}


# Remove multiple entries from the dictionary.
>>> del wombat["talent"], wombat["size"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Attempting a deletion of a non-existent key raises a KeyError
>>> del wombat["number_of_legs"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'number_of_legs'

Egy szótár bejárása / iterálás

Ha egy szótáron for item in dict vagy while item segítségével haladsz végig, az alapértelmezés szerint a kulcsokon iterál. Ugyanabban a ciklusban a értékeket szögletes zárójelek használatával érheted el:

>>> for key in bear:
...     print((key, bear[key])) # <--This prints a tuple of (key, value).
('name', 'Black Bear')
('speed', 40)
('land_animal', True)

Használhatod a .items() metódust is, amely (key, value) párokat ad vissza:

# dict.items() forms (key, value tuples) that can be 
# unpacked and iterated over.
>>> for key, value in whale.items():
...     print(key, ":", value)
name : Blue Whale
speed : 25
land_animal : False
blowholes : 1

Hasonlóképpen a .keys() a keys kulcsokat, a .values() pedig a values értékeket adja vissza.

A Python szótárainak részletes magyarázatához a hivatalos dokumentáció kiváló kiindulópont, de megnézheted a W3-Schools bemutatót is.

A szótárfunkcionalitás bővítése: a collections modul

A collections modul speciális funkciókkal bővíti a Python szabványos gyűjteményalapú adattípusait (dict, set, list, tuple). A három leghasznosabb szótáralapú osztály:

• A Counter automatikusan megszámolja az elemeket, és egy dict-ben adja vissza őket úgy, hogy az elemek a kulcsok, a darabszámuk pedig az érték.
• Az OrderedDict metódusokkal rendelkezik a szótárbejegyzések sorrendjének elrendezéséhez.
• A defaultdict gyártó metódust használ az alapérték beállításához, ha egy key nem található, amikor egy szótárbejegyzést próbálunk kiolvasni vagy hozzárendelni.