Python-sanakirja – kaikki mitä sinun tarvitsee tietää

Python-sanakirjat ovat uskomattoman hyödyllinen tietorakenne, jota tulet kurkottamaan usein ohjelmointipyrkimyksissäsi. Niiden ainutlaatuinen kyky yhdistää avaimet vastaaviin arvoihin mahdollistaa nopean, tehokkaan pääsyn ja yksinkertaistetun koodin hallittaessa monimutkaisia ​​tietojoukkoja.

Python-sanakirjat ovat pohjimmiltaan assosiatiivisten taulukoiden toteutus. Ne tarjoavat joustavan ja tehokkaan tavan tallentaa ja käsitellä tietoja avain-arvo-parien muodossa.

Ne ovat erittäin monipuolisia ja niihin mahtuu vaihdettavia ja tilattuja kokoelmia ilman päällekkäisiä avaimia.

Kun sukeltaamme tässä artikkelissa sanakirjoihin, huomaat, että ne ovat tehokkaita työkaluja tietojen järjestämiseen ja käyttämiseen.

Muista siis tutustua sanakirjojen ytimiin, jotta voit hyödyntää niiden täyden potentiaalin projekteissasi!

Sisällysluettelo

• Python-sanakirjojen ymmärtäminen
• Python-sanakirjan luominen
  • Curly Bracketsin käyttö
  • Dict Constructorin käyttö
• Kuinka käyttää sanakirjaelementtejä
  • Avainten käyttö
  • Käytä Get Methodia
• Sanakirjan elementtien muokkaaminen
  • Uusien elementtien lisääminen
  • Päivitetään olemassa olevia elementtejä
• Sanakirjan elementtien poistaminen
  • Del Avainsana
  • Tyhjennä menetelmä
• Mitkä ovat yleisiä sanakirjamenetelmiä?
  • Avaimet
  • Arvot
  • Tuotteet
  • Päivittää
  • Pop
  • Popitem
• Python-sanakirjojen käyttäminen
  • Silmukoimalla sanakirjoja
  • Mitä ovat sanakirjan ymmärtämiset?
  • Mitä ovat sisäkkäiset sanakirjat?
• Yleisiä sanakirjan käyttötapauksia

Python-sanakirjojen ymmärtäminen

Sanakirja on tehokas ja joustava tietorakenne, jonka avulla voit tallentaa kokoelman avainarvopareja. Ajattele sanakirjaa tapana yhdistää avaimet niitä vastaaviin arvoihin, mikä helpottaa tiettyyn tunnisteeseen liittyvien tietojen hakemista.

Sanakirjan luomiseen voit käyttää aaltosulkeet ( { } ), jotka sisältävät pilkuilla erotetun luettelon avainarvopareista. Esimerkiksi:

your_dict = {"key1": "value1", "key2": "value2", "key3": "value3"}

Muista, että Pythonin sanakirjat ovat muuttuvia, mikä tarkoittaa, että voit muokata niiden sisältöä luomisen jälkeen. Voit lisätä tai päivittää avain-arvo-parin käyttämällä seuraavaa syntaksia:

your_dict["new_key"] = "new_value"

#You can also update an old key's value
your_dict["old_key"] = "new_value"

Kun kyse on sanakirjan arvojen käyttämisestä, tarvitset vain avaimen:

value = your_dict["key1"]

Jos yrität käyttää avainta, jota ei ole sanakirjassa, kohtaat KeyError-ilmoituksen. Tämän välttämiseksi voit käyttää get()-menetelmää:

value = your_dict.get("non_existent_key", "default_value")

Yksi asia, joka sinun on muistettava, on, että Python-sanakirja ei voi sisältää päällekkäisiä avaimia. Jokaisen avaimen on oltava ainutlaatuinen ja muuttumaton tietotyyppi.

Voit esimerkiksi käyttää monikkoa, merkkijonoa, kokonaislukua tai jopa Boolen arvoa avaimesi. Et kuitenkaan voi käyttää luetteloita, sanakirjoja tai joukkoja.

Arvoille ei ole tällaisia ​​rajoituksia. Voit käyttää sekä muuttuvia että muuttumattomia tietotyyppejä.

Elementin poistaminen sanakirjasta tehdään del - avainsanalla:

del your_dict["key1"]

