Python’da İç İçe Döngüler: For Döngüsü ile Neler Yapabilirsiniz?

Pythonda For Döngülerinin Temel Kavramları

Python programlama dilinde döngüler, belirli bir işlemi veya işlemleri birden fazla kez tekrarlamak için kullanılır. Bu, özellikle veri üzerindeki tekrarlayıcı işlemleri gerçekleştirmek için son derece faydalıdır. Python’da en yaygın kullanılan döngü yapılarından biri ‘for’ döngüsüdür. For döngüsü, genellikle bir dizi, liste veya başka bir iterable (tekrarlanabilir) veri yapısı üzerinden geçiş yapmak için tercih edilir.

For döngülerinin en temel kullanımı, bir listeyi veya bir dizi veriyi döngüsel olarak incelemek için yapılır. Örneğin, bir liste içindeki tüm elemanlara erişmek ve üzerlerinde işlem yapmak için ‘for’ döngüsünü kullanabilirsiniz. İşte basit bir örnek:

my_list = [1, 2, 3, 4, 5]
for num in my_list:
    print(num)

Yukarıdaki örnekte, ‘my_list’ isimli bir liste üzerinde for döngüsü kullanarak her bir sayıyı sırayla yazdırıyoruz. Bu sayede her bir elemanı tek tek elde edebiliriz. Ancak, for döngüsü sadece bir düzeyde döngü yapmaz; aynı zamanda iç içe döngülerle daha karmaşık yapılar oluşturulabilir.

İç İçe For Döngüleri Nedir?

İç içe for döngüleri, bir for döngüsünün başka bir for döngüsünün içinde yer alması durumunda oluşur. Bu yapı, çok boyutlu diziler veya matrisler gibi veri yapılarını işlemek için sıklıkla kullanılır. Her iki döngü de bağımsız olarak hareket eder ve dıştaki döngü her döndüğünde içteki döngü tekrar çalıştırılır. Böylece karmaşık verileri daha kolay yönetebiliriz.

Örneğin, bir matris üzerinde çalışmak isteyebilirsiniz. Aşağıda, bir 2D liste (matris) kullanarak iç içe for döngülerinin nasıl çalıştığını gösteren bir örnek bulunmaktadır:

matrix = [[1, 2, 3], 
          [4, 5, 6], 
          [7, 8, 9]]

for row in matrix:
    for value in row:
        print(value)

Bu örnekte, `matrix` isimli 2D liste tablosunda her bir satırı (row) dış döngü ile alıyoruz ve her bir satıra ait değerleri (value) iç döngü ile yazdırıyoruz. Sonuç olarak, matrisin her bir elemanına tek tek erişmiş oluyoruz. İç içe döngüler, karmaşık veriler ile çalışmanızı kolaylaştırır ve çeşitli algoritmalar için temel bir yapı sağlar.

İç İçe For Döngüleri ile Python’da Uygulama Örnekleri

İç içe döngülerle birlikte çeşitli programlama senaryolarıyla karşılaşabilirsiniz. İşte bu senaryolardan bazıları ve iç içe for döngülerinin nasıl kullanılabileceğine dair örnekler:

Örnek 1: Çarpanlar Tablosu Oluşturma

İç içe for döngüleri, çarpanlar tablosu gibi matematiksel işlemleri gerçekleştirmek için idealdir. Aşağıdaki örnekte, 1’den 10’a kadar olan sayıların çarpanlarını hesaplayan bir program yazalım:

for i in range(1, 11):
    print(f'{i} in çarpanları: ', end='')
    for j in range(1, i + 1):
        if i % j == 0:
            print(j, end=' ')
    print()  # Yeni satıra geçiş

Bu örnekte, dıştaki döngü 1 ile 10 arasındaki sayıları döngüsel olarak işlerken, içteki döngü her sayının çarpanlarını bulmak için kullanılıyor. ‘if’ koşulu, sadece sayının çarpanlarını ekrana yazdırmak için kullanılır.

