Python'un gizli özellikleri [kapalı]

Python programlama dilinin daha az bilinen ama yararlı özellikleri nelerdir?

• Cevapları Python çekirdeğine sınırlamaya çalışın.
• Yanıt başına bir özellik.
• Yalnızca belgelere bir bağlantı değil, özelliğin bir örneğini ve kısa bir açıklamasını verin.
• İlk satır olarak bir başlık kullanarak özelliği etiketleyin.

Yanıtlara hızlı bağlantılar:

• Bağımsız Değişken Açma
• pantolon askısı
• Zincirleme Karşılaştırma Operatörleri
• Dekoratörler
• Varsayılan Bağımsız Değişken Gotchas / Değişken Varsayılan Tehlikeleri
• Tanımlayıcılar
• Sözlük varsayılan .getdeğeri
• Doktora Testleri
• Üç Nokta Dilimleme Sözdizimi
• sayım
• İçin / else
• İter () argümanı olarak işlev
• Jeneratör ifadeleri
• import this
• Yerinde Değer Değişimi
• Liste adımlaması
• __missing__ ürün
• Çok Satırlı Normal İfade
• Adlandırılmış dize biçimlendirme
• Yuvalanmış liste / jeneratör kavrayışları
• Çalışma zamanında yeni türler
• .pth Dosyalar
• ROT13 Kodlama
• Normal İfade Hata Ayıklama
• Jeneratörlere Gönderme
• Etkileşimli Yorumlayıcıda Sekme Tamamlama
• Üçlü İfade
• try/except/else
• Ambalajdan çıkarma + print()işlevi
• with Beyan

Zincirleme karşılaştırma operatörleri:

>>> x = 5
>>> 1 < x < 10
True
>>> 10 < x < 20 
False
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True

Yaptığını düşünüyorsanız 1 < x, hangi olarak ortaya çıkıyor Trueve sonra da karşılaştırıyor True < 10, ki o da Truehayır, o zaman gerçekten bu değil (son örneğe bakın.) Gerçekten çeviriyor 1 < x and x < 10ve x < 10 and 10 < x * 10 and x*10 < 100daha az yazarak ve her biri terim sadece bir kez değerlendirilir.

Regex hata ayıklamak için python regex ayrıştırma ağacı alın.

Düzenli ifadeler python'un harika bir özelliğidir, ancak bunları ayıklamak bir acı olabilir ve regex'i yanlış yapmak çok kolaydır.

Neyse ki, piton, belgesiz, deneysel, gizli bayrağı re.DEBUG(aslında 128) ileterek normal ifade ayrıştırma ağacını yazdırabilir re.compile.

>>> re.compile("^\[font(?:=(?P<size>[-+][0-9]{1,2}))?\](.*?)[/font]",
    re.DEBUG)
at at_beginning
literal 91
literal 102
literal 111
literal 110
literal 116
max_repeat 0 1
  subpattern None
    literal 61
    subpattern 1
      in
        literal 45
        literal 43
      max_repeat 1 2
        in
          range (48, 57)
literal 93
subpattern 2
  min_repeat 0 65535
    any None
in
  literal 47
  literal 102
  literal 111
  literal 110
  literal 116

Sözdizimini anladıktan sonra hatalarınızı tespit edebilirsiniz. Biz kaçmaya unuttum Orada görebilirsiniz []in [/font].

Elbette, yorumlanmış normal ifadeler gibi istediğiniz bayraklarla birleştirebilirsiniz:

>>> re.compile("""
 ^              # start of a line
 \[font         # the font tag
 (?:=(?P<size>  # optional [font=+size]
 [-+][0-9]{1,2} # size specification
 ))?
 \]             # end of tag
 (.*?)          # text between the tags
 \[/font\]      # end of the tag
 """, re.DEBUG|re.VERBOSE|re.DOTALL)

numaralandırmak