Ne tarjoavat myös useita menetelmiä sisällön iterointiin. Voit esimerkiksi kiertää sanakirjan avaimia, arvoja tai jopa molempia:

for key in your_dict.keys():
    print(key)

for value in your_dict.values():
    print(value)

for key, value in your_dict.items():
    print(key, value)

Voit nyt käyttää näitä sanakirjamenetelmiä ja -tekniikoita tietojen tehokkaaseen tallentamiseen, hakemiseen ja käsittelyyn työskennellessään .

Python-sanakirjan luominen

Python-sanakirjoja voidaan luoda kahdella päätavalla: käyttämällä kiharasulkuja ja dict()- konstruktoria.

Curly Bracketsin käyttö

Yksi tapa, jolla voit luoda sanakirjan, on käyttää kiharasulkuja ( {} ). Tyhjän sanakirjan alustamiseksi voit yksinkertaisesti käyttää toimintoa empty_dict = {} .

Jos haluat luoda sanakirjan, jossa on avain-arvo-pareja, erota avaimet ja arvot kaksoispisteillä. Erota seuraavaksi kukin pari pilkulla:

python_dict = {
    'key1': 'value1',
    'key2': 'value2',
    'key3': 'value3'
}

Tätä muotoa käyttämällä olet luonut Python-sanakirjan, jossa on kolme avainarvoparia. Muista, että avainten on oltava yksilöllisiä, kun taas sanakirjan arvot voidaan monistaa.

Dict Constructorin käyttö

Toinen tapa Python-sanakirjan luomiseen on käyttää dict()- konstruktoria. Voit luoda tyhjän sanakirjan kutsumalla tätä funktiota ilman argumentteja: empty_dict = dict() .

Voit luoda sanakirjan dict()- konstruktorilla käyttämällä seuraavaa syntaksia:

python_dict = dict(
    key1='value1',
    key2='value2',
    key3='value3'
)

Tämä menetelmä luo myös Python-sanakirjan, jossa on kolme avainarvoelementtiä. Huomaa, että toisin kuin curly brackets -menetelmässä, dict()- konstruktori ei vaadi lainausmerkkejä näppäinten ympäriltä.

Sanakirjan arvot vaativat kuitenkin edelleen lainausmerkkejä ympärilleen

Nyt kun tunnet kaksi tapaa luoda Python-sanakirjoja, voit aloittaa niiden toteuttamisen koodissasi ja hyödyntää niiden tehokkaita ominaisuuksia sovelluksissasi.

Kuinka käyttää sanakirjaelementtejä

Tässä osiossa opit eri tavoista käyttää sanakirjan elementtejä. Sanakirjat tallentavat tiedot avain-arvo-pareina, ja voit käyttää jokaista sanakirjan arvoa vastaavilla avaimilla.

Käsittelemme kahta suosittua menetelmää: Avainten käyttö ja get - menetelmä.

Avainten käyttö

Yksi yksinkertaisimmista tavoista päästä käsiksi sanakirjan elementteihin on käyttää näppäimiä. Saadaksesi tietyn sanakirjan avaimen arvon laita avain hakasulkeisiin sanakirjan nimen viereen:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name_value = my_dict['name']

phone_value = mydict['phone-number']

Tässä esimerkissä nimi_arvo tallentaa merkkijonon "John" . Huomaa, että jos yrität käyttää olematonta avainta, Python herättää KeyError- ilmoituksen .

Käytä Get Methodia

Vaihtoehto avainten suoralle käytölle on get()- menetelmä, jonka avulla voit käyttää sanaston elementtejä ilman KeyError-virheen aiheuttamisen riskiä. Sen sijaan get -menetelmä palauttaa oletusarvon, jos määritettyä avainta ei löydy:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name_value = my_dict.get('name', 'Key not found')
country_value = my_dict.get('country', 'Key not found')

Tässä esimerkissä nimi_arvo tallentaisi merkkijonon John kuten ennenkin, koska avain " nimi " on läsnä sanakirjassa. Country_value kuitenkin tallentaa oletusarvon Avainta ei löydy , koska maa- avainta ei ole sanakirjassa.

Get ()- menetelmä tarjoaa joustavamman tavan käyttää sanakirjaelementtejä, koska sen avulla voit käsitellä puuttuvia avaimia sulavasti. Voit valita kumpaa tahansa menetelmää riippuen tarpeistasi ja mahdollisuudesta kohdata olemattomia avaimia.

