Wie erklärt sich diese Python-Funktion[Fakultät berechnen]?

Hallo, ich bin neu im Programmierkosmos und habe eine Funktion gesehen (siehe unten, hab sie mal kopiert), die die Fakultät berechnen soll. Ich verstehe aber nicht, wie diese mathematisch abläuft. Das Ergebnis soll sein gleich 1, für i haben wir range(2, n+1), also würde am Ende sowas wie ergebnis = ergebnis * i stehen, oder? Ich verstehe nicht, wie er auf 1, 2, oder n+1 kommt. Wie man die Fakultät mathematisch an sich berechnet, weiss ich, nur die Programmierschritte verstehe ich nicht. Im Buch stand als Kommentar nur "Die Funktion sollte selbsterklärend sein" 😅

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

1 Antwort

Vom Fragesteller als hilfreich ausgezeichnet

MagicalGrill

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Mathematik

16.09.2021, 14:46

Schauen wir uns mal ein paar Beispielabläufe an:

Wenn n = 1 ist:

Im ersten Schritt wird ergebnis auf 1 gesetzt.
Für jedes i, das in range(2, 2) liegt, führen wir den Schritt ergebnis *= i durch. Aber range (2, 2) ist leer, da keine Zahl kleiner als 2 und zugleich größergleich 2 ist. Deswegen wird hier überhaupt nichts gemacht
Wir returnen ergebnis, welches nach wie vor den Wert 1 besitzt (und das ist richtig, denn 1! = 1).

Wenn n = 2 ist:

Im ersten Schritt wird ergebnis auf 1 gesetzt.
Für jedes i, das in range(2,3) liegt, führen wir den Schritt ergebnis *= i durch. Die einzige Zahl in range(2,3) ist i = 2. Also führen wir nur den Schritt ergebnis *= 2 durch, was dazu führt, das ergebnis nun den Wert 2 besitzt.
Wir returnen das Ergebnis (2! = 2 ist korrekt).

Wenn n = 3 ist:

[...]
[...] Die Zahlen in range(2,4) sind i = 2 und i = 3. D.h. wir führen erst ergebnis *= 2 durch, was ergebnis auf den Wert 2 bringt. Danach führen wir ergebnis *= 3 durch, was den Wert auf 6 bringt
Wir returnen das Ergebnis (3! = 6 ist korrekt).

Ruhrpotter4324

Fragesteller

16.09.2021, 14:48

DANKE! Toll, dass du dir so eine Mühe machst und das so aufschreibst, ich bin dir sehr dankbar. Ich lese gerade das Kapitel weiter, danach gehe ich das mal langsam durch und versuche es umzusetzen, aber du hast das sehr gut erklärt!

Ähnliche Fragen

Fakultät mit for/while -Schleife?

Servus,

ich versuche ein Python-Programm zu ertsellen, bei der man die Fakultät berechnen kann. Dabei dürfen nur for (+range) Schleifen oder einer while Schleife benutzt werden, also nichts darf importiert werden Hat jemand Tipps für mich?

...zur Frage

python fakultät programmieren?

für die fakultät einer zahl N. also N! quasi. wie würde das gehen? mein ansatz:

def funktion(N):

x = 1

for n in range(1,N)

x*=n

return x

...zur Frage

Wofür ist die return Funktion genau?

Hallo, ich lerne gerade Python und bin gerade zu den return Funktionen gekommen. Aber wofür ist die genau, ich weiß nur, dass wenn ich eine definierte Funktion wie diese: def mittelwert(x,y): ergebnis=(x+y)/2 als Ergebnis einfach nur "None" kriege, falls ich später die Funktion "mittelwert" verwenden möchte, etwa so: c=mittelwert(3,9) print(c) Wenn ich aber "return Ergebnis dran hänge: def mittelwert(x,y): ergebnis=(x+y)/2 return ergebnis Dann bekomme ich als Ergebniss 6. Warum ist das so? Die anderen Seiten im Internet verwirrten mich nur noch mehr. Danke schonmal, MRColourblock

...zur Frage

global alternative Python?

# Hey, welcje alternativen gibt 
es zu globalen Variablen in Funktionen? 
Beispielcode:

def a():
    b = Input("Bla...")
    return b

def c():
    d = b + 2
    return d

...zur Frage

Gradientenabstieg Python?

def function(x):
    return x**2
def ableitung_function(x):
    return 2*x


x = 20
epochen = 15
for i in range(epochen):
    ableitung = ableitung_function(x)
    print(":____:")
    print(ableitung)
    print(x)
    print(":____:")
    lernrate = 0.1
    x_new = x-(lernrate*ableitung)
    x = x_new

Ist mein Gradientenabstieg korrekt? Meiner Meinung nach liefert es gute Ergebnisse, aber wenn ich eine Funktion wie z.b. x^3 und die Ableitung 3*x^2 benutze läuft alles falsch und wo brauche ich meine Funktion 'function'?

...zur Frage

Kann jemand denn Python Code erklären?

