melanie_tutorial.py

# test om ipython virker...
print("hello world")

# lav en liste af værdier mellem 1 og 10
list(range(1, 10))

# lav en anonym funktion
min_funktion = lambda x: x + 3

# kald den anonyme funktion
min_funktion(42)

# læg en til alle tal mellem 1 og 10 (dette returnerer en lazy sequence som de i python kalder iterable)
map(lambda x: x + 1, range(1, 10))

# man kan evaluere en lazy sequence ved at kalde list på den
list(map(lambda x: x + 1, range(1, 10))

# brug den anonyme funktion til at addere 3 til alle værdier mellem 1 og 10
list(map(min_funktion, range(1, 10))

# lav alle værdier mellem 1 og 10 om til strings med str funktionen
list(map(str, range(1,10)))
     
# Det kan vises at lazy sequnces virkelig er 'lazy' ved at vi laver vores egen funktion som skriver noget ud før den returnerer
# (OBS: du skal nok trykke enter 2-3 gange når du har copy-pastet den her funktion ind i ipython...)
def min_funktion2(x):
     print("hejhej ", x)
     return x + 17
     
# ... der bliver ikke skrevet noget ud når vi kalder følgende     
map(min_funktion2, range(4))
     
# men hvis vi tvinger vores lazy seq til at blive evalueret, så sker der ting og sager!
list(map(min_funktion2, range(4)))

# man kan nemt lave en string om til en liste...     
list("foobar")

# man kan sortere en liste (eller en lazy seq) med sorted
sorted([4,3,9,0,1,2,2])
     
# man kan sortere strings (og den laver den automatisk om til en liste)
sorted("duisfhuwdsf")     

# man kan sortere en liste af hvadsomhelst ved at angive en funktion til 'key' parametren
sorted([{"foo": 11, "bar": 3}, {"foo": 1, "bar": 99}, {"foo": 9, "bar": 0}], key = lambda x: x["foo"])

# man kan sortere i omvendt rækkefølge ved at give 'True' med til reverse parametren
sorted([{"foo": 11, "bar": 3}, {"foo": 1, "bar": 99}, {"foo": 9, "bar": 0}], key = lambda x: x["foo"], reverse = True)
     
sorted([33, 0, 8, 1, -2], reverse = True)
     
# en tuple er en form for liste af værdier og angives i paranteser     
min_tuple = ("hej", 42)

# du kan tilgå værdier nøjagtigt som i en liste     
min_tuple[0]
      
min_tuple[1]     

# du kan lave en dictionary fra en liste af tuples     
dict([("a", 2), ("b", 3), ("d", 0)])
     
# du kan lave en dictionary om til en liste af tuples ved at kalde
list(dict.items({'a': 2, 'b': 3, 'd': 0}))

# itertools biblioteket har en funktion som hedder groupby...
# den gør præcist som det den hedder, -eg den grupperer værdier...     
from itertools import groupby

# men hvis vi bare kalder den direkte, så returnerer den bare et lazy object     
groupby("ijwiojdwjwdddd")

# hvis vi kalder list funktionen på den kan vi se hvad den rent faktisk gør     
list(groupby("ijwiojdwjwdddjjd"))
     
# Pythons groupby kræver at den liste som man giver den, er sorteret i forvejen.
list(groupby(sorted("ijwiojdwjwdddjjd")))
# Nu er det nemmere at se at den laver 'noget med at gruppere'(den har givet os en liste af tuples)...     

# men 2'ndet element i tuplen er lidt sær...
# det kan vi råde bod på ved at kalde list funktionen på 2'ndet elementet
fix_tuple = lambda x: (x[0], list(x[1]))
list(map(fix_tuple, groupby(sorted("ijwiojdwjwdddjjd"))))
      
# nu kan vi lave den om til en dictionary, -hvis det er det som vi har lyst til...
dict(list(map(fix_tuple, groupby(sorted("ijwiojdwjwdddjjd")))))
     
# ... men lister er sjovere :)... så lad os sortere den efter hvor mange elementer der er i hver gruppe
# til dette kan vi bruge funktionen 'len' som returnerer længden af en liste
sorted(list(map(fix_tuple, groupby(sorted("ijwiojdwjwdddjjd")))), key = lambda x: len(x[1]))
     
# vi kan også bare map'e hen over den og tælle hver liste
list(map(lambda x: (x[0], len(x[1])), map(fix_tuple, groupby(sorted("ijwiojdwjwdddjjd")))))
     
# lad os lave en funktion ud af det så vi kan bruge den igen og igen og igen :)
def custom_groupby(data):
     grouped_data = map(fix_tuple, groupby(sorted(data)))
     return map(lambda x: (x[0], len(x[1])), grouped_data)
     
# hvis vi f.eks. ønsker at se alle værdier som der er mere end 4 af, kan vi bruge filter funktionen
list(filter(lambda x: x[1] > 4, custom_groupby("uiwjfuwjidjwiqjdoiwjuifewuwfffff")))