Ukryte funkcje Pythona [zamknięte]

Jakie są mniej znane, ale przydatne funkcje języka programowania Python?

• Spróbuj ograniczyć odpowiedzi do rdzenia Pythona.
• Jedna funkcja na odpowiedź.
• Podaj przykład i krótki opis funkcji, a nie tylko link do dokumentacji.
• Oznacz obiekt, używając tytułu jako pierwszego wiersza.

Szybkie linki do odpowiedzi:

• Rozpakowywanie argumentów
• Aparat ortodontyczny
• Łączenie łańcuchowe operatorów
• Dekoratorzy
• Domyślny argument Gotchas / Dangers of Mutable Default arguments
• Deskryptory
• Domyślna .getwartość słownika
• Testy docstringowe
• Ellipsis Slicing Składnia
• Wyliczenie
• Dla / else
• Funkcja jako argument iter ()
• Wyrażenia generatora
• import this
• Zamiana wartości na miejscu
• Krocząca lista
• __missing__ przedmiotów
• Regex wieloliniowy
• Formatowane ciągi nazwane
• Zagnieżdżone listy / generatory
• Nowe typy w czasie wykonywania
• .pth akta
• Kodowanie ROT13
• Debugowanie Regex
• Wysyłanie do generatorów
• Wypełnianie tabulatorów w interaktywnym tłumaczu
• Wyrażenie trójskładnikowe
• try/except/else
• Rozpakowanie + print()funkcja
• with komunikat

Łańcuchowe operatory porównania:

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

W przypadku, gdy myślisz, że działa 1 < x, wychodzi True, a następnie porównuje True < 10, co również oznacza True, że nie, to naprawdę nie to, co się dzieje (patrz ostatni przykład). To naprawdę przekłada się na 1 < x and x < 10i x < 10 and 10 < x * 10 and x*10 < 100, ale z mniejszym pisaniem i każdym z nich semestr jest oceniany tylko raz.

Pobierz drzewo parsowania wyrażenia regularnego w Pythonie, aby debugować wyrażenie regularne.

Wyrażenia regularne są świetną funkcją Pythona, ale ich debugowanie może być uciążliwe i zbyt łatwo jest pomylić wyrażenie regularne.

Na szczęście Python może wydrukować drzewo analizy wyrażeń regularnych, przekazując nieudokumentowaną, eksperymentalną, ukrytą flagę re.DEBUG(właściwie 128) do 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

Po zrozumieniu składni możesz dostrzec swoje błędy. Nie widzimy, że zapomniałem uciec []in [/font].

Oczywiście możesz to połączyć z dowolnymi flagami, takimi jak skomentowane wyrażenia regularne:

>>> 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)

wyliczać

Zawijaj iterowalny wyliczeniem, a otrzymasz element wraz z jego indeksem.

Na przykład:

>>> 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
>>>

Bibliografia:

• Samouczek języka Python - techniki zapętlania
• Dokumenty Python — wbudowane funkcje—enumerate
• PEP 279

Tworzenie obiektów generatorów

Jeśli napiszesz

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

możesz wyjść z generatora i przypisać go do x. Teraz oznacza to, że możesz to zrobić

for n in x:

Zaletą tego jest to, że nie potrzebujesz pośredniego magazynu, który byłby potrzebny, gdybyś to zrobił

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

W niektórych przypadkach może to prowadzić do znacznego przyspieszenia.

Możesz dołączyć wiele instrukcji if na końcu generatora, w zasadzie replikując zagnieżdżone dla pętli:

>>> 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 () może przyjąć argument wywoływalny

Na przykład:

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

iter(callable, until_value)Funkcja wielokrotnie wzywa callablei daje swój wynik aż until_valuezostanie zwrócony.

Uważaj na zmienne argumenty domyślne

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

Zamiast tego powinieneś użyć wartownika oznaczającego „nie podano” i zastąpić zmienną, którą chcesz domyślnie:

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

Przesyłanie wartości do funkcji generatora . Na przykład mając tę ​​funkcję:

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

