Listeler ve tuples arasındaki fark nedir?

Fark ne?

Tüplerin / listelerin avantajları / dezavantajları nelerdir?

Tupllerin değişmez olmasının yanı sıra, kullanımlarına rehberlik etmesi gereken bir anlamsal ayrım da vardır. Gruplar heterojen veri yapılarıdır (yani girişleri farklı anlamlara sahiptir), listeler homojen dizilerdir. Tuples'in yapısı, listelerin düzeni var.

Bu ayrımı kullanmak kodu daha açık ve anlaşılır hale getirir.

Bir örnek, bir kitaptaki konumlara referans vermek için sayfa çiftleri ve satır numarasıdır, örneğin:

my_location = (42, 11)  # page number, line number

Ardından, notları konumlarda saklamak için sözlükte bir anahtar olarak kullanabilirsiniz. Öte yandan bir liste birden fazla konumu saklamak için kullanılabilir. Doğal olarak, listeye konum eklemek veya listeden konum kaldırmak isteyebilirsiniz, bu nedenle listelerin değiştirilebilir olduğu mantıklıdır. Öte yandan, mevcut bir konuma öğe eklemek veya mevcut bir konuma öğe çıkarmak mantıklı değildir;

Varolan bir konum demetindeki öğeleri değiştirmek istediğiniz durumlar olabilir, örneğin bir sayfanın satırları boyunca yineleme yaparken. Ancak grup değişmezliği sizi her yeni değer için yeni bir konum grubu oluşturmaya zorlar. Bu yüzünde rahatsız edici görünüyor, ancak bunun gibi değişmez veriler kullanmak, önemli avantajlara sahip olabilen değer türlerinin ve fonksiyonel programlama tekniklerinin temel taşıdır.

Bu konuda bazı ilginç makaleler var, örneğin "Python Tuples Sadece Sabit Listeler Değil" veya "Tytles ve Python'daki listelerin anlaşılması" . Resmi Python belgeleri de bundan bahsediyor

"Tupler değişmezdir ve genellikle heterojen bir sekans içerir ...".

Haskell gibi statik olarak yazılan bir dilde , bir demet içindeki değerler genellikle farklı tiplere sahiptir ve demetin uzunluğu sabitlenmelidir. Bir listede değerlerin tümü aynı tiptedir ve uzunluk sabit değildir. Yani fark çok açık.

Son olarak , bir demet zaten yapıya sahip olduğu için Python'da adlandırılmış üçlü var. Bu, tuple'lerin sınıflara ve örneklere hafif bir alternatif olduğu fikrinin altını çiziyor.

Liste ve demet arasındaki fark

1. kelimesi kelimesine

   someTuple = (1,2)
   someList  = [1,2] 

2. Boyut

   a = tuple(range(1000))
   b = list(range(1000))
   
   a.__sizeof__() # 8024
   b.__sizeof__() # 9088

   Bir tuple işleminin daha küçük boyutu nedeniyle, biraz daha hızlı hale gelir, ancak çok sayıda öğeye sahip oluncaya kadar bahsetmek için çok fazla şey olmaz.

3. İzin verilen işlemler

   b    = [1,2]   
   b[0] = 3       # [3, 2]
   
   a    = (1,2)
   a[0] = 3       # Error

   Bu ayrıca bir öğeyi silemeyeceğiniz veya bir tuple sıralayamayacağınız anlamına gelir. Bununla birlikte, hem listeye hem de tuple'a yeni bir eleman ekleyebilirsiniz; tek fark, tuple değişmez olduğundan, gerçekten bir eleman eklemezsiniz, ancak yeni bir tuple yaratırsınız, böylece kimliği değişecektir

   a     = (1,2)
   b     = [1,2]  
   
   id(a)          # 140230916716520
   id(b)          # 748527696
   
   a   += (3,)    # (1, 2, 3)
   b   += [3]     # [1, 2, 3]
   
   id(a)          # 140230916878160
   id(b)          # 748527696

4. kullanım

   Liste değiştirilebilir olduğu için sözlükte anahtar olarak kullanılamaz, oysa bir demet kullanılabilir.

   a    = (1,2)
   b    = [1,2] 
   
   c = {a: 1}     # OK
   c = {b: 1}     # Error

