Python'da Fibonacci Dizisi: Kodlama Tekniklerini Öğrenin ve Keşfedin

Fibonacci dizisi, Python pratiği yapmaya devam etmenin eğlenceli bir yoludur. Bu yazıda, verimli fonksiyonlar yazmaktan özyineleme yönetimine ve nesne yönelimli ilkeleri kullanarak daha optimize çözümler geliştirmeye kadar farklı Python teknikleriyle Python'da Fibonacci dizisinin nasıl uygulanacağını öğreneceksiniz. 

Tümünü bitirdikten sonra, kapsam ve hata yönetimi gibi kavramları pekiştirmek için Python'da Fonksiyon Yazma kursumuzu alın ya da kalıtım ve temel sınıfları öğrenmek için Python'da Orta Düzey Nesne Yönelimli Programlama kursumuzu deneyin. Şimdi Fibonacci dizisini uygulayalım.

Hızlı Yanıt

Fibonacci dizisi 0 ve 1 ile başlar; her sayı kendisinden önce gelen iki sayının toplamıdır. Bunu Python'da üretmenin en basit yolu bir döngüdür:

n = 10
a, b = 0, 1

fibonacci_numbers = []

for _ in range(n):  
    fibonacci_numbers.append(str(a)) 
    a, b = b, a + b

print(' '.join(fibonacci_numbers))

# This prints the first 10 Fibonacci numbers
# 0 1 1 2 3 5 8 13 21 34Altyapı:

Fibonacci Dizisi Nedir?

Fibonacci dizisi, bilimin ve doğanın birçok alanında karşımıza çıkan bir matematiksel kavramdır. 0 ve 1 ile başlayarak, her sayının kendisinden önce gelen iki sayının toplamı olduğu bir sayı serisidir. Bu örüntü, bilgisayar bilimi ve finans gibi alanlardaki uygulamaların temelini oluşturur. 

Fibonacci dizisini tanımlayan iki ana yön vardır: dizinin özyinelemeli yapısı ve altın oranla ilişkisi.

Fibonacci dizisinin özyinelemeli doğası

Fibonacci dizisi 0 ve 1 ile başlar. Her yeni sayı, kendisinden önce gelen iki sayının toplamıdır. Örneğin:

0 + 1 = 1

1 + 1 = 2

1 + 2 = 3

2 + 3 = 5

3 + 5 = 8

5 + 8 = 13

Ve böyle devam eder. 

Matematiksel olarak F(n) = F(n-1) + F(n-2) şeklinde yazarız. Dizi, son iki sayıyı tekrar tekrar toplayarak kendini oluşturur. İlk iki sayı olan 0 ve 1 başlangıç noktası ya da temel durumlarıdır. Bunlar olmadan dizi çalışmazdı.

Bu özyinelemeli örüntü, bilgisayar bilimindeki bazı algoritmaların temelini oluşturur. Örneğin, programlamada özyineleme, Fibonacci sayıları üretmek ya da görevleri daha küçük, yönetilebilir parçalara bölmek gibi problemleri çözerken bu dizi üzerinde çalışır.

Altın oran bağlantısı 

Fibonacci dizisi, φ ile gösterilen (değeri yaklaşık 1,618 olan) irrasyonel sayı altın oranla yakından ilişkilidir. Bir Fibonacci sayısını kendisinden önce gelen sayıya bölerseniz, oran φ'ye giderek daha fazla yaklaşır. Örneğin:

5 ÷ 3 ≈ 1,666

8 ÷ 5 ≈ 1,6

13 ÷ 8 ≈ 1,625

İlerledikçe 1,618'e daha çok yaklaşır. Bu bir tesadüf değildir — oran, sayıların büyüme biçimi nedeniyle Fibonacci dizisinde doğal olarak ortaya çıkar.

Bunu ilk kez Öklid antik Yunanistan'da uç ve orta oran olarak tanımladı. O zamandan beri, deniz kabukları ve çiçeklerdeki sarmallar gibi doğadaki örüntülerle, ayrıca sanat ve mimarideki örüntülerle ilişkilendirilmiştir.

Sanatta altın oran. Kaynak

Fibonacci Dizisinin Pratik Uygulamaları

Fibonacci dizisi birçok alanda şaşırtıcı şekillerde karşımıza çıkar. Gelin, doğadaki örüntülerine ve bilgisayar bilimindeki kullanımına odaklanalım.

Doğada Fibonacci