Możesz:

>>> 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

Jeśli nie lubisz używać białych znaków do oznaczania zakresów, możesz użyć stylu C {}, wydając:

from __future__ import braces

Argument kroku w operatorach wycinków. Na przykład:

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

Przypadek specjalny x[::-1]jest przydatnym idiomem dla „x reverse”.

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

Dekoratorzy

Dekoratory pozwalają na zawinięcie funkcji lub metody w inną funkcję, która może dodawać funkcjonalność, modyfikować argumenty lub wyniki itp. Dekoratory piszesz jeden wiersz powyżej definicji funkcji, zaczynając od znaku „at” (@).

Przykład pokazuje print_argsdekorator, który drukuje argumenty dekorowanej funkcji przed jej wywołaniem:

>>> 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

Składnia for ... else (patrz http://docs.python.org/ref/for.html )

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

Blok „else” będzie normalnie wykonywany na końcu pętli for, chyba że wywołane zostanie przerwanie.

Powyższy kod można emulować w następujący sposób:

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

Od 2.5 dyktatury mają specjalną metodę, __missing__która jest wywoływana dla brakujących elementów:

>>> 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]}

W collectionswywołanej jest również podklasa dict, defaultdictktóra działa prawie tak samo, ale wywołuje funkcję bez argumentów dla nieistniejących elementów:

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

Polecam konwersję takich nagrań na zwykłe nagrania przed przekazaniem ich do funkcji, które nie oczekują takich podklas. Wiele kodów używa d[a_key]i łapie KeyErrors, aby sprawdzić, czy istnieje element, który dodałby nowy element do dykta.

Zamiana wartości w miejscu

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

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

Prawa strona zadania jest wyrażeniem, które tworzy nową krotkę. Lewa strona zadania natychmiast rozpakowuje, że (bez odniesienia) krotka do nazw ai b.

Po przypisaniu nowa krotka nie jest przywoływana i jest oznaczana do wyrzucania elementów bezużytecznych, a wartości powiązane ai bzostały zamienione.

Jak zauważono w sekcji samouczka poświęconej Pythonowi na temat struktur danych ,

Zauważ, że wielokrotne przypisywanie jest tak naprawdę kombinacją pakowania krotek i rozpakowywania sekwencji.

Czytelne wyrażenia regularne

W Pythonie możesz podzielić wyrażenie regularne na wiele wierszy, nazwać swoje dopasowania i wstawić komentarze.

Przykładowa pełna składnia (od Dive do Python ):

>>> 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)

Przykładowe dopasowania nazewnictwa (z wyrażenia regularnego HOWTO )

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

Możesz także napisać wyrażeniem regularnym wyrażenie regularne bez użycia re.VERBOSEliterackiej łańcuchowej konkatenacji.

>>> 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})$"

Rozpakowywanie argumentów funkcji

Możesz rozpakować listę lub słownik jako argumenty funkcji za pomocą *i **.

Na przykład:

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)

Bardzo przydatny skrót, ponieważ listy, krotki i dyktanda są szeroko stosowane jako kontenery.

ROT13 jest prawidłowym kodowaniem kodu źródłowego, jeśli użyto właściwej deklaracji kodowania na górze pliku kodu:

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

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

Tworzenie nowych typów w pełni dynamiczny sposób

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

który jest dokładnie taki sam jak

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

Prawdopodobnie nie najbardziej użyteczna rzecz, ale miło wiedzieć.

Edycja : Stała nazwa nowego typu powinna być NewTypedokładnie taka sama jak w przypadku classinstrukcji.

Edycja : Dostosowano tytuł, aby dokładniej opisać funkcję.

Menedżery kontekstu i instrukcja „ with”

Menedżer kontekstu, wprowadzony w PEP 343 , jest obiektem działającym jako kontekst wykonawczy dla zestawu instrukcji.