Eğer bir yürüyüşe gittiyseniz, herhangi bir anda koordinatlarınızı bir (x,y)demet halinde not edebilirsiniz .

Yolculuğunuzu kaydetmek istiyorsanız, konumunuzu birkaç saniyede bir listeye ekleyebilirsiniz.

Ama bunu başka türlü yapamazdın.

Temel fark, tupllerin değişmez olmasıdır. Bu, bir demet oluşturduktan sonra değerleri değiştiremeyeceğiniz anlamına gelir.

Bu nedenle, değerleri değiştirmeniz gerekirse bir Liste kullanın.

Tuples için faydaları:

1. Hafif performans artışı.
2. Bir demet değiştirilemez olduğundan sözlükte bir anahtar olarak kullanılabilir.
3. Bunu değiştiremezseniz, başka herhangi bir kişi de olamaz, yani herhangi bir API işlevi vb. Hakkında endişelenmenize gerek yoktur.

Listeler değiştirilebilir; tuples değil.

Gönderen docs.python.org/2/tutorial/datastructures.html

Tupller değişmezdir ve genellikle ambalajdan çıkarma (bu bölümün ilerleyen kısımlarında bakınız) veya indeksleme (hatta adlandırılmış üçlü durumunda özniteliğe göre) yoluyla erişilen heterojen bir eleman dizisi içerir. Listeler değiştirilebilir ve öğeleri genellikle homojendir ve liste üzerinde yineleme yapılarak erişilebilir.

Oluyor belirtilmiş fark büyük ölçüde semantik şudur: insanlar tuple ve liste farklı bilgileri temsil bekliyoruz. Ancak bu bir kılavuzdan daha ileri gider; bazı kütüphaneler aslında geçtiklerine göre farklı davranırlar. Örneğin NumPy'yi alın ( daha fazla örnek istediğim başka bir gönderiden kopyalandı ):

>>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> idx = (1,1)
>>> a[idx]
4
>>> idx = [1,1]
>>> a[idx]
array([[3, 4, 5],
       [3, 4, 5]])

Mesele şu ki, NumPy standart kütüphanenin bir parçası olmasa da, bu büyük bir Python kütüphanesi ve NumPy listeleri ve tuples'leri tamamen farklı şeyler.

Listeler döngü için, tuples yapılar için yani "%s %s" %tuple .

Listeler genellikle homojendir, tüller genellikle heterojendir.

Listeler değişken uzunluk, tupler sabit uzunluk içindir.

Bu Python listelerine bir örnektir:

my_list = [0,1,2,3,4]
top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]

Bu Python grubunun bir örneğidir:

my_tuple = (a,b,c,d,e)
celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")

Python listeleri ve tuples, her ikisinin de sıralı değer koleksiyonları olması bakımından benzerdir. Listelerin "[..., ...]" köşeli parantezleri ve "(..., ...)" parantezleri kullanılarak oluşturulan sığ farkın yanı sıra, aralarındaki temel teknik "Python sözdiziminde sabit kodlanmış" fark belirli bir grubun öğelerinin değişmez olduğu, ancak listelerin değişebildiği (... bu nedenle yalnızca tuples yıkanabilir ve sözlük / karma anahtarları olarak kullanılabilir!). Bu, nasıl kullanıp kullanılamayacakları (sözdizimiyle bir önsezi zorunlu kılıyor) ve insanların bunları kullanmayı nasıl seçtikleri ('en iyi uygulamalar', bir posteriori olarak teşvik edilir), akıllı programcıların yaptığı şey budur . insanlar elementlerin düzenini verir.

Tuples için, 'düzen' bilgi tutmak için sadece belirli bir 'yapıdan' başka bir şey ifade etmez. İlk alanda bulunan değerler, her biri iki farklı boyutta veya ölçekte değerler sağladığından kolayca ikinci alana dönüştürülebilir. Farklı tür sorulara cevap verirler ve tipik olarak şu şekildedirler: belirli bir nesne / konu için özellikleri nelerdir? Nesne / özne sabit kalır, öznitelikler farklıdır.

