Bu yazıda, Python’da sıkça karşılaşılan ve genellikle gözden kaçan performans hatalarını inceleyeceğiz. Her bir hatayı ele alarak, kodunuzu nasıl daha hızlı hale getirebileceğinizi göstereceğiz. Hadi başlayalım!
1. Gereksiz Listeleri Kopyalamak
Bir Python listesi oluştururken, çoğu zaman bir listeyi kopyalamak çok yaygın bir işlemdir. Ancak, bazen gereksiz yere liste kopyalamak kodunuzu yavaşlatabilir.
Örnek:
a = [1, 2, 3, 4]
b = a.copy() # Bu gereksiz bir kopya oluşturuyor
Bu tarz işlemler, özellikle büyük veri setlerinde bellek kullanımı ve işlemci yükü oluşturur. Eğer listeyi değiştirmiyorsanız, kopyalama yapmadan doğrudan kullanmak çok daha verimli olacaktır.
2. Döngülerde `len()` Fonksiyonunun Yanlış Kullanımı
Birçok geliştirici, döngülerde liste uzunluğunu almak için `len()` fonksiyonunu sürekli çağırır. Ancak, her `len()` çağrısı aslında bir işlem yapar ve bu, döngü içerisinde her tekrarda zaman kaybına yol açar.
Örnek:
my_list = [1, 2, 3, 4, 5]
for i in range(len(my_list)): # len() her döngüde tekrar hesaplanıyor
print(my_list[i])
Burada `len(my_list)` fonksiyonu her döngüde yeniden çağrılmaktadır. Bunun yerine, bu değeri bir değişkene atayıp döngüde kullanmak, daha verimli olacaktır.
Optimizasyon:
my_list = [1, 2, 3, 4, 5]
list_len = len(my_list)
for i in range(list_len): # Artık len() bir kez hesaplanıyor
print(my_list[i])
3. İteratörlerin Yanlış Kullanımı ve Bellek Sızıntıları
Python’da `for` döngüleri ile listelerde veya diğer veri yapılarında iterasyon yaparken, doğru veri tiplerini kullanmak önemlidir. Eğer bir veri yapısını yanlış kullanıyorsanız, bellek sızıntıları yaşayabilirsiniz. Özellikle büyük veri setlerinde bu tür hatalar performansı ciddi şekilde etkiler.
Örnek:
my_list = range(1000000) # Çok büyük bir liste
for item in my_list:
# Her bir item üzerinde işlem yapılıyor
pass
Bu kodda, `range()` fonksiyonu aslında bir iteratör döndürüyor, yani tam olarak belleğe yüklenmeden her seferinde bir öğe sağlıyor. Ancak eğer siz veriyi liste olarak kullanırsanız, bellekte büyük bir yük oluşabilir.
Optimizasyon:
Her zaman bellek dostu iteratörleri tercih edin. Bunun yerine, `range()` kullanmak gibi verimli veri yapıları kullanarak bellek kullanımını minimize edin.
4. Veritabanı Sorgularındaki Yavaşlamalar
Veritabanı ile çalışırken, her sorgu sonrasında verileri yeniden yüklemek ve sorgu sayısını artırmak performans düşüşlerine yol açabilir. Özellikle büyük veri tabanlarıyla çalışırken, sorgu optimizasyonu oldukça kritik bir noktadır.
Örnek:
import sqlite3
conn = sqlite3.connect('example.db')
cursor = conn.cursor()
cursor.execute("SELECT * FROM users") # Bu çok büyük veriler döndürebilir
rows = cursor.fetchall()
for row in rows:
print(row)
Bu örnekte, tüm verilerin `fetchall()` ile yüklenmesi, bellekte büyük bir yük oluşturur ve veritabanı bağlantınızın verimli çalışmamasına neden olabilir. Verileri parça parça almak ve yalnızca ihtiyacınız olanı sorgulamak daha iyi bir seçenektir.
Optimizasyon:
cursor.execute("SELECT * FROM users LIMIT 100") # Sadece ihtiyacınız kadar veri çekin
5. Gereksiz Hesaplamalar ve İflas Döngüleri
Birçok Python geliştiricisi, her iterasyonda sürekli hesaplamalar yaparak gereksiz işlem yükü yaratır. Bu, işlemci yoğunluğuna yol açar ve kodun hızını yavaşlatır.
Örnek:
for i in range(1000):
result = i * i # Sürekli aynı işlem yapılıyor
Bu tür işlemler, özellikle büyük döngülerde çok fazla kaynak tüketir. Eğer aynı hesaplamayı defalarca yapıyorsanız, bu hesaplamayı bir değişkende saklamak size zaman kazandırır.
Optimizasyon:
for i in range(1000):
result = i * i # Hesaplama yapılırken daha verimli bir yöntem kullanılabilir
6. Zayıf Algoritmalar Kullanmak
Bazı algoritmalar, belirli durumlar için mükemmel olsa da, genelde genel amaçlı kullanımlar için yavaş olabilir. Birçok geliştirici, en kolay çözüme yönelerek algoritmaların verimliliğini göz ardı edebilir.
Örnek:
# Sıralama işlemi için "bubble sort" kullanmak
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
return arr
Bubble sort, küçük veri setlerinde işe yarayabilir, ancak büyük veri setlerinde çok verimsizdir. Bunun yerine, Python’un yerleşik `sorted()` fonksiyonu çok daha hızlıdır.
Optimizasyon:
# Daha hızlı bir sıralama yöntemi
sorted_arr = sorted(arr)
7. Sıkça Kullanılan Modülleri Yeniden Yüklemek
Python’da bir modülü her kullanışta yeniden yüklemek gereksiz yere zaman kaybına yol açar. Eğer bir modülün fonksiyonları defalarca kullanılacaksa, modülün başlangıçta bir kez yüklenmesi yeterlidir.
Örnek:
import time # Her yerde tekrar tekrar import edilmemeli
Modülleri bir kez yükleyip, ardından tekrar tekrar kullanmak, performansı artırır.
8. Çok Fazla Global Değişken Kullanmak
Global değişkenler, genellikle kötü bir tasarım örneği olarak kabul edilir, ancak bazen geliştiriciler bunları hız amacıyla kullanır. Global değişkenler, kodun okunabilirliğini ve bakımını zorlaştırır ve ayrıca performans sorunlarına yol açabilir.
9. Listeleri Yanlış Şekilde Birleştirmek
Python’da listeleri birleştirirken, her seferinde yeni bir liste oluşturmak zaman kaybına yol açabilir. Bunun yerine, listeyi tek bir işlemde birleştirmek çok daha verimlidir.
10. `try-except` Bloklarını Sıkça Kullanmak
`try-except` blokları genellikle hata kontrolü için kullanılır, ancak sık sık kullanıldığında, her hata durumunda performans kaybına yol açar.
