Características ocultas de Python [cerrado]

¿Cuáles son las características menos conocidas pero útiles del lenguaje de programación Python?

• Intenta limitar las respuestas al núcleo de Python.
• Una característica por respuesta.
• Dé un ejemplo y una breve descripción de la función, no solo un enlace a la documentación.
• Etiquete la característica usando un título como la primera línea.

Enlaces rápidos a respuestas:

• Argumento Desembalaje
• Tirantes
• Operadores de comparación de encadenamiento
• Decoradores
• Argumento predeterminado Gotchas / Peligros de Mutable Argumentos predeterminados
• Descriptores
• .getValor predeterminado del diccionario
• Pruebas de Docstring
• Sintaxis de corte de puntos suspensivos
• Enumeración
• Para / más
• Funciona como argumento iter ()
• Generador de expresiones
• import this
• Intercambio de valor en el lugar
• Lista de pasos
• __missing__ artículos
• Regex multilínea
• Formato de cadena con nombre
• Lista anidada / comprensión del generador
• Nuevos tipos en tiempo de ejecución
• .pth archivos
• Codificación ROT13
• Depuración de expresiones regulares
• Envío a generadores
• Finalización de tabulación en Intérprete interactivo
• Expresión Ternaria
• try/except/else
• Desembalaje + print()función
• with declaración

Operadores de comparación de encadenamiento:

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

En caso de que piense que lo está haciendo 1 < x, que aparece como True, y luego compara True < 10, que también es True, entonces no, eso no es realmente lo que sucede (vea el último ejemplo). Realmente se traduce en 1 < x and x < 10, y x < 10 and 10 < x * 10 and x*10 < 100, con menos tipeo y cada uno el término solo se evalúa una vez.

Obtenga el árbol de análisis de expresiones regulares de python para depurar su expresión regular.

Las expresiones regulares son una gran característica de python, pero depurarlas puede ser una molestia, y es muy fácil equivocarse con una expresión regular.

