Python Tuple vs List: Benzerlikler ve Farklılıklar, Açıklaması

Bu kılavuzda, Python demetleri ve listeleri arasındaki benzerlikleri ve farklılıkları öğreneceksiniz. Bir Tuple'ı ne zaman kullanmanız gerektiğini de anlayacaksınız.

Liste ve demetler, Python'da yerleşik veri yapılarıdır. Bir öğe koleksiyonunu depolamak için kullanılabilirler.

Dizin oluşturma ve dilimleme desteğinden heterojen veri türlerini içermeye kadar, demetler ve listeler benzer işlevlere sahip görünebilir. Bu nedenle, ikisi arasındaki benzerlikleri ve farklılıkları anlamak, hangi veri yapısının kullanılacağına karar vermenize yardımcı olabilir.

Hadi başlayalım.

Bir Python REPL başlatabilir ve bu öğreticiyi takip edebilirsiniz. Ayrıca kodlamak için Geekflare'nin çevrimiçi Python düzenleyicisini de kullanabilirsiniz.

Python Tuple vs Liste: Benzerlikler Nelerdir?

Listeler ve demetler arasındaki benzerlikleri öğrenerek başlayalım. Daha iyi öğrenmeyi kolaylaştırmak için hem liste hem de demet örnekleri sunuyoruz.

#1 . Python Yinelenebilirler

Python'da listeler bir çift köşeli parantez içine alınırken, demetler parantez içine alınır. Ayrıca, parantezler olmadan virgülle ayrılmış bir değerler kümesi olarak bir tanımlama grubu oluşturabilirsiniz.

Her ikisi de yinelenebilir; böylece bir for döngüsü kullanarak bunlar arasında dolaşabilirsiniz.

Aşağıdaki kod hücresi, bir listenin nasıl yineleneceğini gösterir.

 nums = [2,6,7,10] print(f"Type of nums is {type(nums)}") for num in nums: print(num) # Output Type of nums is <class 'list'> 2 6 7 10

Aşağıda açıklandığı gibi, ayrıca bir döngü kullanarak bir demeti yineleyebilirsiniz.

 nums = (2,6,7,10) # Note: nums = 2,6,7,10 is a valid tuple as well. If needed, run a quick check! print(f"Type of nums is {type(nums)}") for num in nums: print(num) # Output Type of nums is <class 'tuple'> 2 6 7 10

# 2 . Diğer Dizilerden Oluşturma Desteği

Listeler ve demetler arasındaki bir sonraki benzerlik, dizeler gibi mevcut dizilerden oluşturulabilmeleridir.

 sample_str = "Coding!"

Aşağıdaki kod hücresi, list(string) öğesinin, liste öğeleri dizedeki karakterler olan bir listeyi nasıl döndürdüğünü gösterir.

 list_from_str = list(sample_str) print(list_from_str) # Output ['C', 'o', 'd', 'i', 'n', 'g', '!']

Benzer şekilde, tuple(sequence) kullanılarak bir dizeden veya başka bir diziden bir demet oluşturulabilir. Aşağıdaki kod hücresi bunu nasıl yapabileceğinizi gösterir.

 tuple_from_str = tuple(sample_str) print(tuple_from_str) # Output ('C', 'o', 'd', 'i', 'n', 'g', '!')

#3 İndeksleme ve Dilimleme Desteği

Python, ilk öğenin indeks sıfırda, ikincisinin indeks birde vb. olduğu sıfır indekslemeyi destekler. Python ayrıca, son öğenin dizin -1'de olduğu, sondan ikinci öğenin dizin -2'de olduğu vb. negatif dizinlemeyi de destekler.

 list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o

-2 dizinindeki öğe sondan ikinci öğedir, 'g'.

 tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!') print(tuple_from_str[-2]) # g

Listenin veya demetin küçük bir bölümüyle çalışmak istediğinizde dilimlemeyi kullanabilirsiniz. list[start:end], dizin başlangıcından başlayıp sonuna kadar uzanan listenin bir dilimini döndürür – 1 Başlangıç ​​için varsayılan değer 0'dır ve bitiş, yinelenebilirdeki son öğedir.

