Dictionary
Dictionary översätts till ordbok eller lexikon på svenska, vilket ger en hint om hur det fungerar.
{ key : value }
Så vi har att göra med key : value -par, där key är nyckeln (uppslagsordet) för att få ut vårt value ("översättningen") så att säga.
ord = {"bil":"car", "buss" : "bus", "cykel" : "bike"}
print(ord)
För att komma åt ett av orden i vår dictionary kan vi göra såhär ...
ord = {"bil":"car", "buss" : "bus", "cykel" : "bike"}
print(ord["bil"])
print(ord["cykel"])
Vill du ändra på ett värde i en dictionary, så kan du göra det med samma åtkomstmetod.
ord = {"bil":"car", "buss" : "bus", "cykel" : "bike"}
ord["cykel"] = "bicycle"
print(ord["bil"])
print(ord["cykel"])
Du kan lägga till värde i en dictionary som inte tidigare fanns genom att bara ange det.
ord = {"bil":"car", "buss" : "bus", "cykel" : "bike"}
ord["eld"] = "fire"
ord["favoritmusik"] = "kpop"
for o in ord:
print(o, "=", ord[o])
Observera att om nyckeln redan finns så händer ingenting, det är först om den inte finns som den läggs till. Om den finns och value är annorlunda så ändras value.
get()
Vi kan också använda metoden get() för att hämta ett value. Vad är poängen med det?ord = {"bil":"car", "buss" : "bus", "cykel" : "bike"}
print(ord.get("bil"))
print(ord.get("cykel"))
get() ger None om key saknas
Poängen med get() är att vi får svaret None om det vi söker efter inte finns. Öppna editorn och prova att komma åt ett värde som inte finns t.ex. ord["cyckel"]. Det som händer är att vi får ett felmeddelande ifall vi använder [ ... ]. Med get() får vi None om ett värde saknas.
ord = {"bil":"car", "buss" : "bus", "cykel" : "bike"}
def hitta(ordet):
o = ord.get(ordet)
if(o!=None):
print(o)
else:
print(ordet,"finns inte")
hitta("cyckel")
get() med default -värde
Det finns ytterligare en finess med get() och det är att det kan ges ett extra argument. Ett default -svar om det du vill slå upp inte finns. Så vi kan skriva såhär:
ord = {"bil":"car", "buss" : "bus", "cykel" : "bike"}
def hitta(ordet):
o = ord.get(ordet, "ordet finns ej i dicten")
print(o)
hitta("cyckel")
Om du läst på ordentligt, fram till slutet, i avsnittet strängar, så vet du att vi kan använda format för att få mänskligare formaterade strängar.
ord = {"bil":"car", "buss" : "bus", "cykel" : "bike"}
def hitta(ordet):
o = ord.get(ordet, "ordet {0} finns ej i dicten".format(ordet))
print(o)
hitta("cyckel")
hitta("cykel")
key kan vara en siffra
En dictionary kan arbeta med tal också. Om key är en siffra, då behövs inga citat-tecken runt den.
siffra_till_text = {0 : "noll", 1 : "ett", 2 : "två", 3: "tre" }
print(siffra_till_text[0])
print(siffra_till_text[1])
print(siffra_till_text[2])
Det ser ut som vi adresserar en lista, men det gör vi inte. Titta nedan, nu är det inte lika likt längre.
siffra_till_text = {10 : "noll", 1 : "ett", 20 : "två", 30: "tre" }
print(siffra_till_text[10])
print(siffra_till_text[20])
print(siffra_till_text[30])
Vi kan också tvärtom låta valute vara ett tal, då behövs inga citat där heller.
siffra_till_text = {"noll" : 0 , "ett" : 1 , "två": 2 }
print(siffra_till_text["noll"])
print(siffra_till_text["ett"])
print(siffra_till_text["två"])
Så vi kan skapa en översättningstabell
siffra_till_siffra= {10 : 2 , 5 : 1 , 7 : 32 }
print(siffra_till_siffra[10])
print(siffra_till_siffra[5])
print(siffra_till_siffra[7])
update()
Med update kan du uppdatera en dictionary. Om det du vill uppdatera saknas, så skapas det.
ord = {"bil":"car", "cykel" : "bicykle"}
ord.update({"cykel" : "bike"})
print(ord)
Med update kan du skapa en dictionary från ingenting.
ord = {}
ord.update({"bil" : "car"})
ord.update({"cykel" : "bike"})
print(ord)
Observera att du kan lägga till element på samma sätt som du kan ändra i ett element, med den vanliga åtkomstmetoden.
ord = {}
ord.update({"bil" : "car"})
ord.update({"cykel" : "bike"})
print(ord)
ord["bil"] = "Hacker was here!"
print(ord)
ord["ingenting"] = "någonting"
print(ord)
Så, vad är då poängen med update(), frågar du dig. Med get(key) fanns ju finessen att den gav ifrån sig None ifall key saknades.
Poängen med update är att du kan uppdatera med en hel dictionary, du kan kasta in en dictionary som argument.
Poängen med update är att du kan uppdatera med en hel dictionary, du kan kasta in en dictionary som argument.
 |
