GeezerVison

Ao longo do tempo têm sido desenvolvidos pela comunidade de programadores muitas bibliotecas de funções especializadas (módulos) que permitem expandir as capacidades base da linguagem. Entre estes módulos especializados destacam-se:

Existem vários ambientes de desenvolvimento integrado (IDE) disponíveis para Python:

Construções de Python incluem: estrutura de seleção (if, else, elif); estrutura de repetição (for, while), que itera por um container, capturando cada elemento em uma variável local dada; construção de classes (class); construção de sub-rotinas (def); construção de escopo (with), como por exemplo para adquirir um recurso.

A tipagem de Python é forte, pois os valores e objetos têm tipos bem definidos e não sofrem coerções como em C ou Perl. São disponibilizados diversos tipos de dados nativos:

Python também permite a definição dos tipos de dados próprios, através de classes. Instâncias são construídas invocando a classe (FooClass()), e as classes são instância da classe type, o que permite metaprogramação e reflexão. Métodos são definidos como funções anexadas à classe, e a sintaxe instância.método(argumento) é um atalho para Classe.método(instância, argumento). Os métodos devem referenciar explicitamente a referência para o objeto incluindo o parâmetro self como o primeiro argumento do método.^[34]

Antes da versão 3.0, Python possuía dois tipos de classes: "old-style" e "new-style". Classes old-style foram eliminadas no Python 3.0, e todas são new-style. Em versões entre 2.2 e 3.0, ambos tipos de classes podiam ser usadas. A sintaxe de ambos estilos é a mesma, a diferença acaba sendo de onde objeto da classe é herdado, direta ou indiretamente (todas classes new-style herdam de object e são instancias de type). As classes new-styles nada mais são que tipos definidos pelo usuário.

O Python 3 define as seguintes palavras reservadas:^[35]

A versão 3.10.0 implementou a Structural Pattern Matching (Correspondência de Padrão Estrutural), semelhante ao Switch-Case de outras linguagens, assim como definido na PEP 634.^[37] Por isso as palavras match e case passarão a ser reservadas.

Notas

Os operadores básicos de comparação como ==, <, >=, entre outros são usados em todos os tipos de dados, como números, cadeias de texto, listas e mapeamentos. Comparações em cadeia como a < b < c possuem o mesmo significado básico que na matemática: os termos são comparadas na ordem. É garantido que o processamento da expressão lógica irá terminar tão cedo o veredito seja claro, o princípio da avaliação mínima. Usando a expressão anterior, se a < b é falso, c não é avaliado.

Quanto aos operadores lógicos, até Python 2.2 não havia o tipo de dado booleano. Em todas as versões da linguagem os operadores lógicos tratam "", 0, None, 0.0, [] e {} como falso, enquanto o restante é tratado como verdadeiro de modo geral. Na versão 2.2.1 as constantes True e False foram adicionadas (subclasses de 1 e 0 respectivamente). A comparação binária retorna uma das duas constantes acima.

Os operadores booleanos and e or também seguem a avaliação mínima. Por exemplo, y == 0 or x/y > 100 nunca lançará a exceção de divisão por zero.

O interpretador interativo é uma característica diferencial da linguagem, porque há a possibilidade de testar o código de um programa e receber o resultado em tempo real, antes de iniciar a compilação ou incluí-las nos programas. Por exemplo:

>>> 1+1
2
>>>
>>> a = 1+1
>>> print a
2
>>> print(a)
2
>>>

No segundo capítulo do Manual de Referência da Linguagem Python é citado que a análise léxica é uma análise do interpretador em si, os programas são lidos por um analisador sintático que divide o código em tokens.

Todo programa é dividido em linhas lógicas que são separadas pelo token NEWLINE ou NOVA LINHA, as linhas físicas são trechos de código divididos pelo caractere ENTER. Linhas lógicas não podem ultrapassar linhas físicas com exceção de junção de linhas, por exemplo:

if resultado > 2 and \
    1 <= 5  and \
    2 < 5:
        print ('Resultado: %f' % d)

ou

MESES_DO_ANO = ['janeiro', 'fevereiro', 'março',
                'abril',   'maio',      'junho',
                'julho',   'agosto',    'setembro',
                'outubro', 'novembro',  'dezembro']

Para a delimitação de blocos de códigos, os delimitadores são colocados em uma pilha e diferenciados por sua indentação, iniciando a pilha com valor 0 (zero) e colocando valores maiores que os anteriores na pilha. Para cada começo de linha, o nível de indentação é comparado com o valor do topo da pilha. Se o número da linha for igual ao topo da pilha, a pilha não é alterada. Se o valor for maior, a pilha recebe o nível de indentação da linha e o nome INDENT (empilhamento). Se o nível de indentação for menor, então é desempilhado até chegar a um nível de indentação recebendo o nome DEDENT (desempilhamento). Se não encontrar nenhum valor, é gerado um erro de indentação.