Ponieważ funkcja korzysta z nowych słów kluczowych, jest wprowadzana stopniowo: jest dostępna w Pythonie 2.5 poprzez __future__dyrektywę. Python 2.6 i nowsze wersje (w tym Python 3) domyślnie są dostępne.

Często używałem wyrażenia „z”, ponieważ uważam, że jest to bardzo przydatna konstrukcja, oto krótkie demo:

from __future__ import with_statement

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

To, co dzieje się tutaj za kulisami, polega na tym, że instrukcja „with” wywołuje funkcje specjalne __enter__i __exit__metody na obiekcie pliku. Szczegóły wyjątku są również przekazywane, __exit__jeśli z treści instrukcji with został zgłoszony jakiś wyjątek, umożliwiając tam obsługę wyjątków.

W tym konkretnym przypadku oznacza to, że gwarantuje zamknięcie pliku, gdy wykonanie wykracza poza zakres withpakietu, niezależnie od tego , czy nastąpi to normalnie, czy też zgłoszono wyjątek. Jest to w zasadzie sposób wyodrębnienia wspólnego kodu obsługi wyjątków.

Inne typowe przypadki użycia to blokowanie za pomocą wątków i transakcji w bazie danych.

Słowniki mają metodę get ()

Słowniki mają metodę „get ()”. Jeśli zrobisz d [„klucz”], a klucza go nie ma, otrzymasz wyjątek. Jeśli wykonasz d.get („klucz”), otrzymasz zwrot Brak, jeśli „klucz” nie istnieje. Możesz dodać drugi argument, aby odzyskać ten element zamiast None, np .: d.get ('key', 0).

Doskonale nadaje się do dodawania liczb:

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

Deskryptory

Są magią kryjącą się za całym szeregiem podstawowych funkcji Pythona.

Kiedy używasz dostępu przerywanego do wyszukiwania członka (np. Xy), Python najpierw szuka członka w słowniku instancji. Jeśli nie zostanie znaleziony, szuka go w słowniku klas. Jeśli znajdzie go w słowniku klas, a obiekt zaimplementuje protokół deskryptora, zamiast go zwracać, Python wykonuje go. Deskryptor jest dowolną klasę, która realizuje __get__, __set__lub __delete__metod.

Oto, w jaki sposób zaimplementujesz własną (tylko do odczytu) wersję właściwości za pomocą deskryptorów:

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)

i użyjesz go tak jak wbudowanej właściwości ():

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

Deskryptory są używane w Pythonie do implementacji między innymi właściwości, metod powiązanych, metod statycznych, metod klas i gniazd. Ich zrozumienie ułatwia zrozumienie, dlaczego wiele rzeczy, które wcześniej wyglądały jak „dziwactwa” Pythona, są takie, jakie są.

Raymond Hettinger ma świetny samouczek , który lepiej opisuje je niż ja.

Przypisanie warunkowe

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

Robi dokładnie tak, jak to brzmi: „przypisz 3 do x, jeśli y wynosi 1, w przeciwnym razie przypisz 2 do x”. Pamiętaj, że pareny nie są konieczne, ale podoba mi się ich czytelność. Możesz również połączyć go w łańcuch, jeśli masz coś bardziej skomplikowanego:

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

Chociaż w pewnym momencie idzie to trochę za daleko.

Pamiętaj, że możesz użyć if ... else w dowolnym wyrażeniu. Na przykład:

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

Tutaj func1 zostanie wywołany, jeśli y wynosi 1, a func2, w przeciwnym razie. W obu przypadkach odpowiednia funkcja zostanie wywołana z argumentami arg1 i arg2.

Analogicznie obowiązuje również:

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

gdzie klasa 1 i klasa 2 to dwie klasy.

Doctest : dokumentacja i testy jednostkowe w tym samym czasie.

Przykład wyodrębniony z dokumentacji Python:

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()

Nazwane formatowanie

% -formatting pobiera słownik (stosuje również sprawdzanie poprawności% i /% s itp.).

>>> 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.

