Recursos ocultos do Python [fechado]

Quais são os recursos menos conhecidos, mas úteis, da linguagem de programação Python?

• Tente limitar as respostas ao núcleo do Python.
• Um recurso por resposta.
• Dê um exemplo e uma breve descrição do recurso, não apenas um link para a documentação.
• Rotule o recurso usando um título como a primeira linha.

Links rápidos para respostas:

• Argumento Desempacotando
• Suspensórios
• Operadores de comparação de encadeamento
• Decoradores
• Pegadas de argumento padrão / perigos de argumentos padrão mutáveis
• Descritores
• .getValor padrão do dicionário
• Testes de Docstring
• Sintaxe de corte de reticências
• Enumeração
• For / else
• Função como argumento iter ()
• Expressões do gerador
• import this
• Troca de valor no local
• Passo da lista
• __missing__ Itens
• Regex de várias linhas
• Formatação de string nomeada
• Compreensões de lista / gerador aninhadas
• Novos tipos em tempo de execução
• .pth arquivos
• Codificação ROT13
• Depuração de Regex
• Enviando para Geradores
• Conclusão da guia no intérprete interativo
• Expressão ternária
• try/except/else
• Desempacotando + print()função
• with declaração

Operadores de comparação de encadeamento:

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

No caso de você está pensando que está fazendo 1 < x, que sai como True, e em seguida, comparando True < 10, que é também True, então não, isso não é realmente o que acontece (ver o último exemplo.) É realmente traduzindo-se 1 < x and x < 10, e x < 10 and 10 < x * 10 and x*10 < 100, mas com menos digitação e cada O termo é avaliado apenas uma vez.

Obtenha a árvore de análise python regex para depurar seu regex.

Expressões regulares são um ótimo recurso do python, mas depurá-las pode ser uma dor, e é muito fácil cometer erros de regex.

Felizmente, o python pode imprimir a árvore de análise regex, passando o sinalizador não documentado, experimental e oculto re.DEBUG(na verdade, 128) para 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

Depois de entender a sintaxe, você poderá identificar seus erros. Não podemos ver que eu esqueci de escapar do []no [/font].

Obviamente, você pode combiná-lo com qualquer sinalizador que desejar, como regexes 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

Envolva um iterável com enumerar e ele produzirá o item junto com seu índice.

Por exemplo:

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

Referências:

• Tutorial do Python - técnicas de loop
• Documentos Python - funções internas -enumerate
• PEP 279

Criando objetos geradores

Se você escrever

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

você pode sair do gerador e atribuí-lo a x. Agora isso significa que você pode fazer

for n in x:

A vantagem disso é que você não precisa de armazenamento intermediário, o que você precisaria se precisasse

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

Em alguns casos, isso pode levar a uma velocidade significativa.

Você pode anexar muitas instruções if ao final do gerador, basicamente replicando aninhados para loops:

>>> 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 () pode usar um argumento que pode ser chamado

Por exemplo:

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

A iter(callable, until_value)função chama callablee produz repetidamente seu resultado até que until_valueseja retornada.

Cuidado com argumentos padrão mutáveis

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

Em vez disso, você deve usar um valor sentinela indicando "não fornecido" e substituir pelo mutável que você deseja como padrão:

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

Enviando valores para as funções do gerador . Por exemplo, tendo esta função:

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

Você pode:

>>> 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 você não gosta de usar espaço em branco para indicar escopos, pode usar o estilo C {} emitindo:

from __future__ import braces

O argumento step em operadores de fatia. Por exemplo:

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

O caso especial x[::-1]é um idioma útil para 'x invertido'.

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

Decoradores

Os decoradores permitem agrupar uma função ou método em outra função que pode adicionar funcionalidade, modificar argumentos ou resultados, etc. Você escreve decoradores uma linha acima da definição da função, começando com um sinal de "arroba" (@).

O exemplo mostra um print_argsdecorador que imprime os argumentos da função decorada antes de chamá-la:

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