Abaixo um exemplo de permutação, retirado do capítulo 2.1 sobre Estrutura de linhas na Análise léxica do Manual de Referência da linguagem (Language Reference Manual):

         def perm(l):                   NOVA LINHA
INDENT        if len(l) <= 1:           NOVA LINHA
INDENT           return[1]              NOVA LINHA
DEDENT        r = [ ]                   NOVA LINHA
              for i in range(len(l)):   NOVA LINHA
INDENT            s = l[:i] + l[i+1:]   NOVA LINHA
                  p = perm(s)           NOVA LINHA
DEDENT        for x in p:               NOVA LINHA
INDENT            r.append(l[i:i+1]+x)  NOVA LINHA
DEDENT        return r

def valor1():
    while True:
        try:
            c = int(input('Primeiro Valor: '))
            return c
        except ValueError:
            print 'Inválido!'

def valor1():
while True:
try:
c = int(input('Primeiro Valor: '))
return c
except ValueError:
print 'Inválido!'

A linguagem é de altíssimo nível, como já dito, mas ela também pode compilar seus programas para que a próxima vez que o executar não precise compilar novamente o programa, reduzindo o tempo de carga na execução.

Utilizando o interpretador interativo não é necessário a criação do arquivo de Python compilado, os comandos são executados interativamente. Porém quando um programa ou um módulo é evocado, o interpretador realiza a análise léxica e sintática, compila o código de alto nível se necessário e o executa na máquina virtual da linguagem.

O bytecode é armazenado em arquivos com extensão .pyc ou .pyo, este último no caso de bytecode otimizado. Interessante notar que o bytecode da linguagem também é de alto nível, ou seja, é mais legível aos seres humanos que o código de byte do C, por exemplo. Para descompilar um código de byte é utilizado o módulo dis da biblioteca padrão da linguagem e existem módulos de terceiros que tornam o bytecode mais confuso, tornando a descompilação ineficaz.

Normalmente, o Python trabalha com dois grupos de arquivos:

1. Os módulos do núcleo da linguagem, sua biblioteca padrão e os módulos independentes, criados pelo usuário.
2. No núcleo do interpretador existe o analisador léxico, o analisador sintático que utiliza Estruturas de Objetos (tempo de execução), o Compilador que aloca memória (tempo de execução) e depois do Avaliador de código que modifica o estado atual do programa (tempo de execução), mostrando resultado para o usuário.

Python suporta a maioria das técnicas da programação orientada a objeto. Qualquer objeto pode ser usado para qualquer tipo, e o código funcionará enquanto haja métodos e atributos adequados. O conceito de objeto na linguagem é bastante abrangente: classes, funções, números e módulos são todos considerados objetos. Também há suporte para metaclasses, polimorfismo, e herança (inclusive herança múltipla). Há um suporte limitado para variáveis privadas.

Na versão 2.2 de Python foi introduzido um novo estilo de classes em que objetos e tipos foram unificados, permitindo a especialização de tipos. Já a partir da versão 2.3 foi introduzido um novo método de resolução de ambiguidades para heranças múltiplas.^[39]

Uma classe é definida com class nome:, e o código seguinte é a composição dos atributos. Todos os métodos da classe recebem uma referência a uma instância da própria classe como seu primeiro argumento, e a convenção é que se chame este argumento self. Assim os métodos são chamados objeto.método(argumento1, argumento2, ...) e são definidos iguais a uma função, como método(self, argumento1, argumento2, ...). Veja que o parâmetro self conterá uma referência para a instância da classe definida em objeto quando for efetuada esta chamada. Os atributos da classe podem ser acessados em qualquer lugar da classe, e os atributos de instância (ou variável de instância) devem ser declarados dentro dos métodos utilizando a referência à instância atual (self) (ver código contextualizado em anexo).

Em Python não existe proteção dos membros duma classe ou instância pelo interpretador, o chamado encapsulamento. Convenciona-se que atributos com o nome começando com um _ são de uso privado da classe, mas não há um policiamento do interpretador contra acesso a estes atributos. Uma exceção são nomes começando com __, no caso em que o interpretador modifica o nome do atributo (ver código contextualizado em anexo).

Python permite polimorfismo, que condiz com a reutilização de código. É fato que funções semelhantes em várias partes do software sejam utilizadas várias vezes, então definimos esta função como uma biblioteca e todas as outras funções que precisarem desta a chamam sem a necessidade de reescrevê-la (ver código contextualizado em anexo).

Python não possui overloading; não é possível criar duas funções com o mesmo nome, pois elas são consideradas atributos da classe. Caso o nome da função se repita em outra assinatura, o interpretador considera esta última como override e sobrescreve a função anterior. Algumas operações entre diferentes tipos são realizadas através de coerção (ex.: 3.2 + 3).

