Python map() İşlevi: Kapsamlı Rehber

Python'ın map() fonksiyonu, veri dönüştürme için fonksiyonel programlama kalıplarını etkinleştiren güçlü bir yerleşik araçtır. Büyük veri kümelerini işlemek, metin verilerini temizlemek veya toplu hesaplamalar yapmak istiyorsanız, map() fonksiyonu verimliliğinizi artırmada oldukça yardımcı olabilir.

Bu eğitimde, Python'un map() fonksiyonunun söz dizimini, pratik kullanım alanlarını ve ileri tekniklerini göstereceğim. Ayrıca bellek verimliliği için tembel değerlendirmeye bakacak, map()’i liste üreteçleri gibi alternatiflerle karşılaştıracak ve en iyi performans için en iyi uygulamaları tartışacağız.

Yineleyicileri anlamak verimli kod yazmanın sadece ilk adımıdır. Veri işleme konusunda ustalaşmak için, hata yönetiminden gelişmiş yinelenebilir yapılara kadar her şeyi içeren eksiksiz bir Python programlama araç kutusuna ihtiyacınız var.

Python map() Söz Dizimi

map() fonksiyonunun kullanımına geçmeden önce, bu fonksiyonun nasıl çalıştığına bakalım. Söz dizimini ve davranışını anlamak, onu daha etkili uygulamamıza yardımcı olur.

map() fonksiyonunun temelleri

map() fonksiyonu, belirtilen bir fonksiyonu yinelenebilir bir yapıdaki (liste, demet veya dize gibi) her öğeye uygulayan ve dönüştürülmüş sonuçları içeren bir yineleyici döndüren yerleşik bir Python yardımcı aracıdır. Bunun sonucu olarak değişmezliği ve kodun yeniden kullanılabilirliğini teşvik eder; bu, veri işleme boru hatları ve makine öğrenimi modelleri için önişleme özelliklerinde önemlidir. 

Söz dizimi aşağıda gösterildiği gibi basittir:

map(function, iterable, ...) 

function, len() gibi yerleşik bir fonksiyon ya da özel yazdığınız bir fonksiyon olabilir ve iterable içindeki her öğeye uygulanır. Paralel eşlemeyi etkinleştirmek için birden fazla yinelenebilir yapı da ekleyebiliriz. Buna birazdan değineceğiz.

İştahlı değerlendirmeden (her şeyi en başta hesaplayan) farklı olarak, map() tembel değerlendirme kullanır. Talep üzerine değerler üreten bir yineleyici olan bir map nesnesi döndürür. Bu, üzerinde yineleme yapana kadar hesaplamayı erteler ve büyük veri kümeleri için bellek tasarrufu sağlar.

Hızlı bir görsel için, sayıların karesini alan şu basit örneği düşünün:

numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared))

[1, 4, 9, 16]

Parametre değerleri ve dönüş değerleri

map() fonksiyonu en az iki parametre gerektirir: çağrılabilir bir fonksiyon ve bir yinelenebilir. İsteğe bağlı ek yinelenebilirler, fonksiyonun birleştirilmiş diziler üzerinde yayınlanmasına olanak tanır; bu da NumPy'ın apply_along_axis() işlevine benzer vektörleştirilmiş işlemler için idealdir.

Python 3’te map() bir liste yerine bir yineleyici alt sınıfı olan bir map nesnesi döndürür. Bu değişim, sonuçların tamamı için en baştan yer ayırmadığından bellek verimliliğini artırır. Sonuçları somutlaştırmak için açıkça dönüştürün:

• Listeye: list(map(function, iterable))

• Kümeye: set(map(function, iterable))

• Doğrudan yineleyin: for item in map(function, iterable): ..

İşte dönüştürmeyi gösteren bir kod parçası:

words = ['python', 'data', 'science']
# Converts map object to list
lengths = list(map(len, words)) 
print(lengths)

[6, 4, 7]

Bu eğitim boyunca kullanılan farklı Python işlemlerinin hızlı bir özeti için, şu Python cheat sheet'ine göz atmanızı öneririm. 

Python 2'den Python 3'e geçiş

Python 2’de map() iştahlı olarak bir liste döndürürdü; bu da büyük girdiler için belleği şişirerek eski veri betiklerinde yaygın bir tuzaktı. Python 3’ün tembel map nesnesi bunu değiştirdi ve büyük veri ortamlarında (ör. PySpark) ölçeklenebilirlik için yineleyici protokolleriyle hizaladı.