Listeler için 'sipariş' bir sıra veya yönlülük anlamına gelir. İkinci eleman , birinci elemandan sonra gelmelidir ZORUNLUDUR çünkü belirli ve ortak bir ölçeğe veya boyuta göre 2. sırada yer alır. Elemanlar bir bütün olarak ele alınır ve çoğunlukla belirli bir özellik için tipik olarak formdaki tek bir soruya cevaplar sağlar , bu nesneler / konular nasıl karşılaştırılır? Öznitelik sabit kalır, nesne / özne farklıdır.

Popüler kültürde ve bu farklılıklara uymayan programcıların sayısız örneği vardır ve ana kursları için salata çatalı kullanabilen sayısız insan vardır. Günün sonunda, sorun değil ve her ikisi de genellikle işi halledebilir.

İnce ayrıntıları özetlemek için

benzerlikler:

1. Kopyalar - Hem tuples hem de listeler kopyalara izin verir

2. Dizin Oluşturma, Seçme ve Dilimleme - Parantez içinde bulunan tamsayı değerlerini kullanarak hem tuples hem de listeyi listeler. Dolayısıyla, belirli bir listenin veya grubun ilk 3 değerini istiyorsanız, sözdizimi aynı olur:

   >>> my_list[0:3]
   [0,1,2]
   >>> my_tuple[0:3]
   [a,b,c]

3. Karşılaştırma ve Sıralama - İki tuple veya iki liste hem ilk öğeleriyle hem de bir kravat varsa, ikinci öğe ile karşılaştırılır. Önceki elemanlar bir fark gösterdikten sonra sonraki elemanlara daha fazla dikkat edilmez.

   >>> [0,2,0,0,0,0]>[0,0,0,0,0,500]
   True
   >>> (0,2,0,0,0,0)>(0,0,0,0,0,500)
   True

Farklılıklar: - Bir a priori, tanım gereği

1. Sözdizimi - Listeler kullanım [], tuples use ()

2. Değiştirilebilirlik - Belirli bir listedeki öğeler değiştirilebilir, belirli bir gruptaki öğeler değiştirilebilir DEĞİLDİR.

   # Lists are mutable:
   >>> top_rock_list
   ['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son']
   >>> top_rock_list[1]
   'Kashmir'
   >>> top_rock_list[1] = "Stairway to Heaven"
   >>> top_rock_list
   ['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son']
   
   # Tuples are NOT mutable:       
   >>> celebrity_tuple
   ('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead')
   >>> celebrity_tuple[5]
   'Dead'
   >>> celebrity_tuple[5]="Alive"
   Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   TypeError: 'tuple' object does not support item assignment

3. Hashtables (Sözlükler) - Hashhtables (sözlükler) anahtarlarının yıkanabilir olmasını ve dolayısıyla değişmez olmasını gerektirdiğinden, listeler değil yalnızca tuples sözlük anahtarı olarak işlev görebilir.

   #Lists CAN'T act as keys for hashtables(dictionaries)
   >>> my_dict = {[a,b,c]:"some value"}
   Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   TypeError: unhashable type: 'list'
   
   #Tuples CAN act as keys for hashtables(dictionaries)
   >>> my_dict = {("John","Wayne"): 90210}
   >>> my_dict
   {('John', 'Wayne'): 90210}

Farklar - Kullanımdaki bir posteriori

1. Homo - Elementlerin Heterojenitesi - Genel olarak liste nesneleri homojendir ve tuple nesneleri heterojendir. Yani, listeler aynı türden nesneler / konular için kullanılır (tüm başkan adayları veya tüm şarkılar veya tüm koşucular gibi), oysa zorlanmasa da, tupolar heterojen nesneler için daha fazladır.

2. Döngü ve Yapılar - Her ikisi de döngüye izin verse de (listemdeki x için ...), bunu bir liste için yapmak gerçekten mantıklı. Tuples bilgileri yapılandırmak ve sunmak için daha uygundur (% s içinde bulunan% s% s,% s ve şu anda% s% ("John", "Wayne", 90210, "Aktör", "Ölü"))

