Sintaxe e semântica de Python

Ver artigo principal: Python

A sintaxe da linguagem de programação Python é o conjunto de regras que definem como um programa em Python será escrito e interpretado (tanto pelo sistema de tempo de execução como pelo ser humano). Python foi concebido para ser uma linguagem altamente legível.^[1] Ela possui um layout visual relativamente organizado e usa palavras em Inglês com freqüência, quando outras linguagens usam pontuação. Python objetiva a simplicidade e generalidade na concepção da sua sintaxe, encapsulados no mantra "Deve haver um - e preferencialmente só um - modo óbvio de fazer isso", do "The Zen of Python".^[2] Observe que este mantra é deliberadamente oposto ao mantra do Perl de "há mais de uma maneira de fazê-lo".

Palavras-chave

O Python tem as seguintes palavras-chave ou palavras reservadas; eles não podem ser usados como identificadores.^[3]

• and
• as
• assert
• break
• class
• continue
• def
• del
• elif
• else
• except
• exec^{[note 1]}
• False^{[note 2]}
• finally
• for
• from
• global
• if
• import
• in
• is
• lambda
• None
• nonlocal^{[note 2]}
• not
• or
• pass
• print^{[note 1]}
• raise
• return
• True^{[note 2]}
• try
• while
• with
• yield

No Python 3.5 ela vem com as seguintes palavras adicionais: async and await.^[4]

Programação funcional

Como mencionado acima, outra força do Python é a disponibilidade do estilo de programação funcional. Como pode ser esperado, isto torna o trabalho com listas e outras coleções muito mais sério.

Geradores

Introduzido no Python 2.2 como uma funcionalidade opcional e finalizada na versão 2.3, os geradores são mecanismos do Python para avaliação preguiçosa de uma função que diferentemente retornaria uma lista proibitiva de espaço ou computacionalmente intensiva.

Este é um exemplo para gerar preguiçosamente números primos:

from itertools import count

def gera_primos(parar_em=0):
    primos = []
    for n in count(2):
        if 0 < parar_em < n:
            return # lança a exceção StopIteration
        composto = False
        for p in primos:
            if not n % p:
                composto = True
                break
            elif p ** 2 > n: 
                break
        if not composto:
            primos.append(n)
            yield n

Expressões geradoras

Introduzidas no Python 2.4, expressões geradoras são a avaliação preguiçosa (lazy) equivalentes de compreensões de listas. Usando o gerador de número primo fornecido na seção acima, podemos definir uma coleção preguiçosa, mas não completamente infinita.

from itertools import islice

primos_sob_milhao = (i for i in gera_primos() if i < 1000000)
doir_milesimo_primo = islice(primos_sob_milhao, 1999, 2000).next()

Decoradores

Um decorator, ou decorador, é um objeto Python que pode ser chamado com um argumento simples, e que altera as funções ou métodos. Decoradores do Python foram inspirados em parte por anotações de Java e têm uma sintaxe similar. A sintaxe do decorador é um açúcar sintático puro, que usa o @ como a palavra-chave:

@viking_chorus
def item_menu():
    print "spam"

é equivalente a

def item_menu():
    print "spam"
item_menu = viking_chorus(item_menu)

Decoradores são uma forma de metaprogramação, pois eles aumentam a ação da função ou método que eles decoram. Por exemplo, no exemplo acima, viking_chorus pode fazer menu_item ser executado 8 vezes para cada vez que é chamado:

def viking_chorus(minhafunc):
    def func_interna(*args, **kwargs):
        for i in range(8):
            minhafunc(*args, **kwargs)
    return func_interna

Usos canônicos de decoradores de funções são para a criação de métodos de classe ou métodos estáticos, adição de atributos de função, detecção, configuração de pré e pós-condições e sincronização, mas pode ser usado para muito mais além, incluindo eliminação de recursão de cauda, memoização e até mesmo para melhorar a escrita dos decoradores.

Decoradores podem ser encadeados colocando-os em linhas adjacentes:

@invincible
@favorite_color("Azul")
def cavaleiro_branco():
    pass

é equivalente a

def cavaleiro_branco():
    pass
cavaleiro_branco = invincible(favorite_color("Azul")(cavaleiro_branco))

ou, usando variáveis intermediárias

def cavaleiro_branco():
    pass
blue_decorator = favorite_color("Azul")
decorated_by_blue = blue_decorator(cavaleiro_branco)
cavaleiro_branco = invincible(decorated_by_blue)

No exemplo acima, o decorador favorite_color tem um argumento. Os decoradores de funções que fazem isso devem retornar ainda uma outra função que recebe um argumento, a função a ser decorada:

def favorite_color(color):
    def yet_another_decorator(func):
        def wrapper():
            print color
            func()
        return wrapper
    return yet_another_decorator

Isto iria então decorar a função cavaleiro_branco de tal forma que a cor "Azul " seria impressa antes da execução da função cavaleiro_branco.

Em versões do Python anteriores à versão 2.6, os decoradores se aplicavam às funções e métodos, mas não às classes. No entanto, decorar um método (falso) __new__ pode modificar uma classe. Decoradores de classe são suportados a partir do Python 2.6. Apesar do nome, decoradores Python não são uma implementação do padrão de decorador. O padrão de decorador é um padrão de projeto usado em linguagens de programação orientada a objetos de tipagem estática, para permitir que a funcionalidade seja adicionada a objetos em tempo de execução. Os decoradores Python adicionam funcionalidade para funções e métodos em tempo de definição e, portanto, são um nível mais alto do que construir classes do padrão decorador. O padrão decorador em si é trivialmente implementável ​​em Python, devido a linguagem ser duck typed, e por isso geralmente não ser considerada como tal.

Ver também

Advice em Lisp.

Referências

1. "Readability counts." - PEP 20 - The Zen of Python
2. «PEP 20 - The Zen of Python». Python Software Foundation. 23 de agosto de 2004. Consultado em 24 de novembro de 2008
3. «Keywords»
4. «Keywords»

1. Starting from Python 3, exec and print are functions, so they are not keywords anymore.
2. Starting from Python 3, keywords True, False and nonlocal were introduced.