Aynı sözdizimini kullanarak demetleri dilimleyebilirsiniz. Daha önce oluşturduğumuz liste ve demetin dilimlerini oluşturalım.

 list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'i', 'n']

Başlangıç ​​ve bitiş değerlerine ek olarak bir adım değeri de belirtebilirsiniz. tuple(start:end:step) , step adımlarında start end - 1 kadar demetin bir dilimini döndürür.

 tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!') print(tuple_from_str[::2]) ('C', 'd', 'n', '!')

Burada step değerini 2 olarak ayarladık. Böylece dilim her ikinci elemanı içerir.

#4 Çoklu Veri Türlerinin Koleksiyonları

İncelediğimiz örneklerde, listedeki tüm öğeler ve demetler aynı veri türündeydi.

Ancak, farklı veri türlerinin değerlerini tek bir liste veya bir demet içinde saklayabilirsiniz.

student_list altındaki kod parçacığı, bir dize olarak bir öğrencinin adını, bir tamsayı olarak yaşı ve bir kayan nokta olarak sabitlenmiş işaretleri içerir.

 student_list = ["John",22,96.5] for item in student_list: print(f"{item} is of type {type(item)}") # Output John is of type <class 'str'> 22 is of type <class 'int'> 96.5 is of type <class 'float'>

Tuple için de benzer bir örnek verebiliriz.

 student_tuple = ("Jane",23,99.5) for item in student_tuple: print(f"{item} is of type {type(item)}") # Output Jane is of type <class 'str'> 23 is of type <class 'int'> 99.5 is of type <class 'float'>

#5 . Üyelik Testi Desteği

Hem listeler hem de demetler, belirli öğelerin varlığı için üyelik testi yapmanızı sağlar. Listede veya demette belirli bir öğenin olup olmadığını kontrol etmek istiyorsanız, in operatörünü kullanabilirsiniz.

Yinelenebilir içindeki ifade item in iterable item iterable True olarak değerlendirilir; başka, False .

 "Alex" in student_list # False "Jane" in student_tuple # True

Şimdiye kadar Python'da listeler ve demetler arasındaki benzerlikleri öğrendiniz. Şimdi, iki veri yapısı arasındaki temel farkları öğrenelim.

Python Tuple vs Liste: Farklar Nelerdir?

#1 . Python'da Listelerin Değişebilirliği ve Tuplelerin Değişmezliği

Python'da bir liste ile bir demet arasındaki en önemli fark, bir demetin değişmez olmasıdır. Bu, bir Tuple'ı yerinde değiştiremeyeceğiniz anlamına gelir.

️ İşte bir örnek.

 tuple1 = ("Java","Python","C++") tuple1[0] = "Rust" # Output ----> 2 tuple1[0] = "Rust" TypeError: 'tuple' object does not support item assignment

Liste değiştirilebilir bir veri yapısıdır, bu nedenle aşağıdaki kod hücresinde olduğu gibi belirli bir dizindeki bir öğeyi değiştirerek listeyi değiştirebiliriz.

 list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']

# 2 . Değişken Uzunluk Listeleri ve Sabit Uzunluk Tuples

Python listesi, değişken uzunluklu bir veri yapısıdır.

Aşağıdakileri yapabilirsiniz:

• Listenin sonuna bir öğe ekleyin
• Geçerli listenin sonuna başka bir listeden öğeler ekleyin
• Listeden belirli bir dizindeki öğeleri kaldırın

 list1 = [2,3,4,5] # add an item to the end list1.append(9) print(list1) # add items from list2 to the end of list1 list2 = [0,7] list1.extend(list2) print(list1) # remove an item from list1 list1.pop(0) print(list1)

️ Yukarıdaki kod parçacığının çıktısı.

 # Output [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]

