Funzionalità nascoste di Python [chiuso]

Quali sono le funzionalità meno conosciute ma utili del linguaggio di programmazione Python?

• Prova a limitare le risposte al core di Python.
• Una funzione per risposta.
• Fornisci un esempio e una breve descrizione della funzione, non solo un collegamento alla documentazione.
• Etichetta la funzione usando un titolo come prima riga.

Collegamenti rapidi alle risposte:

• Argomento Disimballaggio
• Bretelle
• Concatenamento di operatori di confronto
• decoratori
• Argomento predefinito Gotcha / pericoli di argomenti predefiniti mutabili
• descrittori
• .getValore predefinito del dizionario
• Test di Docstring
• Sintassi di afflizione ellittica
• Enumerazione
• Per / else
• Funziona come argomento iter ()
• Espressioni del generatore
• import this
• Scambio di valore sul posto
• Elenco passo-passo
• __missing__ elementi
• Regex multilinea
• Formattazione stringa denominata
• Elenco nidificato / comprensione del generatore
• Nuovi tipi in fase di esecuzione
• .pth File
• Codifica ROT13
• Debug di Regex
• Invio ai generatori
• Completamento della scheda nell'interprete interattivo
• Espressione ternaria
• try/except/else
• Disimballaggio + print()funzione
• with dichiarazione

Concatenare operatori di confronto:

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