Afortunadamente, python puede imprimir el árbol de análisis de expresiones regulares, pasando el indicador oculto, indocumentado, experimental re.DEBUG(en realidad, 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 vez que comprenda la sintaxis, puede detectar sus errores. No podemos ver que se me olvidó para escapar de la []en [/font].

Por supuesto, puede combinarlo con las banderas que desee, como expresiones regulares comentadas:

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

enumerar

Envuelva un iterable con enumerate y generará el elemento junto con su índice.

Por ejemplo:

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

Referencias

• Tutorial de Python: técnicas de bucle
• Documentos de Python (funciones integradas)enumerate
• PEP 279

Crear objetos generadores

Si tú escribes

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

puedes sacar el generador y asignarlo a x. Ahora significa que puedes hacer

for n in x:

La ventaja de esto es que no necesita almacenamiento intermedio, que necesitaría si lo necesitara

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

En algunos casos, esto puede conducir a una aceleración significativa.

Puede agregar muchas declaraciones if al final del generador, básicamente replicando los bucles anidados:

>>> 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 () puede tomar un argumento invocable

Por ejemplo:

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

La iter(callable, until_value)función llama repetidamente callabley produce su resultado hasta que until_valuese devuelve.

Tenga cuidado con los argumentos predeterminados mutables

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

En su lugar, debe usar un valor centinela que denote "no dado" y reemplazarlo con el mutable que desea por defecto:

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

Envío de valores a las funciones del generador . Por ejemplo, tener esta función:

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

Usted puede:

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

Si no le gusta usar espacios en blanco para denotar ámbitos, puede usar el estilo C {} emitiendo:

from __future__ import braces

El argumento paso en operadores de corte. Por ejemplo:

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

El caso especial x[::-1]es un lenguaje útil para 'x invertido'.

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

Decoradores

Los decoradores permiten ajustar una función o método en otra función que puede agregar funcionalidad, modificar argumentos o resultados, etc. Usted escribe decoradores una línea sobre la definición de la función, comenzando con un signo "at" (@).

El ejemplo muestra un print_argsdecorador que imprime los argumentos de la función decorada antes de llamarla:

>>> 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 sintaxis de for ... else (ver http://docs.python.org/ref/for.html )

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

El bloque "else" se ejecutará normalmente al final del ciclo for, a menos que se llame al break.

El código anterior se puede emular de la siguiente manera:

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

De 2.5 en adelante, los dictos tienen un método especial __missing__que se invoca para los elementos faltantes:

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

También hay una subclase dict en collectionsllamada defaultdictque hace más o menos lo mismo pero llama a una función sin argumentos para elementos no existentes:

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

Recomiendo convertir dichos dictos a dictos regulares antes de pasarlos a funciones que no esperan tales subclases. Una gran cantidad de código usa d[a_key]y captura KeyErrors para verificar si existe un elemento que agregaría un nuevo elemento al dict.

Intercambio de valor en el lugar

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

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

El lado derecho de la tarea es una expresión que crea una nueva tupla. El lado izquierdo de la tarea desempaqueta inmediatamente esa tupla (sin referencia) a los nombresa y b.

Después de la asignación, la nueva tupla no está referenciada y marcada para la recolección de basura, y los valores vinculados a a y bse han intercambiado.

Como se señaló en el sección del tutorial de Python sobre estructuras de datos ,

Tenga en cuenta que la asignación múltiple es realmente solo una combinación de empaque de tuplas y desempaque de secuencia.

Expresiones regulares legibles

En Python puede dividir una expresión regular en varias líneas, nombrar sus coincidencias e insertar comentarios.

Ejemplo de sintaxis detallada (de Dive into 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)

Ejemplo de coincidencias de nomenclatura (del COMO de expresiones regulares )

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

También puedes escribir una expresión regular sin usar re.VERBOSEgracias a la concatenación literal de cadenas.

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

Desembalaje de argumento de función

Puede descomprimir una lista o un diccionario como argumentos de función utilizando *y **.

Por ejemplo:

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)

Atajo muy útil ya que las listas, tuplas y dictados se usan ampliamente como contenedores.

ROT13 es una codificación válida para el código fuente, cuando utiliza la declaración de codificación correcta en la parte superior del archivo de código:

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

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

Crear nuevos tipos de manera totalmente dinámica

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

que es exactamente lo mismo que

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

Probablemente no sea lo más útil, pero es bueno saberlo.

Editar : El nombre fijo del nuevo tipo debe ser NewTypeexactamente lo mismo que con la classdeclaración.

Editar : Ajustó el título para describir con mayor precisión la función.

Los administradores de contexto y la " with" Declaración

Introducido en PEP 343 , un administrador de contexto es un objeto que actúa como contexto de tiempo de ejecución para un conjunto de declaraciones.

Dado que la función utiliza nuevas palabras clave, se introduce gradualmente: está disponible en Python 2.5 a través de __future__ directiva. Python 2.6 y superior (incluido Python 3) lo tiene disponible de forma predeterminada.

He usado mucho la declaración "con" porque creo que es una construcción muy útil, aquí hay una demostración rápida:

from __future__ import with_statement

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

Lo que sucede aquí detrás de escena es que la instrucción "con" llama a los métodos especiales __enter__y __exit__al objeto del archivo. Los detalles de excepción también se pasan a__exit__ si surgió alguna excepción del cuerpo de la declaración with, lo que permite el manejo de excepciones allí.

Lo que esto hace por usted en este caso particular es que garantiza que el archivo se cierre cuando la ejecución esté fuera del alcance de la withsuite, independientemente de si eso ocurre normalmente o si se produjo una excepción. Básicamente es una forma de abstraer el código común de manejo de excepciones.

Otros casos de uso comunes para esto incluyen el bloqueo con hilos y transacciones de bases de datos.

Los diccionarios tienen un método get ()

Los diccionarios tienen un método 'get ()'. Si haces d ['clave'] y la clave no está allí, obtienes una excepción. Si hace d.get ('clave'), regresa Ninguno si 'clave' no está allí. Puede agregar un segundo argumento para recuperar ese elemento en lugar de Ninguno, por ejemplo: d.get ('clave', 0).

Es genial para cosas como sumar números:

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

Descriptores

Son la magia detrás de un montón de características centrales de Python.

Cuando usa el acceso punteado para buscar un miembro (por ejemplo, xy), Python primero busca el miembro en el diccionario de instancias. Si no se encuentra, lo busca en el diccionario de la clase. Si lo encuentra en el diccionario de la clase y el objeto implementa el protocolo descriptor, en lugar de simplemente devolverlo, Python lo ejecuta. Un descriptor es cualquier clase que implementa la __get__, __set__o__delete__ métodos.

Así es como implementaría su propia versión (de solo lectura) de la propiedad utilizando descriptores:

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)

y lo usarías igual que la propiedad incorporada ():

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