A sintaxe for ... else (consulte http://docs.python.org/ref/for.html )

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

O bloco "else" será normalmente executado no final do loop for, a menos que a interrupção seja chamada.

O código acima pode ser emulado da seguinte maneira:

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

A partir de 2.5, os ditados têm um método especial __missing__que é chamado para itens ausentes:

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

Também existe uma subclasse dict collectionschamada, defaultdictque faz praticamente o mesmo, mas chama uma função sem argumentos para itens não existentes:

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

Eu recomendo converter esses dictos em ditados regulares antes de passá-los para funções que não esperam tais subclasses. Muitos códigos usam d[a_key]e capturam KeyErrors para verificar se existe um item que adicionaria um novo item ao ditado.

Troca de valor no local

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

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

O lado direito da atribuição é uma expressão que cria uma nova tupla. O lado esquerdo da tarefa descompacta imediatamente essa tupla (não referenciada) dos nomes ae b.

Após a atribuição, a nova tupla não é referenciada e marcada para coleta de lixo, e os valores vinculados ae bforam trocados.

Conforme observado na seção do tutorial do Python sobre estruturas de dados ,

Observe que a atribuição múltipla é realmente apenas uma combinação de empacotamento de tupla e descompactação de sequência.

Expressões regulares legíveis

No Python, você pode dividir uma expressão regular em várias linhas, nomear suas correspondências e inserir comentários.

Exemplo de sintaxe detalhada (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)

Exemplo de correspondências de nomeação (no HOWTO de Expressão Regular )

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

Você também pode escrever uma regex verbalmente sem usar re.VERBOSEa concatenação literal de cadeias.

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

Argumento de Função Descompactando

Você pode descompactar uma lista ou um dicionário como argumentos de função usando *e **.

Por exemplo:

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)

Atalho muito útil, pois listas, tuplas e dictos são amplamente utilizados como contêineres.

ROT13 é uma codificação válida para o código fonte, quando você usa a declaração de codificação correta na parte superior do arquivo de código:

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

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

Criando novos tipos de uma maneira totalmente dinâmica

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

que é exatamente o mesmo que

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

Provavelmente não é a coisa mais útil, mas é bom saber.

Edit : Nome fixo do novo tipo, deve ser NewTypeexatamente a mesma coisa que com a classinstrução.

Editar : ajustou o título para descrever com mais precisão o recurso.

Gerentes de contexto e a withdeclaração " "

Introduzido no PEP 343 , um gerenciador de contexto é um objeto que atua como um contexto de tempo de execução para um conjunto de instruções.

Como o recurso faz uso de novas palavras-chave, é introduzido gradualmente: está disponível no Python 2.5 através da __future__diretiva. O Python 2.6 e superior (incluindo o Python 3) o disponibilizam por padrão.

Eu tenho usado muito a instrução "with" porque acho que é uma construção muito útil, aqui está uma demonstração rápida:

from __future__ import with_statement

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

O que está acontecendo aqui nos bastidores é que a instrução "with" chama os métodos __enter__e especiais __exit__no objeto de arquivo. Os detalhes da exceção também são passados ​​para __exit__se alguma exceção foi levantada do corpo da instrução with, permitindo que o tratamento da exceção ocorra lá.

O que isso faz com você nesse caso específico é que garante que o arquivo seja fechado quando a execução estiver fora do escopo do withconjunto, independentemente se isso ocorrer normalmente ou se uma exceção foi lançada. É basicamente uma maneira de abstrair o código comum de tratamento de exceções.

Outros casos de uso comuns para isso incluem bloqueio com threads e transações com o banco de dados.

Os dicionários têm um método get ()

Os dicionários têm um método 'get ()'. Se você d ['key'] e a chave não estiverem lá, você receberá uma exceção. Se você fizer d.get ('key'), retornará None se 'key' não estiver lá. Você pode adicionar um segundo argumento para recuperar esse item em vez de Nenhum, por exemplo: d.get ('key', 0).

É ótimo para coisas como somar números:

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

Descritores

Eles são a mágica por trás de vários recursos principais do Python.

Quando você usa acesso pontilhado para procurar um membro (por exemplo, xy), o Python primeiro procura o membro no dicionário de instância. Se não for encontrado, ele o procura no dicionário de classes. Se o encontrar no dicionário de classes e o objeto implementar o protocolo do descritor, em vez de apenas devolvê-lo, o Python o executará. Um descritor é qualquer classe que implementa as __get__, __set__ou __delete__métodos.

Veja como você implementaria sua própria versão (somente leitura) da propriedade usando descritores:

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 você o usaria exatamente como a propriedade interna ():

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