Sanakirjan elementtien muokkaaminen

Tässä osiossa opit muokkaamaan Python-sanakirjan elementtejä. Tämän saavuttamiseksi on kaksi päätoimintoa: uusien elementtien lisääminen ja olemassa olevien elementtien päivittäminen.

Molemmat menetelmät auttavat sinua säilyttämään sanakirjan tarkkuuden ja hyödyllisyyden. Katsotaanpa niitä:

1. Uusien elementtien lisääminen

Uuden elementin lisääminen sanakirjaan on helppoa. Voit tehdä tämän määrittämällä uuden avain-arvo-parin määritysoperaattorilla seuraavasti:

your_dict = {"key1": "value1", "key2": "value2"}
your_dict["new_key"] = "new_value"

Kun olet suorittanut yllä olevan koodinpätkän, sanakirjasi sisältää nyt uuden parin:

{"key1": "value1", "key2": "value2", "new_key": "new_value"}

Voit myös lisätä useita avainarvopareja kerralla käyttämällä sanakirjan update()- menetelmää

new_elements = {"key3": "value3", "key4": "value4"}
your_dict.update(new_elements)

Nyt sanakirjasi sisältää seuraavat merkinnät:

{"key1": "value1", "key2": "value2", "key3": "value3", "key4": "value4"}

1. Päivitetään olemassa olevia elementtejä

Jos haluat päivittää olemassa olevan elementin arvon, sinun on vain viitattava avaimeen ja määritettävä sille uusi arvo:

your_dict["key1"] = "updated_value1"

Tämä muutos johtaa seuraavan sanakirjan:

{"key1": "updated_value1", "key2": "value2", "key3": "value3", "key4": "value4"}

Jos sinun on päivitettävä useita elementtejä kerralla, käytä update()- menetelmää uudelleen. Käyttääksesi sitä, välitä uusi sanakirja, joka sisältää haluamasi muutokset.

Päivitetään esimerkiksi your_dict-sanakirja päivityssanakirjan arvoilla:

updates = {"key2": "updated_value2", "key4": "updated_value4"}
your_dict.update(updates)

Kun nämä päivitykset on otettu käyttöön, your_dict-sanakirja näyttää tältä:

{"key1": "updated_value1", "key2": "updated_value2", "key3": "value3", "key4": "updated_value4"}

Nämä toiminnot ovat tärkeitä työkaluja työskennellessäsi, koska niiden avulla voit pitää tietorakenteet ajan tasalla ja tarkkoina.

Sanakirjan elementtien poistaminen

Tässä osiossa tutkimme kahta yleistä tapaa poistaa sanakirjaelementtejä Pythonissa: del- avainsana ja clear()- menetelmä.

1. Del Avainsana

Avainsanaa del käytetään tietyn avain-arvo-parin poistamiseen sanakirjasta. Se toimii paikan päällä ja aiheuttaa KeyError-ilmoituksen, jos avainta ei ole sanakirjassa. Jos haluat poistaa elementin, käytä seuraavaa syntaksia:

del my_dict[key]

Jos esimerkiksi haluat poistaa " brändi "-nimisen avaimen sanakirjasta, jonka nimi on my_dict, kirjoitat:

del my_dict["brand"]

Muista, että on hyvä käytäntö varmistaa, että avain on olemassa sanakirjassa ennen del-avainsanan käyttöä. Voit tehdä tämän tarkistamalla, onko avain sanakirjassa:

if "brand" in my_dict:
    del my_dict["brand"]

1. Tyhjennä menetelmä

Clear()-menetelmä on toinen tapa poistaa sanakirjaelementtejä. Tämä menetelmä poistaa kaikki sanakirjan avaimet ja arvot yhdellä toiminnolla, jolloin sanakirja on tyhjä.

Käytä sanakirjassasi clear()-menetelmää kutsumalla sitä. Jos sinulla on esimerkiksi olemassa oleva sanakirja nimeltä my_dict ja haluat poistaa sen kaiken sisällön, kirjoitat:

my_dict.clear()

Lopuksi, olet oppinut kaksi tapaa poistaa elementtejä Python-sanakirjasta: del-avainsanan yksittäisten avainarvoparien poistamiseen ja clear()-menetelmän koko sanakirjan tyhjentämiseen.

Mitkä ovat yleisiä sanakirjamenetelmiä?

