Python Dictionary – Allt du behöver veta

Python-ordböcker är en otroligt användbar datastruktur som du kommer att finna att du ofta söker efter i dina programmeringssträvanden. Deras unika förmåga att mappa nycklar till sina respektive värden möjliggör snabb, effektiv åtkomst och förenklad kod vid hantering av komplexa datauppsättningar.

Python-ordböcker är i huvudsak en implementering av associativa arrayer. De ger ett flexibelt och effektivt sätt att lagra och manipulera data i form av nyckel-värdepar.

De är mycket mångsidiga och kan ta emot utbytbara och beställda samlingar utan att tillåta dubbletter av nycklar.

När vi dyker in i ordböcker i den här artikeln kommer du att upptäcka att de är kraftfulla verktyg för att organisera och komma åt dina data.

Så var noga med att bekanta dig med ins och outs i ordböcker för att frigöra deras fulla potential i dina projekt!

Innehållsförteckning

• Förstå Python-ordböcker
• Hur man skapar en Python-ordbok
  • Använda lockiga parenteser
  • Använder Dict Constructor
• Hur man får åtkomst till ordbokselement
  • Använda nycklar
  • Använder Get Method
• Hur man ändrar ordbokselement
  • Lägga till nya element
  • Uppdatering av befintliga element
• Ta bort ordbokselement
  • Del nyckelord
  • Tydlig metod
• Vilka är några vanliga ordboksmetoder?
  • Nycklar
  • Värderingar
  • Föremål
  • Uppdatering
  • Pop
  • Popitem
• Använder Python Dictionaries
  • Slingor över ordböcker
  • Vad är ordboksförståelser?
  • Vad är kapslade ordböcker?
• Vanliga användningsfall för ordbok

Förstå Python-ordböcker

En ordbok i är en kraftfull och flexibel datastruktur som låter dig lagra en samling nyckel-värdepar. Tänk på en ordbok som ett sätt att mappa nycklar till deras motsvarande värden, vilket gör det enkelt att hämta information som är relaterad till en specifik identifierare.

För att skapa en ordbok kan du använda klammerparenteser ( { } ) som omsluter en kommaseparerad lista med nyckel-värdepar. Till exempel:

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

Tänk på att ordböcker i Python är föränderliga, vilket innebär att du kan ändra deras innehåll efter att de har skapats. För att lägga till eller uppdatera ett nyckel-värdepar, använd helt enkelt följande syntax:

your_dict["new_key"] = "new_value"

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

När det gäller att komma åt värden i en ordbok behöver du bara nyckeln:

value = your_dict["key1"]

Om du försöker komma åt en nyckel som inte finns i ordboken, kommer du att stöta på ett KeyError. För att undvika detta kan du använda metoden get():

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

En sak du måste komma ihåg är att en Python-ordbok inte kan innehålla dubbletter av nycklar. Varje nyckel måste vara unik och vara av en oföränderlig datatyp.

Du kan till exempel använda en tupel, sträng, heltal eller till och med en boolesk nyckel. Du kan dock inte använda listor, ordböcker eller uppsättningar.

Det finns inga sådana begränsningar för värden. Du kan använda både föränderliga och oföränderliga datatyper.

Att ta bort ett element från en ordbok görs med hjälp av nyckelordet del :

del your_dict["key1"]

De tillhandahåller också flera metoder för att iterera genom deras innehåll. Till exempel kan du gå över ordboksnycklarna, värdena eller till och med båda:

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)

Du kan nu använda dessa ordboksmetoder och tekniker för att effektivt lagra, hämta och manipulera data medan du arbetar med .

Hur man skapar en Python-ordbok

Det finns två huvudsakliga sätt att skapa Python-ordböcker: med hjälp av parenteser och dict() -konstruktorn.

Använda lockiga parenteser

En metod du kan använda för att skapa en ordbok är att använda parenteser( {} ) . För att initiera en tom ordbok kan du helt enkelt använda empty_dict = {} .

För att skapa en ordbok med nyckel-värde-par, separera nycklarna och värdena med kolon. Separera sedan varje par med ett kommatecken:

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

Med det här formatet har du skapat en Python-ordbok med tre nyckel-värdepar. Kom ihåg att nycklarna måste vara unika medan ordboksvärdena kan dupliceras.

Använder Dict Constructor

En annan metod för att skapa en Python-ordbok är att använda dict() -konstruktorn. För att skapa en tom ordbok, anrop helt enkelt den här funktionen utan några argument: empty_dict = dict() .

För att skapa en ordbok med dict() -konstruktorn kan du använda följande syntax:

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

Denna metod skapar också en Python-ordbok med tre nyckel-värdeelement. Observera att, till skillnad från metoden med lockiga parenteser, kräver dict() -konstruktorn inte citattecken runt nycklarna.

Men ordboksvärdena kräver fortfarande citattecken runt dem

Nu när du är bekant med två sätt att skapa Python-ordböcker kan du börja implementera dem i din kod och utnyttja deras kraftfulla funktioner i dina applikationer.

Hur man får åtkomst till ordbokselement

