Das deutsche Python-Forum

Hallo,

folgendes Script :
(aus einem meiner vielen Bücher die ich Frischling gerade lese)

def fak(zahl) :
  ergebnis = 1
  for i in range(2, zahl+1) :
       ergebnis = ergbnis * 1
  return ergebnis

while true :
  eingabe =int(raw_input("geben sie eine zahl ein: "))
  print fak(eingabe)

___________
Was hier passiert ist mir im groben klar, aber ?
das Ergebnis des z.b. ersten Schleifendurchlaufs
wird im "Namen" Ergebnis referenziert.
damit wird dann der wert im Hauptprogramm
wieder verfügbar und zurückgegeben.

Wo wird denn das Ergebnis im Hauptprogramm aufgerufen ?
bzw angesprochen ?

Die Funktion fak wird aufgerufen und die über
raw input eingelesene Zahl an die Funktion übergeben.
Dort wird die Berechnung vorgenommen. ABER WO/ WOHER
stammt dann die Rückgabe ?

Gruß
Kai

Vorab vielen Dank

Wenn du deinen Code in Code-Tags setzt, wäre das ein echter Fortschritt.

Der Schleifenkörper ist so auch nicht richtig (wird so auch nicht in deinem Buch stehen); aber das findest du selbst heraus.

Der Rückgabewert wird beim Funktionsaufruf in der letzten Zeile an das Hauptprogramm zurückgeliefert und durch print direkt ausgegeben.

Du könntest ihn z.B. auch einer Variablen zuweisen, wenn du ihn weiter verwenden willst.

derkai hat geschrieben:Die Funktion fak wird aufgerufen und die über
raw input eingelesene Zahl an die Funktion übergeben.
Dort wird die Berechnung vorgenommen. ABER WO/ WOHER
stammt dann die Rückgabe ?

Aus der letzten Zeile von ``fak``.

Wenn du den Code in Tags setzen würdest, dann könnte man dir sogar noch eine Zeilenzahl sagen.

Ich denke mal es geht hier um die Fakultät

Ist aber vor allem nen schönes Beispiel für Rekursion(Funktion ruft sich selbst wieder auf) siehe:

Code: Alles auswählen

def factorial(number):
    """
        Calculates the factorial ( n * n-1 * ... * 1) of a given number.
    """
    if number < 0:          #factorial is only defined for non-negative numbers
        raise ValueError
    if number is 0:
        return 1
    else:
        return number * factorial(number-1)

Aber zurück zu deiner Frage:

Code: Alles auswählen

def fak(zahl) :
    ergebnis = 1
    for i in range(2, zahl+1) :
        ergebnis = ergebnis * 1
    return ergebnis

Ergebnis wird bei Aufruf der Funktion zurückgegeben, wie Leonidas und pütone schon sagten.
Und zwar an ``print'', das das dann ausgibt.

Es heißt übrigens "factorial" und nicht "faculty"

Der Rekursionsanker geht noch besser:

Code: Alles auswählen

def factorial n:
    if n<0:
        raise ValueError
    elif n==0:
        return 1
    
    return n * factorial(n-1)

Naja, bis auf dass die Signatur in Python eben ``def factorial(n)`` ist, also mit Klammern

Sollte ich noch etwas zu PEP8 sagen?

cofi hat geschrieben:Ich denke mal es geht hier um die Fakultät
Code: Alles auswählen
def fak(zahl) :
    ergebnis = 1
    for i in range(2, zahl+1) :
        ergebnis = ergebnis * 1
    return ergebnis 

Der Schleifenkörper ist immer noch falsch ...

pütone hat geschrieben:Der Schleifenkörper ist immer noch falsch ...

Tipp:

De Vier Botze / 3 Laachduve hat geschrieben:Dreimol null es null

pütone hat geschrieben:
cofi hat geschrieben:Ich denke mal es geht hier um die Fakultät
Code: Alles auswählen
def fak(zahl) :
    ergebnis = 1
    for i in range(2, zahl+1) :
        ergebnis = ergebnis * 1
    return ergebnis 
Der Schleifenkörper ist immer noch falsch ...

ich hab das nur eingerückt und in code gesetzt, da ich das einfach umständlich finde das per schleife zu lösen, wenn Python doch Rekursion unterstützt

@EyDu hmmm richtig ... wie kam ich nur auf ``faculty''? Na wohl nur weils sich besser anhört

und danke für den Einwand, so passts auch besser mit der Definition der Fakultät

cofi hat geschrieben:ich hab das nur eingerückt und in code gesetzt, da ich das einfach umständlich finde das per schleife zu lösen, wenn Python doch Rekursion unterstützt

Das Problem mit Rekursion ist, dass Python von sich aus, Endrekursion nicht optimiert, d.h bei größeren Zahlen wirft der Interpreter eine Exception. Auch sind Funktionsaufrufe in Python recht teuer (von der Performance gesehen).

Klar, Fakultät ist normalerweise ein klassischer Fall für Rekursion.

Von wegen Rekursion!

Code: Alles auswählen

from operator import mul

fak = lambda n: reduce(mul, xrange(2, n+1))

fak(0) == 1, übrigens. Das sollte schon drin sein.

Aber ich hab grad nur Python2.4 zur Hand und das kann das inline if-else nicht

Extra für dich:

Code: Alles auswählen

def fak(n):
    if n > 0:
        return reduce(mul, xrange(1, n+1))
    elif n == 0:
        return 1
    else:
        raise TypeError("Only defined on positive integers")

Noch kürzer:

Code: Alles auswählen

def fak(n):
    if n >= 0:
        return reduce(mul, xrange(1, n+1), 1)
    else:
        raise TypeError("Only defined on positive integers")

MfG
HWK

Sehr gut. Nächste Aufgabe: Erweiterung auf n! = Γ(n+1)

Sagt, mal: selbst, wenn man "ergbnis" richtig schreiben würde, die ursprüngliche Funktion ist doch nur eine komplizierte Variante von

Code: Alles auswählen

def fak(n): return 1

Will sagen: Der Algorithmus ist falsch abgeschrieben.

Stefan

@sma: Ja, genau!

birkenfeld hat geschrieben:Sehr gut. Nächste Aufgabe: Erweiterung auf n! = Γ(n+1)

Code: Alles auswählen

from scipy.special import gamma
def fac(n):
	return gamma(n + 1)

MfG
HWK

audax hat geschrieben:Aber ich hab grad nur Python2.4 zur Hand und das kann das inline if-else nicht

Geht trotzdem

Code: Alles auswählen

from operator import mul
fak = lambda n: (n == 0 and (1,) or reduce(mul, xrange(1, n + 1)))[0]

Das Tupel und [0] sind aber falsch da.

Richtig. Fixed

Code: Alles auswählen

from operator import mul
fak = lambda n: (n == 0 and (1,) or (reduce(mul, xrange(1, n + 1)),))[0]

Das deutsche Python-Forum

Frage zur Return Anweisung ....

Frage zur Return Anweisung ....

Re: Frage zur Return Anweisung ....