Tässä osiossa tutkimme joitain yleisiä Python-sanakirjamenetelmiä. Nämä sisäänrakennetut menetelmät auttavat sinua käsittelemään ja muokkaamaan sanakirjoja tarpeidesi mukaan.

Avaimet

Voit hakea kaikki avaimet sanakirjastasi käyttämällä keys()- menetelmää. Tämä palauttaa näkymäobjektin, joka sisältää kaikki sanakirjan avaimet.

Esimerkiksi:

your_dict = {'a': 1, 'b': 2, 'c': 3}
key_view = your_dict.keys()
print(key_view)
# Output: dict_keys(['a', 'b', 'c'])

Arvot

Vastaavasti arvot()- menetelmän avulla voit saada kaikki sanakirjaan tallennetut arvot. Tämä esitetään myös näkymäobjektina.

Esimerkiksi:

value_view = your_dict.values()
print(value_view)
# Output: dict_values([1, 2, 3])

Tuotteet

Jos sinun on käytettävä sekä avaimia että arvoja samanaikaisesti, käytä items()-menetelmää. Tämä palauttaa näkymäobjektin, joka sisältää avainarvo-pareja monikoina.

Katsotaanpa esimerkkiä:

item_view = your_dict.items()
print(item_view)
# Output: dict_items([('a', 1), ('b', 2), ('c', 3)])

Päivittää

Update()-menetelmän avulla voit muokata sanakirjaasi lisäämällä tai päivittämällä avainarvoelementtejä. Jotta voit käyttää menetelmää, sinun on annettava sanakirja argumenttina.

Voit yhdistää kaksi sanakirjaa tai päivittää tiettyjä avaimia käyttämällä tätä menetelmää:

your_dict.update({'d': 4, 'e': 5})
print(your_dict)
# Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

Pop

Pop()-menetelmällä voit poistaa tietyn kohteen sanakirjasta. Jos haluat käyttää sitä, anna poistettava avain menetelmän argumenttina.

Menetelmä palauttaa määritettyyn avaimeen liittyvän arvon ja poistaa sen sanakirjasta:

removed_value = your_dict.pop('a')
print(removed_value)
# Output: 1
print(your_dict)
# Output: {'b': 2, 'c': 3, 'd': 4, 'e': 5}

Popitem

Popitem ()- menetelmä poistaa sanakirjan viimeisen avain-arvo-parin. Se palauttaa monikon, joka sisältää poistetun avaimen ja arvon. Esimerkiksi:

removed_item = your_dict.popitem()
print(removed_item)
# Output: ('e', 5)
print(your_dict)
# Output: {'b': 2, 'c': 3, 'd': 4}

Käyttämällä näitä menetelmiä voit tehokkaasti hallita ja käsitellä sanakirjojasi erilaisten tehtävien suorittamiseksi.

Python-sanakirjojen käyttäminen

Tässä osiossa opit erilaisia ​​tekniikoita sanakirjojen kanssa työskentelyyn, kuten niiden silmukan, sanakirjan ymmärtämisen ja sisäkkäisten sanakirjojen käyttämisen.

Silmukoimalla sanakirjoja

Jos haluat kiertää sanakirjan, voit käyttää sisäänrakennettua menetelmää items() iteroidaksesi avainarvo-pareja. Näin voit suorittaa toimintoja sekä avaimille että arvoille luettavalla ja tehokkaalla tavalla.

Tässä on esimerkki:

my_dict = {"apple": 1, "banana": 2, "cherry": 3}

for key, value in my_dict.items():
    print(key, value)

Vaihtoehtoisesti voit käyttää keys()- ja arvot()- menetelmiä iteroidaksesi joko sanakirjan avainten tai arvojen yli.

Mitä ovat sanakirjan ymmärtämiset?

Sanakirjan ymmärtäminen on ytimekäs tapa luoda sanakirjoja käyttämällä yhtä koodiriviä. Ne ovat samanlaisia ​​kuin luettelon ymmärtäminen, mutta toimivat sen sijaan sanakirjojen kanssa.

Tässä on esimerkki sanakirjan ymmärtämisestä, joka neliöi numerot 1:stä 5:een:

squared_numbers = {num: num**2 for num in range(1, 6)}

Sanakirjan ymmärtäminen voi olla erittäin arvokasta esimerkiksi sanakirjojen suodatuksessa tai niiden arvojen muuntamisessa.