Hey, ich kann nicht wirklich Python aber es ist grade sehr wichtig das ich diesen Code verstehe (also was die einzelnen Elemente machen) könnte jemand der das versteht vielleicht Kommentare mit Erklärung hinzufügen oder ähnliches?

vielen Dank

Code:

l=[]
 
 
def damenprüfung(x,y):
  ö=0
  for ä in range(len(x)):
 
    if x[ä]==y or x[ä]+(len(x)-ä)==y or x[ä]-(len(x)-ä)==y:
      ö=ö+1
  if ö>0:
    return("j")
  else:
    return("n")
 
 
l.append([])
for i in range(8):
  l[-1].append([i+1])
     
for a in range(7):
  l.append([])
  for p in range(len(l[a])):
    for k in range(8):
      if damenprüfung(l[a][p],k+1)!="j":
        l[-1].append([])
        for s in range(len(l[a][p])):
          l[-1][-1].append(l[a][p][s])
        l[-1][-1].append(k+1)
 
print(len(l[7]))

...zur Frage

Wie ist dieser Code in Python zu verstehen (Fibonacci-Rechner)?

Hallo, ich sehe mir gerade einen Python-Code zur Berechnung der Fibonacci-Zahlen an und verstehe folgenden Teil nicht: self.A, self.B = self.B, self.A + self.B - wie genau wird das mathematisch berechnet? Wie genau man die Fibonacci-Zahlen mathematisch berechnet, verstehe ich, aber wie genau das in diesem Code funktioniert, ist mir schleierhaaft. Was bezweckt denn self.B hinter der Klammer? Und warum hat self.B in __iter__(self) den Wert 1?

class Fibonacci:
    def __init__(self, max_n):
        self.MaxN = max_n #Legt das Endelement fest, bei dem Berechnung stoppen soll!
        self.N = 0 #Zählt, wie viele Elemente bereits zurückgegeben wurden
        self.A = 0 
        self.B = 0
    def __iter__(self):
        self.N = 0
        self.A = 0
        self.B = 1
        return self
    def __next__(self):
        if self.N < self.MaxN:
            self.N += 1
            self.A, self.B = self.B, self.A + self.B
            return self.A
        else:
            raise StopIteration

...zur Frage

Wie kann ich meinen Python-Code schneller machen?

Hallo,

ich habe gestern in Python ein paar Funktionen geschrieben, die mir ein interessantes Bild ausrechnen sollen. Ich kriege es jedoch nicht hin, dass das Programm einigermaßen schnell läuft und am Ende muss auch die Auflösung darunter leiden

Wenn da mal jemand drüberschauen könnte, wäre das wirklich hilfreich.

import numpy as np
import matplotlib.pyplot as plt
from math import pi, sqrt, atan

#Punkt definieren
class point:
    def __init__(self,x=0,y=0,z=0):
        self.x = x
        self.y = y

    #Operationen
    def __str__(self):
        return "({0},{1})".format(self.x, self.y)

    def __add__(self, other):
        return point(self.x+other.x,self.y+other.y)

    def __sub__(self, other):
        return point(self.x - other.x, self.y - other.y)

    def __abs__(self):
        return sqrt(self.x**2 + self.y**2)

    def __mul__(self, other):
        if type(other) == point:
            return point(self.x * other.x, self.y * other.y)
        return point(self.x * other, self.y * other)

    def __truediv__(self, other):
        if type(other) == point:
            return point(self.x / other.x, self.y / other.y)
        return point(self.x / other, self.y / other)

    def __neg__(self):
        return point(-self.x,-self.y)

# weitere Funktionen für Punkte
def dis(PointA,PointB):
    return abs(PointB-PointA)

def dir(PointA,PointB):
    return (PointB-PointA)/dis(PointA,PointB)


#Funktion für den Wert
def grav_v(x,y,time=5,frames=60):
    p = point(-1,0)
    sp = point(x+1,y)

    c = point(0,0)
    sc = point(0,0)
    
    #Vielleicht wegen des for-loops so langsam?
    for k in range(frames*time):
        try:
            plus = dir(p,c) * 1/dis(p,c)**2 / frames
            sp += plus
            p += sp/frames
            sc -= plus
            c += sc/frames
        except:
            pass

    return p


#Funktion für das Bild
def grav_c(a=-4, b=4, smoothness=1):
    ROWS = []
    p = 0
    print(0)
    #zwei for-loops...
    for Y in np.linspace(a,b,int(200*smoothness)):
        row = []
        for X in np.linspace(a,b,int(200*smoothness)):
            g = grav_v(X, Y)
            row.append( (abs(atan(g.x)*2/pi), abs(atan(g.y)*2/pi), abs(atan(abs(g))*2/pi)) )
        ROWS.append(row)
        p += 1
        print(p / (200 * smoothness))
    plt.imshow(ROWS, extent=(a, b, a, b))
    plt.show()

grav_c()

...zur Frage