Bir yinelenebilir numaralandırma ile sarın ve öğeyi indeksi ile birlikte verecektir.

Örneğin:

>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
3 d
4 e
>>>

Referanslar:

• Python eğitimi - döngü teknikleri
• Python belgeleri - yerleşik işlevler -enumerate
• PEP 279

Jeneratör nesneleri oluşturma

Yazarsan

x=(n for n in foo if bar(n))

jeneratörü çıkarabilir ve x'e atayabilirsiniz. Şimdi yapabileceğiniz anlamına geliyor

for n in x:

Bunun avantajı, ara depolamaya ihtiyacınız olmamasıdır.

x = [n for n in foo if bar(n)]

Bazı durumlarda bu önemli bir hızlanmaya yol açabilir.

Temelde döngüler için yuvalanmış çoğaltmayı üretecin sonuna birçok if ifadesi ekleyebilirsiniz:

>>> n = ((a,b) for a in range(0,2) for b in range(4,6))
>>> for i in n:
...   print i 

(0, 4)
(0, 5)
(1, 4)
(1, 5)

iter () çağrılabilir bir argüman alabilir

Örneğin:

def seek_next_line(f):
    for c in iter(lambda: f.read(1),'\n'):
        pass

iter(callable, until_value)Fonksiyonu sürekli çağırır callableve dek sonucu verir until_valuedöndürülür.

Değişken varsayılan bağımsız değişkenlere dikkat edin

>>> def foo(x=[]):
...     x.append(1)
...     print x
... 
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]

Bunun yerine, "verilmez" i gösteren bir sentinel değeri kullanmalı ve varsayılan olarak istediğiniz mutable ile değiştirmelisiniz:

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print x
>>> foo()
[1]
>>> foo()
[1]

Jeneratör fonksiyonlarına değer gönderme . Örneğin, bu işleve sahip olmak:

def mygen():
    """Yield 5 until something else is passed back via send()"""
    a = 5
    while True:
        f = (yield a) #yield a and possibly get f in return
        if f is not None: 
            a = f  #store the new value

Yapabilirsin:

>>> g = mygen()
>>> g.next()
5
>>> g.next()
5
>>> g.send(7)  #we send this back to the generator
7
>>> g.next() #now it will yield 7 until we send something else
7

Kapsamları belirtmek için boşluk kullanmaktan hoşlanmıyorsanız, C-stili {} kullanarak şunları yapabilirsiniz:

from __future__ import braces

Dilim işleçlerinde adım bağımsız değişkeni. Örneğin:

a = [1,2,3,4,5]
>>> a[::2]  # iterate over the whole list in 2-increments
[1,3,5]

Özel durum x[::-1], 'x ters çevrilmiş' için yararlı bir deyimdir.

>>> a[::-1]
[5,4,3,2,1]

Dekoratörler

Dekoratörler , bir işlev veya yöntemi işlevsellik ekleyebilecek, bağımsız değişkenleri veya sonuçları değiştirebilecek vb. Bir başka işleve sarmaya izin verir.

Örnek, print_argsdekore edilmiş işlevin bağımsız değişkenlerini çağırmadan önce yazdıran bir dekoratörü gösterir :

>>> def print_args(function):
>>>     def wrapper(*args, **kwargs):
>>>         print 'Arguments:', args, kwargs
>>>         return function(*args, **kwargs)
>>>     return wrapper

>>> @print_args
>>> def write(text):
>>>     print text

>>> write('foo')
Arguments: ('foo',) {}
foo

