Datastrukturer

Lister, tuples og dictionaries hører alle ind under datastrukturer. Disse tre strukturerer dine data.

Lister []

# Lister
# Starter og slutter med []

min_liste = ["bog", "kaffekop", "computer", "lommeregner", "kuglepen"]
print(min_liste) # <- printer listen

# len
print(len(min_liste))

# reverse
min_liste.reverse() # <- omvendt liste
print(min_liste)

# sort
min_liste.sort() # <- sorter efter alfabetisk rækkefølge
print(min_liste)

# append
min_liste.append("banan")
print(min_liste)

# extend
ny_liste = ["blomster", "vaser", "strikketøj"]
min_liste.extend(ny_liste) # ny_liste concatenates min_liste
print(min_liste)

# insert
min_liste.insert(1, "tryllefløjte") # <- Tryllefløjte overtager position 1
print(min_liste)

# remove
min_liste.remove("blomster") # <- fjerner blomster
print(min_liste)

# pop
min_liste.pop() # <- fjerner det sidste element
print(min_liste)

# copy
min_liste.copy()
print(min_liste)

# count
print(min_liste.count("kaffekop")) # tæller antallet af kaffekopper

# index
print(min_liste.index("vaser")) # vaser har det 7. index i min_liste

# clear
min_liste.clear() #<- fjerner listens indhold
print(min_liste)

# loop
min_liste = [1, 2, 4, 16]
for i in min_liste:
    print(i * 2) 

# Adder to lister
liste_1 = [5, 6]
liste_2 = [9, 4]
summen = liste_1 + liste_2

# Find rund i lister
liste_1 = ["w", 8, [5, 76]] # nested liste = [5, 76]
liste[0]
liste[1]
liste[2][0]

Slicing

# Slicing

# Slicing er lidt som at spise pizza. 
# Du skærer din pizza over i dele. Delene kalder vi for et index. Vi starter altid fra 0. 
# Den første skive har derfor index[0] osv. 
# Hvis du skærer din pizza i 4 dele, er dit første stykke placeret i index[0], dit andet stykke i 
# index[1], dit tredje i index[2] og dit fjerde i index[3].

# Hvis du nogensinde bliver i tvivl om, hvor index er i en liste
# kan du fx skrive, liste.index(2) hvis du leder efter index 2 plads

pizza = [1, 2, 3, 4, 5, 6, 7, 8] # pizzaen skæres lige ud i otte dele
pizza # [1, 2, 3, 4, 5, 6, 7, 8]

# For at vise eksemplet med index()-funktionen
pizza.index(2) # 3

# Lad os skære nogle stykker i den
# vi husker at en liste altid starter fra 0.
# Vores første skive hedder altså 0
pizza[0] # 1

# Men hvad nu, hvis vi i stedet vil have den gode ved 4's plads
pizza[3] # 4

# Nogle gange vil vi tage flere stykker hen på vores talekerne.
# Lad os tage de første tre skiver
# Læg mærke til at vi starter fra 0 og slutter indtil index 4
pizza[0:4] # [1, 2, 3, 4]
# Index 4 er altså nummer 5
pizza[4] # 5

# Lad os prøve den anden vej, og starte fra index 4 uden at give instruks om, hvornår den skal stoppe
pizza[4:] # [5, 6, 7, 8] er tilbage

# Når vi ikke skriver noget foran eller bag ved :(kolon) betyder det altså, at Python bare kan tage det som
# enten er foran eller bagi
pizza[:4] # [1, 2, 3, 4]

# Din kammerat vil have tre stykker.
# Han tager derfra, hvor du slap: altså fra index 4.
pizza[4:7] # Her skærer vi fra index 4 til index 7. Vi får [5, 6, 7]

# Hvis vi nu har en ven som altid tager det bedste stykke af pizzaen
# så vil han måske finde et godt stykke midt i det hele.
pizza[5:6] # mmm - han syntes pizzaen på nummer 6 plads så indbydede ud. [6]

# Reverse
# Lad os lige dreje pizzaen en omgang
pizza.reverse()
pizza

# Prøv nu at bruge de andre funktioner, og se hvad de gør ved vores pizza

Tuples ()

# En tuple kan laves på følgende måder
superliga = "Brøndby", "AGF", "FC Nordsjælland"
superliga = ("Brøndby", "AGF", "FC Nordsjælland")
superliga = "Brøndby", "AGF", "FC Nordsjælland",

# Kommaer indikerer tuples
# kommaet indikerer en tuple, så x er altså IKKE en variabel, men en tuple
x = 2,
type(x) # tuple

# isinstance, kan også være nyttigt
isinstance(x, dict) # False
isinstance(x, tuple)# True

# En tuples længde
len(superliga) # 3

# Sæt to tuples sammen
kampe = superliga, (1, 2, 3, 4, 5)
print(kampe)

Tildel værdier

# tildel vaerdier

x = (10, 26, "hej")
#(10, 26, 'hej')
(y, z, v) = x
print(v, z, y)
# hej 26 10

Dictionary {}

# Dictionaries
# Også kaldet en map, består af en key og en value
# en dictionary har {}

bynavne = {"Helsingør" : 3000, "København Ø" : 2100, "Flekkefjord" : 2900}
print(bynavne)

# Keys
print(list(bynavne)) 

# København Ø
print(bynavne["København Ø"])

# Sorted
print(sorted(bynavne))

# True or False
print("Helsingør" in bynavne)

# delete bynavne
del bynavne["Flekkefjord"]
print(bynavne)

# Looper hver key
for key in bynavne:
    print(key)

# Print både key og val
for item in bynavne.items():
    print(item)

Sets {}

Sets bruger vi kun yderst sjældent, og indtil videre har jeg ikke undervist i dem. De er hyppigst brugt inden for dele af den diskrete matematik.

# Sets {}

# Sets bruger vi yderst sjældent i vores programmer.
# Men de findes, og jeg vil derfor forklare lidt om, hvad de gør
# Sets inddeles, som dictionaries, i curly bracket = {}
# Men tag ikke fejl af, at de opfører sig meget forskelligt

A = {1, 2, 3, 4}
type(A)
B = {5}
type(B)
C = {8, 2, 34, 9}

# Union returnere set
union1 = A.union(B) # to set
union2 = A.union(B, C) # tre set
# A = {1, 2, 3, 4}, mens de andre har B = {5} og C = {8, 2, 34, 9}
diff1 = A.intersection(union2) 
 # dermed får vi {5} i dette eksempel
diff2 = B.intersection(union1)

# Et set indeholder kun et enkelt element, 
# så har vi fx 3, 3, 3 findes der altså kun eet 3-tal.
A = {2, 3, 4, 5, 2, 3, 3, 1} # {1, 2, 3, 4, 5}
B = {1, 2, 3, 4, 5} # samme som A
A == B # True

# Vil du se om en variabel indeholder et set:
isinstance(A, set)

Add og discard

x = {1, 2, 3, 4, 5, 6, 7, 8}
x.add("t")
# {1, 2, 3, 4, 5, 6, 7, 8, 't'}
x.discard(3)
# {1, 2, 4, 5, 6, 7, 8, 't'}