É possível encapsular abstrações em módulos e pacotes. Quando um arquivo é criado com a extensão .py, ele automaticamente define um módulo. Um diretório com vários módulos é chamado de pacote e deve conter um modulo chamado __init__, para defini-lo como principal. Estas diferenciações ocorrem apenas no sistema de arquivos. Os objetos criados são sempre módulos. Caso o código não defina qual dos módulos será importado, o padrão é o __init__.

Uma das construções funcionais de Python é compreensão de listas, uma forma de construir listas. Por exemplo, pode-se usar a técnica para calcular as cinco primeiras potências de dois. O algoritmo quicksort também pode ser expressado usando a mesma técnica (ver códigos contextualizados para ambos os casos em anexo).

Em Python, funções são objetos de primeira classe que podem ser criados e armazenados dinamicamente. O suporte a funções anônimas está na construção lambda (cálculo Lambda). Não há disponibilidade de funções anônimas de fato, pois os lambdas contêm somente expressões e não blocos de código.

Python também suporta clausuras léxicas desde a versão 2.2 (ver códigos contextualizados para ambos os casos em anexo). Já geradores foram introduzidos na versão 2.2 e finalizados na versão 2.3, e representam o mecanismo de Python para a avaliação preguiçosa de funções (ver códigos contextualizados para ambos os casos em anexo).

Python suporta e faz uso constante de tratamento de exceções como uma forma de testar condições de erro e outros eventos inesperados no programa. É inclusive possível capturar uma exceção causada por um erro de sintaxe. O estilo da linguagem apóia o uso de exceções sempre que uma condição de erro pode aparecer. Por exemplo, ao invés de testar a disponibilidade de acesso a um recurso, a convenção é simplesmente tentar usar o recurso e capturar a exceção caso o acesso seja rejeitado (recurso inexistente, permissão de acesso insuficiente, recurso já em uso, ...).

Exceções são usadas frequentemente como uma estrutura de seleção, substituindo blocos if-else, especialmente em situações que envolvem threads. Uma convenção de codificação é o EAFP, do inglês, "é mais fácil pedir perdão que permissão". Isso significa que em termos de desempenho é preferível capturar exceções do que testar atributos antes de os usar. Segue abaixo exemplos de código que testam atributos ("pedem permissão") e que capturam exceções ("pedem perdão"):

if hasattr(spam, 'eggs'):
    ham = spam.eggs
else:
    handle_error()

try:
    ham = spam.eggs
except AttributeError:
    handle_error()

Ambos os códigos produzem o mesmo efeito, mas há diferenças de desempenho. Quando spam possui o atributo eggs, o código que captura exceções é mais rápido. Caso contrário, a captura da exceção representa uma perda considerável de desempenho, e o código que testa o atributo é mais rápido. Na maioria dos casos o paradigma da captura de exceções é mais rápido, e também pode evitar problemas de concorrência.^[40] Por exemplo, num ambiente multitarefa, o espaço de tempo entre o teste do atributo e seu uso de fato pode invalidar o atributo, problema que não acontece no caso da captura de exceções.

Python possui uma grande biblioteca padrão, geralmente citada como um dos maiores trunfos da linguagem,^[41] fornecendo ferramentas para diversas tarefas. Por conta da grande variedade de ferramentas fornecida pela biblioteca padrão, combinada com a habilidade de usar linguagens de nível mais baixo como C e C++, Python pode ser poderosa para conectar componentes diversos de software.

A biblioteca padrão conta com facilidades para escrever aplicações para a Internet, contando com diversos formatos e protocolos como MIME e HTTP. Também há módulos para criar interfaces gráficas, conectar em bancos de dados relacionais e manipular expressões regulares.

Algumas partes da biblioteca são cobertas por especificações (por exemplo, a implementação WSGI da wsgiref segue o PEP 333^[42]), mas a maioria dos módulos não segue.

Um outro ponto forte da linguagem é sua capacidade de interoperar com várias outras linguagens, principalmente código nativo. A documentação da linguagem inclui exemplos de como usar a Python C-API para escrever funções em C que podem ser chamadas diretamente de código Python - mas atualmente esse sequer é o modo mais indicado de interoperação, havendo alternativas tais como Cython, Swig ou cffi. A biblioteca Boost do C++ inclui uma biblioteca para permitir a interoperabilidade entre as duas linguagens, e pacotes científicos fazem uso de bibliotecas de alta performance numérica escritos em Fortran e mantidos há décadas.

Python fornece duas alternativas para documentar o código. A primeira é o uso de comentários para indicar o que certo código faz. Comentários começam com # e são terminados pela quebra da linha. Não há suporte para comentários que se estendem por mais de uma linha; cada linha consecutiva de comentário deve indicar #. A segunda alternativa é o uso de cadeias de caractere, literais de texto inseridos no código sem atribuição. Cadeias de caracteres em Python são delimitadas por " ou ' para única linha e por """ ou ''' para múltiplas linhas. Entretanto, é convenção usar o métodos de múltiplas linhas em ambos os casos.