A ponieważ locals () jest także słownikiem, możesz po prostu przekazać to jako słownik i mieć% -substitions ze zmiennych lokalnych. Myślę, że jest to niezadowolone, ale upraszcza rzeczy ...

Nowe formatowanie stylu

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

Aby dodać więcej modułów Pythona (szczególnie zewnętrznych), większość ludzi wydaje się używać zmiennych środowiskowych PYTHONPATH lub dodaje dowiązania symboliczne lub katalogi w swoich katalogach pakietów stron. Innym sposobem jest użycie plików * .pth. Oto oficjalne wyjaśnienie doktora Pythona:

„Najwygodniejszym sposobem [modyfikacji ścieżki wyszukiwania Pythona] jest dodanie pliku konfiguracji ścieżki do katalogu, który już znajduje się na ścieżce Pythona, zwykle do katalogu ... / site-packages /. Pliki konfiguracji ścieżki mają rozszerzenie .pth , a każda linia musi zawierać jedną ścieżkę, która zostanie dołączona do sys.path. (Ponieważ nowe ścieżki są dołączone do sys.path, moduły w dodanych katalogach nie zastąpią standardowych modułów. Oznacza to, że nie można użyć tego mechanizmu do instalowania stałych wersji standardowych modułów.) ”

Wyjątek od pozostałych klauzul:

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

Użycie klauzuli else jest lepsze niż dodanie dodatkowego kodu do klauzuli try, ponieważ pozwala uniknąć przypadkowego wyłapania wyjątku, który nie został zgłoszony przez kod chroniony przez instrukcję try ....

Zobacz http://docs.python.org/tut/node10.html

Ponowne zgłaszanie wyjątków :

# 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)

Instrukcja „podbicia” bez argumentów w module obsługi błędów mówi Pythonowi, aby ponownie podniósł wyjątek z nienaruszonym oryginalnym śledzeniem , pozwalając powiedzieć „och, przepraszam, przepraszam, nie chciałem tego złapać, przepraszam, przepraszam. „

Jeśli chcesz drukować, przechowywać lub bawić się przy użyciu oryginalnego traceback, możesz go uzyskać za pomocą sys.exc_info (), a drukowanie w taki sposób, jak w Pythonie, odbywa się za pomocą modułu „traceback”.

Główne wiadomości :)

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

Odszyfrowane :

Zen of Python, autor: Tim Peters

Piękne jest lepsze niż brzydkie.
Jawne jest lepsze niż niejawne.
Prosty jest lepszy niż złożony.
Złożony jest lepszy niż skomplikowany.
Mieszkanie jest lepsze niż zagnieżdżone.
Rzadki jest lepszy niż gęsty.
Liczy się czytelność.
Przypadki specjalne nie są wystarczająco wyjątkowe, aby złamać zasady.
Chociaż praktyczność przewyższa czystość.
Błędy nigdy nie powinny przejść bezgłośnie.
Chyba że wyraźnie uciszony.
W obliczu dwuznaczności odmów pokusy zgadywania. Powinien być jeden - a najlepiej tylko jeden - oczywisty sposób na zrobienie tego.
Chociaż na początku taki sposób może nie być oczywisty, chyba że jesteś Holendrem.
Teraz jest lepiej niż nigdy.
Chociaż nigdy nie jest często lepszy niżwłaśnie teraz.
Jeśli implementacja jest trudna do wyjaśnienia, to zły pomysł.
Jeśli implementacja jest łatwa do wyjaśnienia, może to być dobry pomysł.
Przestrzenie nazw to jeden świetny pomysł - zróbmy więcej z nich!

Wypełnienie zakładki interaktywnego interpretera

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()

Będziesz także musiał ustawić zmienną środowiskową PYTHONSTARTUP.

Wyjaśnienia list zagnieżdżonych i wyrażenia generatorów:

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

Mogą one zastąpić duże fragmenty kodu zagnieżdżonej pętli.

Przeciążenie operatora dla setwbudowanego:

>>> 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}

Więcej szczegółów ze standardowego odniesienia do biblioteki: Ustaw typy