Einfacher Einstieg ins Programmieren

Quote from Tell

Sucht die Fehler

Alle?

Auf den ersten Blick (ungetestet):

- sys wird importiert, aber nicht verwendet

- die Funktion fibonacci() wird garnicht aufgerufen

- das Skript kann bei großen Zahlen (bezüglich Rekursionstiefe) abschmieren und sollte wenigstens davor geschützt werden.

- Floats (oder überhaupt ein Typ) werden nicht berücksichtigt

Da habe ich bestimmt noch einiges übersehen?!

1) Das Programm ist unvollstaendig. Nach der if Zeile 9 kommen sicherlich im Original noch diverse Codezeilen. Die haben nur die ersten 9 Zeilen angegeben. Das ist noch soweit verstaendlich.

Aber

2) Die eigentliche Fibonaccirekusion ist falsch

ist ein echter Faux Pas

Ich habe mal den Code ergaenzt und korrigiert.

import sys

def fibonacci(n):
    if n > 1:
        return fibonacci(n-1)+fibonacci(n-2)
    else:
        return n

if __name__ == "__main__":
    for i in range(10):
        print i,fibonacci(i)

Na ja, der erste Fehler kommt ja automatisch von Python-Interpreter.

Und für `fibonacci(1)` funktioniert der Code auch...

Gruß, noisefloor

Hallo,

framp 'Did you mean print(...)'

Grüße

Dennis

framp Da bekomme ich beim ``print`` einen Syntaxfehler. Da fehlen die Klammern. Oder der Fehler ist es immer noch Python 2.x zu verwenden.

Die `fibonacci()`-Funktion könnte man auch etwas kürzer mit nur einem ``return`` schreiben:

#!/usr/bin/env python3


def fibonacci(n):
    return fibonacci(n - 1) + fibonacci(n - 2) if n > 1 else n


def main():
    for i in range(10):
        print(i, fibonacci(i))


if __name__ == "__main__":
    main()

Ansonsten ist es natürlich ineffizient a) da Rekursion zu verwenden, und b) für jedes `i` immer alle vorhergehenden Zahlen zu berechnen.

#!/usr/bin/env python3
from itertools import islice
from more_itertools import nth


def iter_fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b


# Der Vollständigkeit halber eine Funktion die auf `iter_fibonacci()` aufbaut
# und die n-te Zahl berechnet.
def fibonacci(n):
    return nth(iter_fibonacci(), n)


def main():
    for i, number in enumerate(islice(iter_fibonacci(), 10)):
        print(i, number)


if __name__ == "__main__":
    main()

Dennis89

Zu der Zeit in der es sich begab dass ich Python programmierte wusste noch niemand etwas von Python3

__blackjack__

Das der Code ineffizient ist sieht jeder schnell. Aber um das Prinzip einer etwas komplizierteren Rekursion zu demonstrieren eignet sich der Code sehr gut. Nicht umsonst findet man diesen in Programmiertutorials bzw für die Oldies in Programmiereinsteigerlehrbuechern.

framp Ich weis, deswegen auch der Smily

Moin!

Tja, ist halt nur ein Titelbild.

Hier findet ihr die richtigen Code: https://www.ct.de/ytja

73 de Bernd

Quote from Dennis89

deswegen auch der Smily

der hat normalerweise keine rausgestreckte Zunge

Quote from Bernd666

Tja, ist halt nur ein Titelbild.

Jupp. Aber dort den Kern der Fibonaccifolge - die Rekursion - falsch anzugeben ist schon peinlich und zeigt dass es offensichtlich verschiedene Abteilungen bei der c't gibt die fuer das Titelbild und die Inhaltsseiten zustaendig sind

Naja, das Programm auf der Titelgrafik ist ja noch eine Baustelle. Da liegen ja noch Bausteine herum die noch nicht in das Programm eingesetzt wurden. 😇

Die Codes im github sehen auch aus wie Baustellen, besonders der iterative Code erinnert mich an Mörtel mit der Kelle an die Wand geklatscht und danach nicht glatt gezogen und verrieben.

Ein jeder rekursive Code kann auch iterativ geschrieben werden. Allerdings ist er dann meist nicht mehr so einfach zu verstehen

Allerdings ist die iterative Loesung bei Fibonacci noch sehr gut zu verstehen. Wo siehst Du da Moertel und Kelle?

Wenn man Mörtel an die Wand rotzt, dann ist das Material zwar dort wo es hin muss, aber eine verputzte Wand würde ich das dann nicht unbedingt nennen.

Es gibt PEP8.

Ich muss zu meiner Schande gestehen dass ich zwar PEP kenne aber nie gelesen habe ...

Mir ist auch gerade aufgefallen dass der Code sowieso eine irrwitzige Rekursion ist die fuer jeden Input 1 liefert ausser bei 0.

n+f(n-1)

oder

n*f(n-1)

liefern noch die Summe aller Zahlen von 1..n bzw das Produkt von 1..n und machen noch einen gewissen wenn auch eher akademischen Sinn. Aber einfach f(n-1) ist Bullshit.

Kurzum: Die c't sollte mal die Kommunikation zwischen ihren Abteilungen verbessern damit sowas nicht mehr passiert.

Quote from framp

Mir ist auch gerade aufgefallen dass der Code sowieso eine irrwitzige Rekursion ist die fuer jeden Input 1 liefert ausser bei 0.

In dem von der Startseite, jain. Jain, weil man dort auch floats verwenden könnte und damit irgendwas mit 0.099* geliefert würde.

Bei dem anderen, wenn man dann eine größere Zahl (z.B ab 100) verwendet, braucht man vieeeeeeel Zeit und Rechenleistung, bis das Ergebnis mal erscheint.

Iterativ ist schneller und hat einen vielfach geringeren Memory-Footprint.

Rekursive Algorithmen in iterative umzuformen, ist in manchen Fällen sehr fordernd.

def fibonacci_recursive(n):
    if n > 1:
        return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)
    else:
        return n


def fibonacci_iterative(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b

    return a


if __name__ == "__main__":
    import timeit

    print("Rekursion: fibonacci_recursive(10) | ", end="", flush=True)
    fib_recur = timeit.timeit("fibonacci_recursive(10)", globals=globals())
    print(f"{fib_recur:.2f} s")
    print("Iterativ: fibonacci_iterative(100) (das 10-fache) | ", end="", flush=True)
    fib_iter = timeit.timeit("fibonacci_iterative(100)", globals=globals())
    print(f"{fib_iter:.2f} s")

Rekursion: fibonacci_recursive(10) | 6.19 s
Iterativ: fibonacci_iterative(100) (das 10-fache) | 2.22 s