I det här avsnittet kommer du att lära dig om olika sätt att komma åt element i en ordbok. Ordböcker lagrar data i nyckel-värdepar, och du kan komma åt varje ordboksvärde med deras respektive nycklar.

Vi kommer att täcka två populära metoder: Använda nycklar och get -metoden.

Använda nycklar

Ett av de enklaste sätten att komma åt ordbokselement är att använda tangenterna. För att få värdet på en viss ordboksnyckel, sätt helt enkelt nyckeln inom hakparenteser bredvid ordboksnamnet:

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

phone_value = mydict['phone-number']

I det här exemplet skulle namn_värde lagra strängen 'John' . Observera att om du försöker komma åt en icke-existerande nyckel, kommer Python att skapa ett KeyError .

Använder Get Method

Ett alternativ till att använda nycklar direkt är metoden get() , som låter dig komma åt ordbokselement utan risk att skapa ett KeyError. Istället returnerar get -metoden ett standardvärde om den angivna nyckeln inte hittas:

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

I det här exemplet skulle namn_värde lagra strängen " John " som tidigare eftersom nyckeln " namn " finns i ordboken. Country_value kommer dock att lagra standardvärdet ' Key not found ' eftersom ' country '-nyckeln inte finns i ordboken.

Get () -metoden ger ett mer flexibelt sätt att komma åt ordbokselement, eftersom den låter dig hantera saknade nycklar på ett elegant sätt. Du kan välja att använda båda metoderna beroende på dina krav och möjligheten att stöta på obefintliga nycklar.

Hur man ändrar ordbokselement

I det här avsnittet kommer du att lära dig hur du ändrar element i en Python-ordbok. Det finns två primära operationer för att åstadkomma detta: lägga till nya element och uppdatera befintliga.

Båda dessa metoder hjälper dig att bibehålla noggrannheten och användbarheten i din ordbok. Låt oss titta på dem:

1. Lägga till nya element

Det är enkelt att lägga till ett nytt element i en ordbok. För att göra det, ange det nya nyckel-värdeparet med hjälp av en tilldelningsoperator, så här:

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

Efter att ha kört ovanstående kodavsnitt kommer din ordbok nu att inkludera det nya paret:

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

Du kan också lägga till flera nyckel-värdepar samtidigt genom att använda ordbokens update() -metod

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

Nu kommer din ordbok att innehålla följande poster:

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

1. Uppdatering av befintliga element

För att uppdatera värdet på ett befintligt element behöver du bara referera till nyckeln och tilldela ett nytt värde till den:

your_dict["key1"] = "updated_value1"

Denna ändring kommer att resultera i följande ordbok:

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

Om du behöver uppdatera flera element samtidigt, använd metoden update() igen. För att använda den, skicka in en ny ordbok som innehåller de önskade ändringarna.

Låt oss till exempel uppdatera your_dict-ordboken med värdena från uppdateringsordboken:

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

Med dessa uppdateringar tillämpade kommer your_dict-ordboken att se ut så här:

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

Dessa operationer är viktiga verktyg när du arbetar eftersom de tillåter dig att hålla dina datastrukturer uppdaterade och korrekta.

Ta bort ordbokselement

I det här avsnittet kommer vi att utforska två vanliga sätt att ta bort ordbokselement i Python: nyckelordet del och metoden clear() .

1. Del nyckelord

Nyckelordet del används för att ta bort ett specifikt nyckel-värdepar från en ordbok. Den fungerar på plats och skapar ett KeyError om nyckeln inte finns i ordboken. För att ta bort ett element, använd helt enkelt följande syntax:

del my_dict[key]

Om du till exempel vill ta bort en nyckel som heter " brand " från en ordbok med namnet my_dict, kommer du att skriva:

del my_dict["brand"]

Tänk på att det är bra att se till att nyckeln finns i ordboken innan du använder nyckelordet del. Du kan göra detta genom att kontrollera om nyckeln finns i ordboken:

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

1. Tydlig metod

Metoden clear() är ett annat sätt att ta bort ordbokselement. Denna metod tar bort alla ordboksnycklar och värden i en operation, vilket resulterar i en tom ordbok.

För att använda metoden clear() i din ordbok, ring den helt enkelt. Till exempel, om du har en befintlig ordbok som heter my_dict och du vill ta bort allt innehåll i den, skulle du skriva:

my_dict.clear()

Sammanfattningsvis har du lärt dig två metoder för att ta bort element från en Python-ordbok: nyckelordet del för att ta bort individuella nyckel-värdepar och metoden clear() för att tömma en hel ordbok.

Vilka är några vanliga ordboksmetoder?

I det här avsnittet kommer vi att utforska några vanliga Python-ordbokmetoder. Dessa inbyggda metoder hjälper dig att manipulera och modifiera ordböcker så att de passar dina behov.

Nycklar

För att hämta alla nycklar från din ordbok kan du använda metoden keys() . Detta kommer att returnera ett vyobjekt som innehåller alla ordbokens nycklar.

Till exempel:

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

Värderingar

