[Python] Aantal onduidelijkheden

[flugelisoke]

Er zijn voor mij een aantal onduidelijkheden in de volgende codes:


Probleem 1:

code:

def f(x):
  if x == 0:
    return 0
  return x + f(x-1)

print(f(3))

Als ik door de code heen lees, zie ik het volgende:

Functie F, geven we een waarde van 3 mee, if x == 0, niet van toepassing want x is 3.
return x + f ( x - 1 ), wat ik hier lees: return 3 + F(x-1) F = 3, min 1 is 2.

Dus: 3 + 2 = 5, maar de uitkomst is 6.....

Probleem 2:

code:

dct = {}
lst = ['a','b','c','d']
for i in range(len(lst) -1):
  dct[lst[i]] = ( lst[i], )

for i in sorted(dct.keys()):
  k = dct[i]
  print(k[0])

# What code to insert at line 8 to get as result:
#a
#b
#c

Ik zie niet goed in wat het laatste stuk nu exact inhoudt en doet, waarom als je print k[0] invoert, komt er a, b ,c te staan. 0 lijkt mij namelijk steeds de beginwaarde.

Alsvolgt zie ik het nut niet van de komma achter lst:

code:

for i in range(len(lst) -1):
  dct[lst[i]] = ( lst[i], )

[Boudewijn]

Zoek even op wat recursie is.

[flugelisoke]

Ik zie nu het nut wel van de komma, ze maken er een tuple van. in de dict.

[Wintervacht]

