Python List Size: 8 Different Methods for Finding the Length of a List in Python

Python listeleri, öğe koleksiyonlarını depolamak ve bunlarla çalışmak için temel bir veri yapısı olarak öne çıkar. Esneklikleri ve kullanım kolaylıkları sayesinde veri analizinden web geliştirmeye kadar geniş bir yelpazede vazgeçilmezdir. Bu kadar yaygın kullanıldıkları için sık karşılaşılan bir gereksinim de bir listenin boyutunu belirlemektir. len() işlevi yaygın olarak bilinse de, Python’un zengin sözdizimi ve kütüphane desteği, her birinin kendine özgü incelikleri ve kullanım alanları olan başka yollar da sunar. Bu makale, bu tür sekiz yöntemi ele alarak nasıl çalıştıklarına ve verimliliklerine dair içgörüler sağlar.

Python Listeleri Neden Önemlidir?

Python’daki listeler, farklı veri türlerini bir arada tutabilen dinamik dizilerdir ve veri depolama ile işleme için çok yönlü bir araç sunar. Append(), remove(), sort() gibi yerleşik yöntemler sayesinde yineleme, dilimleme ve kapsamlı manipülasyonları kolaylaştırırlar. Bu eğitimde liste manipülasyonları hakkında daha fazla bilgi edinebilirsiniz.

Python’da Liste Nasıl Tanımlanır

Bu eğitimin amaçları doğrultusunda, her yöntemi göstermek için basit bir liste kullanacağız. Aşağıdaki gibi tanımlanan my_list listesini düşünün:

# Define a sample list to be used throughout the tutorial
my_list = ["I", "Love", "Learning", "Python"]Altyapı:

Bu liste her ne kadar basit olsa da, uzunluğunu belirlemek için farklı teknikleri göstermek adına ideal bir örnek teşkil eder.

Python Liste Boyutunu Bulmanın 8 Yolu

1. len() İşlevini Kullanarak Listenin Boyutunu Bulma

len() işlevi, bir listenin boyutunu belirlemenin en basit yoludur. Hem özlü hem de oldukça verimlidir; bu nedenle çoğu durumda başvurulan yöntemdir.

# Use len() to find the size of the list
length = len(my_list)
print(length)  # Output: 4Altyapı:

2. For Döngüsü Kullanarak Listenin Boyutunu Bulma

Saf yöntem olarak anılan bu yaklaşım, liste üzerinde bir for döngüsü kurup her bir öğe için bir sayacı artırmayı içerir. For döngüleri ve diğer döngü türleri hakkında bu eğitimden daha fazla bilgi edinebilirsiniz.

# Naive method using a for loop to count the list's size
counter = 0
for item in my_list:
    counter += 1
print(counter)  # Output: 4Altyapı:

3. List Comprehension Kullanarak Listenin Boyutunu Bulma

Python’daki list comprehension söz dizimi, bir liste üzerinde işlemleri kompakt şekilde yürütmeyi sağlar. Burada, öğeleri saymak için sum() ile birlikte kullanıyoruz.

# Using list comprehension to count the list's size
length = sum([1 for item in my_list])
print(length)  # Output: 4Altyapı:

4. reduce() Kullanarak Listenin Boyutunu Bulma

reduce() işlevi biraz daha ileri düzeydir ancak çok güçlüdür. Bir listenin öğelerine soldan sağa doğru, ikili argüman alan bir işlevi kümülatif olarak uygular ve listeyi tek bir değere indirger. Bizim amacımız için, listedeki öğe sayısını saymak üzere kullanacağız.

Bunu daha anlaşılır kılmak için iki parçaya ayıralım:

1. Basit Bir İşlev Tanımlayın: Önce iki argüman alan basit bir işlev tanımlayacağız: mevcut sayım (count_so_far) ve listeden tek bir öğe (bu öğeyi aslında kullanmayacağımızı belirtmek için _ diye adlandıracağız).
2. reduce() Kullanın: Ardından bu işlevi listedeki her öğeye uygulamak için reduce() kullanacağız; böylece ilerledikçe öğeleri saymış olacağız.

# Import the reduce function from the functools module
from functools import reduce

