Python

Python é uma linguagem de programação de alto

nível,[10] interpretada de script, imperativa, orientada a Python
objetos, funcional, de tipagem dinâmica e forte. Foi
lançada por Guido van Rossum em 1991.[1] Atualmente,
possui um modelo de desenvolvimento comunitário,
aberto e gerenciado pela organização sem fins lucrativos
Python Software Foundation. Apesar de várias partes da
linguagem possuírem padrões e especificações formais, a Paradigma Multiparadigma:
linguagem, como um todo, não é formalmente orientada a objetos ·
imperativa · funcional
especificada. O padrão na pratica é a implementação
CPython. Surgido em 20 de fevereiro de
1991 (33 anos)[1]
A linguagem foi projetada com a filosofia de enfatizar a Última versão 3.13.0 (7 de outubro de
importância do esforço do programador sobre o esforço 2024[2])

computacional. Prioriza a legibilidade do código sobre a Criado por Guido van Rossum[1]
velocidade ou expressividade. Combina uma sintaxe Estilo de dinâmica · forte · duck
concisa e clara com os recursos poderosos de sua tipagem · gradual (desde a
versão 3.5)
biblioteca padrão e por módulos e frameworks
desenvolvidos por terceiros. Principais CPython · IronPython
implementações · Jython · PyPy ·
Stackless Python ·
Python é uma linguagem de propósito geral de alto nível, MicroPython ·
multiparadigma, suporta o paradigma orientado a CircuitPython
objetos, imperativo, funcional e procedural. Possui Dialetos Cython, RPython,
tipagem dinâmica e uma de suas principais Starlark[3]
características é permitir a fácil leitura do código e exigir Influenciada por ABC[4]
poucas linhas de código se comparado ao mesmo Ada[5] · ALGOL 68 ·
programa em outras linguagens. Devido às suas APL[6] · C[4] · CLU ·
características, ela é utilizada, principalmente, para Dylan · Haskell · Icon
· Java · Lisp ·
processamento de textos, dados científicos e criação de Modula-3[4] · Perl ·
CGIs para páginas dinâmicas para a web. Foi Smalltalk · Standard
considerada pelo público a 3ª linguagem "mais amada", ML
de acordo com uma pesquisa conduzida pelo site Stack Influenciou Boo · CoffeeScript · D
Overflow em 2018[11] e está entre as 5 linguagens mais · Fantom · GDScript ·
Go · Groovy ·
populares, de acordo com uma pesquisa conduzida pela JavaScript · Julia ·
RedMonk.[12] Mojo[7] · Nim · Py ·
Ruby · Squirrel · Swift
Plataforma Prioridade 1
x86-64 · Apple Silicon
(macOS) · i686
(Windows)[8]
Prioridade 2
O nome Python teve a sua origem no grupo AArch64 (Linux) ·
WebAssembly
humorístico britânico Monty Python,[13] criador do
(WASI)[8]
programa Monty Python's Flying Circus, embora muitas
Sistema Linux · Windows ·
pessoas façam associação com o réptil do mesmo nome operacional macOS[8]
(em português, píton ou pitão).
Licença Python Software
Foundation License[9]
Extensão do .py · .pyc · .pyd · .pyo
História arquivo · .pyw · .pyz
Página oficial www.python.org (http
O Python foi concebido no final de 1989[10][13] por Guido s://www.python.org/)
van Rossum no Instituto de Pesquisa Nacional para
Matemática e Ciência da Computação (CWI), nos Países
Baixos, como um sucessor da ABC capaz de tratar exceções
e prover interface com o sistema operacional Amoeba[14]
através de scripts. Também da CWI, a linguagem ABC era
mais produtiva que C, ainda que com o custo do
desempenho em tempo de execução. Mas ela não possuía
funcionalidades importantes para a interação com o
sistema operacional, uma necessidade do grupo. Um dos
focos primordiais de Python era aumentar a produtividade
do programador.[13] Guido van Rossum, São Francisco,
Califórnia
Python foi feita com base na linguagem ABC, possui parte
da sintaxe derivada do C, compreensão de listas, funções
anonimas e função map de Haskell. Os iteradores são baseados na Icon, tratamentos de exceção e
módulos da Modula-3, expressões regulares de Perl.

Em 1991, Guido publicou o código (nomeado versão 0.9.0) no grupo de discussão alt.sources.[1]
Nessa versão já estavam presentes classes com herança, tratamento de exceções, funções e os tipos
de dado nativos list, dict, str, e assim por diante. Também estava presente nessa versão um
sistema de módulos emprestado do Modula-3. O modelo de exceções também lembrava muito o do
Modula-3, com a adição da opção else clause.[14] Em 1994 foi formado o principal fórum de
discussão do Python, comp.lang.python, um marco para o crescimento da base de usuários da
linguagem.

A versão 1.0 foi lançada em janeiro de 1994. Novas funcionalidades incluíam ferramentas para
programação funcional como lambda, map, filter e reduce. A última versão enquanto Guido
estava na CWI foi o Python 1.2. Em 1995, ele continuou o trabalho no CNRI em Reston, Estados
Unidos, de onde lançou diversas versões. Na versão 1.4 a linguagem ganhou parâmetros nomeados
(a capacidade de passar parâmetro pelo nome e não pela posição na lista de parâmetros) e suporte
nativo a números complexos, assim como uma forma de encapsulamento.[15]

Ainda na CNRI, Guido lançou a iniciativa Computer Programming for Everybody (CP4E;
literalmente, "Programação de Computadores para Todos"), que visava tornar a programação mais
acessível, um projeto financiado pela DARPA.[16] Atualmente o CP4E encontra-se inativo.

Em 2000, o time de desenvolvimento da linguagem se mudou para a BeOpen a fim de formar o

time PythonLabs. A CNRI pediu que a versão 1.6 fosse lançada para marcar o fim de
desenvolvimento da linguagem naquele local. O único lançamento na BeOpen foi o Python 2.0, e
após o lançamento o grupo de desenvolvedores da PythonLabs agrupou-se na Digital Creations.
Python 2.0 implementou list comprehension, uma relevante funcionalidade de linguagens
funcionais como SETL e Haskell. A sintaxe da linguagem para essa construção é bastante similar a
de Haskell, exceto pela preferência do Haskell por caracteres de pontuação e da preferência do
python por palavras reservadas alfabéticas. Essa versão 2.0 também introduziu um sistema coletor
de lixo capaz de identificar e tratar ciclos de referências.[17]

Já o 1.6 incluiu uma licença CNRI substancialmente mais longa que a licença CWI que estavam
usando nas versões anteriores. Entre outras mudanças, essa licença incluía uma cláusula atestando
que a licença era governada pelas leis da Virgínia. A Free Software Foundation alegou que isso era
incompatível com a GNU GPL. Tanto BeOpen quanto CNRI e FSF negociaram uma mudança na
licença livre do Python que o tornaria compatível com a GPL. Python 1.6.1 é idêntico ao 1.6.0,
exceto por pequenas correções de falhas e uma licença nova, compatível com a GPL.[18]

Python 2.1 era parecido com as versões 1.6.1 e 2.0. Sua licença foi renomeada para Python Software
Foundation License.[9] Todo código, documentação e especificação desde o lançamento da versão
alfa da 2.1 é propriedade da Python Software Foundation (PSF), uma organização sem fins
lucrativos fundada em 2001, um modelo tal qual da Apache Software Foundation.[18] O
lançamento incluiu a mudança na especificação para suportar escopo aninhado, assim como outras
linguagens com escopo estático.[19] Esta funcionalidade estava desativada por padrão, e somente
foi requerida na versão 2.2.

Uma grande inovação da versão 2.2 foi a unificação dos tipos Python (escritos em C) e classes
(escritas em Python) em somente uma hierarquia. Isto tornou o modelo de objetos do Python
consistentemente orientado a objeto.[20] Também foi adicionado generator, inspirado em Icon.[21]

O incremento da biblioteca padrão e as escolhas sintáticas foram fortemente influenciadas por

Java em alguns casos: o pacote logging[22] introduzido na versão 2.3,[23] o analisador sintático
SAX, introduzido na versão 2.0 e a sintaxe de decoradores que usa @,[24] adicionadas na versão
2.4.[25]

Em 1 de outubro de 2008 foi lançada a versão 2.6, já visando a transição para a versão 3.0 da
linguagem. Entre outras modificações, foram incluídas bibliotecas para multiprocessamento,
JSON e E/S, além de uma nova forma de formatação de cadeias de caracteres.[26]

Atualmente a linguagem é usada em diversas áreas, como servidores de aplicação e computação

gráfica. Está disponível como linguagem de script em aplicações como OpenOffice (Python UNO
Bridge), Blender e pode ser utilizada em procedimentos armazenados no sistema gerenciador de
banco de dados PostgreSQL (PL/Python).

A terceira versão da linguagem foi lançada em dezembro de 2008,[27] chamada Python 3.0 ou
Python 3000. Com noticiado desde antes de seu lançamento,[28] houve quebra de compatibilidade
com a família 2.x para corrigir falhas que foram descobertas neste padrão, e para limpar os
excessos das versões anteriores.[13] A primeira versão alfa foi lançada em 31 de agosto de 2007, a
segunda em 7 de dezembro do mesmo ano.

Mudanças da versão incluem a alteração da palavra reservada print, que passa a ser uma função,
tornando mais fácil a utilização de uma versão alternativa da rotina. Em Python 2.6, isso já está
disponível ao adicionar o código from __future__ import print_function.[29] Também, a
mudança para Unicode de todas as cadeias de caracteres.[30]
Em 2012, foi criado o Raspberry Pi, cujo nome foi baseado na linguagem Python. Uma das
principais linguagens escolhidas é Python. Python influenciou várias linguagens, algumas delas
foram Boo e Cobra, que usa a indentação como definição de bloco e Go, que se baseia nos
princípios de desenvolvimento rápido de Python.

Atualmente, Python é um dos componentes padrão de vários sistemas operacionais, entre eles
estão a maioria das distribuições do Linux, AmigaOS 4, FreeBSD, NetBSD, OpenBSD e OS X. A
linguagem se tornou a padrão no curso de ciências da computação do MIT em 2009

Filosofia
Parte da cultura da linguagem gira ao redor de The Zen of Python, um poema que faz parte do
documento "PEP 20 (The Zen of Python)",[31] escrito pelo programador em Python de longa data
Tim Peters, descrevendo sumariamente a filosofia do Python. Entre os vinte princípios do poema,
estão presentes:

Bonito é melhor que feio;

Explícito é melhor que implícito;
Simples é melhor que complexo;
Complexo é melhor que complicado;
Legibilidade faz diferença.
Pode-se vê-lo através de um easter egg do Python pelo comando:

>>> import this

Desenvolvimento
O desenvolvimento de Python é conduzido amplamente através do processo Python Enhancement
Proposal ("PEP"), em português Proposta de Melhoria do Python. Os PEPs são documentos de
projeto padronizados que fornecem informações gerais relacionadas ao Python, incluindo
propostas, descrições, justificativas de projeto (design rationales) e explicações para características
da linguagem. PEPs pendentes são revisados e comentados por Van Rossum, o Benevolent Dictator
for Life (líder arquiteto da linguagem) do projeto Python. Desenvolvedores do CPython também se
comunicam através de uma lista de discussão, python-dev, que é o fórum principal para discussão
sobre o desenvolvimento da linguagem. Questões específicas são discutidas no gerenciador de
erros Roundup mantido em python.org. O desenvolvimento acontece no auto-hospedado
https://svn.python.org/

Python possui uma licença livre aprovada pela OSI e compatível com a GPL, porém menos
restritiva. Ela prevê (entre outras coisas) que binários da linguagem sejam distribuídos sem a
necessidade de fornecer o código fonte junto.[9]

Módulos e frameworks
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:
 Matplotlib – biblioteca para manipulação de
Frameworks web gráficos
TensorFlow – framework para aprendizado
Django – framework MVC de máquina (ML)
TurboGears – framework MVC; usa
PyTorch – framework para aprendizado de
CherryPy máquina (ML)
web2py – framework MVC inspirado no
Django Rede e bancos de dados
FastAPI – framework REST
Flask – framework REST Twisted – framework orientado a eventos
Plone – sistema de gerenciamento de ZODB – sistema de persistência e banco de
conteúdo (CMS) dados orientado a objetos
SQLAlchemy – mapeamento objeto-
Computação gráfica relacional (ORM)
SQLObject – mapeamento objeto-relacional
PIL & Pillow – processamento de imagens (ORM)
PyOpenGL – suporte multiplataforma ao
OpenGL Interfaces gráficas
Pygame – conjunto de módulos para o
desenvolvimento de jogos eletrônicos com Tkinter – módulo padrão do Python; usa Tcl
SDL PyGTK – interface para a biblioteca GTK
PyQt – interface para a biblioteca Qt
Computação científica e IA wxPython – interface para a biblioteca
wxWidgets
NumPy – matrizes e matemática
Kivy – framework multiplataforma
pandas – análise de dados

Ambientes de desenvolvimento integrado

Existem vários ambientes de desenvolvimento integrado (IDE) disponíveis para Python:
 Geany - IDE pequeno e ágil, também usa
IDLE (Integrated Development and Learning
Environment) – IDE padrão distribuído com plugins.[32]
o CPython (iniciantes).[32] PyDev (Eclipse) - com código aberto muito
usado, conhecido por sua flexibilidade e
PyCharm - IDE muito usado, criado pela
JetBrains, suporta JavaScript e CSS extensibilidade com muitos plugins.[32]
(profissionais)[32] Eric Python IDE - IDE completo
multiplataforma construído no framework
Komodo Edit - IDE versátil e forte para
linguagens de programação dinâmicas, com QtGUI, com bons plugins.[32]
recursos avançados.[32] PyScripter - compilado nativamente para
Windows, combinando pouca memória com
Visual Studio[33] grande desempenho, tem os recursos do
Visual Studio Code - IDE de código aberto IDE moderno.[32]
criado pela Microsoft, com recursos bons Spyder - IDE com código aberto mais usado
que apenas alguns IDE pagos oferecem.[32] para desenvolvimento científico e ciência de
Sublime Text - IDE popular que usa muitas dados.[32]
linguagens, altamente personalizável e Wing IDE - oferece teste de 30 dias aos
oferece velocidades de desenvolvimento.[32] desenvolvedores.[32]
Atom - IDE de código aberto criado pelo Thonny - IDE bom para uso no ensino da
GitHub semelhante ao Sublime, oferece programação, possui depurador simples
quase os mesmos recursos.[32] (iniciantes)[32]
GNOME Builder

Sintaxe e semântica

Construções
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.

Tipos de dados
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:
 Tipo de dado Descrição Exemplo da sintaxe

bool Booleano True ou False

Número de precisão fixa, é transparentemente 42

int
convertido para long caso não caiba em um int. 2147483648L

float Ponto flutuante 3.1415927

complex Número complexo 3+2j

list Lista heterogênea mutável [4.0, 'string', True]

tuple Tupla imutável (4.0, 'string', True)

range(10)
Sequência de números imutável que pode ser
range range(0, 10)
transformada em lista
range(0, 10, 1)
{4.0, 'string', True}
Conjunto não ordenado, não contém elementos
set, frozenset frozenset([4.0, 'string',
duplicados
True])

'Wikipedia'
str, unicode Uma cadeia de caracteres imutável
u'Wikipedia'

b'Wikipedia'
bytes, bytearray,
Sequência binária bytearray(b'Wikipedia')
memoryview
memoryview(b'Wikipedia')

{'key1': 1.0, 'key2':

dict Conjunto associativo
False}

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.

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

continue finally
and
def for
as
del from
assert
elif global
async[nota 1]
else if
await[nota 1]
except import
break
False[nota 2] in
class
is
 lambda pass while
None raise with
nonlocal[nota 3] return yield
not True[nota 2]
or try
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

1. async e await foram introduzidas na Python 3.5.[36]

2. True e False tornaram-se palavras-chave na Python 3.0. Anteriormente elas eram variáveis ​
globais.
3. nonlocal foi introduzida na Python 3.0.

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

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

Análise léxica
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.
Exemplo de script

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

Indentação
Python foi desenvolvido para ser uma linguagem de fácil leitura, com um visual agradável,
frequentemente usando palavras e não pontuações como em outras linguagens. Para a separação
de blocos de código, a linguagem usa espaços em branco e indentação ao invés de delimitadores
visuais como chaves (C, Java) ou palavras (BASIC, Fortran, Pascal). Diferente de linguagens com
delimitadores visuais de blocos, em Python a indentação é obrigatória. O aumento da indentação
indica o início de um novo bloco, que termina da diminuição da indentação.
Usando um editor de texto comum é muito fácil existir erros de indentação, o recomendado é
configurar o editor conforme a análise léxica do Python ou utilizar uma IDE. Todas as IDE que
suportam a linguagem fazem indentação automaticamente.

Exemplo:

Indentação correta

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

Indentação incorreta

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

O código está correto para os dois exemplos, mas o analisador léxico verificará se a indentação está
coerente. O analisador reconhecerá as palavras reservadas while, def, try, except, return,
print e as cadeias de caracteres entre aspas simples e a indentação, e se não houver problemas o
programa executará normalmente, senão apresentará a exceção: "Seu programa está com erro no
bloco de indentação".

Na internet, há uma comparação de velocidade e de codificação entre as linguagens Python e

BASIC, esta última, o dialeto BBC BASIC for Windows.

Compilador de bytecode
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.

Orientação a objetos
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__.

Programação funcional
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).