Değerleri Liste her zaman değiştirilebilir, ancak tuples değerleri değiştirilemez.

Avantajlar ve dezavantajlar kullanımına bağlıdır. Asla değiştirmek istemediğiniz bir veri varsa, o zaman tuple kullanmanız gerekir, aksi takdirde liste en iyi seçenektir.

Liste ve demet arasındaki fark

Tuples ve listelerin her ikisi de Python'daki benzer dizi türleridir.

1. Değişmez sözdizimi

   Yeni bir liste almak için tuples ve köşeli parantez [ ]oluşturmak için parantez ( ) kullanırız . Ayrıca, gerekli yapıyı elde etmek için uygun türdeki çağrıyı kullanabiliriz - grup veya liste.

   someTuple = (4,6)
   someList  = [2,6] 

2. mutability

   Tupller değişmezken, listeler değiştirilebilir. Bu nokta, aşağıdakiler için temeldir.

3. Hafıza kullanımı

   Değişebilirlik nedeniyle, listeler için daha fazla belleğe ve tuples için daha az belleğe ihtiyacınız vardır.

4. uzatma

   Hem tuples hem de listelere, tuple kimliğinin değiştirileceği tek farkla yeni bir öğe ekleyebilirsiniz (yani, yeni bir nesnemiz olacak).

5. Karma

   Tuples yıkanabilir ve listeler değildir. Bu, bir sözlüğü bir sözlükte anahtar olarak kullanabileceğiniz anlamına gelir. Liste sözlükte anahtar olarak kullanılamaz, oysa bir demet kullanılabilir

   tup      = (1,2)
   list_    = [1,2] 
   
   c = {tup   : 1}     # ok
   c = {list_ : 1}     # error

6. semantik

   Bu nokta en iyi uygulama hakkındadır. Listeleri homojen dizilerken, tüpleri heterojen veri yapıları olarak kullanmalısınız.

Listelerin homojen diziler olması amaçlanırken, tupolar heterojen veri yapılarıdır.

İnsanlar burada zaten cevap verdiği tuplesgibi değişmezlists olan değişebilir, ancak hatırlamamız gereken tuples kullanmanın önemli bir yönü var

Eğer tuplebir içeriyorsa listveya dictionaryiçine eğer, o bile değiştirilebilirtuple kendisi sabittir.

Örneğin, bir liste ve sözlük içeren bir grubumuz olduğunu varsayalım.

my_tuple = (10,20,30,[40,50],{ 'a' : 10})

listenin içeriğini şu şekilde değiştirebiliriz:

my_tuple[3][0] = 400
my_tuple[3][1] = 500

bu da yeni parçayı

(10, 20, 30, [400, 500], {'a': 10})

tuple içindeki sözlüğü şu şekilde de değiştirebiliriz:

my_tuple[4]['a'] = 500

bu da genel parçanın

(10, 20, 30, [400, 500], {'a': 500})

Bu olur çünkü listvedictionary nesnelerdir ve bu nesneler değişen değildir, ancak içeriğine onun işaret etmek.

Yani tupleistisnasız değişmez kalıyor

PEP 484 - Tip İpuçları bir unsurlarının türleri söylüyor tuplebireysel olarak yazılabilir; diyebilirsiniz ki Tuple[str, int, float]; ancak a list, Listtyping class ile yalnızca bir tür parametresi alabilir:List[str] bu, 2'nin farkının gerçekten birincisinin heterojen olduğunu, ikincisinin de özdeş olarak homojen olduğunu ima eder.

Ayrıca, standart kütüphane çoğunlukla C'yi a'nın döneceği standart fonksiyonlardan bir dönüş değeri olarak tuple kullanır struct.

İnsanlar farklılıklardan daha önce bahsettiğim gibi neden tuples hakkında yazacağım.

Tuples neden tercih edilir?

Küçük şişeler için tahsis optimizasyonu

Bellek parçalanmasını azaltmak ve ayırmaları hızlandırmak için Python eski kapları yeniden kullanır. Bir tuple artık gerekmiyorsa ve kalıcı olarak silmek yerine 20'den az öğe içeriyorsa Python onu ücretsiz bir listeye taşır.