Os descritores são usados ​​no Python para implementar propriedades, métodos vinculados, métodos estáticos, métodos de classe e slots, entre outras coisas. Compreendê-los facilita ver por que muitas coisas que antes pareciam 'peculiaridades' do Python são do jeito que são.

Raymond Hettinger tem um excelente tutorial que faz um trabalho muito melhor de descrevê-los do que eu.

Atribuição Condicional

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

Ele faz exatamente o que parece: "atribua 3 a x se y for 1; caso contrário, atribua 2 a x". Observe que os parênteses não são necessários, mas eu gosto deles para facilitar a leitura. Você também pode encadeá-lo se tiver algo mais complicado:

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

Embora em um certo ponto, vá um pouco longe demais.

Observe que você pode usar if ... else em qualquer expressão. Por exemplo:

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

Aqui, func1 será chamado se y for 1 e func2, caso contrário. Nos dois casos, a função correspondente será chamada com os argumentos arg1 e arg2.

Analogamente, o seguinte também é válido:

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

onde class1 e class2 são duas classes.

Doctest : documentação e testes de unidade ao mesmo tempo.

Exemplo extraído da documentação do 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()

Formatação nomeada

A formatação% usa um dicionário (também aplica a validação% 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.

E como locals () também é um dicionário, você pode simplesmente passar isso como um ditado e ter% -substitions de suas variáveis ​​locais. Eu acho que isso é desaprovado, mas simplifica as coisas ..

Nova formatação de estilo

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

Para adicionar mais módulos python (especialmente os de terceiros), a maioria das pessoas parece usar variáveis ​​de ambiente PYTHONPATH ou adiciona links simbólicos ou diretórios em seus diretórios de pacotes de sites. Outra maneira é usar arquivos * .pth. Aqui está a explicação oficial do documento python:

"A maneira mais conveniente [de modificar o caminho de pesquisa do python] é adicionar um arquivo de configuração do caminho a um diretório que já está no caminho do Python, geralmente ao diretório ... / site-packages /. Os arquivos de configuração do caminho têm uma extensão .pth , e cada linha deve conter um único caminho que será anexado ao sys.path. (Como os novos caminhos são anexados ao sys.path, os módulos nos diretórios adicionados não substituirão os módulos padrão. Isso significa que você não pode usar esse mecanismo para instalar versões fixas de módulos padrão.) "

Cláusula Exception else :

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

O uso da cláusula else é melhor do que adicionar código adicional à cláusula try, pois evita a captura acidental de uma exceção que não foi gerada pelo código sendo protegido pela instrução try ... exceto.

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

Redigitando exceções :

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

A instrução 'raise' sem argumentos dentro de um manipulador de erros diz ao Python para aumentar novamente a exceção com o traceback original intacto , permitindo que você diga "oh, desculpe, desculpe, não pretendi pegar isso, desculpe, desculpe. "

Se você deseja imprimir, armazenar ou mexer no traceback original, pode obtê-lo com sys.exc_info (), e imprimi-lo como o Python faria com o módulo 'traceback'.

Mensagens principais :)

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

Decifrado :

O Zen de Python, de Tim Peters

Bonito é melhor que feio.
Explícito é melhor que implícito.
Simples é melhor que complexo.
Complexo é melhor que complicado.
Flat é melhor que aninhado.
Esparso é melhor que denso.
Legibilidade conta.
Casos especiais não são especiais o suficiente para violar as regras.
Embora praticidade supere a pureza.
Os erros nunca devem passar silenciosamente.
A menos que seja explicitamente silenciado.
Diante da ambiguidade, recuse a tentação de adivinhar. Deve haver uma - e preferencialmente apenas uma - maneira óbvia de fazê-lo.
Embora esse caminho possa não ser óbvio a princípio, a menos que você seja holandês.
Agora é melhor do que nunca.
Embora nunca seja frequentemente melhor do queagora mesmo .
Se a implementação é difícil de explicar, é uma má ideia.
Se a implementação é fácil de explicar, pode ser uma boa ideia.
Os espaços para nome são uma ótima idéia - vamos fazer mais!

Conclusão da guia Interpretador interativo

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

Você também precisará definir uma variável de ambiente PYTHONSTARTUP.

Compreensões de lista aninhadas e expressões geradoras:

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

Eles podem substituir grandes pedaços de código de loop aninhado.

Sobrecarga do operador para o setbuiltin:

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

Mais detalhes da referência da biblioteca padrão: Tipos de conjunto