Los descriptores se usan en Python para implementar propiedades, métodos enlazados, métodos estáticos, métodos de clase y ranuras, entre otras cosas. Comprenderlos hace que sea fácil ver por qué muchas de las cosas que antes parecían 'peculiaridades' de Python son como son.

Raymond Hettinger tiene un excelente tutorial que hace un trabajo mucho mejor describiéndolos que yo.

Asignación Condicional

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

Hace exactamente lo que parece: "asigna 3 a x si y es 1, de lo contrario asigna 2 a x". Tenga en cuenta que los parens no son necesarios, pero me gustan para facilitar la lectura. También puedes encadenarlo si tienes algo más complicado:

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

Aunque en cierto punto, va un poco demasiado lejos.

Tenga en cuenta que puede usar if ... else en cualquier expresión. Por ejemplo:

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

Aquí se llamará a func1 si y es 1 y func2, de lo contrario. En ambos casos, la función correspondiente se llamará con argumentos arg1 y arg2.

Análogamente, lo siguiente también es válido:

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

donde class1 y class2 son dos clases.

Doctest : documentación y pruebas unitarias al mismo tiempo.

Ejemplo extraído de la documentación de 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()

Formato con nombre

El formato% toma un diccionario (también aplica la validación% i /% s, etc.).

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

Y dado que locals () también es un diccionario, simplemente puede pasarlo como un dict y tener% -substitions de sus variables locales. Creo que esto está mal visto, pero simplifica las cosas ...

Nuevo formato de estilo

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

Para agregar más módulos de Python (especialmente los de terceros), la mayoría de las personas parecen usar las variables de entorno PYTHONPATH o agregan enlaces simbólicos o directorios en sus directorios de paquetes de sitio. Otra forma es usar archivos * .pth. Aquí está la explicación oficial del documento de Python:

"La forma más conveniente [de modificar la ruta de búsqueda de Python] es agregar un archivo de configuración de ruta a un directorio que ya está en la ruta de Python, generalmente al directorio ... / site-packages /. Los archivos de configuración de ruta tienen una extensión de .pth , y cada línea debe contener una única ruta que se agregará a sys.path. (Debido a que las nuevas rutas se agregan a sys.path, los módulos en los directorios agregados no anularán los módulos estándar. Esto significa que no puede usar este mecanismo para instalar versiones fijas de módulos estándar.) "

Excepción otra cláusula:

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

El uso de la cláusula else es mejor que agregar código adicional a la cláusula try porque evita detectar accidentalmente una excepción que no fue generada por el código protegido por la declaración try ... except.

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

Volver a plantear excepciones :

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

La declaración 'raise' sin argumentos dentro de un controlador de errores le dice a Python que vuelva a aumentar la excepción con el rastreo original intacto , permitiéndole decir "oh, lo siento, lo siento, no quise captar eso, lo siento, lo siento. "

Si desea imprimir, almacenar o manipular el rastreo original, puede obtenerlo con sys.exc_info (), e imprimirlo como Python lo haría con el módulo 'rastreo'.

Mensajes principales :)

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

Descifrado :

El zen de Python, por Tim Peters

Hermoso es mejor que feo.
Explícito es mejor que implícito.
Simple es mejor que complejo.
Complejo es mejor que complicado.
Plano es mejor que anidado.
Escaso es mejor que denso.
La legibilidad cuenta.
Los casos especiales no son lo suficientemente especiales como para romper las reglas.
Aunque la practicidad supera la pureza.
Los errores nunca deben pasar en silencio.
A menos que sea silenciado explícitamente.
Ante la ambigüedad, rechaza la tentación de adivinar. Debe haber una, y preferiblemente solo una, forma obvia de hacerlo.
Aunque esa manera puede no ser obvia al principio a menos que seas holandés. correcto Si la implementación es difícil de explicar, es una mala idea.
Ahora es mejor que nunca.
Aunque nunca es a menudo mejor que ahora. Si la implementación es fácil de explicar, puede ser una buena idea. Los espacios de nombres son una gran idea, ¡hagamos más de eso!

Finalización de la pestaña de intérprete interactivo

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

También deberá establecer una variable de entorno PYTHONSTARTUP.

Lista de comprensiones anidadas y expresiones generadoras:

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

Estos pueden reemplazar enormes fragmentos de código de bucle anidado.

Sobrecarga del operador para la setconstrucción:

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

Más detalles de la referencia de biblioteca estándar: Establecer tipos