Sonuçları mı? Bellek yetersizliği (OOM) hataları olmadan devasa veri kümelerinin daha sorunsuz ele alınması; ancak indeksleme için açık dönüşüm gerekir. Örneğin, my_map[0] çalışmaz, bu yüzden bunun yerine next(iter(my_map)) kullanmalıyız. 

Liste tabanlı yaklaşımlara alışkınsanız, vektörleştirilmiş işlemlerden Python yineleyicilerine geçişinizi kolaylaştırmak için MATLAB kullanıcıları için Python kursuna göz atın.

Python'da map() Nasıl Kullanılır

Artık temellere baktığımıza göre, map() fonksiyonunu uygulayalım. map()’i basit yerleşik fonksiyonlardan daha karmaşık çoklu yinelenebilir dönüşümlere kadar en yaygın şekillerde nasıl kullanacağımıza bakacağız.

Temel map() kullanımı

map()’i kullanmanın en basit yolu, bir yerleşik fonksiyonla kullanmaktır. Diyelim ki bir dize listeniz var ve her birinin uzunluğunu bulmak istiyorsunuz. map() fonksiyonunu uygulamak için:

1. Yinelenebilir yapınızı belirleyin: words = ['apple', 'banana', 'cherry']

2. Fonksiyonunuzu belirleyin: Yerleşik len() fonksiyonu.

3. map() uygulayın: map(len, words)