Je mist een stap in je eerste redenering. Hij returned daar f(3(f(2(f1))), ook bij de 2e iteratie pakt hij voor f(2) nog eens de x+f(x-1), dus effectief geeft hij 3+2+1 = 6 terug.

Also:

Boudewijn schreef op zaterdag 14 december 2019 @ 21:34:
Zoek even op wat recursie is.

[flugelisoke]

Wintervacht schreef op zaterdag 14 december 2019 @ 21:57:
Je mist een stap in je eerste redenering. Hij returned daar f(3(f(2(f1))), ook bij de 2e iteratie pakt hij voor f(2) nog eens de x+f(x-1), dus effectief geeft hij 3+2+1 = 6 terug.

Also:

[...]

Ah kijk, hoe kan ik het het beste zien? Zit daar een handigheidje in als je ziet: return x + f ( x - 1 ) ? Want zo te zien pakt hij de eerste x voor de + f steeds niet mee in de iteratie? Want anders krijg je:

3 + 2 .... 3 + 1 .. Bij de 0 ziet hij return 0.. En komt dan weer uit op 7 als dat het geval zou zijn, ik snap alleen nog niet goed waarom hij die eerste x niet meepakt.

[ Voor 16% gewijzigd door flugelisoke op 14-12-2019 22:05 ]

[Daos]

Elke functie-aanroep heeft zijn eigen x.

[NMH]

flugelisoke schreef op zaterdag 14 december 2019 @ 22:04:
[...]


Ah kijk, hoe kan ik het het beste zien? Zit daar een handigheidje in als je ziet: return x + f ( x - 1 ) ? Want zo te zien pakt hij de eerste x voor de + f steeds niet mee in de iteratie? Want anders krijg je:

3 + 2 .... 3 + 1 .. Bij de 0 ziet hij return 0.. En komt dan weer uit op 7 als dat het geval zou zijn, ik snap alleen nog niet goed waarom hij die eerste x niet meepakt.

Ah, recursie. Ik weet nog dat ik het een kleine twintig jaar geleden voor het eerst tegenkwam. Nu triviaal, maar toen moest ik ook even wennen.

Wat hier gebeurt is dat de functie zichzelf steeds opnieuw aanroept, waarbij de parameter bij elke aanroep een verlaagd wordt, tot de functie wordt aangeroepen met 0 als parameter; dan roept hij zichzelf niet meer aan en returned hij direct 0.

Bij deze simpele functie kun je de recursie nog uitschrijven:

code:

f(3) ->
3 + f(2) ->
3 + 2 + f(1) ->
3 + 2 + 1 + f(0) ->
3 + 2 + 1 + 0 ->
6

[flugelisoke]

NMH schreef op zaterdag 14 december 2019 @ 22:25:
[...]

Ah, recursie. Ik weet nog dat ik het een kleine twintig jaar geleden voor het eerst tegenkwam. Nu triviaal, maar toen moest ik ook even wennen.

Wat hier gebeurt is dat de functie zichzelf steeds opnieuw aanroept, waarbij de parameter bij elke aanroep een verlaagd wordt, tot de functie wordt aangeroepen met 0 als parameter; dan roept hij zichzelf niet meer aan en returned hij direct 0.

Bij deze simpele functie kun je de recursie nog uitschrijven:

code:

f(3) ->
3 + f(2) ->
3 + 2 + f(1) ->
3 + 2 + 1 + f(0) ->
3 + 2 + 1 + 0 ->
6

Tnx, dit maakt het inzichtelijk en duidelijk Ik zie dat enkel de f tussen de haakjes wordt aangeroepen en dat de x zijn originele waarde blijft behouden en eigenlijk niet wordt bijgeteld elke keer.

[bwerg]

Je kan het ook omdraaien:

f(0) = 0 is wel duidelijk, hierin heb je geen recursie nodig.
Dus f(1) = 1 + f(0) = 1 + 0 = 1.
En dus is f(2) = 2 + f(1) = 2 + 1 = 3.
En dus is f(3) = 3 + f(2) = 3 + 3 = 6.
Enzovoorts.

Bovenstaande is trouwens helemaal niet specifiek voor python, of zelfs voor programmeren, maar is gewoon wiskunde. Al zijn vergelijkingen in de wiskunde in het algemeen niet hetzelfde als in programmeren: een functie in een programmeertaal kan doorgaans de toestand van je programma veranderen, met de buitenwereld communiceren, etc. Maar als dat niet gebeurt en functies gewoon 'netjes' waarden doorgeven als argumenten en als return-waarden, dan kun je gewoon de regels uit de wiskunde toepassen.

[ Voor 49% gewijzigd door bwerg op 16-12-2019 09:40 ]

[PageFault]

Boudewijn schreef op zaterdag 14 december 2019 @ 21:34:
Zoek even op wat recursie is.

Om uit te leggen wat recursie is, zullen we eerst uit moeten leggen wat recursie is

[Wintervacht]

PageFault schreef op maandag 16 december 2019 @ 20:37:
[...]


Om uit te leggen wat recursie is, zullen we eerst uit moeten leggen wat recursie is

Maar dan heeft hij het al begrepen voor we het uitleggen

[pedorus]

Python:

dct = {}
lst = ['a','b','c','d']
for i in range(len(lst) -1):
  dct[lst[i]] = ( lst[i], )

Is geen mooi voorbeeld en kan efficiënter worden herschreven:

Python:

lst = ['a','b','c','d']
dct = {x : (x,) for x in lst[:-1]}

zie https://docs.python.org/3....html#list-comprehensions en https://docs.python.org/3...uctures.html#dictionaries

flugelisoke schreef op zaterdag 14 december 2019 @ 21:10:
Ik zie niet goed in wat het laatste stuk nu exact inhoudt en doet, waarom als je print k[0] invoert, komt er a, b ,c te staan. 0 lijkt mij namelijk steeds de beginwaarde.

Alsvolgt zie ik het nut niet van de komma achter lst:

code:

for i in range(len(lst) -1):
  dct[lst[i]] = ( lst[i], )

Haal ze gewoon eens weg anders? Wat gebeurd er als je [0] weg haalt? Wat gebeurd er als je de komma weg haalt?

[bwerg]

Een tupel van grootte 1 is ook wel echt een misbaksel, dat indirect voortkomt uit dynamische typering: je kan met dynamische typering niet meer at runtime vastleggen hoe groot een tupel is, en je kunt dus tupels gebruiken alsof het lijsten zijn, en je 'wil' daarom ook de mogelijkheid hebben om een tupel van lengte 1 te definiëren. En zo werd (42,) geboren, een tupel van grootte 1. Misschien is dit geen pythonic mening, maar gebruik gewoon een lijst en schrijf [42] in plaats van (42,), tenzij het niet anders kan (een library die enkel tupels accepteert of zo).

Ik vind probleem 2 maar rare code. Als je wil weten hoe dicts en tupels werken lijken 'normale' voorbeelden me zinniger. Als je die goed snapt, dan snap je voorbeeld 2 waarschijnlijk ook. En dan denk je "wat een rare code".

[ Voor 19% gewijzigd door bwerg op 17-12-2019 00:37 ]