Neden Python'da (veya herhangi bir değiştirilemez veri türünde) tupllere ihtiyacımız var?

Birkaç python öğretici (bir tanesi için Python Dive) ve Python.org dil referansı okudum - Dilin neden tuples ihtiyacı olduğunu anlamıyorum.

Tuples'ın bir liste veya kümeye kıyasla hiçbir yöntemi yoktur ve bunları sıralamak için bir tuple set veya listeye dönüştürmem gerekirse, ilk etapta bir tuple kullanmanın anlamı nedir?

Değişmezlik?

Neden bir değişkenin bellekte tahsis edildiğinden farklı bir yerde yaşayıp yaşamadığını önemsiyor? Python'daki bu değişmezlik işi fazlasıyla vurgulanmış görünüyor.

C / C ++ 'da bir işaretçi ayırır ve geçerli bir belleğe işaret edersem, kullanmadan önce adresin boş olmadığı sürece adresin nerede olduğu umurumda değildir.

Bu değişkene ne zaman başvursam, işaretçinin hala orijinal adrese işaret edip etmediğini bilmeme gerek yok. Sadece null olup olmadığını kontrol edip kullanıyorum (ya da kullanmıyorum).

Python'da, bir dize (veya tuple) ayırdığımda x'e atadığımda, dizeyi değiştirdiğimde, neden orijinal nesne olup olmadığına bakarım? Değişken verilerimi işaret ettiği sürece önemli olan budur.

>>> x='hello'
>>> id(x)
1234567
>>> x='good bye'
>>> id(x)
5432167

x yine de istediğim verilere referansta bulunuyor, neden kimliğinin aynı mı yoksa farklı mı olduğuna kimin dikkat etmesi gerekiyor?

1. değişmez nesneler önemli ölçüde optimizasyon sağlayabilir; Bu muhtemelen dizelerde Java'da değişmezdir, oldukça ayrı ancak Python ile aynı zamanda gelişmiştir ve hemen hemen her şey gerçekten işlevsel dillerde değişmezdir.

2. özellikle Python'da sadece değişmezler yıkanabilir (ve dolayısıyla sözlüklerdeki setlerin veya anahtarların üyeleri). Yine, bu optimizasyon sağlar, ancak sadece "önemli" olmaktan çok daha fazlasıdır (tamamen değiştirilebilir nesneleri depolayan iyi karma tablolar tasarlamak bir kabustur - ya hash alır almaz her şeyin kopyalarını alırsınız ya da nesnenin hashını kontrol etmenin kabusu olur. son başvurudan bu yana değişti, çirkin kafasını taşıyor).

Optimizasyon sorununa örnek:

$ python -mtimeit '["fee", "fie", "fo", "fum"]'
1000000 loops, best of 3: 0.432 usec per loop
$ python -mtimeit '("fee", "fie", "fo", "fum")'
10000000 loops, best of 3: 0.0563 usec per loop

Yukarıdaki cevapların hiçbiri, Python'a yeni gelen pek çok şeyin tam olarak anlamadığı görünen tuples ve listelerin gerçek sorununa işaret etmiyor.

Tuples ve listeler farklı amaçlara hizmet eder. Homojen verileri depolar. Bunun gibi bir listeye sahip olabilirsiniz ve olması gerekir:

["Bob", "Joe", "John", "Sam"]

Listelerin doğru kullanılmasının nedeni, bunların hepsinin homojen veri türleri, özellikle de insanların adları olmasıdır. Ancak şöyle bir liste alın:

["Billy", "Bob", "Joe", 42]

Bu liste bir kişinin tam adı ve yaşıdır. Bu bir veri türü değil. Bu bilgileri depolamanın doğru yolu bir demet içinde ya da bir nesnedir. Diyelim ki birkaç tane var:

[("Billy", "Bob", "Joe", 42), ("Robert", "", "Smith", 31)]

Tuples ve Listelerin değişmezliği ve değişebilirliği temel fark değildir. Liste, aynı tür öğelerin listesidir: dosyalar, adlar, nesneler. Tuples, farklı nesne türlerinin bir gruplandırmasıdır. Farklı kullanımları vardır ve birçok Python kodlayıcısı, tuple'lerin ne anlama geldiğini gösteren listeleri kötüye kullanır.