# Define a simple function to use with reduce
def update_count(count_so_far, _):
    """Increases the count by 1. The second parameter is not used."""
    return count_so_far + 1

# Use reduce to count the items in the list
# We start counting from 0, which is why we have '0' at the end
list_length = reduce(update_count, my_list, 0)

# Print out the result
print(list_length)  # Output will be 4Altyapı:

5. iter() ve next() Kullanarak Listenin Boyutunu Bulma

iter() ve next() kullanarak listedeki öğeleri saymayı anlamak, yineleyicilere (iterator) aşina olmayı gerektirir. Yineleyici, bir listedeki tüm öğeleri tek tek dolaşmamıza olanak tanıyan bir Python nesnesidir. iter() bir listeyi yineleyiciye dönüştürür, next() ise yineleyicide bir sonraki öğeye ilerler.

Adım adım özet şöyle:

1. Bir Yineleyici Oluşturun: Önce listemizi iter() kullanarak bir yineleyiciye dönüştürürüz. Bu sayede listeyi birer birer dolaşabiliriz.
2. Bir Döngü ile Sayın: Listede öğe kalmayana kadar sürecek bir döngü kurarız. Döngü içinde next() ile sıradaki öğeye geçeriz. Her başarılı geçişte sayacı 1 artırırız.
3. Listenin Sonunu Yönetin: Eninde sonunda listenin sonuna ulaşırız. Bu olduğunda next(), artık öğe kalmadığını bildiren bir StopIteration hatası fırlatır. Bu hatayı try-except bloğunda yakalar ve saymayı durdururuz.

Her adımı anlamayı kolaylaştıracak, açıklamalı sadeleştirilmiş kod:

# Step 1: Turn the list into an iterator
list_iterator = iter(my_list)

# Initialize a counter to keep track of the number of items
count = 0

# Step 2: Loop through the list using the iterator
while True:
    try:
        # Use next() to get the next item from the iterator
        next(list_iterator)
        
        # If next() was successful, increase the count
        count += 1
    except StopIteration:
        # Step 3: If we reach the end of the list, break out of the loop
        break

# Print out the total count of items in the list
print(count)  # Output will be 4Altyapı:

6. enumerate() Kullanarak Listenin Boyutunu Bulma

Python’daki enumerate() işlevi, bir yinelenebilirin üzerine bir sayaç ekler ve bunu bir enumerate nesnesi olarak döndürür. Bu işlev genellikle döngülerde hem dizini hem de listedeki öğenin değerini almak için kullanılır. enumerate() tipik olarak listenin boyutunu bulmak için kullanılmasa da, Python’un ne kadar esnek olabileceğini göstermek için bu yoldan da yararlanabiliriz.

# Step 1: Enumerate the list and convert it to a list of tuples (index, element)
enumerated_list = list(enumerate(my_list))

# Step 2: Extract the last tuple (which contains the last index and the last element)
last_tuple = enumerated_list[-1]

# Step 3: The size of the list is the last index plus 1 (because of zero-based indexing)
list_size = last_tuple[0] + 1

# Print out the size of the list
print(list_size)  # Output will be 4Altyapı:

7. NumPy Kullanarak Listenin Boyutunu Bulma

NumPy, bilimsel hesaplama alanında yaygın olarak kullanılan güçlü bir Python kütüphanesidir. Büyük, çok boyutlu diziler ve matrisler için destek sağlar ve bu diziler üzerinde çalışmaya yönelik pek çok matematiksel işlev sunar. Sayısal verilerle çalışanlar için NumPy, büyük veri kümelerinde verimli depolama ve işlemler sunduğundan vazgeçilmezdir. Python’da bir listenin boyutunu NumPy kullanarak bulmak için aşağıda gösterildiği gibi .size özniteliğinden yararlanabiliriz.

# Import the NumPy library
import numpy as np

# Step 1: Convert the list into a NumPy array
my_array = np.array(my_list)

# Step 2: Use the 'size' attribute of the NumPy array to find its size
array_size = my_array.size

# Print out the size of the array (which is the same as the length of the list)
print(array_size)  # Output will be 4Altyapı:

8. map() ve sum() Kullanarak Listenin Boyutunu Bulma