For ... else sözdizimi (bkz. Http://docs.python.org/ref/for.html )

for i in foo:
    if i == 0:
        break
else:
    print("i was never 0")

"Else" bloğu, break çağrılmadığı sürece normalde for döngüsünün sonunda yürütülür.

Yukarıdaki kod aşağıdaki gibi taklit edilebilir:

found = False
for i in foo:
    if i == 0:
        found = True
        break
if not found: 
    print("i was never 0")

2,5'ten itibaren diktelerin __missing__eksik öğeler için çağrılan özel bir yöntemi vardır:

>>> class MyDict(dict):
...  def __missing__(self, key):
...   self[key] = rv = []
...   return rv
... 
>>> m = MyDict()
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

Bir dict alt sınıf da vardır collectionsdenilen defaultdicthemen hemen aynı yapar ama mevcut değil öğeler için bağımsız değişkeni olmayan bir işlevini çağırır:

>>> from collections import defaultdict
>>> m = defaultdict(list)
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

Bu gibi alt sınıfları beklemeyen işlevlere geçirmeden önce bu tür dikmeleri düzenli dikimlere dönüştürmenizi öneririm. Pek çok kod, d[a_key]sözlüğe yeni bir öğe ekleyecek bir öğe olup olmadığını kontrol etmek için KeyErrors kullanır ve yakalar.

Yerinde değer değişimi

>>> a = 10
>>> b = 5
>>> a, b
(10, 5)

>>> a, b = b, a
>>> a, b
(5, 10)

Ödevin sağ tarafı yeni bir grup oluşturan bir ifadedir. Ödevin sol tarafı, adların (referanssız) grubunu derhal açar ave b.

Atamadan sonra yeni demet referans alınmaz ve çöp toplama için işaretlenir ve değerler bağlı ave bdeğiştirilir.

Veri yapıları ile ilgili Python öğretici bölümünde belirtildiği gibi ,

Çoklu atamanın gerçekten sadece demet paketlemenin ve sıralı paketlemenin bir kombinasyonu olduğunu unutmayın.

Okunabilir düzenli ifadeler

Python'da normal bir ifadeyi birden çok satıra bölebilir, eşleşmelerinize ad verebilir ve yorum ekleyebilirsiniz.

Örnek ayrıntılı sözdizimi (Dive'dan Python'a ):

>>> pattern = """
... ^                   # beginning of string
... M{0,4}              # thousands - 0 to 4 M's
... (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                     #            or 500-800 (D, followed by 0 to 3 C's)
... (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                     #        or 50-80 (L, followed by 0 to 3 X's)
... (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                     #        or 5-8 (V, followed by 0 to 3 I's)
... $                   # end of string
... """
>>> re.search(pattern, 'M', re.VERBOSE)

Örnek adlandırma eşleşmeleri ( Normal İfade NASIL belgesinden )

>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'

Ayrıca re.VERBOSE, dizgi değişmezi birleştirme sayesinde kullanmadan ayrıntılı bir şekilde normal ifade yazabilirsiniz .

>>> pattern = (
...     "^"                 # beginning of string
...     "M{0,4}"            # thousands - 0 to 4 M's
...     "(CM|CD|D?C{0,3})"  # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                         #            or 500-800 (D, followed by 0 to 3 C's)
...     "(XC|XL|L?X{0,3})"  # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                         #        or 50-80 (L, followed by 0 to 3 X's)
...     "(IX|IV|V?I{0,3})"  # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                         #        or 5-8 (V, followed by 0 to 3 I's)
...     "$"                 # end of string
... )
>>> print pattern
"^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$"

İşlev bağımsız değişkeninin açılması

Bir liste veya kullanarak işlev parametresi olarak bir sözlük paketten *ve **.

Örneğin:

def draw_point(x, y):
    # do some magic

point_foo = (3, 4)
point_bar = {'y': 3, 'x': 2}

draw_point(*point_foo)
draw_point(**point_bar)

Listeler, tuples ve dikenler kaplar olarak yaygın olarak kullanıldığından çok yararlı bir kısayol.

Kod dosyasının üstünde doğru kodlama bildirimini kullandığınızda, ROT13 kaynak kodu için geçerli bir kodlamadır:

#!/usr/bin/env python
# -*- coding: rot13 -*-

cevag "Uryyb fgnpxbiresybj!".rapbqr("rot13")

Tamamen dinamik bir şekilde yeni türler oluşturma

>>> NewType = type("NewType", (object,), {"x": "hello"})
>>> n = NewType()
>>> n.x
"hello"

ki tam olarak aynı

>>> class NewType(object):
>>>     x = "hello"
>>> n = NewType()
>>> n.x
"hello"

Muhtemelen en faydalı şey değil, ama bilmek güzel.

Düzenleme : Yeni türün sabit adı, ifadeyle NewTypeaynı şey olmalıdır class.

Düzenle : Özelliği daha doğru bir şekilde tanımlamak için başlığı ayarladı.

Bağlam yöneticileri ve "with " Bildirimi

PEP 343'te tanıtıldı bir bağlam yöneticisi , bir ifade takımı için çalışma zamanı bağlamı olarak işlev gören bir nesnedir.

Özellik yeni anahtar kelimeler kullandığı için, yavaş yavaş tanıtıldı: Python 2.5'te __future__ yönerge . Python 2.6 ve üstü (Python 3 dahil) varsayılan olarak mevcuttur.

Ben kullandım açıklamada "ile" çok kullandım çünkü çok yararlı bir yapı olduğunu düşünüyorum, İşte hızlı bir demo:

from __future__ import with_statement

with open('foo.txt', 'w') as f:
    f.write('hello!')

Burada perde arkasında olan, "with" ifadesinin özel__enter____exit__ dosya nesnesindeki ve yöntemleri çağırmasıdır. İfade __exit__gövdesinden herhangi bir istisna oluşturulmuşsa, istisna işlemenin orada gerçekleşmesine izin verirse istisna ayrıntıları da iletilir .

Bu özel durumda, bunun sizin için yaptığı şey, yürütme işlemin kapsamı dışında kaldığında dosyanın kapatılmasını garanti etmesidir. with ne yaparsa, normalde meydana gelip gelmediğine veya bir istisna atıp atılmadığına bakılmaksızın, paketin . Temelde ortak istisna işleme kodunu soyutlamanın bir yoludur.

Bunun diğer yaygın kullanım durumları, iş parçacıkları ve veritabanı işlemleri ile kilitleme içerir.

Sözlüklerin bir get () yöntemi vardır

Sözlüklerin bir 'get ()' yöntemi vardır. D ['anahtar'] yaparsanız ve anahtar orada yoksa, bir istisna alırsınız. D.get ('anahtar') yaparsanız, 'anahtar' yoksa Yok'u alırsınız. Bu öğeyi Geri almak yerine ikinci bir argüman ekleyebilirsiniz, örneğin: d.get ('anahtar', 0).

Sayı eklemek gibi şeyler için harikadır:

sum[value] = sum.get(value, 0) + 1

Tanımlayıcılar

Bir sürü temel Python özelliğinin ardındaki sihir.

Bir üyeyi aramak için noktalı erişimi kullandığınızda (örneğin, xy), Python ilk olarak örneği örnek sözlüğünde arar. Bulunmazsa, sınıf sözlüğünde arar. Sınıf sözlüğünde bulursa ve nesne, yalnızca döndürmek yerine tanımlayıcı protokolünü uygularsa, Python bunu yürütür. Bir tanımlayıcı uygulayan her sınıf __get__, __set__ya da__delete__ yöntemleri.

Tanımlayıcıları kullanarak mülkün kendi (salt okunur) sürümünü nasıl uygulayacağınız aşağıda açıklanmıştır:

class Property(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, type):
        if obj is None:
            return self
        return self.fget(obj)

ve bunu yerleşik özellik gibi kullanırsınız ():

class MyClass(object):
    @Property
    def foo(self):
        return "Foo!"

Python'da, diğer şeylerin yanı sıra özellikleri, bağlı yöntemleri, statik yöntemleri, sınıf yöntemlerini ve yuvaları uygulamak için tanımlayıcılar kullanılır. Onları anlamak, daha önce Python 'tuhaflıkları' gibi görünen birçok şeyin neden oldukları gibi olduğunu görmeyi kolaylaştırır.

Raymond Hettinger, onları tanımlamak benden daha iyi bir iş yapan mükemmel bir öğreticiye sahiptir.

Koşullu Atama

x = 3 if (y == 1) else 2

Tam olarak göründüğü gibi yapar: "y 1 ise 3'e x, aksi takdirde 2'ye x atayın". Parens gerekli değildir, ancak okunabilirlik için onları seviyorum. Daha karmaşık bir şeyiniz varsa zincirleyebilirsiniz:

x = 3 if (y == 1) else 2 if (y == -1) else 1

Belli bir noktada, biraz fazla ileri gidiyor.

Herhangi bir ifadede if ... else komutunu kullanabileceğinizi unutmayın. Örneğin:

(func1 if y == 1 else func2)(arg1, arg2) 

Burada y, 1 ve f22 ise func1 çağrılır, aksi takdirde. Her iki durumda da ilgili işlev arg1 ve arg2 bağımsız değişkenleriyle çağrılır.

Benzer şekilde, aşağıdakiler de geçerlidir:

x = (class1 if y == 1 else class2)(arg1, arg2)

burada class1 ve class2 iki sınıftır.

doctest : aynı anda dokümantasyon ve birim testi.

Python belgelerinden çıkarılan örnek:

def factorial(n):
    """Return the factorial of n, an exact integer >= 0.

    If the result is small enough to fit in an int, return an int.
    Else return a long.

    >>> [factorial(n) for n in range(6)]
    [1, 1, 2, 6, 24, 120]
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n must be >= 0

    Factorials of floats are OK, but the float must be an exact integer:
    """

    import math
    if not n >= 0:
        raise ValueError("n must be >= 0")
    if math.floor(n) != n:
        raise ValueError("n must be exact integer")
    if n+1 == n:  # catch a value like 1e300
        raise OverflowError("n too large")
    result = 1
    factor = 2
    while factor <= n:
        result *= factor
        factor += 1
    return result

def _test():
    import doctest
    doctest.testmod()    

if __name__ == "__main__":
    _test()

Adlandırılmış biçimlendirme

% -formatting bir sözlük alır (% i /% s vb. doğrulama da uygular).

>>> print "The %(foo)s is %(bar)i." % {'foo': 'answer', 'bar':42}
The answer is 42.

>>> foo, bar = 'question', 123

>>> print "The %(foo)s is %(bar)i." % locals()
The question is 123.

Ve locals () da bir sözlük olduğundan, bunu bir dikte olarak iletebilir ve yerel değişkenlerinizden% -substitions alabilirsiniz. Bence bu kaşlarını çattı, ama işleri basitleştirir ..

Yeni Stil Biçimlendirme

>>> print("The {foo} is {bar}".format(foo='answer', bar=42))

Daha fazla python modülü eklemek için (özellikle 3. taraf olanlar), çoğu insan PYTHONPATH ortam değişkenlerini kullanıyor gibi görünüyor veya site paketleri dizinlerine sembolik veya dizin ekliyor. Başka bir yol da, * .pth dosyalarını kullanmaktır. İşte resmi python doc'ın açıklaması:

"Python'un arama yolunu değiştirmenin en kolay yolu, zaten Python'un yolunda bulunan bir dizine, genellikle ... / site-paketleri / dizinine bir yol yapılandırma dosyası eklemektir. Yol yapılandırma dosyalarının uzantısı .pth'dir. ve her satırın sys.path öğesine eklenecek tek bir yol içermesi gerekir. (Yeni yollar sys.path dosyasına eklendiğinden, eklenen dizinlerdeki modüller standart modülleri geçersiz kılmaz. standart modüllerin sabit sürümlerini kurmak için.) "

Başka istisna maddesi:

try:
  put_4000000000_volts_through_it(parrot)
except Voom:
  print "'E's pining!"
else:
  print "This parrot is no more!"
finally:
  end_sketch()

Else yan tümcesinin kullanımı, try deyimi tarafından korunan kod tarafından korunmayan bir istisna yakalamadan kaçındığından, try yan tümcesine ek kod eklemekten daha iyidir.

Bkz. Http://docs.python.org/tut/node10.html

İstisnaları yeniden yükseltme :

# Python 2 syntax
try:
    some_operation()
except SomeError, e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

# Python 3 syntax
try:
    some_operation()
except SomeError as e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

Bir hata işleyicisinin içinde argüman bulunmayan 'zam' ifadesi, Python'a istisnayı orijinal geri izleme bozulmadan yeniden yükseltmesini söyler ve "oh, üzgünüm, üzgünüm, bunu yakalamak demek istemedim, üzgünüm, üzgünüm. "

Orijinal geri izleme ile yazdırmak, depolamak veya keman çalmak istiyorsanız, sys.exc_info () ile alabilirsiniz ve Python 'traceback' modülüyle yazdırıldığı gibi yazdırmak mümkündür.

Ana mesajlar :)