Ücretsiz bir liste 20 gruba ayrılır, burada her grup 0 ile 20 arasında n uzunluğundaki tuplların bir listesini temsil eder. Her grup en fazla 2.000 tuple depolayabilir. İlk (sıfır) grup sadece 1 eleman içerir ve boş bir tupu temsil eder.

>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104

Yukarıdaki örnekte, a ve b'nin aynı kimliğe sahip olduğunu görebiliriz. Çünkü derhal, serbest listedeki yıkılmış bir tupu işgal ettik.

Listeler için tahsis optimizasyonu

Listeler değiştirilebildiğinden, Python gruplardakiyle aynı optimizasyonu kullanmaz. Bununla birlikte, Python listelerinin de ücretsiz bir listesi vardır, ancak yalnızca boş nesneler için kullanılır. Boş bir liste GC tarafından silinir veya toplanırsa, daha sonra tekrar kullanılabilir.

>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792

Kaynak: https://rushter.com/blog/python-lists-and-tuples/

Tüller neden listelerden daha verimlidir? -> https://stackoverflow.com/a/22140115

5.3'teki belgelerden bir yön teklifi . Tuples ve Diziler :

Tüpler listelere benzer görünse de, genellikle farklı durumlarda ve farklı amaçlar için kullanılırlar. Tupller değişmezdir ve genellikle ambalajdan çıkarma (bu bölümün ilerleyen kısımlarında bakınız) veya indeksleme (hatta adlandırılmış üçlü durumunda öznitelik yoluyla) ile erişilen heterojen bir eleman dizisi içerir . Listeler değiştirilebilir ve öğeleri genellikle homojendir ve liste üzerinde yineleme yapılarak erişilebilir .

Her şeyden önce, her ikisi de Python'daki skaler olmayan nesnelerdir (bileşik nesneler olarak da bilinir).

• Tuples, sıralı eleman dizisi (diğer adlandırma sorunu olmayan herhangi bir nesneyi içerebilir)
  • Değişmez (tuple, int, float, str)
  • Birleştirme +(elbette yepyeni bir grup oluşturulacak)
  • indeksleme
  • Dilimleme
  • Singleton (3,) # -> (3)yerine(3) # -> 3
• Liste (Diğer dillerde dizi), sıralı değer sırası
  • değişken
  • Singleton [3]
  • Klonlama new_array = origin_array[:]
  • Liste kavrayışı [x**2 for x in range(1,7)]size verir [1,4,9,16,25,36](Okunamaz)

Listeyi kullanmak da bir takma ad hatasına neden olabilir (aynı nesneyi gösteren iki farklı yol).

Listeler değiştirilebilir ve tupller değiştirilemez. Sadece bu örneği düşünün.

a = ["1", "2", "ra", "sa"]    #list
b = ("1", "2", "ra", "sa")    #tuple

Şimdi listenin ve demetin dizin değerlerini değiştirin.

a[2] = 1000
print a     #output : ['1', '2', 1000, 'sa']
b[2] = 1000
print b     #output : TypeError: 'tuple' object does not support item assignment.

Bu nedenle, aşağıdaki kodun tuple ile geçersiz olduğunu kanıtladık, çünkü izin verilmeyen bir tupleı güncellemeye çalıştık.

Liste değişebilir ve tuples değişmez. Değişken ve değişmez arasındaki temel fark, bir öğe eklemeye çalışırken bellek kullanımıdır.

Bir değişken oluşturduğunuzda, değişkene bir miktar sabit bellek atanır. Bir liste ise, gerçekte kullanılandan daha fazla bellek atanır. Örneğin, geçerli bellek ataması 100 bayt ise, 101 bayt eklemek istediğinizde, belki başka bir 100 bayt atanır (bu durumda toplam 200 bayt).

Ancak, sık sık yeni öğeler eklemediğinizi biliyorsanız, o zaman tuples kullanmalısınız. Tuples tam olarak gereken belleğin boyutunu atar ve bu nedenle özellikle büyük bellek blokları kullandığınızda bellek tasarrufu sağlar.