Örnek 2: Matris Çarpımı

Farklı matrisleri çarpmak için de iç içe döngüler kullanılabilir. İki 2D listeyi çarparken, her bir elemanı almak ve çarpıp sonuç matrisine eklemek için iç içe for döngülerine ihtiyaç duyulur. İşte basit bir örnek:

def matrix_mult(A, B):
    result = [[0 for _ in range(len(B[0]))] for _ in range(len(A))]
    for i in range(len(A)):
        for j in range(len(B[0])):
            for k in range(len(B)):
                result[i][j] += A[i][k] * B[k][j]
    return result

# Kullanım örneği
A = [[1, 2, 3], 
     [4, 5, 6]]
B = [[7, 8], 
     [9, 10], 
     [11, 12]]
sonuc = matrix_mult(A, B)
print(sonuc)

Yukarıdaki `matrix_mult` fonksiyonu, iki matrisin çarpımını hesaplamak için üç katmanlı iç içe for döngüleri kullanıyor. Dıştaki döngü, sonuç matrisinin satırlarını belirtilirken, iç döngüler her bir satır ve sütunun çarpımını yapmak için kullanılır.

Örnek 3: İkili İlişki Bulma

İç içe döngüler ayrıca liste içindeki ikili ilişkileri bulmak için de kullanılabilir. Örneğin, bir liste içinde hangi elemanların birbiriyle eşleştiğini kontrol edebiliriz:

my_items = ['elma', 'armut', 'muz', 'elma', 'çilek']
for i in range(len(my_items)):
    for j in range(i + 1, len(my_items)):
        if my_items[i] == my_items[j]:
            print(f'Duplike: {my_items[i]}')

Bu örnekte, ‘my_items’ listesindeki elemanların birbirleriyle eşleşen kopyalarını bulmak için iki katmanlı döngüler kullanıyoruz. Dıştaki döngü, liste elemanlarını dönerken içteki döngü, dış döngünün belirlediği elemandan sonraki elemanları kontrol eder ve kopyaları yazdırır.

Performans ve Karmaşıklık Dikkate Alınmalı

İç içe döngüler güçlü bir yapıya sahip olsalar da, performans açısından dikkatli kullanılmaları gerekir. Özellikle büyük veri setleri üzerinde çalışırken, iç içe döngüler zaman karmaşıklığınızı artırabilir. Her bir ek döngü, toplam çalışma süresini etkileyebilir ve bu, sistem kaynaklarınızı zorlayabilir.

Örneğin, iki iç içe döngü kullanırken, her bir döngü n sayıda işlemi gerçekleştiriyorsa, bu durumda toplam karmaşıklığınız O(n²) olur. Bu nedenle, olasılıkla daha verimli algoritmalar araştırmak veya diğer veri yapılarını değerlendirmek isteyebilirsiniz.

Ayrıca, eğer döngülerinizdeki işlemler bağımsızsa, çok iş parçacıklı programlama veya işlemci çekirdeklerini kullanma konusunda bir yol düşünebilirsiniz. Python’da multiprocessing veya threading modülleri, uzun süren döngü öğelerini başkalarıyla eş zamanlı hale getirmeye yardımcı olabilir.

Sonuç

Python’da iç içe for döngüleri, karmaşık veri yapılarıyla çalışma sırasında oldukça yararlıdır. Matris işlemleri, çarpan hesaplamaları ve benzeri problemleri çözerken sıklıkla kullanılır. Ancak, performansa dikkat etmek ve gerektiği durumlarda daha verimli algoritmalar aramak her zaman önemlidir. İç içe döngüler, doğru yerlerde kullanıldığında programlarınızda büyük avantajlar sağlayabilir.

Umarım bu yazıda iç içe for döngülerinin nasıl işlediğini öğrenmişsinizdir. Şimdi, kendi projelerinizde denemeler yaparak bu bilgileri pekiştirin ve daha karmaşık yapılar oluşturmaktan çekinmeyin!