Diferente de comentários, a cadeias de caracteres usadas como documentação são objetos Python e fazem parte do código interpretado. Isso significa que um programa pode acessar sua própria documentação e manipular a informação. Há ferramentas que extraem automaticamente essa documentação para a geração da documentação de API a partir do código. Documentação através de cadeias de caracteres também pode ser acessada a partir do interpretador através da função help().

from math import sqrt


def f(t):
    return sqrt(abs(t)) + 5 * t**3


a = [float(input()) for _ in range(11)]
for i, t in reversed(list(enumerate(a))):
    y = f(t)
    print(i, "TOO LARGE" if y > 400 else y)

Ponto flutuante em Python na maioria das plataformas é IEEE 754, que pode retornar valores "nan" e "inf", ou lançar uma exceção.

Exemplo de um analisador sintático usando uma gramática de análise sintática de expressão (PEG):

#!/usr/bin/env python3

from pyparsing import Char, ParseException, Word, WordEnd, srange


def from_hex(tokens):
    return [int(tokens[0], base=16)]


hex_primary = (
    Word(srange("[a-fA-F0-9]"), max=2)
    .set_parse_action(from_hex)
    .set_name("hex integer")
)
hex_color = (
    Char("#").suppress()
    + hex_primary.set_results_name("red")
    + hex_primary.set_results_name("green")
    + hex_primary.set_results_name("blue")
    + WordEnd()
)


def main():
    try:
        color = hex_color.parse_string("#2F14DF").as_dict()
        print(f"#2F14DF => {color}")
    except ParseException as err:
        print(err.explain())


if __name__ == "__main__":
    main()

Exemplo de uma implementação do echo do Unix:

#!/usr/bin/env python3

__version__ = "0.1.0"

from argparse import ArgumentParser
from sys import stdout


def echo(strip_trailing_newline, strings):
    stdout.write(" ".join(strings))
    if not strip_trailing_newline:
        print()


if __name__ == "__main__":
    parser = ArgumentParser(
        usage="%(prog)s [OPÇÃO]... [TEXTO]...",
        description="Ecoa o(s) TEXTO(s) para a saída padrão.",
    )
    parser.add_argument(
        "--version", action="version", version=f"%(prog)s {__version__}"
    )
    parser.add_argument(
        "-n",
        dest="strip_trailing_newline",
        action="store_true",
        help="Não emitir o caractere de nova linha do final",
    )
    parser.add_argument("strings", metavar="TEXTO", nargs="*")
    args = parser.parse_args()

    echo(args.strip_trailing_newline, args.strings)

Exemplo de um web service RESTful (HTTP) usando funções assíncronas e serialização para JSON; responde com um número de CPF formatado, se for válido, ao acessar http://localhost:8000/consultar-cpf/123:

from datetime import datetime, timezone

from brutils import format_cpf, is_valid_cpf
from fastapi import FastAPI
from fastapi.responses import RedirectResponse
from pydantic import BaseModel

app = FastAPI()


class CheckCpfResponse(BaseModel):
    valid: bool
    formatted: str | None
    timestamp: datetime


@app.get("/", response_model=RedirectResponse)
async def index():
    return "/consultar-cpf/123"


@app.get("/consultar-cpf/{numbers}", response_model=CheckCpfResponse)
async def check_cpf(numbers: str):
    now = datetime.now(timezone.utc)
    valid = is_valid_cpf(numbers)

    return {
        "valid": valid,
        "formatted": format_cpf(numbers) if valid else None,
        "timestamp": now.isoformat(),
    }

Pode ser executado com o seguinte comando:

$ fastapi dev main.py

Python possui várias bibliotecas para interagir com bancos de dados, como por exemplo o sqlite3 (já embutido no Python).^[43]

import sqlite3

try:
    # Conecta ao banco de dados (cria o arquivo se não existir)
    conn = sqlite3.connect('meu_banco.db')
    print("Conexão com SQLite bem-sucedida!")

    # Você pode criar um cursor para executar comandos SQL
    cursor = conn.cursor()
    # Exemplo: criar uma tabela
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS usuarios (
            id INTEGER PRIMARY KEY,
            nome TEXT NOT NULL,
            email TEXT NOT NULL UNIQUE
        )
    ''')
    conn.commit() # Salva as alterações
    print("Tabela 'usuarios' criada ou já existente.")

except sqlite3.Error as e:
    print(f"Erro ao conectar ou operar o SQLite: {e}")

finally:
    if conn:
        conn.close()
        print("Conexão com SQLite fechada.")