Nel caso in cui stai pensando che stia facendo 1 < x, che viene fuori come True, e quindi confrontando True < 10, che è anche True, quindi no, non è proprio quello che succede (vedi l'ultimo esempio.) Si sta davvero traducendo in 1 < x and x < 10, ex < 10 and 10 < x * 10 and x*10 < 100 , ma con meno digitazioni e il termine viene valutato una sola volta.

Ottieni l'albero di analisi di regex python per eseguire il debug di regex.

Le espressioni regolari sono una grande caratteristica di Python, ma il loro debug può essere una seccatura, ed è fin troppo facile sbagliare una regex.

Fortunatamente, Python può stampare l'albero di analisi regex, passando la bandiera nascosta, sperimentale, nascosta re.DEBUG(in realtà, 128) a 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

Una volta compresa la sintassi, è possibile individuare gli errori. Ci possiamo vedere che ho dimenticato di sfuggire al []di[/font] .

Ovviamente puoi combinarlo con qualsiasi flag tu voglia, come regex commentati:

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

enumerare

Avvolgi un iterabile con enumerato e produrrà l'oggetto insieme al suo indice.

Per esempio:

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

Riferimenti:

• Tutorial su Python: tecniche di loop
• Documenti Python — funzioni integrate—enumerate
• PEP 279

Creazione di oggetti generatori

Se scrivi

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

puoi uscire dal generatore e assegnarlo a x. Ora significa che puoi farlo

for n in x:

Il vantaggio di questo è che non hai bisogno di memoria intermedia, di cui avresti bisogno se lo facessi

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

In alcuni casi ciò può comportare una notevole accelerazione.

Puoi aggiungere molte istruzioni if ​​alla fine del generatore, sostanzialmente replicando nidificato per i loop:

>>> 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 () può accettare un argomento richiamabile

Per esempio:

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

La iter(callable, until_value)funzione chiama ripetutamente callablee produce il suo risultato fino a quando non until_valueviene restituita.

Fai attenzione con argomenti predefiniti mutabili

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

Invece, dovresti usare un valore sentinella che indica "non fornito" e sostituirlo con il mutevole che desideri come predefinito:

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

Invio di valori nelle funzioni del generatore . Ad esempio con questa funzione:

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

Puoi:

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

Se non ti piace usare gli spazi bianchi per indicare gli ambiti, puoi usare lo stile C {} emettendo:

from __future__ import braces

L'argomento step negli operatori slice. Per esempio:

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

Il caso speciale x[::-1]è un utile linguaggio per "x invertito".

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

decoratori

I decoratori consentono di avvolgere una funzione o un metodo in un'altra funzione che può aggiungere funzionalità, modificare argomenti o risultati, ecc. Scrivi i decoratori una riga sopra la definizione della funzione, iniziando con un segno "at" (@).

L'esempio mostra un print_argsdecoratore che stampa gli argomenti della funzione decorata prima di chiamarla:

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

La sintassi for ... else (vedi http://docs.python.org/ref/for.html )

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

Il blocco "else" verrà normalmente eseguito alla fine del ciclo for, a meno che non venga chiamato il break.

Il codice sopra potrebbe essere emulato come segue:

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

Da 2.5 in poi i dicts hanno un metodo speciale __missing__che viene invocato per gli oggetti mancanti:

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

Esiste anche una sottoclasse dict che collectionschiama defaultdictpraticamente allo stesso modo ma chiama una funzione senza argomenti per elementi non esistenti:

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

Consiglio di convertire tali dicts in dicts regolari prima di passarli a funzioni che non prevedono tali sottoclassi. Un sacco di codice utilizza d[a_key]e rileva KeyErrors per verificare se esiste un elemento che aggiungerebbe un nuovo elemento al dict.

Scambio di valori sul posto

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

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

Il lato destro del compito è un'espressione che crea una nuova tupla. Il lato sinistro del compito disimballa immediatamente quella tupla (senza riferimenti) ai nomi ae b.

Dopo l'assegnazione, la nuova tupla non è referenziata e contrassegnata per la garbage collection e i valori associati ae bscambiati.

Come notato nella sezione tutorial di Python sulle strutture di dati ,

Si noti che l'assegnazione multipla è in realtà solo una combinazione di imballaggio tupla e disimballaggio sequenza.

Espressioni regolari leggibili

In Python puoi dividere un'espressione regolare su più righe, nominare le tue corrispondenze e inserire commenti.

Sintassi dettagliata di esempio (da Dive in 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)

Esempi di corrispondenze di denominazione (dal Regular Expression HOWTO )

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

Puoi anche scrivere verbalmente una regex senza usare re.VERBOSEgrazie alla concatenazione letterale di stringhe.

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

Argomento della funzione decompressione

È possibile decomprimere un elenco o un dizionario come argomenti di funzione utilizzando *e **.

Per esempio:

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)

Scorciatoia molto utile poiché elenchi, tuple e dadi sono ampiamente usati come contenitori.

ROT13 è una codifica valida per il codice sorgente, quando si utilizza la dichiarazione di codifica corretta nella parte superiore del file di codice:

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

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

Creazione di nuovi tipi in modo completamente dinamico

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

che è esattamente lo stesso di

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

Probabilmente non è la cosa più utile, ma bello da sapere.

Modifica : il nome fisso del nuovo tipo deve essere NewTypeidentico a quello classdell'istruzione.

Modifica : modificato il titolo per descrivere più accuratamente la funzione.

Gestori di contesto e " with" Dichiarazione

Introdotto in PEP 343 , un gestore di contesto è un oggetto che funge da contesto di runtime per una suite di istruzioni.

Poiché la funzione utilizza nuove parole chiave, viene introdotta gradualmente: è disponibile in Python 2.5 tramite la __future__direttiva. Python 2.6 e versioni successive (incluso Python 3) lo rendono disponibile per impostazione predefinita.

Ho usato molto la frase "with" perché penso che sia un costrutto molto utile, ecco una breve demo:

from __future__ import with_statement

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

Quello che sta succedendo qui dietro le quinte è che l' istruzione "with" chiama lo speciale __enter__e i __exit__metodi sull'oggetto file. Anche i dettagli dell'eccezione vengono passati a__exit__ se è stata sollevata un'eccezione dal corpo dell'istruzione with, consentendo in tal modo la gestione delle eccezioni.

Ciò che questo fa per te in questo caso particolare è che garantisce che il file sia chiuso quando l'esecuzione non rientra nell'ambito della withsuite, indipendentemente dal fatto che si verifichi normalmente o che sia stata generata un'eccezione. È fondamentalmente un modo per sottrarre il codice comune di gestione delle eccezioni.

Altri casi d'uso comuni per questo includono il blocco con thread e transazioni di database.

I dizionari hanno un metodo get ()

I dizionari hanno un metodo 'get ()'. Se fai d ['chiave'] e la chiave non c'è, otterrai un'eccezione. Se si fa d.get ('chiave'), si ottiene indietro Nessuno se 'chiave' non è presente. Puoi aggiungere un secondo argomento per riavere quell'elemento invece di None, ad esempio: d.get ('key', 0).

È ottimo per cose come aggiungere numeri:

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

descrittori

Sono la magia dietro un sacco di funzioni Python di base.

Quando si utilizza l'accesso punteggiato per cercare un membro (ad esempio, xy), Python cerca innanzitutto il membro nel dizionario dell'istanza. Se non viene trovato, lo cerca nel dizionario delle classi. Se lo trova nel dizionario delle classi e l'oggetto implementa il protocollo descrittore, invece di restituirlo, Python lo esegue. Un descrittore è un qualsiasi classe che implementa l' __get__, __set__o__delete__ metodi.

Ecco come implementare la tua versione (sola lettura) della proprietà usando i descrittori:

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)

e lo useresti proprio come la proprietà built-in ():

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