Fibonacci dizisini doğanın her yerinde görebilirsiniz. Çiçeklere bakın — taç yapraklarının sayısı sıklıkla Fibonacci sayılarıyla eşleşir. Örneğin, papatyalarda 34, 55 veya 89 yaprak bulunabilir ve zambaklarda genellikle 3, 5 veya 8 olur. Bu örüntüler, bitkilerin güneş ışığı ve yağmurdan en iyi şekilde yararlanacak biçimde büyümesine yardımcı olur.

Kozalaklardaki ve ayçiçeklerindeki sarmallar da Fibonacci sayılarını takip eder. Örneğin, bir ayçiçeğindeki tohumların dizilimi bu diziyle uyumludur. İki sayıyı toplamak kadar basit bir şeyin doğal dünyanın bu kadarını tanımlayabilmesi büyüleyicidir.

Bilgisayar biliminde Fibonacci

Fibonacci dizisi, algoritmalar ve veri yapılarında da önemli bir rol oynar. Örneğin, Fibonacci sayıları, problemleri verimli şekilde daha küçük parçalara ayırmak için arama algoritmalarında kullanılır. Dizi, belirli işlemleri hızlandırmak için kullanılan bir veri yapısı türü olan Fibonacci yığınlarının da arkasındadır; örneğin bir ağda en kısa yolu bulmak gibi.

İşte Python'da Fibonacci dizisi üretmenin basit bir örneği:

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

# Example usage
fibonacci_numbers = []

for i in range(10):
	fibonacci_numbers.append(str(fibonacci(i)))

print(' '.join(fibonacci_numbers))

# 0 1 1 2 3 5 8 13 21 34Altyapı:

Bu özyinelemeli fonksiyon, Fibonacci dizisinin nasıl oluştuğunu gösterir. Özyineleme anlaması kolaydır; ancak Fibonacci sayılarını çok daha hızlı hesaplamak için dinamik programlama gibi optimize edilmiş sürümler de vardır.

Kriptografide Fibonacci sayıları güvenli anahtarlar oluşturmaya yardımcı olabilir. Yapay zekâda ise sinir ağlarını optimize ederek algoritmaların öğrenme ve uyum sağlama biçimini iyileştirirler. 

Diğer yaygın örnekler

Bu dizinin günlük yaşamda ve uzmanlaşmış alanlarda nasıl göründüğüne dair birkaç örnek daha:

• Sanatta: Sanatçılar ve mimarlar yüzyıllardır Fibonacci dizisini kullanmıştır. Parthenon gibi ünlü yapılarda bu oranlar görülür; çünkü göze doğal olarak hoş gelirler.
• Müzikte: Besteciler ritimler ve ezgiler oluşturmak için Fibonacci sayılarını kullanır. Örneğin, uyumlu örüntüler oluşturmak için tam notalara 1, yarım notalara 2 ve çeyrek notalara 3 değerini atayabilirler.
• Yatırımda: Hisse senedi yatırımcıları piyasa trendlerini analiz etmek için Fibonacci sayılarını uygular. Hisse senetlerinin geri dönebileceği olası fiyat seviyelerini tahmin ederek ne zaman alım ya da satım yapacaklarına karar vermelerine yardımcı olur.
• Fizikte: Kuantum fiziğinde, parçacıkların etkileşimleri ve davranışlarında Fibonacci örüntüleri gözlemlenmiştir; bu dizilerin doğanın en küçük ölçeklerinde bile ortaya çıktığını gösterir.

Python'da Fibonacci Dizisini Uygulamak

Python, Fibonacci dizisini üretmek için birkaç yol sunduğundan, en yaygın kullanılanları örneklerle adım adım ele aldım.

Yinelemeli bir yöntem kullanmak

Yinelemeli yöntem, Fibonacci dizisini üretmenin en basit yollarından biridir. Dizideki her terimi hesaplamak için bir döngü kullanır; bu da onu özyinelemeli yöntemlere göre bellek açısından daha verimli kılar. Şöyle çalışır:

İki değişkeni, a ve b'yi 0 ve 1. olarak ayarlıyorum. Bunlar dizideki ilk iki sayıyı temsil eder. Ardından, sonraki sayıları hesaplamak için bir for döngüsü kullanıyorum. a'yı b'nin değerini tutacak şekilde güncelliyorum ve b, önceki a ve b'nin toplamı oluyor.

Bunun için Python kodu şöyle:

n = 10
a, b = 0, 1

fibonacci_numbers = []

for _ in range(n):
    fibonacci_numbers.append(str(a))
    a, b = b, a + b

print(' '.join(fibonacci_numbers))

# 0 1 1 2 3 5 8 13 21 34Altyapı:

Bir for döngüsü yerine while döngüsü kullanmak isterseniz, kodu şöyle yazabilirsiniz:

# Number of terms to print in the Fibonacci series
n = 10

# Initialize the first two terms
a, b = 0, 1
i = 0

fibonacci_numbers = []

while i < n:
	fibonacci_numbers.append(str(a))
	# Update the terms
	a, b = b, a + b
	i += 1

print(' '.join(fibonacci_numbers))

# 0 1 1 2 3 5 8 13 21 34Altyapı:

Her iki yöntem de anlaşılması son derece kolaydır; bu da onları yeni başlayanlar için ideal kılar. 

Özyinelemeli bir yöntem kullanmak

Özyinelemeli yöntem, Fibonacci sayılarını üretmenin bir başka yoludur. Daha uzun diziler için yinelemeli yöntem kadar hızlı değildir; ancak dizinin nasıl oluştuğunun mantığını anlamak için harikadır.

Örneğin, fibonacci_recursive adlı bir fonksiyon oluşturuyorum. Bu fonksiyon girdi olarak bir n sayısı alır. Eğer n 0 ya da 1 ise fonksiyon n'i döndürür. Bunlar, özyinelemenin ne zaman duracağını belirleyen temel durumlardır. Diğer tüm sayılar için fonksiyon, önceki iki sayıyı hesaplamak üzere kendini çağırır ve onları toplar.

Bunun için kod şöyle:

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

num_terms = 10
fibonacci_numbers = []
for i in range(num_terms):
	fibonacci_numbers.append(str(fibonacci_recursive(i)))

print(' '.join(fibonacci_numbers))

# 0 1 1 2 3 5 8 13 21 34Altyapı:

Bu yöntem küçük diziler için iyi çalışır; ancak aynı değerleri birden çok kez yeniden hesapladığı için dizi büyüdükçe yavaşlayabilir.

Önbellekleme ile optimize edilmiş özyinelemeli yöntem

Düz özyinelemenin verimsizliğini gidermek için sıkça önbellekleme kullanırım. Python'un lru_cache'i daha önce hesaplanan değerleri saklar; böylece fonksiyon işi baştan yapmak zorunda kalmaz.

Bunu şöyle yapıyorum:

from functools import lru_cache

@lru_cache(maxsize = None)
def fib_cache(n):
    if n == 0:
        return 0  
    elif n == 1:
        return 1
    else:
        return fib_cache(n-1) + fib_cache(n-2)

print(f"The Fibonacci Number is {fib_cache(10)}")

# The Fibonacci Number is 55Altyapı:

Bu yaklaşım, özyinelemenin açıklığını önbelleklemenin verimliliğiyle birleştirir.

Python'da Fibonacci Dizisini Yapmanın Daha İleri Yolları

Fibonacci sayılarını hesaplamanın başka yollarını arıyorsanız, birkaç daha ileri tekniği burada bulabilirsiniz:

Matris üs alma

Matris üs alma, n'in büyük değerleri için Fibonacci sayılarını hesaplamanın en verimli yollarından biridir. Terimleri tekrar tekrar yeniden hesaplamak yerine, bu yöntem sonuçları logaritmik sürede elde etmek için matris çarpımını kullanır.

Bunu Python'da şöyle uyguladım:

import numpy as np

def fibonacci_matrix(n):
	def matrix_power(matrix, power):
		return np.linalg.matrix_power(matrix, power)
	if n == 0:
		return 0
	matrix = np.array([[1, 1], [1, 0]])
	result = matrix_power(matrix, n-1)
	return result[0][0]

fibonacci_numbers = []

for i in range(10):
	fibonacci_numbers.append(str(fibonacci_matrix(i)))

print(' '.join(fibonacci_numbers))

# 0 1 1 2 3 5 8 13 21 34Altyapı:

Bu kodda, n 0 ise temel durum olarak 0 döndürülür. Diğer değerler için matris, numpy'nin matrix_power fonksiyonu kullanılarak (n-1) üssüne yükseltilir. n konumundaki Fibonacci sayısı, ortaya çıkan matrisin sol üst elemanında bulunur.

Binet formülü

Binet formülü, yineleme ya da özyineleme olmadan doğrudan n'inci Fibonacci sayısını hesaplar. Altın oran φ'ye dayanır ve sonucu anında hesaplamak için bir matematiksel ifade kullanır.

Formül şöyledir:

Burada:

• φ = (1 + √5) / 2​​, altın oran.
• 1 - φ φ'nin eşleniğidir.

Binet formülünün Python kodu şöyle:

import math

def fibonacci_binet(n):
    phi = (1 + math.sqrt(5)) / 2
    return round((phi ** n - (1 - phi) ** n) / math.sqrt(5))