Tuple'lar sabit uzunluklu veri yapılarıdır. Bu nedenle, mevcut bir demete eleman ekleyemez veya kaldıramazsınız. Ancak tanımlama grubunu farklı öğeler içerecek şekilde yeniden tanımlayabilirsiniz.

 tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)

#3 Bellekteki Boyut

Şimdi önceki bölümde öğrendiklerimizin üzerine inşa edeceğiz: liste değişken uzunluklu bir veri yapısıdır.

Listeyi başlangıçta tanımladığınızda, bellekte ona belirli bir boyut tahsis edilir. Şimdi, append() veya extend() yöntemlerini kullanarak bir listeyi değiştirdiğinizde, eklenen öğeleri depolamak için ek bellek ayrılmalıdır. Bu ayırma, neredeyse her zaman eklediğiniz öğe sayısından daha fazla yapılır.

Bu nedenle, listedeki öğelerin sayısını ve ayrılan alanı takip etmeye ihtiyaç vardır. Ek olarak, listeler değişken uzunlukta olduğundan, liste öğelerinin adresini gösteren bir işaretçi vardır. Sonuç olarak, k uzunluğundaki listeler, aynı k elemanlı bir demetten daha fazla bellek kaplar.

İşte basit bir örnek.

Bellekteki bir nesnenin boyutunu almak için bir Python nesnesinde yerleşik sys modülünün getsizeof() yöntemini kullanabilirsiniz.

 import sys list1 = [4,5,9,14] list_size = sys.getsizeof(list1) print(f"Size of list:{list_size}") tuple1 = (4,5,9,14) tuple_size = sys.getsizeof(tuple1) print(f"Size of tuple:{tuple_size}")

Aşağıdaki çıktıda doğrulandığı gibi, bir liste, aynı sayı ve öğe değeri için bir demetten daha fazla bellek kaplar.

 # Output Size of list:104 Size of tuple:88

Python Tuple'ı Ne Zaman Kullanmalısınız?

Python listeleri ve demetler arasındaki farklılıklar ve benzerliklerden, değişken bir koleksiyona ihtiyacınız varsa, bir liste kullanmanız gerektiğini bilirsiniz.

Ancak bunun yerine ne zaman bir Tuple kullanmalısınız?

Bu bölümde bunu ele alacağız.

#1 . Salt Okunur Koleksiyon

Bir koleksiyonun değişmez olmasını istediğinizde, onu bir demet olarak tanımlamanız gerekir. color = (243,55,103) bir renk gölgesine karşılık gelen RGB değerlerini içeren bir demet olduğunu varsayalım. Rengi bir demet olarak tanımlamak, değiştirilememesini sağlar.

Özünde, salt okunur olacak bir koleksiyona ihtiyacınız olduğunda: değerler program sırasında değiştirilmemeli, bir demet kullanmayı düşünmelisiniz. Bu, değerlerin istenmeyen şekilde değiştirilmesini önleyecektir.

# 2 . Sözlük Tuşları

Örneğin, anahtar olarak key_list liste öğelerini kullanarak bir sözlük oluşturursunuz. Bir listeden sözlük oluşturmak için dict.fromkeys() yöntemini kullanabilirsiniz.

 key_list = list("ABCD") dict.fromkeys(key_list) {'A': None, 'B': None, 'C': None, 'D': None}

Sözlüğü oluşturmadan önce listeyi ilk öğe (indeks 0) olarak 'D' içerecek şekilde değiştirdiğinizi varsayalım.

Şimdi, 'A' sözlük anahtarına ne olacak?