Tratamento de exceções
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"):

Teste de atributo

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

Captura de exceção

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.

Biblioteca padrão
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.

Interoperabilidade
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 (https://cffi.readthedocs.org/en/latest/). 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.

Comentários
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().

Exemplos

Programa Olá Mundo

print("Olá, Mundo!")

Algoritmo de Trabb Pardo-Knuth

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.

Analisador sintático
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()

Servidor HTTP
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 pydantic import BaseModel
from starlette.responses import RedirectResponse

app = FastAPI()

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

@app.get("/")
async def index():
return RedirectResponse(url="/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

Interface de linha de comandos

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 [OPTIONS] [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)

Implementações
A linguagem e seu interpretador estão disponíveis para uso nas mais diversas plataformas, que
inclui: Unix (Linux, FreeBSD, Solaris, macOS, etc.); Windows com .NET (IronPython) e
plataforma Java (Jython); consoles de jogos eletrônicos; alguns celulares, como a série 60, N8xx
(PyMaemo) da Nokia e palmtops.

A implementação original e mais conhecida do Python é o CPython, escrita em C e compatível com

o padrão C89,[43] sendo distribuída com uma grande biblioteca padrão escrita em um misto de
Python e C. Esta implementação é suportada em diversas plataformas, incluindo Windows e
sistemas Unix-like modernos. Stackless Python é uma variação do CPython que implementa
microthreads (permitindo multitarefa sem o uso de threads), sendo suportada em quase todas as
plataformas que a implementação original.

Em 2005 a Nokia lançou um interpretador Python para os telefones celulares S60, chamado
PyS60. Essa versão inclui vários módulos das implementações tradicionais, mas também alguns
módulos adicionais para a integração com o sistema operacional Symbian. Uma implementação
para Palm pode ser encontrada no Pippy. Já o PyPy, é a linguagem Python totalmente escrita em
Python.

Diversas implementações, como CPython, pode funcionar como um interpretador de comandos em

que o usuário executa as instruções sequencialmente, recebendo o resultado automaticamente. A
execução compilada do código oferece um ganho substancial em velocidade, com o custo da perda
da interatividade.

Aplicações
Alguns grandes projetos utilizam Python, como por exemplo: o servidor de aplicação Zope; o
compartilhador de arquivos Mnet; o sítio YouTube, e; o cliente original BitTorrent. Grandes
organizações que usam a linguagem incluem Google[44] (parte dos crawlers); Yahoo! (para o sítio
de grupos de usuários); NASA;[45] a Air Canada (no sistema de gerenciamento de reservas).[46] A
linguagem também tem bastante uso na indústria da segurança da informação.
A linguagem tem sido embarcada como linguagem de script em
diversos softwares, como em programas de edição
tridimensional como Maya,[47] Autodesk Softimage, TrueSpace
e Blender.[48] Programas de edição de imagem também a usam
para scripts, como o GIMP.[49] Para diversos sistema
operacionais a linguagem já é um componente padrão, estando
disponível em diversas distribuições Linux. O Red Hat Linux
usa Python para instalação, configuração e gerenciamento de
pacotes.

Outros exemplos incluem o Plone, sistema de gerenciamento de conteúdo desenvolvido em Python

e Zope e, a Industrial Light & Magic,[50] que produz filmes da série Star Wars usando
extensivamente Python para a computação gráfica nos processos de produção dos filmes.

Ver também
Django (framework web)
Flask (framework web)
Perl
Ruby (linguagem de programação)

Referências
1. «HISTORY» (https://web.archive.org/web/20160217132249/http://svn.python.org/view/*checko
ut*/python/trunk/Misc/HISTORY). Fonte do Python (em inglês). Python Software Foundation.
Consultado em 5 de junho de 2008. Arquivado do original (http://svn.python.org/view/*checkout
*/python/trunk/Misc/HISTORY) em 17 de fevereiro de 2016
2. «Python 3.13.0 (final) released» (https://pythoninsider.blogspot.com/2024/10/python-3130-final-
released.html). pythoninsider.blogspot.com (em inglês). 7 de outubro de 2024. Consultado em
9 de outubro de 2024
3. «Starlark Language» (https://docs.bazel.build/versions/master/skylark/language.html).
Consultado em 25 de maio de 2019. Cópia arquivada em 15 de junho de 2020 (https://web.arc
hive.org/web/20200615140534/https://docs.bazel.build/versions/master/skylark/language.html)
4. Guido van Rossum (Maio de 1996). «Foreword for "Programming Python" (1st ed.)» (https://ww
w.python.org/doc/essays/foreword/) (em inglês). Python Software Foundation. Consultado em
12 de junho de 2008
5. «Ada 83 Reference Manual (raise statement)» (http://archive.adaic.com/standards/83lrm/html/lr
m-11-03.html#11.3). Consultado em 7 de janeiro de 2020. Cópia arquivada em 22 de outubro
de 2019 (https://web.archive.org/web/20191022155758/http://archive.adaic.com/standards/83lr
m/html/lrm-11-03.html#11.3)
6. «itertools – Functions creating iterators for efficient looping – Python 3.7.1 documentation» (htt
ps://docs.python.org/3/library/itertools.html). docs.python.org. Consultado em 22 de novembro
de 2016. Cópia arquivada em 14 de junho de 2020 (https://web.archive.org/web/20200614153
629/https://docs.python.org/3/library/itertools.html). "This module implements a number of
iterator building blocks inspired by constructs from APL, Haskell, and SML."
7. Krill, Paul (4 de maio de 2023). «Mojo language marries Python and MLIR for AI development»
(https://www.infoworld.com/article/3695588/mojo-language-marries-python-and-mlir-for-ai-devel
opment.html). InfoWorld (em inglês). Consultado em 5 de maio de 2023. Cópia arquivada em 5
de maio de 2023 (https://web.archive.org/web/20230505064554/https://www.infoworld.com/arti
cle/3695588/mojo-language-marries-python-and-mlir-for-ai-development.html)
 8. «PEP 11 – CPython platform support» (https://peps.python.org/pep-0011/). peps.python.org
(em inglês). Consultado em 9 de outubro de 2024
9. «History and License» (https://docs.python.org/3/license.html) (em inglês). Python Software
Foundation. Consultado em 7 de abril de 2020
10. «The Making of Python» (http://www.artima.com/intv/pythonP.html) (em inglês). Artima
Developer. Consultado em 22 de março de 2007
11. «Stack Overflow Developer Survey 2018» (https://insights.stackoverflow.com/survey/2018#tech
nology-most-loved-dreaded-and-wanted-languages). Stack Overflow. Consultado em 16 de
abril de 2018
12. O'Grady, Stephen (7 de março de 2018). «The RedMonk Programming Language Rankings:
January 2018» (https://redmonk.com/sogrady/2018/03/07/language-rankings-1-18/) (em
inglês). RedMonk. Consultado em 13 de março de 2018
13. Naomi Hamilton (5 de agosto de 2008). «The A-Z of Programming Languages: Python» (http://
www.computerworld.com.au/article/255835/a-z_programming_languages_python/?fp=4194304
&fpid=1&pf=1) (em inglês). Computerworld. Consultado em 17 de agosto de 2008
14. «Why was Python created in the first place?» (https://docs.python.org/faq/general#why-was-pyt
hon-created-in-the-first-place) (em inglês). Python FAQ. Consultado em 22 de março de 2007
15. «LJ #37: Python 1.4 Update» (https://web.archive.org/web/20070501080219/http://www.amk.c
a/python/writing/12-14) (em inglês). Consultado em 29 de abril de 2007. Arquivado do original
(http://www.amk.ca/python/writing/12-14) em 1 de maio de 2007
16. Guido van Rossum. «Computer Programming for Everybody» (https://web.archive.org/web/200
90223101648/http://python.org/doc/essays/cp4e.html) (em inglês). Consultado em 22 de março
de 2007. Arquivado do original (https://www.python.org/doc/essays/cp4e.html) em 23 de
fevereiro de 2009
17. A.M. Kuchling and Moshe Zadka. «What's New in Python 2.0» (https://web.archive.org/web/20
091214142515/http://www.amk.ca/python/2.0) (em inglês). Consultado em 22 de março de
2007. Arquivado do original (http://www.amk.ca/python/2.0/) em 14 de dezembro de 2009
18. «History of the software» (https://docs.python.org/release/2.5/lib/node951.html). Referência da
Biblioteca Python (em inglês). Consultado em 22 de março de 2007
19. Jeremy Hylton. «Statically Nested Scopes» (https://www.python.org/dev/peps/pep-0227/) (em
inglês). Consultado em 22 de março de 2007
20. «2 PEPs 252 and 253: Type and Class Changes» (https://docs.python.org/release/2.2.3/whatsn
ew/sect-rellinks.html) (em inglês). Python Software Foundation. Consultado em 11 de junho de
2008
21. «4 PEP 255: Simple Generators» (https://docs.python.org/release/2.2.3/whatsnew/node5.html)
(em inglês). Python Software Foundation. Consultado em 11 de junho de 2008
22. «PEP 282 - A Logging System» (https://www.python.org/dev/peps/pep-0282/) (em inglês).
Python Software Foundation. Consultado em 11 de junho de 2008
23. «8 PEP 282: The logging Package» (https://docs.python.org/release/2.3/whatsnew/node9.html)
(em inglês). Python Software Foundation. Consultado em 11 de junho de 2008
24. «PEP 318 - Decorators for Functions and Methods» (https://www.python.org/dev/peps/pep-031
8/) (em inglês). Python Software Foundation. Consultado em 11 de junho de 2008
25. «5 PEP 318: Decorators for Functions and Methods» (https://docs.python.org/release/2.4/what
snew/node6.html) (em inglês). Python Software Foundation. Consultado em 11 de junho de
2008
26. A.M. Kuchling (1 de outubro de 2008). «What's New in Python 2.6» (https://docs.python.org/wh
atsnew/2.6.html) (em inglês). Python Software Foundation. Consultado em 3 de outubro de
2008
27. «Python 3.0 Release» (https://www.python.org/download/releases/3.0/) (em inglês). Python
Software Foundation. Consultado em 3 de dezembro de 2008
28. Sarah Stokely (1 de fevereiro de 2008). «Python 3.0 to be backwards incompatible» (http://ww
w.itnews.com.au/News/69326,breaking-the-python-code.aspx) (em inglês). iTnews. Consultado
em 11 de junho de 2008
29. Georg Brandl. «Make print a function» (https://www.python.org/dev/peps/pep-3105/) (em
inglês). Consultado em 3 de outubro de 2008
30. «Diferenças entre Python 2 e Python 3» (https://blog.caelum.com.br/quais-as-diferencas-entre-
python-2-e-python-3/). Blog da Caelum. Consultado em 16 de março de 2019
31. «PEP 20 - The Zen of Python» (https://www.python.org/dev/peps/pep-0020/) (em inglês).
Python - Núcleo de Desenvolvimento. Consultado em 15 de janeiro de 2010
32. «20 Most Popular Python IDEs in 2024: Code Like a Pro» (https://www.simplilearn.com/tutorial
s/python-tutorial/python-ide). www.simplilearn.com (em inglês). Consultado em 8 de agosto de
2024
33. «Python support in Visual Studio on Windows» (https://learn.microsoft.com/en-us/visualstudio/p
ython/overview-of-python-tools-for-visual-studio?view=vs-2022). learn.microsoft.com (em
inglês). 18 de abril de 2024. Consultado em 28 de outubro de 2024
34. «Classes — Random Remarks» (https://docs.python.org/tutorial/classes.html#random-remark
s). Python Documentation (em inglês). Python Software Foundation
35. DOWNEY, Allen B. Pense em Python. [S.l.]: Novatec. 38 páginas. ISBN 9788575225080
36. «New Keywords» (https://docs.python.org/3/whatsnew/3.5.html#new-keywords). Python v3.5
documentation. Docs.python.org. Consultado em 1 de junho de 2016. Cópia arquivada em 18
de junho de 2016 (https://web.archive.org/web/20160618215313/https://docs.python.org/3//wha
tsnew/3.5.html#new-keywords)
37. «PEP 634 – Structural Pattern Matching: Specification» (https://www.python.org/dev/peps/pep-
0634/). Python Enhancement Proposals (PEP) (em inglês). Consultado em 8 de agosto de
2024
38. «What's New In Python 3.0» (https://docs.python.org/release/3.0/whatsnew/3.0.html) (em
inglês). Python Software Foundation. Consultado em 15 de janeiro de 2011
39. Michele Simionato. «The Python 2.3 Method Resolution Order» (https://www.python.org/downlo
ad/releases/2.3/mro/) (em inglês). Python Software Foundation. Consultado em 11 de junho de
2008
40. «EAFP vs LBYL (was Re: A little disappointed so far)» (https://web.archive.org/web/200709291
22422/http://mail.python.org/pipermail/python-list/2003-May/205182.html). web.archive.org.
Consultado em 6 de maio de 2012. Arquivado do original (http://mail.python.org/pipermail/pytho
n-list/2003-May/205182.html) em 29 de setembro de 2007
41. Przemyslaw Piotrowski (Julho de 2006). «Build a Rapid Web Development Environment for
Python Server Pages and Oracle» (http://www.oracle.com/technology/pub/articles/piotrowski-py
thoncore.html) (em inglês). Oracle. Consultado em 11 de junho de 2008
42. Phillip J. Eby (7 de dezembro de 2003). «PEP 333 -- Python Web Server Gateway Interface
v1.0» (https://www.python.org/dev/peps/pep-0333/) (em inglês). Python Software Foundation.
Consultado em 11 de junho de 2008
43. Guido van Rossum (5 de julho de 2001). «PEP 7 -- Style Guide for C Code» (https://www.pytho
n.org/dev/peps/pep-0007/) (em inglês). Python Software Foundation. Consultado em 11 de
junho de 2008
44. «Quotes about Python» (https://python.org/about/quotes/) (em inglês). Python Software
Foundation. Consultado em 11 de junho de 2008
45. Daniel G. Shafer (17 de janeiro de 2003). «Python Streamlines Space Shuttle Mission Design»
(https://www.python.org/about/success/usa/) (em inglês). Python Software Foundation.
Consultado em 11 de junho de 2008
46. Darryl K. Taft (5 de março de 2005). «Python Slithers into Systems» (http://www.eweek.com/c/
a/Application-Development/Python-Slithers-into-Systems/) (em inglês). eWEEK. Consultado
em 11 de junho de 2008
47. «Introduction to Maya Python API» (http://www.autodesk.com/us/maya/docs/Maya85/wwhelp/w
whimpl/common/html/wwhelp.htm?context=DeveloperResources&file=Introduction_to_Maya_P
ython_API.html). Documentação do Maya (em inglês). Autodesk. Consultado em 18 de julho de
2008
48. «Python Scripts» (https://web.archive.org/web/20120618153326/http://wiki.blender.org/index.ph
p/Extensions:Py/Scripts) (em inglês). Blender. Consultado em 18 de julho de 2008. Arquivado
do original (http://wiki.blender.org/index.php/Extensions:Py/Scripts) em 18 de junho de 2012
49. James Henstridge (16 de maio de 2006). «GIMP Python Documentation» (http://www.gimp.org/
docs/python/index.html). Documentação do GIMP (em inglês). GIMP. Consultado em 18 de
julho de 2008
50. Robin Rowe (1 de julho de 2002). «Industrial Light & Magic» (http://www.linuxjournal.com/articl
e/6011) (em inglês). Linux Journal. Consultado em 18 de julho de 2008

Bibliografia
Pilgrim, Mark (2004). Dive into Python (http://diveintopython.net) (em inglês) 2 ed. Nova
Iorque: Apress. 413 páginas. ISBN 978-1-5905-9356-1
Pilgrim, Mark (2009). Dive into Python 3 (http://www.diveinto.org/python3/) (em inglês) 2 ed.
Nova Iorque: Apress. 360 páginas. ISBN 978-1-4302-2415-0
Downey, Allen B. (2012). Think Python (http://shop.oreilly.com/product/0636920025696.do)
(em inglês). Sebastopol (Califórnia): O'Reilly. 300 páginas. ISBN 978-1-4493-3072-9
Lutz, Mark (2013). Learning Python (http://shop.oreilly.com/product/0636920028154.do) (em
inglês) 5 ed. Sebastopol (Califórnia): O'Reilly. 1600 páginas. ISBN 978-1-4493-5573-9
Lutz, Mark (2010). Programming Python (http://shop.oreilly.com/product/9780596158118.do)
(em inglês) 4 ed. Sebastopol (Califórnia): O'Reilly. 1632 páginas. ISBN 978-0-596-15810-1
David Beazley e Brian K. Jones (2013). Python Cookbook (http://shop.oreilly.com/product/0636
920027072.do) (em inglês) 3 ed. Sebastopol (Califórnia): O'Reilly. 706 páginas. ISBN 978-1-
4493-4037-7

Ligações externas
Sítio oficial (https://www.python.org/)
Python (https://github.com/python/cpython) no GitHub
«Wiki da comunidade brasileira de usuários» (https://www.python.org.br/)

Obtida de "https://pt.wikipedia.org/w/index.php?title=Python&oldid=68972596"