I descrittori sono usati in Python per implementare proprietà, metodi associati, metodi statici, metodi di classe e slot, tra le altre cose. Comprenderli rende facile capire perché molte cose che in precedenza sembravano "stranezze" di Python sono come sono.

Raymond Hettinger ha un eccellente tutorial che fa un lavoro molto migliore nel descriverli di me.

Cessione condizionale

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

Fa esattamente quello che sembra: "assegna 3 a x se y è 1, altrimenti assegna 2 a x". Nota che i genitori non sono necessari, ma mi piacciono per leggibilità. Puoi anche incatenarlo se hai qualcosa di più complicato:

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

Anche se a un certo punto, va un po 'troppo lontano.

Nota che puoi usare if ... else in qualsiasi espressione. Per esempio:

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

Qui sarà chiamato func1 se y è 1 e func2, altrimenti. In entrambi i casi la funzione corrispondente verrà chiamata con argomenti arg1 e arg2.

Analogamente, vale anche quanto segue:

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

dove class1 e class2 sono due classi.

Doctest : documentazione e unit test allo stesso tempo.

Esempio estratto dalla documentazione di 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()

Formattazione denominata

% -formatting accetta un dizionario (applica anche la convalida% i /% s ecc.).

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

E poiché locals () è anche un dizionario, puoi semplicemente passarlo come dict e avere% -substitions dalle tue variabili locali. Penso che questo sia disapprovato, ma semplifica le cose ..

Formattazione del nuovo stile

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

Per aggiungere più moduli Python (specialmente quelli di terze parti), la maggior parte delle persone sembra usare le variabili di ambiente PYTHONPATH o aggiungono collegamenti simbolici o directory nelle loro directory dei pacchetti del sito. Un altro modo è utilizzare i file * .pth. Ecco la spiegazione ufficiale del documento Python:

"Il modo più conveniente [per modificare il percorso di ricerca di Python] è aggiungere un file di configurazione del percorso a una directory che è già sul percorso di Python, di solito alla directory ... / site-pacchetti /. I file di configurazione del percorso hanno un'estensione di .pth e ogni riga deve contenere un singolo percorso che verrà aggiunto a sys.path (poiché i nuovi percorsi vengono aggiunti a sys.path, i moduli nelle directory aggiunte non sovrascriveranno i moduli standard. Ciò significa che non è possibile utilizzare questo meccanismo per l'installazione di versioni fisse di moduli standard.) "

Clausola di eccezione altro :

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

L'uso della clausola else è meglio dell'aggiunta di codice aggiuntivo alla clausola try perché evita di catturare accidentalmente un'eccezione che non è stata sollevata dal codice protetto dall'istruzione try ... tranne.

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

Aumentare nuovamente le eccezioni :

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

L'istruzione 'raise' senza argomenti all'interno di un gestore degli errori dice a Python di rilanciare l'eccezione con il traceback originale intatto , permettendoti di dire "oh, scusa, scusa, non volevo prenderlo, scusa, scusa. "

Se desideri stampare, archiviare o giocherellare con il traceback originale, puoi ottenerlo con sys.exc_info () e stamparlo come farebbe Python con il modulo 'traceback'.

Messaggi principali :)

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

Decifrato :

Lo Zen di Python, di Tim Peters

Bello è meglio che brutto.
Esplicito è meglio che implicito.
Semplice è meglio di complesso.
Complesso è meglio che complicato.
Flat è meglio di nidificato.
Sparse è meglio che denso.
La leggibilità conta.
I casi speciali non sono abbastanza speciali da infrangere le regole.
Sebbene la praticità superi la purezza.
Gli errori non dovrebbero mai passare silenziosamente.
A meno che non sia esplicitamente messo a tacere.
Di fronte all'ambiguità, rifiuta la tentazione di indovinare. Dovrebbe esserci uno - e preferibilmente solo un - modo obsoleto di farlo.
Anche se in quel modo all'inizio potrebbe non essere ovvio a meno che tu non sia olandese.
Adesso è meglio che mai.
Anche se spesso non è mai meglio diproprio ora
Se l'implementazione è difficile da spiegare, è una cattiva idea.
Se l'implementazione è facile da spiegare, potrebbe essere una buona idea.
Gli spazi dei nomi sono un'ottima idea per suonare il clacson: facciamo di più!

Completamento della scheda Interprete interattivo

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

Dovrai anche impostare una variabile d'ambiente PYTHONSTARTUP.

Comprensioni dell'elenco nidificato ed espressioni del generatore:

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

Questi possono sostituire enormi blocchi di codice a ciclo nidificato.

Sovraccarico dell'operatore per il setbuilt-in:

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

Maggiori dettagli dal riferimento della libreria standard: Imposta tipi