Lütfen yapma.

Düzenle:

Sanırım bu blog yazısı bunu neden benden daha iyi düşündüğümü açıklıyor: http://news.e-scribe.com/397

bir diziyi sıralayabilmek için bir kümeye veya listeye dönüştürmem gerekiyorsa, öncelikle bir diziyi kullanmanın anlamı nedir?

Bu özel durumda, muhtemelen bir anlamı yoktur. Bu bir sorun değil, çünkü bu bir demet kullanmayı düşüneceğiniz durumlardan biri değil.

İşaret ettiğiniz gibi, tuples değişmez. Değişmez tiplere sahip olmanın nedenleri tuple için geçerlidir:

• kopyalama verimliliği: değişmez bir nesneyi kopyalamak yerine onu diğer adla değiştirebilirsiniz (bir değişkeni bir referansa bağlayabilirsiniz)
• karşılaştırma verimliliği: referansla kopyalamayı kullanırken, içeriği değil konumu karşılaştırarak iki değişkeni karşılaştırabilirsiniz
• stajyerlik: herhangi bir değişmez değerin en fazla bir kopyasını saklamanız gerekir
• eşzamanlı kodda değiştirilemeyen nesnelere erişimi senkronize etmeye gerek yoktur
• const doğruluk: bazı değerlerin değiştirilmesine izin verilmemelidir. Bu (benim için) değişmez türlerin ana nedenidir.

Belirli bir Python uygulamasının yukarıdaki özelliklerin tümünü kullanamayabileceğini unutmayın.

Sözlük anahtarları değiştirilemez olmalıdır, aksi takdirde bir anahtar nesnenin özelliklerini değiştirmek temeldeki veri yapısının değişmezlerini geçersiz kılabilir. Böylece tüller potansiyel olarak anahtar olarak kullanılabilir. Bu, const doğruluğunun bir sonucudur.

Ayrıca "Bkz Tanıtımı dizilerini gelen," Dalış içine Python .

Bazen nesneleri sözlük anahtarı olarak kullanmak isteriz

Değeri için, son zamanlarda tuples (2.6+) büyüdü index()ve count()yöntemler

Her zaman aynı temel veri yapısının (diziler) garip bir tasarım olması için iki ayrı tipe sahip olduğunu gördüm, ancak pratikte gerçek bir sorun değil. (Her dilin siğilleri vardır, Python dahil, ancak bu önemli değildir.)

Neden bir değişkenin bellekte tahsis edildiğinden farklı bir yerde yaşayıp yaşamadığını önemsiyor? Python'daki bu değişmezlik işi fazlasıyla vurgulanmış görünüyor.

Bunlar farklı şeyler. Değişebilirlik, bellekte depolandığı yerle ilgili değildir; işaret edeceği şeylerin değişemeyeceği anlamına gelir .

Python nesneleri oluşturulduktan, değiştirildikten veya değiştirilmedikten sonra konumu değiştiremez. (Daha doğrusu, id () değeri değişemez - pratikte aynı şey.) Değişebilir nesnelerin dahili depolaması değişebilir, ancak bu gizli bir uygulama detayıdır.

>>> x='hello'
>>> id(x)
1234567
>>> x='good bye'
>>> id(x)
5432167

Bu, değişkeni değiştirmez ("değiştirir"); aynı ada sahip yeni bir değişken oluşturur ve eskisini atar. Bir mutasyon işlemiyle karşılaştırın:

>>> a = [1,2,3]
>>> id(a)
3084599212L
>>> a[1] = 5
>>> a
[1, 5, 3]
>>> id(a)
3084599212L

Diğerlerinin de belirttiği gibi, dizilerin sözlükler ve değişmezlik gerektiren diğer veri yapıları için anahtar olarak kullanılmasına izin verir.