4. Listeye dönüştürün: list(map(len, words)

Aşağıdaki koda bakalım:

words = ['apple', 'banana', 'cherry']

# Apply the len() function to each item in the list
lengths_map = map(len, words)

# Convert the map object to a list to see the results
lengths_list = list(lengths_map)

print(lengths_list)

[5, 6, 6]

Görüldüğü gibi, bu yaklaşım bir for döngüsü yazıp yeni bir listeye ekleme yapmak ve o listenin durumunu yönetmekten daha derlidir.

map() ile lambda fonksiyonları kullanma

Çoğu zaman yapmak istediğiniz işlem basit ve kısa ömürlüdür. def ile tam bir fonksiyon tanımlamak yerine, küçük, anonim ve tek satırlık bir fonksiyon olan lambda fonksiyonunu kullanabilirsiniz.

Bu, veri işlemekte son derece yaygındır. Örneğin, bir sayı listesini kareye almak istiyorsanız, lambda fonksiyonu mükemmel bir seçimdir. Aşağıdaki örnekle görelim:

numbers = [1, 2, 3, 4, 5]

# Use a lambda function to square each number
squared_map = map(lambda x: x * x, numbers)

squared_list = list(squared_map)
print(squared_list)

[1, 4, 9, 16, 25]

map() ile lambda fonksiyonlarını şu durumlarda kullanmanız önerilir:

• Dönüşüm basitse (ideal olarak tek bir ifade).

• Fonksiyon kodunuzun başka bir yerinde yeniden kullanılmıyorsa.

Lambda fonksiyonları hakkında daha fazla bilgi edinmek için bu etkileşimli Python lambda eğitimine göz atın.

map() ile kullanıcı tanımlı fonksiyonlar kullanma

Daha karmaşık ya da tekrarlanan dönüşümler için, def anahtar sözcüğüyle tanımlanan özel bir fonksiyon kullanın. Bu, kodunuzu daha okunabilir, modüler ve test etmesi daha kolay hale getirir.

Diyelim ki elinizde Santigrat cinsinden sıcaklıkların bir listesi var ve bunları Fahrenheit'a dönüştürmeniz gerekiyor. Bunu şu şekilde yapabiliriz:

def celsius_to_fahrenheit(c):
    # The formula is (Celsius * 9/5) + 32
    return (c * 9/5) + 32

celsius_temps = [0, 10, 25, 30.5, 100]

# Pass the user-defined function to map()
fahrenheit_map = map(celsius_to_fahrenheit, celsius_temps)

fahrenheit_list = list(fahrenheit_map)
print(fahrenheit_list)

[32.0, 50.0, 77.0, 86.9, 212.0]

celsius_to_fahrenheit() gibi açıklayıcı ada sahip bir fonksiyon kullanmak, kodun amacını net şekilde ortaya koyar ve herhangi bir özel iş mantığı için en iyi uygulama kabul edilir.

map() ile birden fazla yinelenebilir kullanma

map()’in güçlü özelliklerinden biri, birden fazla yinelenebilir yapıyı aynı anda işleyebilmesidir. Bunu yapmak için fonksiyonunuz, sağladığınız yinelenebilir sayısı kadar argüman kabul etmelidir.

Diyelim ki iki sayı listeniz var ve bunları öğe bazında toplamak istiyorsunuz:

list_a = [1, 2, 3, 4]
list_b = [10, 20, 30, 40]

# The lambda function now takes two arguments, x and y
sums_map = map(lambda x, y: x + y, list_a, list_b)

sums_list = list(sums_map)
print(sums_list)

[11, 22, 33, 44]

Peki yinelenebilirlerin boyutları farklıysa ne olur? map() fonksiyonu, en kısa yinelenebilir biter bitmez işlemeyi durdurur; dolayısıyla çıktı en kısa olanın uzunluğuna sahip olur. Bunu bir örnekle görelim:

list_a = [1, 2, 3]          # Length 3
list_b = [10, 20, 30, 40]   # Length 4

# map() will stop after the 3rd element
short_map = map(lambda x, y: x + y, list_a, list_b)

print(list(short_map))

[11, 22, 33]

Bu davranış öngörülebilir ve faydalıdır; IndexError hatalarını önler. Tüm öğeleri işlemek ve daha kısa liste için bir varsayılan değerle doldurmak istiyorsanız, itertools.zip_longest() kullanabilirsiniz. 

Sırada, map() fonksiyonu için günlük kullanım örneklerine bakalım.

Yaygın Python map() Kullanım Alanları

map() fonksiyonu çok yönlüdür ve birçok yaygın veri işleme ve temizleme görevi için oldukça kullanışlıdır. En faydalı bulacağınız yerleri inceleyelim.

Listeler üzerinde hesaplamalar yapmak

Bu en klasik kullanım alanıdır. Bir sayı listeniz olduğunda ve her bir öğeye aynı matematiksel işlemi uygulamanız gerektiğinde, map() temiz ve verimli bir çözümdür.

Önceki bölümde Santigrat’tan Fahrenheit’a dönüşümle bunun güzel bir örneğini gördük. Bir diğer yaygın senaryo, satış vergisi hesaplamak veya para birimi çevirmek gibi finansal bir formülü uygulamaktır.

Elinizde USD cinsinden ürün fiyatlarının bir listesi olduğunu ve bunları EUR'a dönüştürmeniz gerektiğini hayal edin. Bunu aşağıdaki gibi yapabiliriz:

def usd_to_eur(price_usd):
    # Assuming a static exchange rate for this example
    EXCHANGE_RATE = 0.92
    return round(price_usd * EXCHANGE_RATE, 2)

prices_usd = [99.99, 150.00, 45.50, 78.25]

prices_eur_map = map(usd_to_eur, prices_usd)

print(list(prices_eur_map))

[91.99, 138.0, 41.86, 71.99]

Bu kalıp, özellikle dönüşüm mantığı karmaşıksa ve kendi fonksiyonu içinde tutulması en iyisiyse, bir for döngüsünden çok daha okunabilirdir.

Toplu olarak dizeleri işlemek

Veri temizleme genellikle büyük miktarda metin verisi işlemeyi içerir. Analizden önce normalleştirilmesi gereken binlerce metin girdiniz olabilir. map() fonksiyonu, bir dize yöntemini tüm bir listeye uygulamak için idealdir.

Örneğin, istenmeyen boşlukları kaldırıp biçimi standartlaştırarak bir isim listesini temizleyelim:

raw_names = ['  Alice Smith ', ' bob johnson', 'Charlie Brown  ', ' david lee']

# Use map() with the built-in .strip() method
cleaned_names_map = map(str.strip, raw_names)

# Now chain another map() to convert to title case
# Note: we apply the second map to the *results* of the first map
final_names_map = map(str.title, cleaned_names_map)

print(list(final_names_map))

['Alice Smith', 'Bob Johnson', 'Charlie Brown', 'David Lee']

Bu, map() işlemlerini zincirleyebilme yeteneği (her biri bir yineleyici döndürdüğü için) verimli veri boru hatlarını yönetmek açısından önemlidir. 

Verileri filtreleme ve eşleme

Çoğu zaman, her öğeyi dönüştürmek istemezsiniz. Yalnızca belirli bir koşulu sağlayan öğeleri dönüştürmek istersiniz. Bu, veri analizinde yaygın bir kalıptır ve Python'un filter() fonksiyonu ile map()’i birleştirerek kolayca çözülür.

filter(function, iterable) fonksiyonu, map()’e benzer şekilde çalışır; ancak yalnızca fonksiyonun True döndürdüğü öğeleri geri verir. 

Diyelim ki elimizde bir sensör okuma listesi var ve yalnızca pozitif değerleri kareye almak, negatif olanları (hata olabilirler) yok saymak istiyoruz. Bunu şu şekilde yapabiliriz:

1. Filtreleyin: Önce filter() ile yalnızca pozitif sayıları alın.

2. Eşleyin: Sonra, kare alma fonksiyonunu filtrelenmiş sonuçlara uygulamak için map() kullanın.

readings = [10, -5, 3, -1, 20, 0]

# 1. Filter out the negative numbers
positive_readings = filter(lambda x: x > 0, readings)

# 2. Map the squaring function to the filtered iterator
squared_positives = map(lambda x: x * x, positive_readings)

print(list(squared_positives))

[100, 9, 400]

Hem map() hem de filter() tembel olduğundan, bu iki adımlı süreç son derece bellek verimlidir. Ara listeler oluşturulmaz. Bu filter sonra map kalıbı, daha karmaşık bir Python list üretecine güçlü bir alternatiftir.

Uygulamada Pratik map() Örnekleri

Artık temel kavramları ve yaygın kullanım alanlarını gördüğümüze göre, map() fonksiyonunun çeşitli veri dönüştürme görevleri için nasıl temiz ve verimli bir söz dizimi sunduğunu gösteren bazı somut pratik örneklere bakalım.

Büyük harfe dönüştürme

Bu, klasik bir dize işleme görevidir. Bir dize listesi verildiğinde, her öğeyi büyük harfe dönüştürmek için map() fonksiyonunu yerleşik str.upper() yöntemiyle kullanabilirsiniz; aşağıda gösterildiği gibi:

words = ['data science', 'python', 'map function']

# Apply the str.upper method to each item
upper_words = map(str.upper, words)

print(list(upper_words))

['DATA SCIENCE', 'PYTHON', 'MAP FUNCTION']

Dizelerden ilk karakteri çıkarmak

Bazen her öğeden belirli bir bilgiyi çıkarmanız gerekir. Burada, listedeki her dizenin ilk karakterini (indis 0) almak için bir lambda fonksiyonu kullanabiliriz.

names = ['Alice', 'Bob', 'Charlie']

# Use a lambda function to get the character at index 0
first_chars = map(lambda s: s[0], names)

print(list(first_chars))

['A', 'B', 'C']

Dizelerden boşlukları kaldırma

Dizeleri işleme bölümünde gördüğümüz üzere, boşluk temizleme metin verisi hazırlığında temel bir adımdır. str.strip() ile map() bunu yapmanın en Pythonik yoludur.

raw_data = ['  value1 ', ' value2  ', '  value3']

# Apply the str.strip method
cleaned_data = map(str.strip, raw_data)

print(list(cleaned_data))

['value1', 'value2', 'value3']

Dize ve liste verilerini yönetmenin daha fazla yolu için, Python liste fonksiyonları ve yöntemleri üzerine bu etkileşimli eğitimde birçok örnek yer alır.

Çatılar içinde verileri güncelleme (örn. Django)

Bir web ya da veri odaklı uygulamada, genellikle verileri sözlük listesi (JSON yükü gibi) olarak alırsınız. map() fonksiyonu, Django’da ya da MongoDB ile çalışırken olduğu gibi, veri tabanı güncellemesine hazırlamak için kullanılabilir.

Veritabanına göndermeden önce her birine bir processed zaman damgası eklememiz gereken ürün güncellemelerini temsil eden bir sözlük listesine sahip olduğumuzu varsayalım:

import datetime

def add_timestamp(record):
    # Don't modify the original! Return a new copy.
    new_record = record.copy() 
    new_record['processed_at'] = datetime.datetime.now()
    return new_record

product_updates = [
    {'id': 101, 'price': 50.00},
    {'id': 102, 'price': 120.50},
    {'id': 103, 'price': 75.25}
]

processed_data = map(add_timestamp, product_updates)

print(list(processed_data))

[{'id': 101, 'price': 50.0, 'processed_at': datetime.datetime(2025, 11, 11, 13, 40, 25, 123456)}, 
 {'id': 102, 'price': 120.5, 'processed_at': datetime.datetime(2025, 11, 11, 13, 40, 25, 123457)}, 
 {'id': 103, 'price': 75.25, 'processed_at': datetime.datetime(2025, 11, 11, 13, 40, 25, 123458)}]

Bu kalıp, toplu güncellemeler için idealdir ve sözlükleri iyi bilmenin değerini gerçekten gösterir.

HTML öğeleri üretme

Web geliştiricileri için map() basit bir şablon motoru olabilir. Bir veri öğeleri listesini, işlenmeye hazır HTML dize listesine dönüştürebilirsiniz. Aşağıda, bir Python listesini sırasız bir HTML listesine dönüştürmenin bir örneği yer alıyor:

def create_list_item(text):
    return f"<li>{text}</li>"

menu_items = ['Home', 'About', 'Contact']

# Map the function to the list
html_items = map(create_list_item, menu_items)

# Join the results into a single string
html_list = "\n".join(html_items)

print(f"<ul>\n{html_list}\n</ul>")

<ul>
<li>Home</li>
<li>About</li>
<li>Contact</li>
</ul>

Gelişmiş Python map() Uygulamaları

map() basit, bire bir dönüşümler için mükemmel olsa da, gerçek gücünü daha karmaşık senaryolarda gösterir. map()’in sofistike bir veri işleme stratejisinin kilit bileşeni olduğu bazı ileri kalıplara bakalım.

Çoklu yinelenebilir işleme

map()’i birden fazla yinelenebilir ile kullanmaya değinmiştik ve bu kalıp, birçok ileri düzey veri ve bilimsel hesaplamanın temelini oluşturur. Birden fazla yinelenebilir verdiğinizde, map() bir fermuar gibi davranır; her yinelenebilirin i’inci öğesini fonksiyonunuza besler; yani argüman sayısı, yinelenebilir sayısıyla eşleşmelidir.

Örneğin, bir envanterdeki farklı ürünlerin toplam değerini hesaplamak için üç ayrı listeniz olabilir. Burada map() nasıl kullanılır görelim:

product_ids = ['A-101', 'B-202', 'C-303']
quantities = [50, 75, 30]
prices = [10.99, 5.49, 20.00]

# A function that takes three arguments
def calculate_line_total(pid, qty, price):
    # Returns a tuple of (id, total_value)
    return (pid, round(qty * price, 2))

# map() feeds one element from each list into the function
line_totals = map(calculate_line_total, product_ids, quantities, prices)

print(list(line_totals))

[('A-101', 549.5), ('B-202', 411.75), ('C-303', 600.0)]

Daha önce belirtildiği gibi, map() en kısa yinelenebilirde durur. Bu, IndexError hatalarını önlemek için bilinçli bir özelliktir. Mantığınız en uzun listedeki tüm öğelerin işlenmesini gerektiriyorsa (örn. varsayılanlarla doldurma), bunun yerine itertools.zip_longest() kullanmayı unutmayın. Bunu ve diğer birçok yararlı fonksiyonu şu verimli Python kodu yazma kursunda öğrenebilirsiniz.

İç içe yinelenebilirler için itertools.starmap()

Peki verileriniz zaten demet listesi olarak “birleştirilmişse” ne olur? Bu, veritabanı sorgu sonuçları, CSV dosyaları veya koordinat çiftleriyle çalışırken son derece yaygındır.

Aşağıda gösterildiği gibi bir (x,y) noktaları listeniz olduğunu ve her çiftin çarpımını hesaplamak istediğinizi varsayın.

points = [(1, 5), (3, 9), (4, -2)]

Bunu map() ile bir lambda kullanarak yapabilirsiniz; ancak uzun iç içe fonksiyonlarla biraz hantal olur:

list(map(lambda p: p[0] * p[1], points))

Çok daha temiz ve Pythonik bir çözüm itertools.starmap()'tir. Bir fonksiyon ve tek bir yinelenebilir (demet listesi gibi) alır. Daha sonra her iç demeti fonksiyonun argümanları olarak açar. Bunu uygulamada görelim:

import itertools

points = [(1, 5), (3, 9), (4, -2)]

# A simple function that takes two arguments
def product(x, y):
    return x * y

# starmap() unpacks each tuple from 'points' into (x, y)
# and passes them to product()
products = itertools.starmap(product, points)

print(list(products))

[5, 27, -8]

starmap(), fonksiyonunuzun argümanları zaten demetler içinde paketlenmiş olduğunda doğru araçtır. Bu kalıp, özellikle (enlem, boylam) koordinatları listesi gibi coğrafi verileri işlerken faydalıdır. Bu kavramlara daha derin bir bakış için şu Python'da coğrafi verilerle çalışma kursunu öneririm.

Fonksiyonel programlama entegrasyonu

map() fonksiyonu, fonksiyonel programlamada oldukça kullanışlıdır. filter() ve functools.reduce() gibi diğer fonksiyonel araçlarla birleştirerek temiz ve yüksek verimli veri işleme boru hatları kurabiliriz.

filter() ve map() kombinasyonunu zaten gördük. Şimdi, bir yinelenebilir yapıyı tek bir kümülatif değere “indirgeme” (aggregate) yapan reduce()’u nasıl kullanacağımıza bakalım.

Tek sayıları içeren bir listedeki tüm sayıların karelerinin toplamını bulmak istediğinizi düşünelim. Bunu şu şekilde yapabiliriz:

from functools import reduce

numbers = [1, 2, 3, 4, 5, 6, 7]

# 1. Filter: Get only the odd numbers
odd_numbers = filter(lambda x: x % 2 != 0, numbers)
# -> Iterator(1, 3, 5, 7)

# 2. Map: Square the odd numbers
squared_odds = map(lambda x: x * x, odd_numbers)
# -> Iterator(1, 9, 25, 49)

# 3. Reduce: Sum the results
#    (lambda a, b: a + b) is the summing function
#    'a' is the accumulator, 'b' is the next item
total = reduce(lambda acc, val: acc + val, squared_odds)

print(total)

84

Bu güçlü bir kalıptır. map() ve filter() her ikisi de tembel yineleyiciler döndürdüğü için, bu işlemin tamamı inanılmaz derecede bellek verimlidir. Bellekte büyük ara listeler asla oluşturulmaz. Veriler boru hattından, öğe öğe akar. 

Tembel Değerlendirme ve Bellek Yönetimi

Python 3’te map()’in en kritik özelliklerinden biri tembel değerlendirme kullanmasıdır. Bu kavramı anlamak, özellikle düzenli olarak büyük veri kümeleriyle çalışan veri uzmanları için, verimli ve ölçeklenebilir kod yazmak adına gereklidir. Bu bölümde bunun nasıl çalıştığını göreceğiz.

Tembel değerlendirmenin faydaları

Python 3’te map() fonksiyonunuzu hemen çalıştırıp bir liste döndürmez. Bunun yerine bir yineleyici olan bir map nesnesi döndürür. Bu yineleyici hangi fonksiyonu ve hangi veriyi kullanacağını “bilir”, ancak siz açıkça bir sonraki öğeyi isteyene kadar aslında hesaplama yapmaz.

Bu “tam zamanında” hesaplama şu önemli faydaları sağlar:

• Bellek Verimliliği: Bir map nesnesi, 10 ögeyi de 10 milyar ögeyi de işlese küçük ve sabit miktarda bellek kullanır. Sonuçları tutacak yeni bir listeyi bellekte oluşturmaz.

• Büyük Veri Kümelerinde Performans: map nesnesi üzerinde (ör. bir for döngüsünde) yinelediğinizde, her seferinde bir değer hesaplayıp verir. Bu, bir seferde belleğe sığmayacak kadar büyük dosyaları veya veri akışlarını işlemenize olanak tanır.

• Zincirlenebilirlik: Fonksiyonel programlama bölümünde gördüğümüz gibi, tembel yineleyiciler birbirine zincirlenebilir (örn. filter() sonrası map()). Ara listeler oluşturulmadığından, veriler boru hattından birer birer akar; bu da inanılmaz derecede verimlidir.

Bunu, iştahlı değerlendirme kullanan bir liste üreteciyle karşılaştırın. Şu örneği düşünün:

squared = [x * x for x in range(10000000)]

Bu kod, 10 milyon sayılık bir listeyi anında oluşturmaya çalışır ve potansiyel olarak çok büyük miktarda RAM tüketir.

Üreteç ifadeleri kullanma

Bir üreteç ifadesi, bir liste üretecinin tembel eşdeğeridir. Görünüş olarak çok benzer, ancak bellek açısından map() gibi davranır. 

squared = (x * x for x in range(10000000))

Yukarıdaki kod, map()’in yapacağı gibi bellek açısından verimli bir yineleyici oluşturur. map() ile bir üreteç ifadesi arasındaki tercih genellikle okunabilirliğe bağlıdır. map(), karmaşık ve mevcut bir fonksiyonu uygularken daha net olabilirken, basit, satır içi ifadeler için üreteç ifadesi genellikle daha okunabilirdir. 

Bu işlemler için bellek kullanımını karşılaştıralım:

import tracemalloc

# Define the base data for comparison
large_numbers = range(10000000)

print("--- Memory Usage (Object Creation vs. List Materialization) ---")

# --- 1. Memory for List Comprehension (creates full list immediately) ---
tracemalloc.start()
list_comp_obj = [x * x for x in large_numbers]
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak RAM for List Comprehension (full list): {peak / (1024 * 1024):.2f} MB")
del list_comp_obj  # Free up memory


# --- 2. Memory for Map Object (lazy) ---
tracemalloc.start()
map_obj = map(lambda x: x * x, large_numbers)
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak RAM for Map Object (iterator itself): {peak / (1024 * 1024):.2f} MB")
del map_obj  # Free up memory


# --- 3. Memory for Generator Expression (lazy) ---
tracemalloc.start()
gen_exp_obj = (x * x for x in large_numbers)
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak RAM for Generator Expression (iterator itself): {peak / (1024 * 1024):.2f} MB")
del gen_exp_obj  # Free up memory

--- Memory Usage (Object Creation vs. List Materialization) ---
Peak RAM for List Comprehension (full list): 390.16 MB
Peak RAM for Map Object (iterator itself): 0.03 MB
Peak RAM for Generator Expression (iterator itself): 0.03 MB

Not: Buradaki Map/Üreteç Nesneleri için 'Tepe RAM', dönüştürüldüklerinde üretecekleri tam listenin belleğini değil, yineleyici nesnesinin kendisine tahsis edilen belleği ifade eder; bu da tembel doğalarını gösterir.

map nesnelerini yinelenebilir yapılara dönüştürme

map() tembel bir yineleyici döndürdüğünden, sonuçları gerçekten kullanmak için onu somutlaştırmanız veya somut bir koleksiyona dönüştürmeniz sıkça gerekir.

map nesnesini şu durumlarda dönüştürmelisiniz:

• Tüm sonuçları bir kerede görmek istediğinizde (örn. print() etmek).

• Ögelere indisle erişmek istediğinizde (örn. results[0]).

• Sonuçların uzunluğunu almak istediğinizde (örn. len(results)).

• Sonuçları liste veya küme gerektiren bir fonksiyona geçirmek istediğinizde.

• Sonuçlar üzerinde birden fazla kez yinelemek istediğinizde. (Bir map nesnesi, tüm yineleyiciler gibi, tüketilebilirdir.) Yalnızca bir kez döngüye sokabilirsiniz.

Bir map nesnesi şöyle dönüştürülür:

def square(x):
    return x * x

numbers = [1, 2, 3, 3, 4, 5]
map_obj = map(square, numbers)

# --- Common Conversions ---

# 1. To a list:
list_results = list(map_obj) 
print(f"List: {list_results}")

# Important 
# The map_obj is now exhausted. 
# If you try to do list(map_obj) again, you'll get an empty list.
# You must re-create the map object to reuse it.

map_obj = map(square, numbers) # Re-create it

# 2. To a set (removes duplicates):
set_results = set(map_obj)
print(f"Set: {set_results}")

map_obj = map(square, numbers) # Re-create it

# 3. To a tuple:
tuple_results = tuple(map_obj)
print(f"Tuple: {tuple_results}")

List: [1, 4, 9, 9, 16, 25] 
Set: {1, 4, 9, 16, 25} 
Tuple: (1, 4, 9, 9, 16, 25)

Sözlük (çıktı anahtar-değer çiftleriyse) dönüştürmek için map() ile dict() kullanabilirsiniz; ancak Python'un sözlük üreteçleri çoğu zaman daha net olur.

Buradaki temel mesaj, kasıtlı olmaktır. Boru hattınızda map()’in tembel bir yineleyici olarak kalmasına izin verin ve yalnızca gerçekten somut sonuçlara ihtiyaç duyduğunuz en son anda onu listeye dönüştürün.