Uppgifter liknar de som ni gjort i Pythonuppgifter 1-3
Kommunikation (chat) med Johan samt inlämning sker via tenta-klient
for
-loop eller while
-loop?¶for
-loopar är bra på att iterera genom sekvenser utan att vi behöver ta hand om en massa logistik.for value in values:
if value == 42:
print("I found the answer!")
for
-loop, dvs i
är onödig i koden nedan.i = 0
for value in values:
if value == 42:
print("I found the answer!")
i += 1
for
-loop eller while
-loop?¶import random
# while-loopar är bra om man vill fortsätta loopa under vissa
# förutsättningar - villkor
hemligt_ord = random.choice(["apelsin", "banan", "citron"])
gissat_ord = None
antal_försök = 0
while gissat_ord != hemligt_ord:
if gissat_ord != None:
print("Fel!")
gissat_ord = input("Gissa vilket ord jag tänker på: ")
antal_försök += 1
print("Rätt! Det tog " + str(antal_försök) + " försök.")
Gissa vilket ord jag tänker på: apelsin Fel! Gissa vilket ord jag tänker på: banan Fel! Gissa vilket ord jag tänker på: citron Rätt! Det tog 3 försök.
# Funktionen word_exists(words, words) ska returnera True om word finns i
# listan words. Om word inte finns i listan words ska funktionen returnera
# False
def word_exists(word, words):
while word in words:
if word == words:
return True
else:
return False
while <uttryck som ger sanningsvärde>
, dvs uttrycket är word in words
, där in
är pythons medlemsoperator. Om while-loop används för att iterera över en lista behöver man en explicit variabel för index som ökar med 1 varje iteration, samt använda words[index]
för att titta på värdena i listan.for word in words
istället hade for
-loopens variabel word
"skrivit över" funktions-argumentet word
word
kommer aldrig vara lika med words
om word
är ett enskilt värde och words
är
en listaFalse
i loopen - så fort if
-grenen är falsk!# Funktionen word_exists(words, words) ska returnera True om word finns i
# listan words. Om word inte finns i listan words ska funktionen returnera
# False
# FEL. OBS! Nedanstående betyder inte det ni tror att det betyder
# else som hör ihop med for tolkas som "if no break", dvs kommer köras om
# ingen break inträffar i loopen.
def word_exists1(word, words):
for trg_word in words:
if word == trg_word:
result = True
else:
result = False
return result
# Se längre fram i denna föreläsning om f-stringar
print(f"{word_exists1('a', ['b', 'c', 'd'])=}")
print(f"{word_exists1('a', ['b', 'c', 'a', 'd'])=}")
# Korrekt
def word_exists2(word, words):
for trg_word in words:
if word == trg_word:
return True
return False
print(f"{word_exists2('a', ['b', 'c', 'd'])=}")
print(f"{word_exists2('a', ['b', 'c', 'a', 'd'])=}")
word_exists1('a', ['b', 'c', 'd'])=False word_exists1('a', ['b', 'c', 'a', 'd'])=False word_exists2('a', ['b', 'c', 'd'])=False word_exists2('a', ['b', 'c', 'a', 'd'])=True
# Funktionen word_exists(words, words) ska returnera True om word finns i
# listan words. Om word inte finns i listan words ska funktionen returnera
# False
def word_exists3(word, words):
index = 0
while index < len(words):
if word == words[index]:
return True
index += 1
return False
print(f"{word_exists3('a', ['b', 'c', 'd'])=}")
print(f"{word_exists3('a', ['b', 'c', 'a', 'd'])=}")
word_exists3('a', ['b', 'c', 'd'])=False word_exists3('a', ['b', 'c', 'a', 'd'])=True
math
, random
och os
pycodestyle
och pyflakes
: kontrollera pythonkod för fel och stilbrottrequests
: enklare (att använda) HTTP-requests (kommunikation med webbservrar)beautifulsoup
: paket för hantering av HTML och XML (t.ex. extrahera information från webben)matplotlib
: datavisualiseringSciPy
: databeararbetning, diagram och grafer (statistik, linjär algebra, m.m.)NLTK
: naturligt språkbehandlingDjango
och Flask
: två ramverk för webbutvecklingpip
>
skicka utdata från program (via stdout) till fil>>
skicka utdata från program (via stdout) till slutet på en fil<
skicka innehåll i fil till program via standard input|
skicka utdata från ett program som indata till annat programsort
- sorterar de rader den fåruniq
- tar bort dublettercut
- plocka fram text från t.ex. en viss kolumngrep
- leta efter rader som innehåller specificerad textseq
- skriv ut en sekvens av siffror
Fler exempel: https://developer.ibm.com/articles/au-unixtext/
*
betyder 0 eller fler godtyckliga tecken?
betyder exakt ett godyckligt teckenls *.py
visa alla filer som slutar på .py
cp data/*.csv csvfiler/
kopiera alla filer vars namn slutar på .csv från katalogen data till katalogen csvfiler
(givet att csvfiler
är en katalog)cat sub1?.json
skriv ut innehållet i alla filer med namn som börjar på sub1
följt av ett godtyckligt tecken följt av .json
chmod u+x filnamn
#!/usr/bin/env python3
#!/bin/bash
sys
sys.argv
är en lista som innehåller allt som skrevs på kommandoraden (mellanslag som skiljetecken)$ ./greetings.py Ada Bertil Caesar
sys.argv
→ ['./greetings.py', 'Ada', 'Bertil', 'Caesar']
f"Jag är en f-sträng"
{}
, som beräknas när strängen skapas.namn = "Guido"
f"Hej {namn}!"
'Hej Guido!'
f"Jag vet att svaret är {21*2}"
'Jag vet att svaret är 42'
Lägg till =
efter ett uttryck inom {}
i en f-sträng, så följer även det icke-beräknade uttrycket med när strängen skapas
Exempel:
my_value = 123
print(f"{my_value=}")
my_value=123
print(f"{40+2=}")
40+2=42
print(f"{my_value/2=}")
my_value/2=61.5
#!/usr/bin/env python3
import sys
print(f"{sys.argv=}")
index = 0
while index < len(sys.argv):
print(f"Argument {index}: {sys.argv[index]}")
index += 1
$ python3 argv_demo.py apelsin banan citron sys.argv=['argv_demo.py', 'apelsin', 'banan', 'citron'] Argument 0: argv_demo.py Argument 1: apelsin Argument 2: banan Argument 3: citron
sys
stdin
:for line in sys.stdin:
print(line)
line
kommer vara en sträng"""
Exempelanvändning som visar alla rader som innehåller ordet glass
# med pipe
$ cat alice.txt | python3 find.py glass
# med omdirigering
$ python3 find.py glass < alice.txt
"""
import sys
# för varje rad som fås via standard input (t.ex. från en pipe)
for line in sys.stdin:
# om raden innehåller första argumentet som pythonprogrammet får
if sys.argv[1].lower() in line.lower():
# skriv ut raden
print(line.strip())
$ cat alice.txt | python3 find.py glass solid glass; there was nothing on it except a tiny golden key, quite plainly through the glass, and she tried her best to climb Soon her eye fell on a little glass box that was lying under again, and the little golden key was lying on the glass table as swim in the pool, and the great hall, with the glass table and glass. There was no label this time with the words `DRINK ME,' and a crash of broken glass, from which she concluded that it was Come and help me out of THIS!' (Sounds of more broken glass.) sounds of broken glass. `What a number of cucumber-frames there little glass table. `Now, I'll manage better this time,'
#!/usr/bin/env python3
import sys
if len(sys.argv) != 2:
print("Ange exakt ett hälsningsord som argument.")
sys.exit(1)
for line in sys.stdin:
line = line.split(";")
print(f"{sys.argv[1]} användare {line[0]} ({line[1]} {line[2]})!")
$ grep "z" people.csv | ./pretty_print.py "Hejsan" Hejsan användare jazsn103 (Jazmine Snyder)! Hejsan användare thife781 (Thiago Fernandez)! Hejsan användare izasa568 (Izaiah Savage)! Hejsan användare loura901 (Louise Ramirez)! Hejsan användare ezrgi707 (Ezra Giles)! $ head people.csv | grep "z" | ./pretty_print.py "Hejsan" Hejsan användare jazsn103 (Jazmine Snyder)! Hejsan användare thife781 (Thiago Fernandez)!
random
, sys
, json
, pickle
import <modulnamn>
<modulnamn>
används som prefix för att komma åt funktionalitet i modulimport <modulnamn> as <alias>
<alias>
används som prefix för att komma åt funktionalitet i modulfrom modulnamn import <namn_på_något_i_modulen>
<namn_på_något_i_modulen>
direkt till den egna namnrymden (inget prefix behövs)from <modulnamn> import *
<modulnamn>
till den egna namnrymden
OBS! En import-sats per modul räcker. Samla alla importer högst upp i er fil.
# funktioner.py
print("Nu laddas funktionerna in.")
def print_twice(message):
message = message.rstrip()
print("1:", message)
print("2:", message)
print("Funktionerna har laddats.")
if __name__ == "__main__":
print("funktioner.py är \"huvudprogram\". __name__:", repr(__name__))
else:
print("funktioner.py laddas in som en modul. __name__:", repr(__name__))
Nu laddas funktionerna in. Funktionerna har laddats. funktioner.py är "huvudprogram". __name__: '__main__'
# program1.py ##################################
# importera innehållet från filen funktioner.py
# lägger sig under modulnamnet funktioner
import funktioner
funktioner.print_twice("hejsan!")
$ python3 program1.py Nu laddas funktionerna in. Funktionerna har laddats. funktioner.py laddas in som en modul. __name__: 'funktioner' 1: hejsan! 2: hejsan!
# program2.py ##################################
# importera innehållet från filen funktioner.py
# lägger sig under modulnamnet f
import funktioner as f
f.print_twice("hejsan!")
$ python3 program2.py Nu laddas funktionerna in. Funktionerna har laddats. funktioner.py laddas in som en modul. __name__: 'funktioner' 1: hejsan! 2: hejsan!
# program3.py ##################################
# importera innehållet från filen funktioner.py
# lägger sig i den nuvarande namnrymnden
from funktioner import *
print_twice("hejsan!")
$ python3 program3.py Nu laddas funktionerna in. Funktionerna har laddats. funktioner.py laddas in som en modul. __name__: 'funktioner' 1: hejsan! 2: hejsan!
__name__
innehåller en sträng med den namnrymd (namespace) som gäller.__name__ == "__main__"
# funktioner.py
print("Nu laddas funktionerna in.")
def print_twice(message):
message = message.rstrip()
print("1:", message)
print("2:", message)
print("Funktionerna har laddats.")
if __name__ == "__main__":
print("funktioner.py är \"huvudprogram\". __name__:", repr(__name__))
else:
print("funktioner.py laddas in som en modul. __name__:", repr(__name__))
Nu laddas funktionerna in. Funktionerna har laddats. funktioner.py är "huvudprogram". __name__: '__main__'
from min_modul import *
min_modul
innehåller t.ex. en funktion som heter print
så kommer vi inte längre åt den vanliga print
-funktionenimport min_modul
, och sedan gör ändringar i min_modul
, så kan vi inte få tillgång till dessa ändringar i en pågående Python-session (t.ex. när vi kör i interactive mode) genom att köra import min_modul
igen.reload
från den inbyggda modulen importlib
global
global
my_variable = "spam"
print(f"Before calling my_function: {my_variable=}")
def my_function():
print(f"Inside my_function: {my_variable=}")
my_function()
print(f"After calling my_function: {my_variable=}")
Before calling my_function: my_variable='spam' Inside my_function: my_variable='spam' After calling my_function: my_variable='spam'
my_variable = "spam"
print(f"Before calling my_function: {my_variable=}")
def my_function():
my_variable = "eggs"
print(f"Inside my_function: {my_variable=}")
my_function()
print(f"After calling my_function: {my_variable=}")
Before calling my_function: my_variable='spam' Inside my_function: my_variable='eggs' After calling my_function: my_variable='spam'
my_variable = "spam"
print(f"Before calling my_function: {my_variable=}")
def my_function():
global my_variable
my_variable = "eggs"
print(f"Inside my_function: {my_variable=}")
my_function()
print(f"After calling my_function: {my_variable=}")
Before calling my_function: my_variable='spam' Inside my_function: my_variable='eggs' After calling my_function: my_variable='eggs'
[1, 2, 3]
till 5l = [1, 2, 3] # lista
l[0] = 5
print(l)
[5, 2, 3]
tuple
¶tuple
(sve. tupel) fungerar som en lista, förrutom att man inte kan byta dess element.tuple
i Python är vad vi i diskreta matematiken kallat $n$-tupler, dvs de behöver inte ha specifikt två elementt = (1, 2, 3) # tupel
t[0] = 5
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[26], line 2 1 t = (1, 2, 3) # tupel ----> 2 t[0] = 5 TypeError: 'tuple' object does not support item assignment
l1 = [1, 2, 3]
kan ses som att vi säger "låt etiketten l1
referera till värdet ..."l2 = l1
l1 = [1, 2, 3]
# låt l2 referera till samma värde som l1
l2 = l1
# ändra första elementet i värdet som l1 refererar till
l1[0] = "hoppsan"
# vad kommer vi få för utskrifter?
print(l1)
print(l2)
['hoppsan', 2, 3] ['hoppsan', 2, 3]
frukter_1 = ["apelsin", "banan", "citron"]
frukter_2 = frukter_1
frukter_3 = ["druva"]
print(f"* start:\n {frukter_1=},\n {frukter_2=},\n {frukter_3=}")
* start: frukter_1=['apelsin', 'banan', 'citron'], frukter_2=['apelsin', 'banan', 'citron'], frukter_3=['druva']
# .append() -> lägg till existerande lista
frukter_1.append("fikon")
print(f'* efter frukter_1.append("fikon"):')
print(f" {frukter_1=}\n {frukter_2=}")
* efter frukter_1.append("fikon"): frukter_1=['apelsin', 'banan', 'citron', 'fikon'] frukter_2=['apelsin', 'banan', 'citron', 'fikon']
# OBS! Något att se upp för listor fungerar += som .append()
frukter_1 += ["oj"]
print(f'* efter frukter_1 += ["oj"]:')
print(f" {frukter_1=}\n {frukter_2=}")
* efter frukter_1 += ["oj"]: frukter_1=['apelsin', 'banan', 'citron', 'fikon', 'oj'] frukter_2=['apelsin', 'banan', 'citron', 'fikon', 'oj']
# operatorn + skapar en ny lista från operanderna # (om de är listor)
frukter_1 = frukter_1 + frukter_3
print("* efter frukter_1 + frukter_3:")
print(f" {frukter_1=},\n {frukter_2=},\n {frukter_3=}")
* efter frukter_1 + frukter_3: frukter_1=['apelsin', 'banan', 'citron', 'fikon', 'oj', 'druva'], frukter_2=['apelsin', 'banan', 'citron', 'fikon', 'oj'], frukter_3=['druva']
# Varför ändras inte frukter 2 här?
frukter_1 += ["varför"]
print(f'* efter frukter_1 += ["varför"]:')
print(f" {frukter_1=}\n {frukter_2=}")
* efter frukter_1 += ["varför"]: frukter_1=['apelsin', 'banan', 'citron', 'fikon', 'oj', 'druva', 'varför'] frukter_2=['apelsin', 'banan', 'citron', 'fikon', 'oj']
def change_and_return_new_list(a_list):
a_list.append("list was changed")
return [1, 2, 3]
my_list = ["a", "b", "c"]
# låt also_my_list också referera till värdet som my_list refererar till
also_my_list = my_list
# låt my_list referera till det som change_and_return_new_list returnerar
my_list = change_and_return_new_list(my_list)
print(my_list)
print(also_my_list)
[1, 2, 3] ['a', 'b', 'c', 'list was changed']
{}
och består av nycklar och värden:{ nyckel_1:värde1, nyckel_2:värde2, ... , nyckel_n:värde_n }
dictionary1 = {"nyckel 1":"värde 1", 345:"värde 2", (3):54 }
print(dictionary1["nyckel 1"])
värde 1
print(dictionary1[345])
värde 2
print(dictionary1[(3)])
54
Till skillnad från att använda index som är större än längden på listan, så kan man lägga till nya värden i ett dictionary genom att använda en ny nyckel.
dictionary1 = {"nyckel1":"värde 1", 345:"värde 2", (3):54 }
dictionary1["ny nyckel"] = "nytt värde"
dictionary1["böcker"] = ["bok 1", "bok 2", "bok 3"]
print(dictionary1["ny nyckel"])
nytt värde
print(dictionary1["böcker"])
['bok 1', 'bok 2', 'bok 3']
print(dictionary1)
{'nyckel1': 'värde 1', 345: 'värde 2', 3: 54, 'ny nyckel': 'nytt värde', 'böcker': ['bok 1', 'bok 2', 'bok 3']}
Precis som att man kan ange ett index vid tilldelning av ett värde på ett element i en lista, så kan man ange en nyckel vid tilldelning av ett associerat värde i en dictionary.
dictionary1 = {"nyckel1":"värde 1", 345:"värde 2", (3):54 }
print(dictionary1["nyckel1"])
värde 1
dictionary1["nyckel1"] = 1024
print(dictionary1["nyckel1"])
1024
dict.keys()
dict.values()
dict.items()
dict
refererar här till ett värde av typen dictionary, denna notation används även i pythondokumentationendict.keys()
, dict.values()
och dict.items()
returnerar en vy (eng. view) in i dictionary-värdet# syntax
for element in sequence:
# gör saker med element
# ok, men försök att undvika:
for index in range(len(sequence)):
# gör saker med sequence[index]
# felaktigt (ingen användning av for-loopen)
index = 0
for element in sequence:
# gör saker med sequence[index]
index += 1
dict.keys()
, dict.values()
och dict.items()
) följer samma ordning.# loopa genom nycklar, explicit
for key in dictionary1.keys():
print(f"{key=}")
print(f"{dictionary1[key]=}")
key='nyckel1' dictionary1[key]=1024 key=345 dictionary1[key]='värde 2' key=3 dictionary1[key]=54
# loopa genom nycklar, implicit
for key in dictionary1:
print(f"{key=}")
print(f"{dictionary1[key]=}")
key='nyckel1' dictionary1[key]=1024 key=345 dictionary1[key]='värde 2' key=3 dictionary1[key]=54
for value in dictionary1.values():
print(f"{value=}")
value=1024 value='värde 2' value=54
dict.items()
returnerar en vy som kan användas som en lista av tupler med två element per tupel.# loopa genom par av nycklar och värden explicit
for key, value in dictionary1.items():
print(f"{key=}")
print(f"{value=}")
key='nyckel1' value=1024 key=345 value='värde 2' key=3 value=54
# en lista av tupler med två element per tupel kan loopas igenom på samma sätt
list_of_tuples = [("ett", 1), ("två", 2), ("tre", 3)]
for word, number in list_of_tuples:
print(f"{word=}")
print(f"{number=}")
word='ett' number=1 word='två' number=2 word='tre' number=3
list_of_lists = [["Ada Lovelace", 1815], ["Joan Clarke", 1917]]
list_of_dicts = [ { "name": "Ada Lovelace", "birthyear": 1815 }, { "name": "Joan Clarke", "birthyear": 1815 } ]
dict_with_some_list_value = { "name": "ditto", "abilities": ["imposter", "limber"] }
lista1 = [["a", "b", "c"], ["d", "e", "f"]]
# första elementet i lista1
lista1[0]
['a', 'b', 'c']
# första elementet i första elementet i lista1
lista1[0][0]
'a'
# andra elementet i första elementet i lista1
lista1[0][1]
'b'
dict1 = { "frukter": ["a", "b", "c"],
"bilar": ["d", "e", "f"] }
# värdet associerat med nyckeln "frukter"
dict1["frukter"]
['a', 'b', 'c']
# första elementet i listan associerad med nyckeln "frukter"
dict1["frukter"][0]
'a'
# andra elementet i listan associerad med nyckeln "frukter"
dict1["frukter"][1]
'b'
yttre_lista = [ ["a", "b", "c"], ["d", "e", "f", "g"] ]
# om vi för varje inre lista i yttre_lista vill skriva ut den inre listans element?
yttre_index = 0
while yttre_index < len(yttre_lista):
inre_lista = yttre_lista[yttre_index]
# kod som skriver ut varje element i inre_lista
inre_index = 0
while inre_index < len(inre_lista):
print(inre_lista[inre_index])
inre_index += 1
yttre_index += 1
a b c d e f g
yttre_lista = [ ["a", "b", "c"], ["d", "e", "f", "g"] ]
# om vi för varje inre lista i yttre_lista vill skriva ut den inre listans element?
for yttre_element in yttre_lista:
for inre_element in yttre_element:
print(inre_element)
a b c d e f g
pokemons = [ { "name": "bulbasaur", "abilities": ["chlorophyll", "overgrow"] },
{ "name": "squirtle", "abilities": ["rain-dish", "torrent"] } ]
def print_dictionaries(list_of_dictionaries):
# gå igenom listan med dictionaries
for dictionary in list_of_dictionaries:
# gå igenom alla nycklar i aktuellt dictionary
for key in dictionary.keys():
print(f"The key {key} has the value: {dictionary[key]}")
print("pokemons:")
print_dictionaries(pokemons)
pokemons: The key name has the value: bulbasaur The key abilities has the value: ['chlorophyll', 'overgrow'] The key name has the value: squirtle The key abilities has the value: ['rain-dish', 'torrent']
books = [ { "title": "Introduction to Python", "pages": 314 },
{ "title": "Another introduction to Python", "pages": 413 } ]
print("books:")
print_dictionaries(books)
books: The key title has the value: Introduction to Python The key pages has the value: 314 The key title has the value: Another introduction to Python The key pages has the value: 413
def print_dictionaries(list_of_dictionaries):
# gå igenom listan med dictionaries
for dictionary in list_of_dictionaries:
# gå igenom alla nycklar i varje dictionary
for key in dictionary:
# i de fall som värdet för en nyckel är en lista
if type(dictionary[key]) == list:
print(f"Value of key {key} is a list:")
# skriv ut varje värde i listan dictionary[key]
for value in dictionary[key]:
print(f"- {value}")
# när värdet i dictionaryt inte är en lista
else:
print(f"The key {key} has the value: {dictionary[key]}")
print("pokemons:")
print_dictionaries(pokemons)
print("\nbooks:")
print_dictionaries(books)
pokemons: The key name has the value: bulbasaur Value of key abilities is a list: - chlorophyll - overgrow The key name has the value: squirtle Value of key abilities is a list: - rain-dish - torrent books: The key title has the value: Introduction to Python The key pages has the value: 314 The key title has the value: Another introduction to Python The key pages has the value: 413
blandad_lista = [ "a", ["b", "c"], "d", "e", ["f", "g"] ]
def look_for_value(needle, haystack):
# bearbeta yttre listan
for value in haystack:
# bearbetning av yttre värden som är listor
if type(value) == list:
for inner_value in value:
if inner_value == needle:
return True
# om yttre värde inte är en lista, kolla om det är det vi letar efter
elif value == needle:
return True
return False
look_for_value("c", blandad_lista)
True
in
¶plus(x, y)
minus(x, y)
funktionen_or(True, False)
funktionen_not(True)
in
och not in
¶in
returnerar True
om värdet är en medlem i behållaren.not in
returnerar True
om värdet inte är en medlem i behållaren.l = [10, "tre", 3.14]
print("tre" in l)
print("fyra" not in l)
True True
wordlist = { "bil" : "car", "fisk": "fish" }
print("fisk" in wordlist)
print("fish" in wordlist)
True False
def skriv_ut_hej(heltal):
print(f"Hej {heltal}")
skriv_ut_hej(heltal + 1)
print("Klar!")
skriv_ut_hej(0)
def skriv_ut_hej(heltal):
if heltal == 10:
print("Klar!")
else:
print(f"Hej {heltal}")
skriv_ut_hej(heltal + 1)
skriv_ut_hej(0)
Hej 0 Hej 1 Hej 2 Hej 3 Hej 4 Hej 5 Hej 6 Hej 7 Hej 8 Hej 9 Klar!
För att lösa ett problem rekursivt, behöver vi formulera eller dela upp det på ett sådant sätt så att delarna är mindre varianter av det större problemet.
Om vi har problemet summera talen 1
, 2
, 75
, 6
och 7
. Att uttrycka det som 1 + 2 + 75 + 6 + 7
är att försöka lösa allt på en gång.
1
+ summan av de resterande talen; 2, 75, 6, 7
2
+ summan av de resterande talen; 75, 6, 7
numbers = [1, 2, 75, 6, 7]
def sum_list_rec(values):
return values[0] + sum_list_rec(values[1:])
result = sum_list_rec(numbers)
print(result)
--------------------------------------------------------------------------- IndexError Traceback (most recent call last) Cell In[71], line 6 3 def sum_list_rec(values): 4 return values[0] + sum_list_rec(values[1:]) ----> 6 result = sum_list_rec(numbers) 7 print(result) Cell In[71], line 4, in sum_list_rec(values) 3 def sum_list_rec(values): ----> 4 return values[0] + sum_list_rec(values[1:]) Cell In[71], line 4, in sum_list_rec(values) 3 def sum_list_rec(values): ----> 4 return values[0] + sum_list_rec(values[1:]) [... skipping similar frames: sum_list_rec at line 4 (3 times)] Cell In[71], line 4, in sum_list_rec(values) 3 def sum_list_rec(values): ----> 4 return values[0] + sum_list_rec(values[1:]) IndexError: list index out of range
values == []
¶numbers = [1, 2, 75, 6, 7]
def sum_list_rec(values):
return values[0] + sum_list_rec(values[1:])
result = sum_list_rec(numbers)
print(result)
--------------------------------------------------------------------------- IndexError Traceback (most recent call last) Cell In[72], line 6 3 def sum_list_rec(values): 4 return values[0] + sum_list_rec(values[1:]) ----> 6 result = sum_list_rec(numbers) 7 print(result) Cell In[72], line 4, in sum_list_rec(values) 3 def sum_list_rec(values): ----> 4 return values[0] + sum_list_rec(values[1:]) Cell In[72], line 4, in sum_list_rec(values) 3 def sum_list_rec(values): ----> 4 return values[0] + sum_list_rec(values[1:]) [... skipping similar frames: sum_list_rec at line 4 (3 times)] Cell In[72], line 4, in sum_list_rec(values) 3 def sum_list_rec(values): ----> 4 return values[0] + sum_list_rec(values[1:]) IndexError: list index out of range
numbers = [1, 2, 75, 6, 7]
def sum_list_rec(values):
# summan av värdena i en tom lista är 0
if not values:
return 0
# summan av värdena i en icke-tom lista är första värdet + summan av
# resten av värdena i listan
return values[0] + sum_list_rec(values[1:])
result = sum_list_rec(numbers)
print(result)
91
def sum_rec(n):
return n + sum_rec(n-1)
print(sum_rec(3))
--------------------------------------------------------------------------- RecursionError Traceback (most recent call last) Cell In[75], line 1 ----> 1 print(sum_rec(3)) Cell In[74], line 2, in sum_rec(n) 1 def sum_rec(n): ----> 2 return n + sum_rec(n-1) Cell In[74], line 2, in sum_rec(n) 1 def sum_rec(n): ----> 2 return n + sum_rec(n-1) [... skipping similar frames: sum_rec at line 2 (2971 times)] Cell In[74], line 2, in sum_rec(n) 1 def sum_rec(n): ----> 2 return n + sum_rec(n-1) RecursionError: maximum recursion depth exceeded
def sum_rec(n):
return n + sum_rec(n-1)
def sum_rec(n):
if n == 0:
return 0
return n + sum_rec(n-1)
print(sum_rec(100))
5050
return
-satser returnerar värde av samma datatypnumbers = [1, 2, 75, 6, 7, 75, 6, 7, 75, 6, 7]
def sum_list_rec(values):
# summan av värdena i en tom lista är 0
if not values:
return 0
# summan av värdena i en icke-tom lista är första värdet + summan av
# resten av värdena i listan
return values[0] + sum_list_rec(values[1:])
result = sum_list_rec(numbers)
print(result)
267
numbers = [1, 2, 75, 6, 7, 75, 6, 7, 75, 6, 7]
def look_for_value_rec(value, values):
# Inget värde kan finnas i en tom lista
if not values:
return False
# om första värdet är det värde vi letar efter kan vi sluta leta
elif values[0] == value:
return True
# om inte första värdet var det vi letade efter så returnera
# resultatet av att leta efter värdet i resten av listan
else:
return look_for_value_rec(value, values[1:])
print(f"{look_for_value_rec(314, numbers)=}")
print(f"{look_for_value_rec(7, numbers)=}")
look_for_value_rec(314, numbers)=False look_for_value_rec(7, numbers)=True
mixed_list = ["ett", 2, "sjuttiofem", 6, 7, 75, 6, "sju"]
def keep_strings_rec(values):
# om listan är tom så resultatet en tom lista
if not values:
return []
# om första värdet i listan är en sträng så är resultatet
# en lista med den strängen + alla strängar i resten av values
elif type(values[0]) == str:
return [values[0]] + keep_strings_rec(values[1:])
# om första värdet i listan inte var en sträng så är resultatet
# alla strängar i resten av listan
else:
return keep_strings_rec(values[1:])
print(keep_strings_rec(mixed_list))
['ett', 'sjuttiofem', 'sju']
def keep_strings_good(values):
if not values:
return []
elif type(values[0]) == str:
return [values[0]] + keep_strings_good(values[1:])
else:
return keep_strings_good(values[1:])
answer = []
def keep_strings_bad(values):
if len(values) > 0:
if type(values[0]) == str:
answer.append(values[0])
keep_strings_bad(values[1:])
return answer
# men det funkar ju eller?
print(keep_strings_good(["ett", 2, "sjuttiofem", 6, 7]))
print(keep_strings_bad(["ett", 2, "sjuttiofem", 6, 7]))
['ett', 'sjuttiofem'] ['ett', 'sjuttiofem']
print("Två anrop till keep_strings_good()")
print(keep_strings_good(["ett", 2, "sjuttiofem", 6, 7]))
print(keep_strings_good(["ett", 2, "sjuttiofem", 6, 7]))
print("\nTvå anrop till keep_strings_bad()")
print(keep_strings_bad(["ett", 2, "sjuttiofem", 6, 7]))
print(keep_strings_bad(["ett", 2, "sjuttiofem", 6, 7]))
Två anrop till keep_strings_good() ['ett', 'sjuttiofem'] ['ett', 'sjuttiofem'] Två anrop till keep_strings_bad() ['ett', 'sjuttiofem', 'ett', 'sjuttiofem'] ['ett', 'sjuttiofem', 'ett', 'sjuttiofem', 'ett', 'sjuttiofem']
answer
i funktionen?¶def keep_strings_bad(values):
answer = []
if len(values) > 0:
if type(values[0]) == str:
answer.append(values[0])
keep_strings_bad(values[1:])
return answer
print(keep_strings_bad(["ett", 2, "sjuttiofem", 6, 7]))
['ett']
[ 1, 2, 3]
sum_rec([ 1, 2, 3])
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 1, 2, 3]
sum_rec
anropas med resten av listan som argument:sum_rec([ 2, 3])
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 2, 3]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 2, 3]
sum_rec
anropas med resten av listan som argument:sum_rec([ 3])
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 3]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 3]
sum_rec
anropas med resten av listan som argument:sum_rec([ ])
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ ]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 3]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 3]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 2, 3]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 2, 3]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 2, 3]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:)
[ 1, 2, 3]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 1, 2, 3]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[ 1, 2, 3]
def sum_rec(values):
if not values:
return 0
else:
return values[0] + sum_rec(values[1:])
[1, [2, 3], [ [4, 5], 6 ] ]
def sum_rec_nest(values):
# om vi inte har några värden är summan 0
if not values:
return 0
# om noden inte är ett värde, räkna ut delträdets värde och addera det till
# resten av värdena
elif type(values[0]) == list:
return sum_rec_nest(values[0]) + sum_rec_nest(values[1:])
# noden är ett löv, addera dess värde till resten av värdena i trädet
else:
return values[0] + sum_rec_nest(values[1:])
sum_rec_nest([1, 2, 3])
6
sum_rec_nest([1, [2, 3], [[4, 5], 6]])
21
sum_rec_nest([1, [2, 3], [[4, 5, [6, 7, [8]]], 9]])
45
[1, [2, 3], [ [4, 5], 6 ] ]
sum_rec_nest
anropas på resten av listan:sum_rec_nest([ [2, 3], [ [4, 5], 6 ] ])
[ [2, 3], [ [4, 5], 6 ] ]
[ [2, 3], [ [4, 5], 6 ] ]
sum_rec_nest
anropas på första noden:sum_rec_nest([2, 3])
[2, 3]
[ [2, 3] ]
[ [2, 3] ]
[ [2, 3], [ [4, 5], 6 ] ]
sum_rec_nest
anropas på resten av listan:sum_rec_nest([ [ [4, 5], 6 ] ])
[ [ [4, 5], 6 ] ]
[ [ [4, 5], 6 ] ]
sum_rec_nest
anropas på första noden:sum_rec_nest([ [4, 5], 6 ])
[ [4, 5], 6 ]
[ [4, 5], 6 ]
Problem: Vad är summan av alla löv?
Noden är ett delträd: Beräkna summan av delträdet + summan av resten
sum_rec_nest
anropas på första noden:sum_rec_nest([4, 5])
[4, 5]
[4, 5]
[ [4, 5], 6 ]
Problem: Vad är summan av alla löv?
Summan av första noden är 9: Beräkna 9 + summan av resten
sum_rec_nest
anropas på resten av listan:sum_rec_nest([ 6 ])
→ 6[ [4, 5], 6 ]
[ [ [4, 5], 6 ] ]
[ [2, 3], [ [4, 5], 6 ] ]
[ [2, 3], [ [4, 5], 6 ] ]
[1, [2, 3], [ [4, 5], 6 ] ]
[1, [2, 3], [ [4, 5], 6 ] ]
def look_for_value_rec_all(value, values):
# Inget värde kan finnas i en tom lista
if not values:
return False
# om första värdet inte är en lista, kolla om det är det värde
# vi letar efter, returnera i så fall True
elif values[0] == value:
return True
# om första värdet är en lista, returnera resultatet av att
# leta i både den listan och resten av values
elif type(values[0]) == list:
return (look_for_value_rec_all(value, values[0]) or
look_for_value_rec_all(value, values[1:]))
# om inte första värdet varken var en lista eller det vi letade efter
# returnera resultatet av att leta efter värdet i resten av listan
else:
return look_for_value_rec_all(value, values[1:])
numbers1 = [[1, 2, 75, 6, 7], [75, 6, 7], [75, 6, 7],
[1, 2, 75, 6, 7], [75, 6, 7], [73]]
numbers2 = [[1, 2], 75, 6, 7, [75, 6, 7], 75, 6, 7, [1, 2, 75, 6, 7],
75, 6, 7, 73]
numbers3 = [[1, 2], [75, [6, 7]], [75, [6, 7]], [75, [6, 7]],
[1], 2, [75, [6, [7, [75], 6], 7]], 73, []]
look_for_value_rec_all(7, numbers1)
True
look_for_value_rec_all(73, numbers1)
True
look_for_value_rec_all([73], numbers1)
True
look_for_value_rec_all([73], numbers2)
False
def keep_strings_rec_all(values):
# om listan är tom så resultatet en tom lista
if not values:
return []
# om första värdet i listan är en sträng så är resultatet
# en lista med den strängen + alla strängar i resten av values
elif type(values[0]) == str:
return [values[0]] + keep_strings_rec_all(values[1:])
# om första värdet är en lista är resultatet en lista med listan
# utan några andra datatyper än strängar + bearbetningen av resten
# av listan
elif type(values[0]) == list:
return [keep_strings_rec_all(values[0])] + \
keep_strings_rec_all(values[1:])
# om första värdet i listan inte var en sträng så är resultatet
# alla strängar i resten av listan
else:
return keep_strings_rec_all(values[1:])
print(keep_strings_rec_all(["ett", [2, "sjuttiofem", 6], 7, [[75], [6, ["sju"]]]]))
['ett', ['sjuttiofem'], [[], [['sju']]]]
map1 = {"a": ["b", "c"],
"b": [],
"c": ["d"],
"d": ["a"],
"e": ["b"]}
def get_path(s_node, e_node, a_map, visited):
"""Returnera en lista med vägen från s_node till e_node om sådan finns."""
# är e_node direkt tillgänglig?
if e_node in a_map[s_node]:
return visited + [s_node, e_node]
# kolla om vi kan ta oss till e_node från någon av grannarna till s_node
return get_path_hlp(a_map[s_node], e_node, a_map, visited + [s_node])
def get_path_hlp(s_nodes, e_node, a_map, visited):
"""Returnera den första vägen från en nod i s_nodes till e_node om sådan finns."""
# om s_nodes är tom så kan vi inte ta oss till e_node
if not s_nodes:
return []
# om vi inte redan besökt s_nodes[0]
elif s_nodes[0] not in visited:
# kolla om vi kan ta oss till e_node därifrån eller någon av de övriga
# nodern i s_nodes
path = get_path(s_nodes[0], e_node, a_map, visited)
if path:
return path
else:
return get_path_hlp(s_nodes[1:], e_node, a_map, visited)
# om vi redan besökt s_nodes[0]
else:
# kolla om vi kan ta oss till e_node från någon av de övriga noderna
# i s_nodes
return get_path_hlp(s_nodes[2:], e_node, a_map, visited)
print(get_path('c', 'b', map1, []))
['c', 'd', 'a', 'b']
Ibland är den bästa lösningen att kombinera rekursion med vanliga loop-konstruktioner.
def get_path_with_for(s_node, e_node, a_map, visited):
"""Returnera en lista med vägen från s_node till e_node om sådan finns."""
# är e_node direkt tillgänglig?
if e_node in a_map[s_node]:
return visited + [s_node, e_node]
# kolla om vi kan ta oss till e_node från någon av grannarna till s_node
for next_node in a_map[s_node]:
if next_node not in visited:
path = get_path_with_for(next_node, e_node, a_map, visited + [s_node])
if path:
return path
# om vi kommer hit kunde vi inte hitta någon väg
return []
print(get_path_with_for('c', 'b', map1, []))
['c', 'd', 'a', 'b']
map2 = {"a": ["d"],
"b": ["e", "g"],
"c": ["e", "h"],
"d": ["g"],
"e": ["d"],
"f": ["g", "h"],
"g": [],
"h": ["e", "i"],
"i": ["f"]}
print(get_path_with_for('h', 'g', map2, []))
['h', 'e', 'd', 'g']