+ |  |
= |  |
ord = {"bord":"table","eld":"fire"}
ord2 = {"spel":"game","säng":"bed"}
ord.update(ord2)
print(ord)
Du kan använda vilket argument som helst till update som ger ifrån sig ett par av värden, tuples, generator, osv och du kan använda funktionen update som den funktion den är, dvs som argument till andra funktioner som tar funktioner som argument. OBS grotta inte ner dig i detta just nu. Lär dig bara att update är mer flexibel. Bland annat kan du som ovan visat addera en hel dictionary till en annan.
ord = {"bord":"table","eld":"fire"}
ord2 = {"spel":"game","säng":"bed"}
ord.update(ord2)
print(ord)
ord.update([('stol', 'chair'), ('däck', 'tire')])
print(ord)
ord.update([(str(x),str(x)) for x in range(5)])
ord.update(key="hej",value="hello")
print(ord)
def min_uppdatera(fun):
x = ("kallekula","pellejöns")
fun([x])
min_uppdatera(ord.update)
print(ord)
key : whatever
Value kan vara lista, dictionary eller vad som helst. Säg att för value, så vill vi kunna lista flera alternativ.
ord = {"bil":["car"], "buss":["bus"], "cykel":["bike","bicykle"]}
def hitta(ordet):
o = ord.get(ordet, "ordet {0} finns ej i dicten".format(ordet))
print(o)
hitta("bil")
hitta("cykel")
För att se vår dictionary lite tydligare, så delar vi upp den på flera rader. Det är okej, så får man göra. Det viktiga är att syntaxen fortfarande är rätt.
ord = {
"bil":["car"],
"buss":["bus"],
"cykel":["bike","bicykle"]
}
def hitta(ordet):
o = ord.get(ordet, "ordet {0} finns ej i dicten".format(ordet))
print(o)
hitta("bil")
hitta("cykel")
key : dictionary
Säg att vi till value vill koppla en dictionary som dels ger översättningen och dels berättar hur många hjul fordonet har. Titta nu noga vad vi gjort här, så att du är med på det. Att förstå detta är ett mycket stort steg i att förstå dictionaries och möjligheterna. Value är nu en egen dictionary med key : value -par. Eller hur?ord = {
"bil":{"engelska":["car"],"hjul":4},
"buss":{"engelska":["bus"],"hjul":6},
"cykel":{"engelska":["bike","bicykle"],"hjul":2}
}
def hitta(ordet):
o = ord.get(ordet, "ordet {0} finns ej i dicten".format(ordet))
print(o)
hitta("bil")
hitta("cykel")
För att slippa få hela dictionaryn som svar på en viss key, så kan vi vara mer exakta.
ord = {
"bil":{"engelska":["car"],"hjul":4},
"buss":{"engelska":["bus"],"hjul":6},
"cykel":{"engelska":["bike","bicykle"],"hjul":2}
}
print(ord["bil"]["engelska"])
print(ord["cykel"]["hjul"])
print(ord["cykel"]["engelska"])
Ett exempel till där vi letar oss djupare i value ...
authors = {
"William Shakespeare":{"sales":2000000000,"books":42},
"J. K. Rowling":{"sales":2000000000,"books":22},
"Stephen King":{"sales":300000000,"books":77},
"Astrid Lindgren":{"sales":100000000,"books":100}
}
for author in authors:
print(author, "Böcker",authors[author]["books"],"st")
print("\nFörfattat över 50 Böcker:")
for author in authors:
if(authors[author]["books"]>50):
print(author, authors[author]["books"],"st")
listor och dictionary kan nästlas
Vi kan alltså mixa listor med dictionaries. Vi sammanfattar lite! En dictionary i sin minimala form nedan.dictionary = {"x":4, "y":3}
print(dictionary["x"])
print(dictionary["y"])
print(dictionary)
En lista av dictionary nedan. Vi delar upp den på fler rader, så att det skall se snyggt ut. Det viktiga notera här, det är att du ser att det finns en lista av dictionaries. En väldigt liten lista, bara 2 fack. Men det är en lista!
Du ser hakparenterna [ ... ], vilket betyder att det är en lista, du ser att i listan är posterna skilda åt med kommatecken [{},{}] och inuti { ... } har vi våra dictionaries. Dvs, du har en lista av dictionaries.
Listor, där kommer vi åt enskilda element med dessa index (första är 0).
| 0 | 1 |
| {"x":4, "y":3} | {"x":7, "y":6} |
Du ser hakparenterna [ ... ], vilket betyder att det är en lista, du ser att i listan är posterna skilda åt med kommatecken [{},{}] och inuti { ... } har vi våra dictionaries. Dvs, du har en lista av dictionaries.
Listor, där kommer vi åt enskilda element med dessa index (första är 0).
lista_av_dictionary = [
{"x":4, "y":3},
{"x":7, "y":6}
]
print("dict 0=",lista_av_dictionary[0])
print("y-värde i dict 1=",lista_av_dictionary[1]["y"])
faktureringssystem
Du har säkert beställt något på nätet eller sett en utskrift av en beställning någon annan gjort. Om beställningen betalades i förskott, så vad det du tittade på troligtvis ett kvitto. Men det finns beställningar man gör, där man betalar efteråt. Elräkning, hyra, prenumerationer, teleräkning. Det kallas allmänt för faktura. En faktura innehåller dels kundens namn (mottagaren) och dels det som köpts, ifall det är produkter. Men det som köpts kan även vara konsulttimmar (rådgivning) eller vad som helst. Med ifylld exempeldata så ser det kanske ut som nedan, i stort korrekt, men lite förenklat för detta exempel.
Lagret finns från början. Där ligger sådant som man kan vilja ha på fakturan, dvs sälja eller få ersättning för.
Skapandet av fakturan går sedan till såhär...
lager = []
artiklar = []
faktura = []
kunder = []
# Lager är skapat sedan tidigare i företaget
lager+=[{"nr":"100", "beskr":"Konsultarvode ","apris":1500}]
lager+=[{"nr":"201", "beskr":"Licens mjukvara ","apris":1200}]
lager+=[{"nr":"599","beskr":"Utlägg för resa ","apris":2300}]
# Kunden skapas om kunden inte finns sedan tidigare
kunder +=[{"nr":1,"namn":"Per Andersson","stad":"Göteborg"}]
# Här skapar vi fakturan
artiklar+=[{"nr":"100", "ant":12}]
artiklar+=[{"nr":"201", "ant":1}]
artiklar+=[{"nr":"599", "ant":1}]
faktura +=[{"nr":1,"datum":"241025",
"kund":kunder[0],
"artiklar":artiklar}]
def artikel(nr):
for a in lager:
if(a["nr"]==nr):
return a
def summera_faktura(f):
summa_ex_moms = 0
for rad in f["artiklar"]:
art = artikel(rad["nr"])
# Här skapas "beskr" och "apris" med info från lagret
rad["beskr"]=art["beskr"]
rad["apris"]=art["apris"]
# OBS att här skapas "radtotal" första gången
rad["radtotal"] = rad["ant"]*rad["apris"]
summa_ex_moms += rad["radtotal"]
# OBS att här skapas "summa_ex_moms" första gången
f["summa_ex_moms"]=summa_ex_moms
# OBS att här skapas "moms" första gången
f["moms"]=summa_ex_moms*0.25
# OBS att här skapas "attbetala" första gången
f["attbetala"]=f["summa_ex_moms"]+f["moms"]
def print_faktura(f):
print("Fakturanummer"+" "*27+"Datum")
print("{: <6} {: >6}".format(f["nr"],f["datum"]))
print()
print("Kund {: >24}".format(f["kund"]["namn"]))
print("Stad {: >24}".format(f["kund"]["stad"]))
print("Kundnummer {: >18}".format(f["kund"]["nr"]))
print()
print("Art Beskrivning Antal aPris Subtotal")
print("---------------------------------------------")
for arad in f["artiklar"]:
print("{: <3} {: <16}{: >3}{: >9.2f}{: >10.2f} kr".format(
arad["nr"], arad["beskr"],arad["ant"],arad["apris"],arad["radtotal"]))
print(" "*35+"----------")
print(" "*27+"Summa {: >9.2f} kr".format(f["summa_ex_moms"]))
print(" "*28+"Moms {: >9.2f} kr".format(f["moms"]))
print(" "*22+"Att Betala {: >9.2f} kr".format(f["attbetala"]))
print()
summera_faktura(faktura[0])
print_faktura(faktura[0])
När fakturan summeras av summera_faktura(), så skapas av bekvämlighet och utskrift radtotal, dessutom summa_ex_moms, moms och attbetala och det andra. Det ser sedan ut som nedan.
Poängen med ovan exempel är främst att visa hur dictionaries kan användas och tillsammans kan bygga upp något. I verkligheten är förstås ett faktureringssystem en smula mer avancerat.
Poängen med ovan exempel är främst att visa hur dictionaries kan användas och tillsammans kan bygga upp något. I verkligheten är förstås ett faktureringssystem en smula mer avancerat.
items()
Låt oss avslutningsvis prata pyttelite om items(). Så det är en metod som ger ifrån sig key : value -paren som en lista av tupler (key, value) vilket är käckt om vi vill loopa över dictionaryn och behöver enkel tillgång till både key och value.ord = {"bil":"car", "buss" : "bus", "cykel" : "bike"}
for key, value in ord.items():
print(key,value)
Kom du ihåg update? Update kunde uppdatera en dictionary med en lista av key:value -tupler. När vi ändå är på gång med items, låt oss testa om det fungerar!
ord = {"bil":"car", "buss" : "bus", "cykel" : "bike"}
ordlist = []
ord2 = {}
for key, value in ord.items():
ordlist.append((key,value))
print(key,value)
print()
print(ordlist)
print()
ord2.update(ordlist)
print(ord2)
inbyggda dictionary -funktioner
Klicka för mer exempel hur dessa dictionary -funktioner fungerar.| clear(it) | Tar bort alla element |
| copy(it) | Skapar en kopia |
| fromkeys(it) | Skapar dictionary med önskvärda keys |
| keys(it) | Returnerar alla keys |
| get(it) | Ger värde på value |
| items(it) | Alla key:value -par |
| setdefault(it) | Sätter värde på key |
| values(it) | Ger alla values |
| update(it) | Uppdaterar dict med data |
| dict(**arg)) | Skapar en dictionary |
importera JSON -fil
Det är väldigt vanligt i riktiga program att man importerar data till en dictionary från en JSON -fil. JSON är i princip ett format som är en kopia av hur en dictionary ser ut i python. Nästan.Läs om hur du importerar från JSON-fil till dictionary med exempel.
Lite frågor
Vad är skillnaden mellan ord["buss"] och ord.get("buss")
ord.get("buss") ger ifrån sig None om value saknas
get är föråldrat och ord["buss"] modernare
ord = {}
ord.update({"bil" : "car"})
ord.update({"cykel" : "bike"})
ord["bil2"] = "Hacker was here!"
ord.update({"bil3":"Hacker was here"})
print(ord)
Vad är skillnaden med att använda update vid uppdatering av en dict ?
I ovan exempel, ingen skillnad. Men update kan uppdatera en dict med en annan dict, uppdatera med en lista av (key, value) -tupler, ta generator-data eller kan fungera som argument till en funktion.
update är krångligare
Om vi tittar på key : value, kan value vara en dictionary?
Ja
Nej
Om vi tittar på key : value, kan value vara en lista?
Studera följande exempel ...
Ja
Nej
d = {
"elever" : [
{
"namn" : "Eliza",
"alder" : 31,
"stad" : "Göteborg",
"tele": [
{
"type": "mobil",
"nummer": "07070655"
},
{
"type": "mobil",
"nummer": "031-101010"
}
]
},
{
"namn" : "Marion",
"alder" : 55,
"stad" : "Göteborg",
"husdjur" : [ "Maxwell", "Hertz", "Faraday"]
},
{
"namn" : "Olle",
"alder" : 22,
"stad" : "Göteborg"
}
]
}
Hur printar du ut Marion's alla husdjur? Om du måste fuska genom att prova kod ovan, så gör det.
d["elever"]["Marion"]["husdjur"]
d["elever"][1]["husdjur"]
d["elever"]["Marion"][0]
Hur printar du ut Eliza's första telefonnummer?
d["elever"][0]["tele"][0]["mobil"]
d["elever"]["Eliza"]["tele"]["nummer"]
d["elever"][0]["tele"][0]["nummer"]
d = {"sten":"hårt", "vatten":"blött"}
Om du vill skriva ut value för vatten ovan, hur gör du?
print(d)
print(d["vatten"])
d = {"lärare":[
{"namn":"Kalle","ämne":"Matte"},
{"namn":"Lisa","ämne":"Fysik"}]}
Om du vill skriva ut kalle ovan, hur gör du?
print(d["lärare"]["namn"])
print(d["lärare"][0]["namn"])
print(d["lärare"]["Kalle"])
d = {"lärare":[
{"namn":"Kalle","ämne":"Matte"},
{"namn":"Lisa","ämne":"Fysik"}]}
Om du vill skriva ut Fysik ovan, hur gör du?
print(d["lärare"]["ämne"])
print(d["lärare"]["Fysik"])
print(d["lärare"][1]["ämne"])
d = {"lärare":[
{"namn":"Kalle","ämne":"Matte"},
{"namn":"Lisa","ämne":"Fysik"}]}
print(e)