På samma sätt låter metoden values() dig få alla värden som är lagrade i ordboken. Detta presenteras också som ett vyobjekt.

Till exempel:

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

Föremål

Om du behöver komma åt både nycklar och värden samtidigt, använd metoden items(). Detta returnerar ett vyobjekt som innehåller nyckel-värdepar i form av tupler.

Låt oss titta på ett exempel:

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

Uppdatering

Metoden update() låter dig ändra din ordbok genom att lägga till eller uppdatera nyckel-värde-element. För att använda metoden måste du tillhandahålla en ordbok som argument.

För att slå samman två ordböcker eller uppdatera specifika nycklar, använd den här metoden:

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

Pop

Med metoden pop() kan du ta bort ett specifikt objekt från ordlistan. För att använda det, ange nyckeln som ska tas bort som ett argument i metoden.

Metoden returnerar värdet som är associerat med den angivna nyckeln och tar bort det från ordboken:

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

Popitem

Metoden popitem () tar bort det sista nyckel-värdeparet i ordboken. Den returnerar en tuppel som innehåller den borttagna nyckeln och värdet. Till exempel:

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

Genom att använda dessa metoder kan du effektivt hantera och manipulera dina ordböcker för att uppnå en mängd olika uppgifter.

Använder Python Dictionaries

I det här avsnittet kommer du att lära dig olika tekniker för att arbeta med ordböcker, som att gå över dem, använda ordboksförståelser och arbeta med kapslade ordböcker.

Slingor över ordböcker

För att gå över en ordbok kan du använda den inbyggda metoden items() för att iterera över nyckel-värdepar. Detta gör att du kan utföra operationer på både nycklar och värden på ett läsbart och effektivt sätt.

Här är ett exempel:

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

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

Alternativt kan du använda metoderna keys() och values() för att iterera över antingen ordboksnycklarna eller exklusivt värden.

Vad är ordboksförståelser?

Ordboksförståelser är ett kortfattat sätt att skapa ordböcker med en enda kodrad. De liknar listförståelser men arbetar med ordböcker istället.

Här är ett exempel på en ordboksförståelse som kvadrerar talen från 1 till 5:

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

Ordboksförståelser kan vara mycket värdefulla för uppgifter som att filtrera ordböcker eller omvandla deras värden.

Vad är kapslade ordböcker?

Kapslade ordböcker är ordböcker som innehåller andra ordböcker som värden. De kan användas för att representera komplexa hierarkiska datastrukturer.

Här är ett exempel på en kapslad ordbok:

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

För att komma åt ett element i en kapslad ordbok, använd multipel indexering:

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

Du kan ytterligare redigera eller manipulera element i de kapslade ordböckerna efter behov. Kom ihåg att hålla reda på nycklar och kapslingsnivåer när du arbetar med komplexa kapslade ordböcker för att undvika förvirring eller fel.

Vanliga användningsfall för ordbok

Python-ordböcker är mångsidiga, vilket gör att du kan organisera och hantera olika datatyper. I det här avsnittet kommer du att utforska några vanliga användningsfall för ordböcker, som kommer att förbättra din förståelse och hjälpa dig att implementera dem effektivt i dina projekt.

1. Lagring av nyckel-värde-data : Ordböcker är idealiska för att lagra data med unika nycklar och tillhörande värden, såsom användarnamn och användarinformation eller produkt-ID:n och produktinformation:

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

Ett exempel på detta kan ses i den här videon om hur man bygger en Google News Aggregator i LuckyTemplates med Python.

https://youtu.be/InsDb_DR15E

I den här videon använder vi en ordbok för att lagra datavärden som hämtats från ett GoogleNews API-anrop.

2. Räkna förekomster : Du kan använda ordböcker för att räkna förekomsten av objekt, till exempel frekvensen av ord i ett dokument. Genom att använda nycklar för att representera de unika objekten och värden för att indikera antalet, kan du effektivt hantera sådan data.

Kul faktum, du kan göra detta med Counter-klassen i Python Collections-modulen. Den tar in en oordnad lista och returnerar en ordlista med varje unikt element som nyckel och deras frekvens som deras respektive värde.

3. Mappa nycklar till flera värden : Om du behöver lagra flera värden för varje ordboksnyckel kan du använda listor eller uppsättningar som värden i din ordbok:

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

4. Cachning av beräknade resultat : Ordböcker kan användas för att cacha resultat av dyra operationer. Detta är särskilt användbart i memoiseringstekniker och dynamisk programmering, där du lagrar resultaten av beräkningar för att undvika redundanta beräkningar.

5. Skapa inverterade index : I fall som sökmotorer kan du kräva ett inverterat index som mappar varje sökterm till en lista med resurser som innehåller termen. Genom att använda ordböcker kan du lagra dessa data effektivt:

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

Det här är bara några exempel för att illustrera kraften och mångsidigheten hos Python-ordböcker. Genom att förstå dessa användningsfall och deras tillämpningar kan du utnyttja ordböckernas fulla potential för att bygga effektiva lösningar för dina programmeringsuppgifter!