# Find the 10th Fibonacci number
n = 10
result = fibonacci_binet(n)
print(f"The Fibonacci Number of {n}th term is {result}" )

# The Fibonacci Number of 10th term is 55Altyapı:

Bu kodda, fibonacci_binet(n) fonksiyonu Binet formülünü kullanarak n'inci Fibonacci sayısını hesaplar. Fonksiyon içinde, 5'in karekökü için math.sqrt() kullanarak phi'yi (altın oran) (1 + math.sqrt(5)) / 2 olarak hesaplıyorum. Ardından (phi ** n - (1 - phi) ** n) / math.sqrt(5) formülünü doğrudan n'inci Fibonacci sayısını bulmak için uyguluyorum. Küçük kayan nokta hatalarını gidermek için round() fonksiyonunu kullanıyorum.

Diziler

Tüm Fibonacci dizisini üretmek ve saklamak için dizileri de kullanabilirsiniz. Bu, birden fazla terime aynı anda ihtiyaç duyduğunuzda yararlıdır.

Bunun için kod şöyle:

def fibonacci(n):
    if n <= 0:
        return "Incorrect Output"
    data = [0, 1]  # Initialize list with first two Fibonacci terms: 0 and 1
    if n > 2:
        for i in range(2, n):  # Start loop from the third term
            data.append(data[i-1] + data[i-2])  # Calculate next term as sum of previous two
    return data[n-1]  # Return the nth term

print(f"Fibonacci Number: {fibonacci(10)}")

# Fibonacci Number: 34Altyapı:

Geri izleme (backtracking)

Geri izleme, özellikle daha iyi performans için özyinelemeyi anımsama (memoization) ile birleştirmek istediğimde kullanabileceğim bir diğer seçenektir.

Bunun için kod şöyle:

def fibonacci_backtracking(n, computed ={0: 0, 1: 1}):
    if n in computed:
        return computed[n]
    computed[n] = fibonacci_backtracking(n - 1) + fibonacci_backtracking(n - 2)
    return computed[n]

n = 10
result = fibonacci_backtracking(n)
print(f"The {n}th Fibonacci term is {result}")

# The 10th Fibonacci term is 55Altyapı:

Python'da Fibonacci Algoritmalarının Karmaşıklığı

Oldukça fazla örnek inceledik! Şimdi bunların zaman ve bellek karmaşıklığı açısından farklarına bakalım. Belirttiğimiz gibi, bazı yöntemler hızlıdır ama daha fazla bellek kullanır; bazıları ise daha yavaştır ama daha az yer kaplar. Her yaklaşımın verimliliğini karşılaştırmak için bu tabloyu hazırladım.

Yukarıdaki tabloda, her bir zaman ve bellek karmaşıklığının anlamı şöyledir:

Zaman karmaşıklığı

• O(n): Algoritma, her eleman için sabit sayıda işlem yaparak diziyi bir kez dolaşır. Geçen süre, girdi boyutu n ile doğrusal olarak artar.

• O(1): Fibonacci sayısı, yineleme ya da özyineleme olmadan sabit sayıda işlemle hesaplanır.

• O(2ⁿ): Algoritma her girdi için iki özyinelemeli çağrı yapar; bu da n arttıkça fonksiyon çağrılarının sayısında üstel büyümeye yol açar.

• O(log n): Çalışma süresi, girdi boyutu n'in logaritmasıyla orantılı olarak artar.

Bellek karmaşıklığı

• O(n): Algoritma, girdi sayısı n ile doğru orantılı olarak büyüyen bellek kullanır. Burada her eleman sabit miktarda yer kaplar.

• O(1): Girdi boyutundan bağımsız olarak bellek kullanımı sabit kalır.

• O(2ⁿ): Her dal için yeni durumlar oluşturulduğundan üstel düzeyde bellek kullanılır.

• O(log n): Ara matris çarpmalarında logaritmik bellek kullanılır.

Son Düşünceler

Gördüğünüz gibi Python'da Fibonacci sayılarını, basit döngülerden matris üs alma ve Binet formülü gibi ileri tekniklere kadar birçok farklı yöntemle hesaplayabilirsiniz. Her yöntemin güçlü yönleri ve ödünleri vardır.

Umarım hem Fibonacci dizisi hem de Python programlama hakkında bir şeyler öğrenmişsinizdir. Python ve ilgili konuları daha fazla keşfetmek isterseniz, Python'a Giriş kursumuza göz atın. Ayrıca tam Python Geliştirici kariyer yolumuzu deneyebilir, programlama tekniklerini öğrenebilir ve hatta kendi paketlerinizi geliştirmeye başlayabilirsiniz!