List comprehension’a benzer şekilde, bu yöntem map() ile her öğe için 1 döndüren bir işlev uygular; ardından sum() ile bu değerleri toplayarak öğeleri sayar. Bu yöntem, Python’daki lambda işlevlerine aşinalık gerektirir. Hız kazanmak için şu Python lambda eğitimine göz atmayı unutmayın.

# Using map() and sum() to count the list's size
length = sum(map(lambda x: 1, my_list))
print(length)  # Output: 4Altyapı:

Farklı Python Liste Boyutu Yöntemlerinin Performansını Karşılaştırma

Listelerin boyutunu bulmanın sekiz yöntemini bilmek bir şey, en iyi yöntemi kullanmak başka bir şeydir. Tartışılan sekiz yöntemin performansını karşılaştırmak için, küçük Python kod parçalarını zamanlamayı kolaylaştıran Python’un timeit modülünü kullanacağız. Bu, her yöntemin yürütme hızı açısından nasıl bir tablo çizdiğine dair net bir fikir verecek. Çalıştırma sürelerinin bilgisayarınıza veya kodu nerede çalıştırdığınıza bağlı olarak değişebileceğini unutmayın.

Deneyi kurma

İşi kolaylaştırmak için listemizi ve her yöntem için işlevleri tanımlıyoruz. İşlevlere aşina değilseniz sorun değil; burada yaptığımız tek şey, karşılaştırmayı kolaylaştırmak için farklı yöntemleri sistematik hale getirmek.

import timeit
from functools import reduce
import numpy as np

# Define the list
my_list = ["I", "Love", "Learning", "Python"] * 100  # Increased size for better statistical signifcance

# Method 1: Using len()
def method_len():
    return len(my_list)

# Method 2: Looping through the list
def method_loop():
    counter = 0
    for _ in my_list:
        counter += 1
    return counter

# Method 3: Using a list comprehension
def method_list_comprehension():
    return sum([1 for _ in my_list])

# Method 4: Using reduce()
def method_reduce():
    return reduce(lambda acc, _: acc + 1, my_list, 0)

# Method 5: Using iter() and next()
def method_iter_next():
    iterator = iter(my_list)
    counter = 0
    while True:
        try:
            next(iterator)
            counter += 1
        except StopIteration:
            break
    return counter

# Method 6: Using enumerate()
def method_enumerate():
    return max(enumerate(my_list, 1))[0]

# Method 7: Using numpy
def method_numpy():
    np_array = np.array(my_list)
    return np_array.size

# Method 8: Using map() and sum()
def method_map_sum():
    return sum(map(lambda _: 1, my_list))Altyapı:

Her Yöntemi Zamanlama

Sıradaki adımda, belirtilen sıraya göre her bir işlevi zamanlamak için timeit.timeit() kullanacağız:

# List to hold method names and their execution times
timing_results = []

methods = [method_len, method_loop, method_list_comprehension, method_reduce, 
           method_iter_next, method_enumerate, method_numpy, method_map_sum]

# Time each method
for method in methods:
 # Execute the operation 100000 times for better statistical significance  
    time_taken = timeit.timeit(method, number=100000)
    timing_results.append((method.__name__, time_taken))

# Sort results by time taken for better readability
timing_results.sort(key=lambda x: x[1])

# Print the timing results
for method_name, time_taken in timing_results:
    print(f"{method_name}: {time_taken:.5f} seconds")Altyapı:

DataLab’de bunu çalıştırdığımızda aşağıdaki sonuçları elde ediyoruz:

Sonuç

Sonuç olarak, Python’da bir listenin boyutunu bulmaya yönelik çeşitli yöntemlere yaptığımız bu yolculuk, Python’un çok yönlülüğünü ve gücünü ortaya koymakla kalmadı; aynı zamanda farklı yaklaşımların verimliliğini ve uygulanabilirliğini anlamanın önemini de vurguladı.

Yeni başlayanlar için, performans ve okunabilirlik açısından optimize edilmiş, yerleşik len() gibi en basit ve en verimli yöntemlerle başlamak çok önemlidir. Listelerle çalışma hakkında daha fazlası için şu kaynaklara göz atın:

• Python Fundamentals beceri rotası
• Introduction to Python dersi
• Yeni Başlayanlar için Python Cheat Sheet