Mitä ovat sisäkkäiset sanakirjat?

Sisäkkäiset sanakirjat ovat sanakirjoja, jotka sisältävät arvoina muita sanakirjoja. Niitä voidaan käyttää monimutkaisten hierarkkisten tietorakenteiden esittämiseen.

Tässä on esimerkki sisäkkäisestä sanakirjasta:

nested_dict = {
    "person1": {"name": "Alice", "age": 30},
    "person2": {"name": "Bob", "age": 24}
}

Jos haluat käyttää sisäkkäisen sanakirjan elementtiä, käytä useita indeksointia:

name_p1 = nested_dict["person1"]["name"]

Voit muokata tai muokata sisäkkäisten sanakirjojen elementtejä tarpeen mukaan. Muista pitää kirjaa avaimista ja sisäkkäistasoista työskennellessäsi monimutkaisten sisäkkäisten sanakirjojen kanssa sekaannusten ja virheiden välttämiseksi.

Yleisiä sanakirjan käyttötapauksia

Python-sanakirjat ovat monipuolisia, ja niiden avulla voit järjestää ja hallita erilaisia ​​tietotyyppejä. Tässä osiossa tutkit joitain yleisiä sanakirjojen käyttötapauksia, jotka parantavat ymmärrystäsi ja auttavat sinua toteuttamaan ne tehokkaasti projekteissasi.

1. Avainarvotietojen tallentaminen : Sanakirjat ovat ihanteellisia tietojen tallentamiseen yksilöllisillä avaimilla ja niihin liittyvillä arvoilla, kuten käyttäjänimiä ja käyttäjätietoja tai tuotetunnuksia ja tuotetietoja:

{
  "username1": {"name": "Alice", "email": "[email protected]"},
  "username2": {"name": "Bob", "email": "[email protected]"}
}

Esimerkki tästä on tässä videossa Google-uutisten kokoajan rakentamisesta LuckyTemplatesissa Pythonin avulla.

https://youtu.be/InsDb_DR15E

Tässä videossa käytämme sanakirjaa GoogleNews API -kutsusta saatujen tietoarvojen tallentamiseen.

2. Esiintymien laskeminen : Voit käyttää sanakirjoja laskeaksesi kohteiden esiintymät, kuten sanojen esiintymistiheyden asiakirjassa. Käyttämällä avaimia edustamaan yksilöllisiä kohteita ja arvoja osoittamaan lukumäärää, voit hallita näitä tietoja tehokkaasti.

Hauska tosiasia, voit tehdä tämän Python Collections -moduulin Counter-luokassa . Se ottaa käyttöön järjestämättömän luettelon ja palauttaa sanakirjan, jossa jokainen yksilöllinen elementti on avaimena ja niiden taajuus vastaavana arvona.

3. Avainten yhdistäminen useisiin arvoihin : Jos sinun on tallennettava useita arvoja kullekin sanakirjaavaimelle, voit käyttää luetteloita tai joukkoja arvoina sanakirjassasi:

{
  "fruits": ["apple", "banana", "mango"],
  "vegetables": ["carrot", "broccoli", "spinach"]
}

4. Laskettujen tulosten tallentaminen välimuistiin : Sanakirjoja voidaan käyttää kalliiden toimintojen tulosten välimuistiin. Tämä on erityisen hyödyllistä muistitekniikoissa ja dynaamisessa ohjelmoinnissa, joissa tallennat laskelmien tulokset tarpeettomien laskelmien välttämiseksi.

5. Käänteisten hakemistojen luominen : Hakukoneen kaltaisissa tapauksissa saatat tarvita käänteisen hakemiston, joka yhdistää jokaisen hakutermin termin sisältävään resurssiluetteloon. Sanakirjojen avulla voit tallentaa nämä tiedot tehokkaasti:

{
  "python": ["resource1", "resource3"],
  "dictionary": ["resource2", "resource3", "resource4"]
}

Nämä ovat vain muutamia esimerkkejä havainnollistamaan Python-sanakirjojen tehoa ja monipuolisuutta. Kun ymmärrät nämä käyttötapaukset ja niiden sovellukset, voit hyödyntää sanakirjojen täyden potentiaalin rakentaaksesi tehokkaita ratkaisuja ohjelmointitehtäviisi!