import this
# btw look at this module's source :)

Şifrelenmemiş :

Python'un Zen'i, Tim Peters

Güzel, çirkin olmaktan iyidir.
Açık, örtük olmaktan iyidir.
Basit, karmaşık olmaktan iyidir.
Karmaşık karmaşık olmaktan iyidir.
Düz iç içe geçmişten daha iyidir.
Seyrek yoğun olmaktan iyidir.
Okunabilirlik önemlidir.
Özel durumlar kuralları ihlal edecek kadar özel değildir.
Pratiklik saflığı yenmesine rağmen.
Hatalar asla sessizce geçmemelidir.
Açıkça susturulmadıkça.
Belirsizlik karşısında, tahmin etme isteğini reddet. Bunu yapmanın tek ve tercihen tek bir yolu olmalı.
Her ne kadar Hollandalı değilseniz bu yol ilk başta belli olmayabilir.
Şimdi hiç olmadığı kadar iyi.
Her ne kadar asla genellikle daha iyi olmasa daDoğru şimdi.
Uygulamanın açıklanması zorsa, bu kötü bir fikirdir.
Uygulamanın açıklanması kolaysa, iyi bir fikir olabilir.
İsim alanları harika bir fikirdir - hadi bunlardan daha fazlasını yapalım!

Etkileşimli Tercüman Sekmesi Tamamlama