Wie genau funktionieren Defaultwerte in Python?

Hallo, ich habe folgende Frage, die ich mit dieser Funktion hier verdeutlichen möchte:

Angenommen wir haben definiert:

def summe(a, b, c=0, d=0):
    return a + b + c + d
summe(1,2,3,4)

#Im Ergebnis dieser Funktion kommt jetzt 10 raus: Verstehe ich es richtig, dass die 3 und 4 in diesem Fall den Defaultwerten von c=0 und d=0 übergeben wurden, also dass der Funktionsparameter c den Wert 3 und der Funktionsparameter d den Wert 4 zugeschrieben bekommen hat? Anders kann ich mir nicht erklären, wie diese Funktion so geht (sie läuft ja in Python), denn a und b können ja nur durch 2 Werte belegt werden, sodass c und d durch 3 und 4 belegt werden müssen, obwohl sie ursprünglich als Wert 0 zugeschrieben bekommen haben. Sind Defaultwerte also sowas wie optionale Parameter, die immer dann genutzt werden, wenn man sie belegen kann?

...zur Frage

Funktionen in Python schriftlich berechnen können?

Wie kommt man hier schriftlich auf 10?

def Foo(x):
  if (x == 1):
    return 1
  else:
    return x + Foo(x - 1)

print(Foo(4)) # >>> 10

Ich verstehe es nicht. Kann mir jemand erklären, wie man schriftlich das hier berechnet und die 10 herausbekommt?

...zur Frage

Wurzelberechnung in Python Taschenrechner einbauen?

Hi, wir haben aktuell das Thema "Python - Programmierung" in der Schule. Ich habe dabei einen Taschenrechner programmiert, allerdings scheitere ich bei der Zusatz-Aufgabe, bei welcher man Wurzelberechnung einbauen soll...

Vielleicht kann mir jemand sagen, wie diese in meinem Code eingebaut werden kann bzw. wie dieser aussieht. LG

Hier einmal mein Taschenrechner:

from math import sqrt
def addition(a,b):     return a + b
def subtraktion(a,b):     return a-b
def multiplikation(a,b):     return a*b
def division(a,b):     return a/b
def potenz(a,b):     return a**b

def main():
    operator = input("Operator:")
    a = int(input("Erste Zahl: "))
    b = int(input("Zweite Zahl: "))
    if (operator == "+"):
            print(addition(a, b))
    elif (operator== "-"):
            print(subtraktion(a,b))
    elif (operator == ""):             print(multiplikation(a,b))     elif (operator == "/"):             print(division(a,b))     elif(operator=="^"):             print(potenz(a,b)) main()

...zur Frage

Mit Funktionen in Python dividieren funktioniert falsch?

Hallo, leider funktioniert der Code, aber "vertauscht" die Zahlen. Wie kann ich das fixen?

from functools import partial
from operator import add, floordiv, mul, sub


def three(op=None): 
    return 3 if not op else op(3)

def seven(op=None): 
    return 7 if not op else op(7)


def plus(val): 
    return partial(add, val)

def minus(val): 
    return partial(sub, val)

def times(val): 
    return partial(mul, val)

def divided(val): 
    return partial(floordiv, val)

print(seven(divided(three())))  # --> 0 

print(three(divided(seven())))  # --> 2

...zur Frage

Wie funktioniert Rekursion(Python)?

Ich versuche gerade zu verstehen, wie Rekursion funktioniert und bin dann auf die Fakultät gestoßen, die man ja rekursiv programmieren kann. Ich verstehe irgendwie nicht, wieso das überhaupt funktioniert, also ich kann dem Programm nicht wirklich folgen. Bei Iteration weiß ich genau was das Programm macht, aber bei Rekursion, weiß ich nicht mal wieso das funktioniert. Ich habe jetzt mal die Fakultätsfunktion programmiert:

def factorial(n):
    if n == 1:
        return 1
    else:
        b = nfactorial(n-1) print(b) return b

Das Programm gibt mir jetzt durch das "Print" so Zwischenergebnisse und ich kann nicht nachvollziehen, wieso es(z.B. bei Fak(4)) zuerst 12, dann12* 3 und erst zuletzt 1234 berechnet und nicht andersrum. Ich weiß, dass laut Definition Rekursion so funktioniert, also mit Rückeinsetzung, aber am Programm kann ich das nirgendwo erkennen.

...zur Frage

Primzahlenerkennungsprogramm Python?

Hallo habe hier ein Programm mithilfe einer Funktion geschrieben,welche erkennen soll ob die eingegebene Zahl eine Primzahl ist.Allerdings kann ich das Unterprogramm nicht aufrufen weil eine Fehlermeldung kommt.Könntet ihr mir bitte helfen.

Mein Programm:

a = int(input("Zahl ? " )

def primzahl (a) :

for i in range (0,a):

if a == 1:

return False

elif a%i == 0 :

return False

else:

return True

primzahl(a)

...zur Frage

Was möchtest Du wissen?

Deine Frage stellen