key_list'ten bir sözlük oluşturmaya çalışırsanız ve 'A' KeyError karşılık gelen değere erişirseniz, bir key_list ile karşılaşırsınız.

 key_list[0] = 'D' dict.fromkeys(key_list)['A'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-31-c90392acc2cf> in <module>() ----> 1 dict.fromkeys(key_list)['A'] KeyError: 'A'

Bir sözlüğün anahtarları benzersiz olmalıdır. Yani anahtar olarak ikinci bir 'D'ye sahip olamazsınız.

 dict.fromkeys(key_list) {'B': None, 'C': None, 'D': None} # A is no longer a key.

Bunun yerine bir demet kullanırsanız, bu tür bir değişiklik imkansızdır ve hatalarla karşılaşmanız daha az olasıdır. Bu nedenle, Tuple öğelerini anahtar olarak kullanarak bir sözlük oluşturmayı tercih etmelisiniz.

 key_tuple = tuple("ABCD") dict.fromkeys(key_tuple) {'A': None, 'B': None, 'C': None, 'D': None} key_tuple[0] = 'D' --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-12-2cecbefa7db2> in <module>() ----> 1 key_tuple[0] = 'D' TypeError: 'tuple' object does not support item assignment

#3 Fonksiyon Argümanları

Tuple'ların değişmezliği, onları fonksiyon argümanları olarak iletilmeye uygun hale getirir.

Boyutları verilen bir küboidin hacmini döndüren aşağıdaki find_volume() işlevini göz önünde bulundurun: uzunluk, genişlik ve yükseklik.

 def find_volume(dimensions): l,b,h = dimensions return l*b*h

Bu boyutların, dimensions adlı bir listede mevcut olduğunu varsayalım. Argüman olarak dimensions olan find_volume() çağrısı, hacmi döndürür.

 dimensions = [2,8,5] find_volume(dimensions) 80

Bir listede saklanan boyutları her zaman değiştirebilirsiniz.

 dimensions = [20,8,5] find_volume(dimensions) 800

Ancak bazen değerlerin sabit kalması ve değişikliğe direnmesi gerekir. İşte o zaman argümanları bir demet olarak saklamayı ve onları fonksiyon çağrısında kullanmayı düşünmelisiniz.

#4 Fonksiyonlardan Dönüş Değerleri

Python'da, işlevlerden dönüş değerlerinde demetlerle karşılaşacaksınız. Bir işlevden birden çok değer döndürdüğünüzde, Python bunları dolaylı olarak bir tanımlama grubu olarak döndürür.

Şu işlevi göz önünde bulundurun return_even() :

 def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)

• Argüman olarak bir num alır
• [0,num) aralığındaki çift sayıların listesini ve bu listenin uzunluğunu döndürür.

num 20'nin değerini ayarlayalım ve işlevi çağıralım.

 num = 20

return_even() çağrılması, bir tanımlama grubundaki iki değeri döndürür. Doğrulama argümanı olarak işlev çağrısıyla type() işlevini çağırabilirsiniz.

 type(return_even(num)) # <class 'tuple'>

İlk öğe olarak çift sayıların listesini ve ikinci öğe olarak listenin uzunluğunu içeren bir demet olduğunu doğrulamak için dönüş değerini yazdırabilirsiniz.

 print(return_even(num)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], 10)

Tuple'da iki öğe olduğundan, bunları aşağıda gösterildiği gibi iki değişkene ayırabilirsiniz.

 even_nums, count = return_even(num) print(even_nums) print(count) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10

Çözüm

Umarım bu eğitim, Python Tuple vs list'in kapsamlı bir karşılaştırmasını sağlamıştır.

Öğreticiyi hızlı bir özet ile tamamlayalım:

• Liste ve demetler, Python'da yerleşik veri yapılarıdır.
• Benzerlikler : yinelenebilirler, indeksleme, dilimleme desteği, farklı veri türleri ve üyelik testi için operatör.
• Anahtar fark : Listeler değişkendir ve demetler değişmezdir.
• Diğer farklar : Sabit uzunluktaki demetler ve değişken uzunluktaki listeler, demetlerin hafızasında daha küçük boyut.
• Tuple'ı ne zaman kullanmalısınız? Değişmez koleksiyonlar, sözlük anahtarları ve işlev bağımsız değişkenleri için.

Ardından, pratik yapmak ve öğrenmek için Python projelerine göz atın. Veya yinelenen öğeleri Python listelerinden kaldırma yöntemlerini öğrenin. Mutlu öğrenme! o zaman, mutlu kodlama!