try:
    import readline
except ImportError:
    print "Unable to load readline module."
else:
    import rlcompleter
    readline.parse_and_bind("tab: complete")


>>> class myclass:
...    def function(self):
...       print "my function"
... 
>>> class_instance = myclass()
>>> class_instance.<TAB>
class_instance.__class__   class_instance.__module__
class_instance.__doc__     class_instance.function
>>> class_instance.f<TAB>unction()

Ayrıca bir PYTHONSTARTUP ortam değişkeni ayarlamanız gerekir.

Yuvalanmış liste kavrayışları ve jeneratör ifadeleri:

[(i,j) for i in range(3) for j in range(i) ]    
((i,j) for i in range(4) for j in range(i) )

Bunlar, büyük iç içe geçmiş döngü parçalarının yerini alabilir.

Yerleşik için aşırı yük operatörü set:

>>> a = set([1,2,3,4])
>>> b = set([3,4,5,6])
>>> a | b # Union
{1, 2, 3, 4, 5, 6}
>>> a & b # Intersection
{3, 4}
>>> a < b # Subset
False
>>> a - b # Difference
{1, 2}
>>> a ^ b # Symmetric Difference
{1, 2, 5, 6}

Standart kitaplık başvurusundan daha fazla ayrıntı: Küme Türleri