Sözlük anahtarlarının tamamen değişmez olması gerekmediğini unutmayın. Sadece anahtar olarak kullanılan kısmının değişmez olması gerekir; bazı kullanımlar için bu önemli bir ayrımdır. Örneğin, bir kullanıcıyı temsil eden, eşitlik ve karma değerini benzersiz kullanıcı adıyla karşılaştıran bir sınıfınız olabilir. Daha sonra sınıfta diğer değişken verileri asabilirsiniz - "kullanıcı giriş yaptı", vb. Bu eşitlik veya karmayı etkilemediğinden, bunu sözlükte bir anahtar olarak kullanmak mümkündür ve mükemmel bir şekilde geçerlidir. Bu Python'da çok yaygın olarak gerekli değildir; Ben sadece birkaç kişi anahtarların "değişmez" olması gerektiğini iddia etti, çünkü bu sadece kısmen doğru işaret. Bunu birçok kez C ++ haritaları ve setleriyle birlikte kullandım.

Bir yorumda sunulan gnibbler'ın Guido'nun tamamen kabul edilmeyen / takdir edilmeyen bir görüşü vardı : “listeler homojen veriler için, tupeller heterojen veriler içindir”. Elbette, muhaliflerin çoğu bunu bir listenin tüm öğelerinin aynı türden olması gerektiği şeklinde yorumladı.

Farklı görmeyi seviyorum , geçmişte başkalarının aksine değil :

blue= 0, 0, 255
alist= ["red", "green", blue]

Tip (alist [1])! = Tip (alist [2]) olsa bile alistin homojen olduğunu düşünüyorum.

Elemanların sırasını değiştirebilir ve kodumda (varsayımlar dışında, örneğin "sıralanmalıdır") sorunum olmazsa, bir liste kullanılmalıdır. Değilse ( blueyukarıdaki demette olduğu gibi), o zaman bir demet kullanmalıyım.

Arayan kişiye geçtikleri nesnenin mutasyona uğramayacağını garanti ettikleri için önemlidirler. Eğer bunu yaparsan:

a = [1,1,1]
doWork(a)

Arayanın, aramadan sonraki a değerinin garantisi yoktur . Ancak,

a = (1,1,1)
doWorK(a)

Şimdi arayan veya bu kodun bir okuyucu olarak biliyoruz bir aynıdır. Bu senaryo için her zaman listenin bir kopyasını oluşturabilir ve iletebilirsiniz, ancak şimdi daha anlamsal mantıklı bir dil yapısı kullanmak yerine döngüleri boşa harcıyorsunuz.

bununla ilgili bazı tartışmalar için burada görebilirsiniz

Sorunuz (ve takip yorumları) bir ödev sırasında id () değerinin değişip değişmediğine odaklanır. Değişmez nesnenin değiştirilmesi ve değişebilir nesne modifikasyonu arasındaki farkın bu takip etkisine odaklanmak, farkın kendisinden ziyade belki de en iyi yaklaşım değildir.

Devam etmeden önce, aşağıda gösterilen davranışın Python'dan beklediğiniz şey olduğundan emin olun.

>>> a1 = [1]
>>> a2 = a1
>>> print a2[0]
1
>>> a1[0] = 2
>>> print a2[0]
2

Bu durumda, sadece a1'in yeni bir değeri atanmış olmasına rağmen a2'nin içeriği değiştirildi. Aşağıdakilerin aksine:

>>> a1 = (1,)
>>> a2 = a1
>>> print a2[0]
1
>>> a1 = (2,)
>>> print a2[0]
1

Bu son durumda, içeriğini güncellemek yerine listenin tamamını değiştirdik. Tuples gibi değişmez tiplerde, izin verilen tek davranış budur.

Bu neden önemli? Diyelim ki bir kararınız var:

>>> t1 = (1,2)
>>> d1 = { t1 : 'three' }
>>> print d1
{(1,2): 'three'}
>>> t1[0] = 0  ## results in a TypeError, as tuples cannot be modified
>>> t1 = (2,3) ## creates a new tuple, does not modify the old one
>>> print d1   ## as seen here, the dict is still intact
{(1,2): 'three'}

Bir demet kullanarak sözlük, anahtarlarının "altından" farklı bir değere hash edilen öğelere dönüştürülmesini güvenlidir. Bu, etkili uygulama için kritik öneme sahiptir.