Python standart kitaplık öğreticisi iki işlev aracı (tam bir eğitim seti ile)
Python standart kitaplık serisi eğitimi (2) -functools (bölüm 2)
Python gelişmiş öğreticisi
Makine öğrenme
Derin öğrenme
Metni girin
01
Beyan
functools, itertools, operator, Python standart kitaplığı tarafından sağlanan destektir Fonksiyonel programlama Bu üç modülü makul bir şekilde kullanarak, daha kısa ve okunaklı Pythonic kodu yazabiliriz.Bu makale dizisi, python ile birlikte gelen bu standart modülleri tanıtacak ve kullanacaktır. Makale dizisi bölümler halinde serileştirilmiştir. İkinci bölümde geniş içerik göz önünde bulundurularak okumayı kolaylaştırmak için ikinci bölüm ikinci bölüm olan üç bölüme ayrılmıştır. İlgilenen arkadaşlar, daha sonra öğrenmeye dikkat etmeyi unutmayın!
Python Standart Kitaplığının İşlevsel Araçları
içindekiler
1 kısmi işlev
2 kısmi yöntem işlevi
3 azaltma işlevi
4 sarma işlevi
5 update_wrapper işlevi
6 singledispatch işlevi
7 total_ordering işlevi
8 cmp_to_key işlevi
8 adlandırılmış çift işlevi
Alanın uzunluğu göz önüne alındığında, functools modülü açıklama için üç bölüme ayrılacaktır.
Bölüm I: kısmi, kısmi yöntem
Bölüm II: küçültme, sarma, güncelleme_ sarmalayıcı
Bölüm II: singledispatch, total_ordering, cmp_to_key
adlı çift
Önceki iki makaleye devam edin:
Python standart kitaplık serisi eğitimi (2) -functools (bölüm 1)
Python standart kitaplık serisi eğitimi (2) -functools (bölüm 2)
06
tek seferlik
C #, C ++, Java gibi birçok dilde fonksiyon aşırı yükleme (yeniden yazma) olduğunu biliyoruz. Yani aynı fonksiyon adı, farklı parametre türleri nedeniyle farklı işlevleri gerçekleştirir.Bu statik diller için çok önemlidir, ancak python dinamik bir dildir.Fonksiyonları tanımlarken, parametre türlerini belirtmeye gerek yoktur. Bu nedenle, fonksiyon aşırı yükleme diye bir şey yoktur.
Örneğin, C # 'da fonksiyon aşırı yüklemesini uygulamak istersem, şunları yapabilirim:
Sistem kullanarak;
sınıf Hayvan
{
genel geçersizlik testi (int a)
{
Console.WriteLine ($ "Ben bir tamsayıyım {a}");
}
genel geçersiz test (çift a)
{
Console.WriteLine ($ "Ben ondalık biriyim {a}");
}
public void testi (string a)
{
Console.WriteLine ($ "Ben {a} dizgesiyim");
}
}
Python'un bir işlevi tanımlarken parametrelerin türünü belirtmesi gerekmediğinden, işlev aşırı yüklemesi yoktur.Elbette, bunu aynı yöntemde uygulamak için aşağıdaki gibi birden çok if koşulunu kullanabilirim:
işlev araçlarını içe aktarma
def testi (a):
eğer durum (a, int):
print (f'I bir tamsayıyım {a} ')
elif isinstance (a, str):
print (ben {a} 'dizgesiyim)
elif isinstance (a, liste):
yazdır (f'I am a list {a} ')
Parametre türlerini farklı koşullara göre filtrelemek ve farklı işlemleri seçmek elbette sorun değildir, ancak bunu yapmak o kadar "gelişmiş" değildir.
Python, farklı parametre türlerine izin vermek için aynı ada sahip yöntemleri desteklemese de, kodun okunabilirliğini değerlendirmek ve azaltmak için parametre değerlendirmesini yöntemin içine koymak yerine, karşılık gelen yöntem tarafından alınan parametre türlerini dinamik olarak belirtmek için singledispatch'i kullanabiliriz. Basit bir örnekle başlayalım:
functools'tan singledispatch içe aktar
@singledispatch #Wrap aşırı yüklenmesi gereken bir yöntem, bir dekoratör
def testi (obj):
print (ben {obj}, benim türüm {type (obj)} ')
@ test.register (str) # Bu yöntemin ilk aşırı yüklemesi, burada @ özellik özniteliğinin ayarına çok benzer
def test_ (obj):
print (ben {obj}, benim türüm {type (obj)} ')
@ test.register (int) # Bu yöntemin ikinci aşırı yüklemesi
def test_ (obj):
print (ben {obj}, benim türüm {type (obj)} ')
test (1)
test ("iloveu")
Ölçek()
'' 'Devam eden sonuç:
1 yaşındayım, benim tipim < class'int ' >
Ben iloveu, benim tipim < class'str ' >
Benim tipim < sınıf listesi >
'' '
Burada not edilmesi gereken şey şudur: Daha sonra aşırı yükleme yaparken orijinal işlev adı testini kullanmayın, birkaç farklı aşırı yükleme için farklı bir test_ adı kullanabilirim. Her aşırı yüke test1, test2, test3 vb. Gibi farklı bir ad bile verebilirim, ancak parametrelerin aynı olması önemli değil. Tüm aşırı yüklemeler ad testini kullanırsa, aşağıdaki hata ortaya çıkar:
AttributeError: 'function' nesnesinin niteliği yok'register '
neden?
Bu, dekoratörün özüyle başlar, çünkü tekli paket aslında bir dekoratördür (iç içe geçmiş işlev). İçeride bir sarmalayıcı işlevi vardır. Tanıma bakıldığında, bir kayıt işlevini de tanımlar.Özel açıklamayla daha sonra ilgileneceğim. Arkadaşlarınız makaleler dizime göz atabilirsiniz - Python Gelişmiş Programlama için Dekoratörlerin Ayrıntılı Açıklaması.
aşağıdaki gibi:
Python Gelişmiş Programlama-Dekoratör Süper Ayrıntılı Açıklama (Bölüm 2)
Gelişmiş Python Programlama-Dekoratör Süper Ayrıntılı Açıklama (Ek-İç İçe Dekoratör)
Singlepatch tanımında şöyle bir cümle var:
Bir işlevi, ilk bağımsız değişkeninin türüne bağlı olarak farklı davranışlara sahip olabilen genel bir işleve dönüştürür.
Yani, singlepatch, fonksiyonun ilk parametresine göre fonksiyon için farklı davranışlar (yani aşırı yükleme) tanımlayabilir ve bir fonksiyonu "genel fonksiyona" dönüştürebilir. Bu, tek paketin rolüdür. Sınıftaki fonksiyonlar aşağıda açıklanacaktır.
functools'tan singledispatch içe aktar
sınıf Testi:
@singledispatch #Wrap aşırı yüklenmesi gereken bir yöntem, bir dekoratör
def testi (obj):
print (ben {obj}, benim türüm {type (obj)} ')
@ test.register (str) # Bu yöntemin ilk aşırı yüklemesi, burada @ özellik özniteliğinin ayarına çok benzer
def test_ (obj):
print (ben {obj}, benim türüm {type (obj)} ')
@ test.register (int) # Bu yöntemin ikinci aşırı yüklemesi
def test_ (obj):
print (ben {obj}, benim türüm {type (obj)} ')
Test.test (1)
Test.test ('iloveu')
Test.test ()
'' 'Devam eden sonuç:
1 yaşındayım, benim tipim < class'int ' >
Ben iloveu, benim tipim < class'str ' >
Benim tipim < sınıf listesi >
'' '
Birkaç not:
(1) Sınıfta tanımlanan örnek yönteminin ilk parametresi nesnenin kendisi olması gerektiğinden ve tanımlanan sınıf yöntemi, sınıfın kendisi cls olmalıdır, bu nedenle ilk parametre türünü aşırı yüklemenin bir yolu yoktur, bu nedenle yalnızca sınıf için kullanılabilir Aşırı yükte "statik yöntem";
(2) Statik yöntem aşırı yüklenmiş olsa da, @staticmethod test yöntemini dekore etmek için kullanılamaz. Bu nedenle, lütfen bir önceki makale olan The overlay of decorators'a bakın.
Yukarıdaki örnekler yalnızca bir parametre kullanır, ancak bu, yalnızca bir parametreye sahip bir işlevin aşırı yüklenebileceği anlamına gelmez, yalnızca, işlevin ilk parametresinin türünün, hangi aşırı yüklenmiş sürümün yürütüldüğünü belirlemek için kullanıldığı anlamına gelir. Bir örnek:
functools'tan singledispatch içe aktar
sınıf Testi:
@singledispatch #Wrap aşırı yüklenmesi gereken bir yöntem, bir dekoratör
def test (obj, a, b, c = 'gerçekten durum bu mu?'):
print (ben {obj}, benim türüm {type (obj)} ')
baskı (a + b)
baskı (c)
@ test.register (str) # Bu yöntemin ilk aşırı yüklemesi, burada @ özellik özniteliğinin ayarına çok benzer
def test_ (obj, a, b, c = 'Durum gerçekten bu mu?'):
print (ben {obj}, benim türüm {type (obj)} ')
baskı (a + b)
baskı (c)
@ test.register (int) # Bu yöntemin ikinci aşırı yüklemesi
def test_ (obj, a, b, c = 'Durum gerçekten bu mu?'):
print (ben {obj}, benim türüm {type (obj)} ')
baskı (a + b)
baskı (c)
Test.test (1.100.200)
Yazdır('-----------------------------------------')
Test.test ('iloveu', 'istiyorum', 'uyku', 'yok!')
Yazdır('-----------------------------------------')
Test.test (,,, 'İlginç!')
'' 'Devam eden sonuç:
1 yaşındayım, benim tipim < class'int ' >
300
Gerçekten mi?
-----------------------------------------
Ben iloveu, benim tipim < class'str ' >
uyku istiyorum
yok!
-----------------------------------------
Benim tipim < sınıf listesi >
ilginç!
'' '
tek paket özeti:
(1) Ana işlev: Gerçekleştirme işlevi, genel işlev işlevinin ilk parametre türüne göre işlev aşırı yüklemesini gerçekleştirir
(2) Uygulama adımları:
İlk adım: İhtiyacım olan işlevi süslemek için @singlepatch kullanın (örnek olarak testi yapın)
Adım 2: Test işlevinin aşırı yüklenmiş test_ sürümünü dekore etmek için @ test.register kullanın. Aşırı yüklenmiş işlevin işlev adının orijinal işlev adından farklı olmasını sağlamak gerektiğine dikkat edin.
07
toplam_siparişler
Yukarıda belirtilen fonksiyon aşırı yüklemesi, nesne yönelimli programlamada ayrıca " Operatör aşırı yükleme ", python bir istisna değildir, adından da anlaşılacağı gibi total_ordering işlevi bir" Her tür boyutta işlem yapın "İşlev.
Python'da boyutları karşılaştırmaya dahil olan 6 operatör vardır:
(1) __lt __ (öz, diğer) öz < diğer küçüktür
(2) __le __ (öz, diğer) öz < = diğer küçüktür veya eşittir
(3) __gt __ (öz, diğer) öz > diğeri daha büyüktür
(4) __ge __ (kendisi, diğer) öz > = diğer, büyük veya eşittir
(5) __eq __ (öz, diğer) öz == diğer eşittir
(6) __ne __ (öz, diğer) öz! = Diğer eşit değildir
Örneğin, Person nesnelerinin nispeten büyük olması için özel bir Kişi sınıfı uygulamak istersem, bunu yapabiliriz:
sınıf Kişi:
def __init __ (kendisi, adı, yaşı):
self.name = ad
self.age = yaş
def __lt __ (kendisi, diğer):
self.age ise < other.age:
True döndür
def __le __ (kendisi, diğer):
self.age ise < = diğer.age:
True döndür
def __gt __ (kendisi, diğer):
self.age ise > other.age:
True döndür
def __ge __ (kendisi, diğer):
self.age ise > = diğer.age:
True döndür
def __eq __ (kendisi, diğer):
self.age == other.age ise:
True döndür
def __ne __ (kendisi, diğer):
self.age! = other.age ise:
True döndür
p1 = Kişi ('Zhang San', 23)
p2 = Kişi ('Li Si', 20)
p3 = Kişi ('Wang Five', 25)
baskı (p1! = p2)
baskı (p1 < s3)
baskı (s3 > p2)
'' 'Devam eden sonuç:
Doğru
Doğru
Doğru
'' '
Tabii ki bunun dezavantajı yok ama sorun daha zahmetli olması.Her karşılaştırma operatörünü yeniden yüklemem gerekiyor Daha basit bir çözüm var mı? functools.total_ordering bir çözüm sağlar.
Total_ordering'in tanımını kontrol edebiliriz:
def total_ordering (cls):
"" "Eksik sıralama yöntemlerini dolduran sınıf dekoratörü" ""
# Kullanıcı tanımlı karşılaştırmaları bulun (nesneden miras alınanları değil).
Bir olduğunu buldum "Sınıf Dekoratörü" , Bu onun özü, işlevi nasıl tanımlanır?
@ functools.total_ordering
Bir veya daha fazla zengin karşılaştırma sıralama yöntemini tanımlayan bir sınıf verildiğinde,
bu sınıf dekoratörü gerisini sağlar. Bu, çabayı basitleştirir
olası tüm zengin karşılaştırma işlemlerinin belirlenmesinde yer alır:
Sınıf __lt __ (), __le __ (), __gt __ () veya __ge __ () 'den birini tanımlamalıdır.
Ek olarak, sınıf bir __eq __ () yöntemi sağlamalıdır.
'' '
Genel anlam şu şekildedir: Bir sınıf için bir veya birkaç aşırı yüklenmiş karşılaştırma işleci yöntemi tanımlandığı sürece, aşırı yüklenmiş işlem yöntemlerinin geri kalanı bu "sınıf dekoratörü" tarafından sağlanır, yani benim için herkes için gerekli değildir Aşırı yüklemeyi kendiniz tanımlayın;
Ve aşırı yüklenecek sınıfın __lt __ (), __le __ (), __gt __ () veya __ge __ (), bu dördünden birini tanımlaması ve bir __eq__ de tanımlanması gerekir.
Diğer bir deyişle, sadece ikisini tanımlamanız gerekir ve kalan dördü çıkarılabilir, neden? Aslında anlaşılması kolaydır.
Örneğin, bir verinin boyutunu karşılaştırmak istersem, onu yalnızca kendim tanımlarım < (Küçüktür) ve == (eşittir), aşağıda bazı veriler var,
10,11,12
10 == 10, bu tanımlanmıştır ==, True döndür;
10 == 11, == 'e göre çıkar, False döndür;
10! = 11, =='ye göre çıkarım yapın ve True döndür;
10 < 11, göre < Tanımı True döndürür;
10 < = 11, göre < Ve == sonucunu çıkarmak ve True döndürmek için;
10 > 11, göre < Çıkarım, False döndür;
10 > = 10, == çıkarımına göre True döndür;
Yukarıdakilerden, bir boyut ilişkisi, eşit bir ilişki ve diğer ilişkiler çıkarılabildiği sürece, tüm karşılaştırma işlemlerinin tanımını aşırı yüklemeye gerek olmadığını görebiliriz.Toplam_sıralama tam olarak bunu yapar.
Total_ordering kaynak kodunu kontrol ettik ve kaynak kodda bir anahtar uygulama olduğunu bulduk, yani:
_convert = {
'__lt__' :,
'__le__' :,
'__gt__' :,
'__ge__':
}
Layman'ın terimleriyle, aşağıdaki iki ilişkidir
(1) == ve! = Birbirinden türetilebilir;
(2) < , < =, > , > = Dörtten biri üçe iter;
Basit uygulama:
işlev araçlarını içe aktarma
@ functools.total_ordering
sınıf Kişi:
def __init __ (kendisi, adı, yaşı):
self.name = ad
self.age = yaş
def __lt __ (kendisi, diğer):
print ('Karşılaştır < , < =, > , > = Dört ilişki ')
self.age ise < other.age:
True döndür
Başka:
Yanlış dönüş
def __eq __ (kendisi, diğer):
print ('Karşılaştırma ==,! = iki ilişki')
self.age == other.age ise:
True döndür
Başka:
Yanlış dönüş
print (dir (Kişi))
p1 = Kişi ('Zhang San', 23)
p2 = Kişi ('Li Si', 20)
p3 = Kişi ('Wang Five', 25)
print (p1! = p2, end = '\ n ----------------------------------- \ n' )
baskı (p1 < p3, bitiş = '\ n ----------------------------------- \ n')
baskı (s3 > p2, bitiş = '\ n ----------------------------------- \ n')
baskı (s3 < p2, bitiş = '\ n ----------------------------------- \ n')
print (p3 == p2, end = '\ n ----------------------------------- \ n' )
print (p3! = p3, end = '\ n ----------------------------------- \ n' )
'' 'Devam eden sonuç:
Karşılaştır == ,! = İki ilişki
Doğru
-----------------------------------
Karşılaştırmak < , < =, > , > = Dört ilişki
Doğru
-----------------------------------
Karşılaştırmak < , < =, > , > = Dört ilişki
Karşılaştır == ,! = İki ilişki
Doğru
-----------------------------------
Karşılaştırmak < , < =, > , > = Dört ilişki
Yanlış
-----------------------------------
Karşılaştır == ,! = İki ilişki
Yanlış
-----------------------------------
Karşılaştır == ,! = İki ilişki
Yanlış
-----------------------------------
'' '
Person sınıfında __lt__ ve __eq__ olmak üzere iki sihirli yöntemi tanımlamış olsam da dir (Person) kullanırken hala dört __le__, __gt__, __ge__, __ne__ olduğunu görebildiğinizi gördük. , Bu dördü total_ordering tarafından sağlanır.
08
cmp_to_key
Python2'nin cmp işlevi ile başlayalım. Python2'de çok basit yerleşik bir cmp işlevi vardır. Bu işlev iki nesneyi karşılaştırmak için kullanılır. İşlev prototipi: cmp (x, y), eğer x ise < y, sonra -1 döndür, eğer x == y ise, x ise 0 döndür > y, 1 döndürür, bir örnek aşağıdaki gibidir:
> > > cmp (1,2)
-1
> > > cmp (2,2)
0
> > > cmp (2; 1)
1
Not: Python3'te bu yerleşik işlev iptal edildi.
Ancak bu işlevin en yaygın kullanımı, elbette, sadece iki nesnenin boyutunu karşılaştırmak değildir, daha çok "sıralama" için kullanılır, işte örnek olarak sıralı bir sıralama.
Python2'de, sıralı ifadesinin tanımına bakar ve şunu alırız:
sıralı (yinelenebilir, cmp = Yok, anahtar = Yok, ters = Yanlış) - > yeni sıralanmış liste
Üç parametresi olduğu bulundu:
yinelenebilir: Sıralanacak sıra
cmp: cmp, iki bağımsız değişkenin (yinelenebilir öğeler) özel bir karşılaştırma işlevini belirtir, bu paragraf resmi belgeden gelir; bu, cmp parametresi tarafından kabul edilen değerin iki parametreye sahip bir işlev olduğu ve bu iki parametrenin aslında sıralı olduğu anlamına gelir İki unsur. Örneğin: cmp = lambda x, y: cmp (x.lower (), y.lower ())
anahtar: her liste öğesinden bir karşılaştırma anahtarı çıkarmak için kullanılan bir bağımsız değişkenin işlevini belirtir Bu geçiş, anahtar = str.lower gibi dizinin bir öğesi olan bir bağımsız değişkenin işlevini kabul ettiği anlamına gelir.
Cmp ve anahtarın varsayılan değeri Yoktur.
Python2 sürüm sıralaması
(1) Anahtar parametrelerin kullanımı
student_tuples =
> > > sıralı (öğrenci_tipleri, anahtar = lambda öğrenci: öğrenci) # yaşa göre sırala
Buradan, anahtarın bir parametreli bir lambda fonksiyonunu kabul ettiği, yani her bir öğe öğrencisi olduğu ve daha sonra her bir öğenin yaş büyüklüğüne göre sıraladığı görülebilir. Başka bir örneğe bakın:
sınıf öğrencisi:
... def __init __ (kişi, isim, sınıf, yaş):
... self.name = isim
... self.grade = derece
... self.age = yaş
... def __repr __ (öz):
... repr döndür ((self.name, self.grade, self.age))
> > > öğrenci_objeleri =
> > > sıralı (öğrenci_nesneleri, anahtar = lambda öğrenci: öğrenci.age) # yaşa göre sırala
(2) cmp parametrelerinin kullanımı
> > > def numeric_compare (x, y): # iki parametreli bir işlevi tanımlayın
... dönüş x-y
> > > sıralı (, cmp = numeric_compare)
# Geriye doğru da sıralayabilirim
> > > def ters_sayısal (x, y):
... döndür y-x
> > > sıralı (, cmp = ters_sayısal)
Yukarıdan da anlaşılacağı gibi cmp tarafından kabul edilen fonksiyonun iki parametresi vardır.Elbette lambda ifadelerini de aynı şekilde kullanabilirim:
a = sıralı (, cmp = lambda x, y: x-y)
baskı (a)
b = sıralı (, cmp = lambda x, y: y-x)
baskı (b)
'' 'Çalışma sonucu: yukarıdakiyle aynı
'' '
Ancak, cmp yerleşik işlevini kullanmıyor gibi görünüyoruz. Sonra, şunu kullanın: Yerleşik işlev cmp Aynısı doğrudur.
a = sıralı (, cmp = cmp)
baskı (a)
b = sıralı (, cmp = cmp, ters = Doğru)
baskı (b)
'' 'Çalışma sonucu: yukarıdakiyle aynı
'' '
Yukarıdaki birkaç örnek aracılığıyla, cmp'nin tam olarak ne yaptığını ve sıralamadaki uygulamasını açıkça bilebiliriz.
Ancak python3'te yerleşik işlev cmp iptal edildi ve sıralama işlevine ne oldu? Önce tanımına bakın:
sıralı (yinelenebilir, anahtar = Yok, tersine çevrilmiş = Yanlış)
Python2 sürümüyle karşılaştırıldığında, bir adet daha az cmp parametresi ve yalnızca bir anahtar parametresi olduğunu bulduk. Bu parametrenin anlamı bir öncekiyle aynıdır. Aşağıdaki örneğe bakalım:
> > > student_tuples =
> > > sıralı (öğrenci_tipleri, anahtar = lambda öğrenci: öğrenci) # yaşa göre sırala
Öncekiyle aynı, fark yok.
Ancak python3'te cmp yerleşik işlevi yoktur, yukarıdaki python2 gibi olmak istersem çalışmaz mı? Tabii ki hayır, tıpkı python3'ün yerleşik azaltma işlevini iptal etmesi gibi, functools'da aynı şeyi başarmak için özel bir cmp_to_key işlevi de vardır, önce onun tanımına bakın:
def cmp_to_key (mycmp):
"" "Bir cmp = işlevini anahtar = işlevine" ""
Hangi işlevi yerine getiriyor?
Yani, python2'deki cmp = function artık python3'te key = function olarak yazılabilir.
Aşağıdaki örnekleri adım adım görelim
işlev araçlarını içe aktarma
def numeric_compare (x, y):
dönüş x-y
a = sıralı (, anahtar = functools.cmp_to_key (sayısal_compare))
baskı (a)
def ters_sayısal (x, y):
dönüş y-x
b = sıralı (, key = functools.cmp_to_key (sayısal_compare))
baskı (b)
'' 'Devam eden sonuç:
# İşte tersi değil! Tersine çevirmek için, yalnızca ters parametreyi True olarak ayarlayarak
'' '
Yukarıdan da görülebileceği gibi, artık doğrudan key = numeric_compare ayarlayamıyorum ve lambda ifadelerini kullanamıyorum, çünkü key yalnızca bir parametreyi kabul edebilir, ancak iki parametre vardır.
sonuç olarak: Functools.cmp_to_key (function) tam olarak ne yapıyor?
Yani, cmp = python2'nin işlevi python3'ün key = cmp_to_key (işlev) işlevine eşdeğerdir.
09
adlı çift
namedtuple: Adından da anlaşılacağı gibi, "adlandırılmış tuple", yani " Adlandırılmış demet ". Pek çok arkadaş şaşırıyor. Standart kütüphane koleksiyonlarında bir de isimli bir ikili var. Aralarında herhangi bir fark var mı? Aslında tamamen aynılar, bu yüzden burada functools ile açıklayacağım.
Adlandırılmış tuple ve sıradan demet tuplelardır, ancak bu bir kardeş ilişkisi değildir. Adlandırılmış tuple, tuple'ın bir alt tipidir. Ancak işlev daha güçlüdür. Adlandırılmış tuple için artık indeks değerine göre erişmeniz gerekmiyor. Adına göre erişmek için bir sözlük olarak düşünebilirsiniz, ancak değer değiştirilemez. Basit bir demet ile başlayalım:
a = (1,2,3,4,5)
Bu basit bir demettir, ancak onu genel olarak demetler için kullanmayız, çünkü demetler değişmezdir, onu sekans problemlerini ifade etmek için kullanmayız, genellikle şu şekilde kullanırız:
a = ('Zhang San', 'erkek', 25,172), nesne yönelimli bir bakış açısından, demetin her bir öğesi, her nesnenin bir niteliği olarak kabul edilir, burada a bir nesne ve ilk öğe addır Öznitelikler, ikincisi cinsiyet öznitelikleridir, üçüncüsü yaş öznitelikleridir ve dördüncüsü boy öznitelikleridir.
namedtuple bu fikre dayanmaktadır. İlk önce basit bir uygulamaya bakın:
işlev araçlarını içe aktarma
Hayvan = functools.namedtuple ('Hayvan', 'isim yaş yüksekliği')
köpek = Hayvan ('Yavru', 5,23)
baskı (köpek)
baskı (köpek.adı)
baskı (dog.age)
baskı (köpek. yükseklik)
'' 'Devam eden sonuç:
Hayvan (adı = 'köpek yavrusu', yaş = 5, boy = 23)
köpek yavrusu
5
yirmi üç
'' '
Adlandırılmış bir çift oluşturmak için iki parametre gerekir, yani tuple adı Ve nerede Alan adı (veya alan adı olarak adlandırılır) . Örneğin, yukarıdaki örnekte, başlığın adı "Hayvan" dır ve "ad", "yaş" ve "boy" olmak üzere üç alan içerir.
Namedtuple'ın tanımına bakalım:
def namedtuple (typename, field_names, *, verbose = False, rename = False, module = None):
İki parametre gereklidir
typename: Demetin adı
field_names: Alan adı aşağıdaki formlarda olabilir,
İlk tür: bir dize olarak yazılır, boşluklarla ayrılmış "alan1 alan2 alan 3";
İkinci tür: liste olarak yazılır,
Aşağıdaki örnek:
işlev araçlarını içe aktarma
Hayvan = functools.namedtuple ('Hayvan',) # liste olarak yazılır
köpek = Hayvan ('Yavru', 5,23)
baskı (köpek)
baskı (köpek.adı)
baskı (dog.age)
baskı (köpek. yükseklik)
Çalışma sonucu tam olarak yukarıdakiyle aynıdır.
Namedtuple, sıradan demetten daha okunabilirdir ve kodun bakımını kolaylaştırabilir. Aynı zamanda sözlüğe göre daha hafif ve verimlidir. Ancak unutulmaması gereken bir şey, adlandırılmış çiftin özniteliklerinin değişmez olmasıdır. Özniteliğinin değerini değiştirme girişimleri yasa dışıdır.
dog.name = 'Li Si'
Aşağıdaki hata görüntülenir:
AttributeError: öznitelik ayarlanamıyor
Yani, namedtuple hala değişmez bir nesnedir.
Namedtuple, bir tuple alt sınıfıdır. Namedtuple ile ilgili bir başka güzel şey ise, tuple ile tamamen uyumlu olmasıdır. Diğer bir deyişle, isimli bir gruba erişmek için dizini hala kullanabiliriz.
işlev araçlarını içe aktarma
Hayvan = functools.namedtuple ('Hayvan',) # liste olarak yazılır
köpek = Hayvan ('Yavru', 5,23)
baskı (köpek)
print (köpek) # Dizine göre öğelere erişim
baskı (köpek)
baskı (köpek)
Sonuçlar yukarıdakiyle aynıdır.
Adlandırılmıştuple, meta-ata bilgilerine sözlük biçiminde erişebildiğinden, doğal olarak adlandırılmıştuple, sözlükle etkileşime girebilir.
(1) namedtuple'ı OrderedDict'e dönüştür (varsayılan sözlük)
new_dog = dog._asdict () # namedtuple'ı varsayılan sözlüğe dönüştür
print (new_dog) # Köpeğin içeriğini görüntüle
print (type (new_dog))
baskı (new_dog)
baskı (new_dog)
baskı (new_dog)
'' 'Devam eden sonuç:
OrderedDict ()
< class'collections.OrderedDict ' >
köpek yavrusu
5
yirmi üç
'' '
(2) Bir sözlük aracılığıyla adlandırılmış bir çift oluşturun
Bölünmüş operatör eşleyerek yapılır
işlev araçlarını içe aktarma
Hayvan = functools.namedtuple ('Hayvan',) # liste olarak yazılır
d = {'ad': 'köpek', 'yaş': 5, 'yükseklik': 23} #bilinen sözlük
köpek = Hayvan (** d)
baskı (köpek)
baskı (köpek.adı)
baskı (dog.age)
baskı (köpek. yükseklik)
'' 'Devam eden sonuç:
Hayvan (adı = 'köpek yavrusu', yaş = 5, boy = 23)
köpek yavrusu
5
yirmi üç
'' '
adlı çift Özelliklerin özeti:
(1) Her bir öğeye erişmek için öznitelik erişimine benzer bir form kullanın. a.field form;
(2) Tuple'larla uyumludur, bunların hepsi değişmez nesnelerdir ve öğelere ayrıca indeks tarafından a şeklinde erişilebilir;
(3) Sözlüğe dönüştürülebilir;
Herkes için bazı Python öğrenme eğitimleri ve Python e-kitapları PDF formatında hazırladım.Size yardımcı olmayı umuyorum!
Nasıl elde edilir: En eksiksiz python kendi kendine çalışma video eğitimleri ve bir dizi PDF e-kitap almak için lütfen dikkatinizi iletin ve editöre özel olarak yazın (öğrenin)!
Desteğin için teşekkürler! Tanınmanız, ilerlemem için itici güçtür!
