(Ucze się :)) Mam pytanie, czy ktoś mógłby mi wytłumaczyć znaczenie tych zapisów?

def fib(n):
    pwyrazy = (0, 1)
    a, b = pwyrazy
    print(a, end=" ")
    while n > 1:
        print(b, end=" ")
        a, b = b, a + b
        n -= 1

=========================================

def fib2(n):
    a, b = 0, 1
    print("Wyraz", 1, a)
    print("Wyraz", 2, b)
    for i in range(1, n - 1):
        a, b = b, a + b
        print("Wyraz", i + 2, b)

    print()
    return b

=========================================

def fibr(n):
    if n < 1:
        return 0
    if n < 2:
        return 1
    return fibr(n - 1) + fibr(n - 2)

=========================================

def main(args):
    n = int(input("Podaj numer wyrazu: "))
    fib(n)
    print()
    print("=" * 40)
    fib2(n)
    print("=" * 40)
    print(fibr(n - 1))
    return 0

======================================

wszystkie te zapisy mają tworzyć ciąg Fibonacciego. Podzieliłem poszczególne polecenia, żebyśćie mogli mi wytłumaczyć każdy z osobna.

1. Oparte o pętlę while
2. Oparte o pętlę for
3. Rekurencja

Czego konkretnie nie rozumiesz?

No i brakuje implementacji opartej o macierze :D (żart, jakby co, OPie)

ile masz lat KomnatoMan? Rynek pracy dla programistów jest przepełniony, nie ma po co obecnie zaczynac nauki dla celow zarobkowych

Ogólnie to z tego kodu ten kawałek jest fajny i wart uwagi:

a, b = b, a + b

W Pythonie można robić wymiankę zmiennych w miejscu. Czyli to co było linijkę wyżej b zostaje przypisane do a, do a zostaje przypisany wynik wyrażenia a + b. Wszystko po prawej stronie jest najpierw ewaluowane i na koniec przypisane. Fajny mechanizm.

@KomnatoMan: wydzielam, bo gadamy o rozwiązaniu.

Powiedz jak uruchamiasz ten skrypt. Generalnie wszystko co ma print powinno coś wypisać na konsoli.

Te zapisy nie mają znaczenia bez spacji które pominąłeś (prawdopodobnie przez brak znaczników kodu).

@tsz

Dobrze, a czy mógłbyś mi wytłumaczyć działanie komendy:

==========================================================
def fibr(n):
    if n < 1:
        return 0
    if n < 2:
        return 1
    return fibr(n - 1) + fibr(n - 2)

Ogólnie to syntax error, bo to się nie skompiluję.

No, dobra, ale odkładając na bok pedantyzm to jest rekurencja. Funkcja wywołuje samą siebie.

Czyli wywołuję fibr(5) i co się wtedy dzieje?

fibr(5)

fibr(4) + fibr(3)

fibr(4)

fibr(3) + 1

fibr(3)

1 + 0

Tak symbolicznie opisane, bo w rzeczywistości to ta funkcja odpali się kilkanaście razy, ale mam nadzieję, że takie rozbicie na kawałki pozwala załapać ideę rekurencji.

niestety, ale chyba nie rozumiem. może to nie dla mnie

@KomnatoMan:
Ktoś kiedyś powiedział "aby pojąć rekurencję musisz pojąć rekurencję".
A teraz do rzeczy:
Zakładam, ze wiesz jak działa ciąg Fibonacciego.

def fibr(n):
    if n < 1:
        return 0
    if n < 2:
        return 1
    return fibr(n - 1) + fibr(n - 2)

Do return 1 chyba wszystko jasne. Wywołujesz fibr(0), zwracane jest 0, wywołujesz fibr(1), zwracane jest 1. Przy tym nie jest to zerowy lub pierwszy wyraz ciągu, ale liczba stojąca pod takim indeksem w tablicy elementów tego ciągu. (Mam nadzieję, że bardziej nie zamotałem).
"Schody" pojawiają się, gdy zechcemy wywołać funkcję fibr() z parametrem większym od 1. Niech już będzie te 5.
n = 5
5<1 - fałsz, kod się nie wykona
5<2 - fałsz, kod się nie wykona
pozostaje ostatnia linijka

 fibr(5-1) + fibr(5-2), czyli fibr(4) + fibr(3)

Dostaliśmy 3 i 4, obie są większe od 1, zatem nadal zwracana jest ostatnia linijka, ale teraz mamy takie coś (użyję nawiasów kwadratowych dla zwiększenia czytelności):

 [fibr(4-1) + fibr(4-2)] + [fibr(3-1) + fibr(3-2)], czyli [fibr(3) + fibr(2)] + [fibr(2) + fibr(1)]

z 5 zrobiło się 3, dwie 2 i 1
1<2 - prawda, więc zwrócone zostanie 1
dla 3 i obu 2 ponownie zostanie wykonana ostatnia linijka. Uzyskamy:

[fibr(3-1) +fibr(3-2)] + [fibr(2-1) + fibr(2-2)] + [fibr(2-1) + fibr(2-2)] + 1
czyli
[fibr(2) + fibr(1)] + [fibr(1) +fibr(0)] +  [fibr(1) +fibr(0)] + 1

Dla 0 i 1 funkcja zwraca konkretną wartość.
0<1, więc dostajemy 0
1<2, więc dostajemy 1
Dla ostatniej 2 wykona się ponownie ostatnia linijka.
Uzyskamy

fibr(2-1) + fibr(2-2) + 1 +1 + 0 + 1 + 0 + 1
co jest równe
fibr(1) + fibr(0) + 1 +1 + 0 + 1 + 0 + 1
czyli
1 + 0 + 1 +1 + 0 + 1 + 0 + 1
a to będzie 
5

Innymi słowy (najlepiej to chyba wyjdzie na rysunku):
fibr(5) = fibr(4) + fibr(3) = fibr(3) + fibr(2) + fibr(2) + fibr(1) = fibr(2) + fibr(1) +fibr(1) + fibr(0) +fibr(1) + fibr(0) + fibr(1) = fibr(1) + fibr(0) + fibr(1) +fibr(1) + fibr(0) +fibr(1) + fibr(0) + fibr(1)

Tak przy okazji - podany kod można zapisać w taki sposób:

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

Wówczas sprawdzany jest tylko jeden warunek.