Python gelişmiş programlama dekoratörü Dekoratör süper ayrıntılı açıklaması (Ek-İç içe dekoratör)
Seni dikkatlice gönder ve beni takip etmeyi unutma! !
Metni girin
Tam metin özeti
Dekoratör, python dilinin önemli bir özelliğidir.Önceki bölümde, python dekoratörlerinin ve python kapanışlarının sonraki içeriği ayrıntılı olarak açıklanmış, esas olarak bir python kapanışının ne olduğu ve python kapanışları ile dekoratörler arasında ne olduğu açıklanmıştır Farklılıklar ve bağlantılar. Bu makale dekoratör serisi makalelerini tanıtacak Ek , Ayrıntılı tanıtım İç içe dekoratör İç içe dekoratör tanımı, işlem süreci, ana işlevler vb. Dahil olmak üzere içeriğin her bölümü.
Kullanın, python gelişmiş programlama-dekoratör serisi makaleler, Üst, Orta, Alt, Ek , Bu makale açıklar Ek , Ve gelişmiş python programlama özellikleri-python tanımlayıcı tanımlayıcı serisi makaleleri takip edin, lütfen dikkat etmeye devam etmeyi unutmayın! Makale çok uzun, tam metni okumak için yaklaşık 30 dakika.
Lütfen önceki makaleye bakın:
Tam metin kataloğu
01 Python dekoratörünün çalışan süreci
1.1 Küçük bir örnekten
1.2 Cümle ile cümle çalıştıran dekoratörün kesme noktası hata ayıklaması
1.3 Dekoratör işleminin özeti
02 Python çok katmanlı dekoratörlerin iç içe kullanımı
2.1 Bir örnekten başlamak
2.2 İç içe dekoratörlerde cümle hata ayıklaması
2.3 Çok katmanlı dekoratörlerin özeti
03 Python çok katmanlı dekoratörün uygulama senaryoları
04 Python gelişmiş programlama-Tanımlayıcı ( Farkına varmak )
Python dekoratörünün ayrıntılı açıklaması (Ek)
Bu makale, python dekoratörleri-tamamlayıcı makalenin ayrıntılı bir açıklamasıdır.Önceki makalede, dekoratörlerin ayrıntılı açıklaması - sonraki makale, bir python kapanışının ne olduğunu ayrıntılı olarak açıkladı. Doğumun arka planı, kapanışların tanımı ve işlevi, dekoratörlerle olan ilişki ve farklılıklar vb. Bu makale, gelişmiş python programlama-çok katmanlı iç içe dekoratörler üzerine bir dizi makalenin kapanış makalesi olarak, dekoratörün çalışma mekanizmasını ve çok katmanlı dekoratörün çalışma sürecini ayrıntılı olarak tanıtacaktır. Bu makale dizisi dört makaleye ayrılmıştır: üst, orta, alt ve ek. bu Dördüncü Bölüm .
01
Python dekoratörünün çalışma süreci
01 Python dekoratörünün çalışan süreci
1.1 Küçük bir örnekten
Python dekoratörünün özü, tanımı, anlamı ve kullanım senaryoları daha önce açıklanmış olsa da, dekoratörün nasıl çalıştığına dair hala iyi bir açıklama yok, bu yüzden bu makale onu tekrar açıklayacak. Basit bir tanesine bakalım:
def A_Decorator (işlev):
print ('Dış katman A tarafından eklenen ilk işlev benim')
def sarmalayıcı (a, b):
print ('İç katman A tarafından eklenen ilk işlev benim')
işlev (a, b)
print ('İç katman A tarafından eklenen ikinci işlev benim')
print ('Dış katman A tarafından eklenen ikinci işlev benim')
dönüş sarıcı
@A_Decorator
def C_function (a, b):
print ('Nihai sonuç: {0}'. format (a + b))
C_fonksiyon (100,200)
Sonuç şu şekildedir:
Dış katman A tarafından eklenen ilk işlev benim
Ben dış katman A tarafından eklenen ikinci işlevim
İç katman A tarafından eklenen ilk işlev benim
Nihai sonuç: 300
Ben iç katman A tarafından eklenen ikinci işlevim
Hayal ettiğimizden farklı mı, şu sonuç değil:
Dış katman A tarafından eklenen ilk işlev benim
İç katman A tarafından eklenen ilk işlev benim
Nihai sonuç: 300
Ben iç katman A tarafından eklenen ikinci işlevim
Ben dış katman A tarafından eklenen ikinci işlevim
01 Python dekoratörünün çalışan süreci
1.2 Dekoratörlerin cümle hata ayıklaması
Bu neden? Bu, özünden başlar, kesme noktası hata ayıklamasını ayarlayarak çalışan süreci görüntüleyebiliriz. Aşağıdaki dinamik resim:
Gerçekten anlamıyorsanız sorun değil. Yukarıdaki dinamik diyagramdan A_Decorator dekoratör işlevine girerken kodun yukarıdan aşağıya sırayla çalıştırılmadığını görebiliriz. Yürütme sırası kabaca şu şekildedir, ikiye bölünmüştür sahne:
(1) Dekoratör işlevini girin, önce dış işlevin işlev gövdesini yürütün ve bir sarmalayıcı geri döndürün;
(2) Daha sonra sarmalanmış işlev yürütüldüğünde, yani, sarılmış işlev gerçekte döndürülen sarmalayıcı olduğundan (dizinin Bölüm 2'nin ikinci bölümüne bakın), işlev sarmalayıcının dahili kodu çalıştırılır.
01 Python dekoratörünün çalışan süreci
1.3 Dekoratör işleminin özeti
sonuç olarak: Dekoratörün çalışması aşağıdaki konulara dikkat etmelidir: Üç "koşu atlama"
(1) @decorator ile dekore edilmiş bir işlevi tanımlarken, bu, dekoratör işlevine girmeniz gerektiği anlamına gelir. Bu ne anlama geliyor? Bu şekilde herkes daha iyi anlayacaktır.
C_function = A_Decorator (C_function) Bu cümle @ ile tanımlananla eşdeğerdir. Bu cümlenin sonu, dış dekoratördeki kodun çalışmayı bitirdiği ve bir sarmalayıcı nesnesinin döndürüldüğü anlamına gelir. Süslü işlevin tanımından dış dekoratörün işlev gövdesine kadar, buna İlk kez atla.
(2) Daha sonra, çalıştırılarak döndürülen sarmalayıcı olan C_function işlevini çalıştırın ve bu, sarmalayıcının dahili uygulamasına atlayacaktır. Süslenmiş işlevi çalıştırın, iç sarmalayıcı uygulamasına atlayın, buna denir İkinci atlama.
(3) Sarmalayıcının içindeyken, sarmalayıcı içindeki işlev aslında tanımlanmış işlev olduğundan, işlev işlevini sarmalayıcı içinde çalıştırırken, dekore edilmiş işlevin işlev gövdesine geri dönecektir. Üçüncü atlama.
(4) Süslü işlevin yürütülmesi tamamlandığında, işlevden sonra bitmemiş bölümü yürütmek için sarmalayıcıya geri dönün.
Aslında özetlemek gerekirse, sadece bir cümle: Dekoratör, işlevi sararken dış katmanı çalıştırır ve sarılmış işlevi çalıştırırken iç sarmalayıcıyı çalıştırır Zihnimizde böyle bir düşünce tarzı oluşturmamız gerekiyor.
Yukarıdaki temelle, şimdi birden fazla dekoratörün yuvalanmasını tartışabiliriz.
02
Python çok katmanlı dekoratörlerin yerleştirilmesi
02 Python çok katmanlı dekoratörlerin yerleştirilmesi
2.1 Basit bir örnekten başlamak
Sözde dekoratörlerin iç içe geçmesi, birden fazla dekoratörün kullanılmasıdır.Örneğin, A, B'yi süsler ve B, A'ya eşdeğer olan C'yi süsler ve B, C'ye ek işlevler ekler. Şimdi C, iki dekoratöre eşdeğerdir, basit uygulama kodu aşağıdaki gibidir:
def A_Decorator (işlev):
print ('Dış katman A tarafından eklenen ilk işlev benim')
def sarmalayıcı (a, b):
print ('İç katman A tarafından eklenen ilk işlev benim')
sonuç = işlev (a, b)
print ('İç katman A tarafından eklenen ikinci işlev benim')
dönüş sonucu
print ('Dış katman A tarafından eklenen ikinci işlev benim')
dönüş sarıcı
def B_Decorator (işlev):
print ('Dış katman B tarafından eklenen ilk işlev benim')
def sarmalayıcı (a, b):
print ('İç katman B tarafından eklenen ilk işlev benim')
sonuç = işlev (a, b)
print ('Ben iç katman B tarafından eklenen ikinci işlevim')
dönüş sonucu
print ('Ben dış katman B tarafından eklenen ikinci işlevim')
dönüş sarıcı
@A_Decorator
@Kiralikaskdizi
def C_function (a, b):
a + b döndür
sonuç = C_fonksiyon (100.200)
Yazdır('--------------------------------------')
baskı (sonuç)
Sonuç şu şekildedir:
Dış katman B tarafından eklenen ilk işlev benim
Ben dış katman B tarafından eklenen ikinci işlevim
Dış katman A tarafından eklenen ilk işlev benim
Ben dış katman A tarafından eklenen ikinci işlevim
İç katman A tarafından eklenen ilk işlev benim
İç katman B tarafından eklenen ilk işlev benim
Ben iç katman B tarafından eklenen ikinci işlevim
Ben iç katman A tarafından eklenen ikinci işlevim
--------------------------------------
300
02 Python çok katmanlı dekoratörlerin yerleştirilmesi
2.2 Çok katmanlı dekoratörlerin cümle hata ayıklaması
Neden önce A dekoratörünü çalıştırmayı bitirmiyor ya da önce B dekoratörünü çalıştırmayı bitirip de bu tür kesişen formu sunmuyorsunuz? Bunun "dekoratör" özüne göre adım adım analiz edilmesi gerekiyor. Ayrıca, aşağıda gösterildiği gibi, en alttaki programın nasıl çalıştığını görmek için adım adım izleme, kesme noktası hata ayıklamasını da ayarlayabiliriz:
Yukarıdaki çalışan gösteriden, koşu sırasının aşağıdaki adımlara bölündüğünü gördük:
(1) Önce B dekoratörünün dış kodunu çalıştırın ve B dekoratöründe bir sarmalayıcı döndür
(2) Ardından, A dekoratörünün dış kodunu çalıştırın ve A dekoratöründe bir sarmalayıcı döndür
(3) Daha sonra dekoratör tarafından dekore edilen fonksiyonu çalıştırın Bu C_function fonksiyonudur C_fonksiyonu esasen A dekoratörü tarafından döndürülen sarmalayıcı olduğundan, önce A'daki sarmalayıcı işlevi çalıştırılacaktır. Ama burada A'daki iç işlev sarmalayıcı bir kerede çalıştırılmıyor, ama B'deki iç işleve atlıyor. Neler oluyor? Dekoratörlerin özünü anlayan öğrenciler bir cevapları olduğuna inanırlarsa.
Aslında, iki seviyeli dekoratörün yuvalanması esasen aşağıdaki koda eşdeğerdir:
C_function = A_Decorator (B_Decorator (C_function))
Bu eşdeğerdir
@A_Decorator
@Kiralikaskdizi
def C_function (a, b):
a + b döndür
Önceki "üç atlama" çalıştırma süreciyle birlikte, artık çok katmanlı iç içe dekoratörlerin çalışma doğasını analiz edebiliriz. Yaparız
C_C_function = B_Decorator (C_function)
# C_C_function, ara transfer değişkenidir, aslında C_C_function'nun, B_Decorator dekoratörü tarafından döndürülen sarmalayıcı olduğunu bilmek kolaydır.
O zaman yukarıdaki formül aşağıdakine eşdeğerdir
C_function = A_Decorator (C_C_function)
O zaman yukarıdaki kod tamamen aşağıdakine eşdeğerdir:
def A_Decorator (işlev):
print ('Dış katman A tarafından eklenen ilk işlev benim')
def sarmalayıcı (a, b):
print ('İç katman A tarafından eklenen ilk işlev benim')
sonuç = işlev (a, b)
print ('İç katman A tarafından eklenen ikinci işlev benim')
dönüş sonucu
print ('Dış katman A tarafından eklenen ikinci işlev benim')
dönüş sarıcı
def B_Decorator (işlev):
print ('Dış katman B tarafından eklenen ilk işlev benim')
def sarmalayıcı (a, b):
print ('İç katman B tarafından eklenen ilk işlev benim')
sonuç = işlev (a, b)
print ('Ben iç katman B tarafından eklenen ikinci işlevim')
dönüş sonucu
print ('Ben dış katman B tarafından eklenen ikinci işlevim')
dönüş sarıcı
# @A_Decorator
# @B_Decorator
def C_function (a, b):
a + b döndür
# C_function = A_Decorator (B_Decorator (C_function))
C_C_function = B_Decorator (C_function)
C_function = A_Decorator (C_C_function)
sonuç = C_fonksiyon (100.200)
Yazdır('--------------------------------------')
baskı (sonuç)
Şimdi hala hata ayıklama için kesme noktaları belirliyoruz, herkes dikkatini Aşağıda basılı bilgiler , Hangi adımı gerçekleştirdiğini anlamamıza yardımcı olur.
02 Python çok katmanlı dekoratörlerin yerleştirilmesi
2.3 Çok katmanlı dekoratör yerleştirmenin özeti
Şimdi cümle cümle analiz edelim Hareket süreci:
(1) Önce uygula C_C_function = B_Decorator (C_function). B'nin dış katmanını girin ve bir B_wrapper döndürün, burada C_C_function B_wrapper'dır. Paketleme uygulaması dış katmanı, öncekini hatırlıyor musunuz?
(2) Yeniden çalıştır C_function = A_Decorator (C_C_function). A'nın dış katmanını girin ve bir A_wrapper döndürün, burada C_function A_wrapper'dır.
(3) Yeniden çalıştır C_fonksiyon (100,200). C_fonksiyonu A_wrapper olduğu için, bu yüzden önce A_wrapper girin; sonra fonksiyon (a, b) ile karşılaştığınızda, çünkü buradaki fonksiyon parametresi gerçekte C_function = A_Decorator (C_C_function) aracılığıyla iletilir, bu nedenle function = C_C_function = B_wrapper, yani B_wrapper'a aktarılacaktır.
(4) Yeniden çalıştır B_wrapper (a, b) işlevi için çalıştırıldığında, buradaki işlev aslında C_C_function = B_Decorator (C_function) tarafından geçirilir, bu da buradaki işlevin orijinal C_function işlevi tanımı olduğu anlamına gelir, bu da C_function işlevine aktarılacağı anlamına gelir Vücudun içinde.
(5) C_function işlev gövdesi yürütülene kadar bekleyin ve sonra önce B_wrapper'ı sonlandırın ve ardından A_wrapper'ı sonlandırın.
Şimdi çok katmanlı dekoratörün çalışma prensibini ve çalışma sürecini anladınız mı?
Bu bölümdeki içerik tam olarak anlaşılmadıysa, python dekoratörlerinin gerçek bir anlayışı olarak görülemez.Önceki makalelerimi (ilk, orta ve sonraki) birkaç kez okumak için birleştirmeyi umuyorum!
03
Python çok katmanlı dekoratörün uygulama senaryoları
03 Python çok katmanlı dekoratörün uygulama senaryoları
3.1 Çok katmanlı dekoratörlerin uygulama senaryoları
Uzun bir anlayış döneminden sonra, nihayet çok katmanlı dekoratörlerin aynı şey olduğunu anladım.Çok katmanlı dekoratörlerin geniş bir uygulama yelpazesi var.Onları kullanmamıza rağmen, python sözdizimsel şeker ürettiği için kapsüllemeyi karşılayabiliriz. Dekoratörün nasıl çalıştığını analiz etmek gerekli değildir, ancak onu anlama temelinde kullanmalısınız, böylece ne olduğunu ve neden olduğunu anlayabilirsiniz!
Dekoratörün rolünün ek bilgiler, yardımcı bilgiler, ek doğrulama vb. Eklemek olduğunu söyledik. Ürün yöneticiniz sizden bir oturum açma prosedürü ve yetkilendirme doğrulama prosedürü yazmanızı isterse,
Burada iki işlev vardır: Birincisi, oturum açıp açamayacağını görmek için ilk olarak oturum açma bilgilerini doğrulamaktır. İkincisi, oturum açmış kullanıcının hangi izinlere sahip olduğunu doğrulamaktır. Bu, birden çok dekorasyonla yapılabilir. Spesifik kod artık burada yazılmaz ve ilgilenen arkadaşlar kendi başlarına deneyebilirler.
Dekoratör dizisi nihayet bitti.Bir Python dekoratörü var ve ben dört büyük makale yazdım.Kendinize sorun bu, anlaşılması en özel, ayrıntılı ve en kolay makale.Size yardımcı olursa, dikkatinizi vermeye devam edebilirsiniz!
Bir sonraki uyarı:
Aşağıdaki makalenin odak noktası Tanımlayıcı:
Tanımlayıcı terim, Python'a yeni başlayanlar veya Python'da yeni olanlar için yabancı olabilir, ancak bu, gelişmiş Python programlama içeriğinin önemli bir ilkesidir ve Python'un birçok gelişmiş özelliğinin temelidir.Açıklayıcıların geniş içeriği göz önüne alındığında, Yine de, doğum geçmişinden ilkenin açıklamasına ve daha sonra aşamalı bir şekilde açıklamak için kural durumuna kadar makale dizisinin yazma yöntemini benimseyin. Ön plan, açıklayıcı makale dizisi açıklama için üç bölüme ayrılmıştır.
İlgilenen arkadaşlar dikkat etmeye devam ediyor!
Ek olarak, Python öğrenme rotasını ve PDF e-kitaplarını edinme yolunu tavsiye etmek istiyorum: öğretmenin paylaştığı öğrenme rotası ve PDF e-kitapları, acele etmeli ve çalışmalısın ve öğretmenden özel mesajla alabilirsin (öğrenme)!
