Python

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Python
Logo do Python
Paradigma Multiparadigma:
Orientação a objetos
Programação imperativa
Programação funcional
Surgido em 1991[1]
Última versão 3.4.1 (18 de maio de 2014[2] )
Criado por Guido van Rossum[1]
Estilo de tipagem: Dinâmica, forte
Dialetos: CPython, IronPython, Jython, PyPy
Influenciada por ABC,[3] ALGOL 68, C[3] , Haskell, Icon, Java, Lisp, Modula-3[3] , Perl, Smalltalk
Influenciou Boo, D, Falcon, Fantom, Groovy, JavaScript, Nimrod, Py, Ruby, Squirrel
Página oficial www.python.org

Python é uma linguagem de programação de alto nível[4] , interpretada, imperativa, orientada a 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 linguagem como um todo não é formalmente especificada. O padrão de facto é a implementação CPython.

A linguagem foi projetada com a filosofia de enfatizar a importância do esforço do programador sobre o esforço computacional. Prioriza a legibilidade do código sobre a velocidade ou expressividade. Combina uma sintaxe concisa e clara com os recursos poderosos de sua biblioteca padrão e por módulos e frameworks desenvolvidos por terceiros.

Python é uma linguagem de propósito geral de alto nível, multi paradigma, suporta o paradigma orientado a objetos, imperativo, funcional e procedural. Possui tipagem dinâmica e uma de suas principais características é permitir a fácil leitura do código e exigir poucas linhas de código se comparado ao mesmo programa em outras linguagens. Devido as suas características, ela é principalmente utilizada para processamento de textos, dados científicos e criação de CGIs para páginas dinâmicas para a web.

O nome Python teve a sua origem no grupo humorístico britânico Monty Python,[5] criador do programa Monty Python's Flying Circus, embora muitas pessoas façam associação com o réptil do mesmo nome (em português, píton ou pitão).

Características[editar | editar código-fonte]

A linguagem possui tipagem dinâmica, não é possível definir um tipo para variáveis ou funções, estes tipos são definidos e alterados dinamicamente durante a interpretação do código. A maioria das implementações são interpretadas e apenas erros de sintaxe são descobertos antes da real execução. Apesar disto, por não permitir a realização de operações com tipos diferentes, que poderiam ter interpretações diferentes, Python é uma linguagem fortemente tipada.

A característica mais marcante é a possibilidade de utilização de poucas linhas de código para fazer algo que em outras linguagens exigiria muito mais linhas e seria mais trabalhoso. A indentação é utilizada como definição de blocos e as linhas não necessitam de um delimitador, deixando a linguagem mais "humana".

Python é, provavelmente, a primeira linguagem a tentar atingir, ao mesmo tempo, iniciantes em programação, profissionais e cientistas da computação. Para iniciantes, a linguagem oferece a simplicidade, interatividade e várias bibliotecas inclusas. Permitindo que seja possível criar algo interessante e utilizável com grande facilidade. Aos profissionais, Python permite a criação de algoritmos complexos de forma simples e legível, permitindo a fácil manutenção do código. Para os cientistas da computação, a possibilidade de utilizar múltiplos paradigmas, possuir muitas bibliotecas e ser legível, tornam o Python uma boa opção.

É possível criar funções aninhadas, ou seja, é possível criar uma função dentro do escopo de uma função mais externa. Neste caso, a função interna pertencerá apenas ao escopo criado pela função externa, as outras funções no mesmo nível na externa não terão acesso a esta função. As funções são objetos de primeira classe, possuem atributos e podem ser atribuídas à uma variável, assim como qualquer outro objeto. Elas também são funções de alta ordem, o que significa que elas podem receber outras funções como argumento e até retornar funções.

É possível criar funções anonimas através da palavra chave "lambda", que vem das linguagens funcionais. Este tipo de função é muito utilizada quando é mais conveniente apenas definir a função e usa-la, do que criar uma definição completa. Um exemplo disso é ao chamar uma função com passagem de parâmetro para callback, uma definição completa de função é considerada uma declaração, e como tal, não pode ser passada como parâmetro. Por outro lado, uma função anonima definida através da lambda, é apenas uma expressão e pode ser definida na mesma linha da chamada.

Em Python, tudo é objeto, e isto inclui a classe e sua instancia. Os dados são representados por objetos ou relações entre objetos. Todos os objetos tem um tipo e um valor. Estes objetos não são explicitamente destruídos, quando não existem mais referências a ele, o objeto é destruído pelo garbage collector. A palavra reservada "class"é apenas um construtor, os objetos definidos por ela, chamados de classe, possuem um tipo genérico chamado "type". Esta definição torna possível acessar uma classe, sem instancia-la, como é acessado qualquer outro objeto, podendo assim acrescentar atributos ou definir valores. Como Python interpreta funções em uma classe como atributos, é possível então adicionar novas funções a classe ou até sobrescrever funções já existentes. As novas instancias desta classe possuirão o novo atributo adicionado ao objeto antes mesmo de cria-las. Existe também o tipo function, criado através da palavra reservada def e é utilizado nas funções.

A linguagem não possui modificadores de acesso, ou seja, é possível acessar, sobrescrever e até mesmo criar novos atributos em qualquer classe, até mesmo as classes internas da linguagem. Esta regra surgiu de uma das máximas da filosofia do Python: "Simple is better than complex". As vantagens desta abordagem são que o programador nunca poderá prever os futuros usos da classe enquanto ele está implementando, futuramente, algum código pode precisar acessar algum atributo ou método privado, ou até mesmo sobrescreve-lo. Esta pode ter sido uma das características que tornou Python uma das linguagens mais adotadas para o software livre em repositórios públicos. Por convenção, foi adotado que um atributo protegido, deverá ser precedido de um underscore, definindo que ele deverá, preferencialmente, ser acessado apenas na classe ou em subclasses. Os atributos privados devem possuir dois underscores como prefixo.

Geradores são uma forma de utilizar lazy-evaluation em Python. Através deles, é possível criar uma lista virtualmente infinita, sem ocorrer um erro de execução. Como os valores são gerados apenas quando necessários, a lista infinita não será um problema. Existem diversas funções nativas implementadas desta forma, uma delas é a xrange.

Uma das principais utilizações de Python é no tratamento de textos, a maioria das funções e até mesmo a sintaxe da linguagem parece privilegiar esta utilização. As formas de se trabalhar com listas são extremamente simples, é possível, por exemplo, obter a ordem inversa da lista decrementando o índice da lista em valores negativos. Na segunda versão, foi implementado o list comprehension, através dele, é possível definir uma lista de forma parecida com a notação matemática utilizada para descrever conjuntos. Existem diversas funções para tratar listas inclusas na biblioteca padrão da linguagem, a função map(), por exemplo, cria uma nova lista baseada em uma lista já existente e aplica uma função especifica a cada valor da nova lista. A função reduce() permite a aplicação de uma função a cada par de elementos da lista de forma que só restará um elemento, pode ser utilizada, por exemplo, para somar todos os elementos da lista e retornar o resultado. Com o filter(), é possível filtrar os elementos da lista, criando uma nova lista com apenas os elementos que validarem a condição passada como função no argumento. Uma boa prática é utilizar expressões lambda para criar as funções condição. Além destas, existem funções para ordenar, inverter, enumerar, embaralhar e várias outras. Como a maioria destes feitos também podem ser feitos utilizando list comprehensions, existe um questionamento sobre a necessidade destas funções na biblioteca padrão, algumas ainda não estão com destino definido, o reduce já foi removido e agora pertence ao modulo functools.

As listas ou tuplas, em Python, podem ser utilizadas para montar uma lista de argumentos, atribuir valor a diversas variáveis ou retornar mais de um valor em uma única função. Caso uma lista ou tupla seja passada como parâmetro, com um asterisco a precedendo, significa que esta tupla será desempacotada para preencher os argumentos. Existem vários interpretadores de Python, a implementação de referência, é chamada CPython e foi implementado em C. Porém, por sua simplicidade, este interpretador é considerado lento, o que acabou fazendo com que os programadores pensassem que a linguagem(considerando todas as implementações) seja lenta. Existem outros interpretadores mais eficientes, um deles é o PyPy, que foi desenvolvido inicialmente utilizando Python e hoje utiliza uma linguagem baseada em um subconjunto de Python, chamada RPython. O PyPy ser escrito em Python não quer dizer que ele é executado sobre um interpretador. O código é compilado para linguagem de máquina, tornando-o tão rápido quando o CPython. Mas o que diferencia o PyPy em desempenho, é o fato de ele utilizar Just In Time compilation(JIT), assim como C#. O JIT converte o código, que antes seria interpretado, diretamente em código de maquina, durante a execução. Além disto, ele aplica diversas otimizações, como manter em memoria o assembly de funções mais utilizadas.

Atrávez do Jython, é possível compilar o código para o bytecode da JVM, e assim como em Java, o aplicativo será altamente portável a custo de desempenho. Existe o IronPython, que permite que sejam utilizadas bibliotecas .Net e o executável final é compilado para rodar no CLR do .Net Framework. O Stackless Python permite que sejam criados aplicativos com alta concorrência e dá suporte a microthreads.

História[editar | editar código-fonte]

Guido van Rossum, São Francisco, Califórnia

Python foi concebido no final de 1989[4] [5] por Guido 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[6] 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.[5]

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.[6] 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.[7]

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.[8] 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.[9]

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.[10]

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. 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.[10] O lançamento incluiu a mudança na especificação para suportar escopo aninhado, assim como outras linguagens com escopo estático.[11] 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.[12] Também foi adicionado generator, inspirado em Icon.[13]

O incremento da biblioteca padrão e as escolhas sintáticas foram fortemente influenciadas por Java em alguns casos: o pacote logging[14] introduzido na versão 2.3,[15] o analisador sintático SAX, introduzido na versão 2.0 e a sintaxe de decoradores que usa @,[16] adicionadas na versão 2.4.[17]

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.[18]

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,[19] chamada Python 3.0 ou Python 3000. Com noticiado desde antes de seu lançamento,[20] 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.[5] 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.[21] Também, a mudança para Unicode de todas as cadeias de caracteres.

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[editar | editar código-fonte]

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)",[22] escrito pelo programador em Python de longa data Tim Peters, descrevendo sumariamente a filosofia do Python. Pode-se vê-lo através de um easter egg do Python pelo comando:

>>> import this

Construções[editar | editar código-fonte]

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 subrotinas (def); construção de escopo (with), como por exemplo para adquirir um recurso.

Tipos de dado[editar | editar código-fonte]

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
str, unicode Uma cadeia de caracteres imutável 'Wikipedia', u'Wikipedia'
list Lista heterogênea mutável [4.0, 'string', True]
tuple Tupla imutável (4.0, 'string', True)
set, frozenset Conjunto não ordenado, não contém elementos duplicados set([4.0, 'string', True])
frozenset([4.0, 'string', True])
dict conjunto associativo {'key1': 1.0, 'key2': False}
int Número de precisão fixa, é transparentemente convertido para long caso não caiba em um int. 42
2147483648L
float Ponto flutuante 3.1415927
complex Número complexo 3+2j
bool Booleano True ou 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.[23]

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[editar | editar código-fonte]

O Python 2.5.2 define as seguintes 31 palavras reservadas:[24]

and        del        from        not        while
as         elif       global      or         with
assert     else       if          pass       yield
break      except     import      print
class      exec       in          raise
continue   finally    is          return
def        for        lambda      try

Operadores[editar | editar código-fonte]

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 é 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[editar | editar código-fonte]

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[editar | editar código-fonte]

Exemplo de script

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) e 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[editar | editar código-fonte]

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:

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

Compilador de bytecode[editar | editar código-fonte]

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.

Polimorfismo[editar | editar código-fonte]

O conceito de polimorfismo descreve como objetos podem ser manipulados e acessados usando atributos e comportamentos em comum sem considerar sua classe específica e indica a presença de late binding, permitindo sobrecarga e determinação de tipos em tempo de execução e verificação.

Muitas linguagens orientadas a objeto utilizam assinaturas de função para determinar qual versão de um método sobrecarregado chamar. No entanto, as chamadas de função em Python são universais ou genéricas sem determinação de tipo. Por isso, sobrecarga não é suportada na linguagem.

A tipagem é forte e dinâmica. Utiliza o "duck typing"como forma de definir um tipo para suas variáveis, isto é, a não ser que a variável seja um objeto que implementa uma classe, ela não deve ser explicitamente tipada. Caso ela seja um objeto, a definição da classe ocorrerá apenas na primeira vez que for chamada, parâmetros e funções não possuem tipo. Sendo assim, Python possui uma tipagem dinâmica, os tipos são implicitamente definidos de acordo com o valor atribuído a variável e pode alterar caso o valor se altere. Porém, operações entre tipos diferentes não são aceitos caso estes possam parecer ambíguos (ex.: 3+”dois”), e caso exista apenas uma solução para a operação (ex.: 3 + 3.2), a operação é válida e feita através de coerção.

A maioria dos tipos incluídos na linguagem vem do C, os booleanos são um subtipo dos inteiros, os inteiros são implementados como o long do C, ou seja, possuem 32 bits. Long Integer possui precisão ilimitada, float é implementada como double em C. Existe um tipo exclusivo para tratar números complexos.

Como os parâmetros não são tipados, o polimorfismo paramétrico é criado de forma natural, todas as funções são polimórficas, também não existe definição de tipo para retorno, podendo a função retornar um valor de qualquer tipo ou nada. É possível criar heranças, e através delas, criar uma espécie de subtipo.

Python não possui overloading diretamente, não é possível criar duas funções com o mesmo nome, pois as elas são consideradas atributos da classe. Caso o nome da função se repita em outra assinatura, o interpretador considera esta ultima como override e sobrescreve a função anterior. Porém, existe a possibilidade de chamar as funções com parâmetros diferentes definindo o valor de alguns deles na própria assinatura, assim, caso não sejam sobrescritos na chamada, eles assumirão o valor padrão. Como não possui overloading direto, algumas operações entre diferentes tipos são realizadas através de coerção(ex.: 3.2 + 3). Os valores padrão de parâmetros são avaliados somente no momento em que a função for definida, e não a cada chamada à mesma. Isto pode criar problemas se a programador considerar que o valor padrão será atribuído a cada chamada.

É possível utilizar herança múltipla, Python suporta este esquema de três formas diferentes. O algorítimo que define a forma como estas heranças serão tratadas é chamado de Method Resolution Order, ou MRO. Existe o MRO clássico, que existe desde a primeira versão da linguagem, no Python 2.2 foi criado um novo estilo, o mais atual é o criado no Python 2.3, chamado de C3. O estilo clássico usava um estilo bem simples, quando um método ou atributo é procurado nas classes base, o algorítimo procura nas classes definidas da esquerda para a direita. O primeiro resultado é retornado. No Python 2.2, o novo estilo definiu que diante de classes base duplicadas, as ultimas ocorrências substituirão a primeira, deixando apenas a ultima. Porém, este novo estilo possuía diversas inconsistências entre a documentação e os valores realmente retornados. O ultimo estilo, o C3, foi feito baseado no fato de que em uma hierarquia de herança complexa, cada relação de herança define uma serie de regras sobre a ordem de verificação das classes. A ideia é que o próprio usuário deve definir as regras da herança.

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

Paradigma[editar | editar código-fonte]

Python é, predominantemente, uma linguagem orientada a objetos. Porém, é uma linguagem multi paradigma que suporta paradigmas como o imperativo, funcional e procedural. Assim como C++, Python não força o programador a utilizar um único paradigma.

É, inclusive, uma boa prática utilizar os diversos paradigmas disponíveis na linguagem de forma complementar. Assim, o programador não fica preso às limitações de um paradigma especifico e tem mais liberdade para modelar o problema, possibilitando que ele fique mais atento ao problema, e não na modelagem. Este tipo de implementação, oferece diversas vantagens em comparação com as linguagens com um único paradigma. Entre eles, estão a possibilidade de escrever um código compacto e simples e, ao mesmo tempo, diminuir o risco de bugs.

Paradigmas como o funcional possuem um poder de expressão muito maior se comparado ao procedural, imperativo ou orientado a objetos. Através dele, é possível criar códigos mais próximos da representação matemática, o que é muito mais fluente e legível para os humanos, que terão que manter o código. Porém, a orientação a objetos é melhor para modelar a maioria dos problemas da nossa realidade, por isto ele é utilizado na maioria das linguagens.

Orientação a objetos[editar | editar código-fonte]

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.[26]

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

Programação funcional[editar | editar código-fonte]

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 à 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[editar | editar código-fonte]

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

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.[27] 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[editar | editar código-fonte]

Python possui uma grande biblioteca padrão, geralmente citada como um dos maiores triunfos da linguagem,[28] fornecendo ferramentas para diversas tarefas. Recentemente, a biblioteca Boost do C++ incluiu uma biblioteca para permitir a interoperabilidade entre as duas linguagens. 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[29] ), mas a maioria dos módulos não segue.

Comentários[editar | editar código-fonte]

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

Plataformas disponíveis[editar | editar código-fonte]

A linguagem e seu interpretador estão disponíveis para as mais diversas plataformas, desde Unix (Linux, FreeBSD, Solaris, MacOS X, etc.), Windows, .NET, versões antigas de MacOS até consoles de jogos eletrônicos ou mesmo alguns celulares, como a série 60, N8xx(PyMaemo) da Nokia e palmtops.

Para algum sistema operacional não suportado, basta que exista um compilador C disponível e gerar o Python a partir do fonte. O código fonte é traduzido pelo interpretador para o formato bytecode, que é multiplataforma e pode ser executado e distribuído sem fonte original.

Implementações[editar | editar código-fonte]

A implementação original e mais conhecida do Python é o CPython, escrita em C e compatível com o padrão C89,[30] 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 Microsoft 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.

Existem também implementações para plataformas já existentes: Jython para a Plataforma Java e IronPython para .NET.

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.

Desenvolvimento[editar | editar código-fonte]

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 svn.python.org

Licença[editar | editar código-fonte]

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.[31]

Módulos e frameworks[editar | editar código-fonte]

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:

Descrição Campos de atuação
Django Framework para desenvolvimento ágil de aplicações web; desenvolvimento web
Pylons Framework para desenvolvimento de aplicações web; desenvolvimento web
TurboGears Framework baseado em várias outras tecnologias existentes no mundo que gira em torno da linguagem Python; desenvolvimento web
Matplotlib - Matplotlib / Pylab biblioteca para manipulação de gráficos 2D; processamento de imagem
Python Imaging Library biblioteca para manipulação de imagens digitais; processamento de imagem
PyOpenGL - Python OpenGL Binding suporte multiplataforma ao OpenGL; computação gráfica
Pygame Conjunto de módulos para o desenvolvimento de jogos eletrônicos, incluindo gráficos SDL; desenvolvimento de jogos eletrônicos; computação gráfica
Twisted Framework para o desenvolvimento de aplicações de rede. Inclui módulos para servidor web, de aplicação, SSH e diversos outros protocolos; desenvolvimento de software; desenvolvimento web
PYRO - Python Remote Objects Framework para o desenvolvimento de sistemas distribuídos; computação distribuída
ZODB Sistema de persistência e banco de dados orientado a objetos; banco de dados
Plone SGC - Sistema de gerenciamento de conteúdo; desenvolvimento web
CherryPy Framework para aplicações web; desenvolvimento web
Web2py Framework para aplicações web; desenvolvimento web
Visual Python Framework 3D de alto nível; computação gráfica
SQLObject Mapeador objeto-relacional: traduz estruturas relacionais para objetos Python e manipula o banco de dados de forma transparente; banco de dados
Numarray Módulo para manipulação de vetores e computação científica. computação científica

Interfaces gráficas[editar | editar código-fonte]

Exemplos de bibliotecas de GUI disponíveis para Python incluem:

Descrição
Etk interface para a biblioteca EFL
PyGTK interface para a biblioteca GTK
PyQT interface para a biblioteca Qt
Tkinter Módulo padrão para GUI no Python
wxPython interface para a biblioteca wxWidgets
Wax Construído para simplificar o uso do wxPython

Ambientes de desenvolvimento integrado[editar | editar código-fonte]

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

Desenvolvedor Última versão Platforma Toolkit Licença
Boa Constructor Team 0.6.1 Independente wxPython GPL
Eric Python IDE Detlev Offenbach 4.1.2 Independente Qt GPL
Geany Team 1.23 Independente GTK2 GPL
IDLE Guido van Rossum et al. 3.0 / 2008 Independente Tkinter PSFL
IronPython Studio Clarius Labs 1.0 / 10 de dezembro de 2007 Windows VS2008 Shell Runtime Microsoft Public License
Komodo ActiveState 4.1.1 / junho de 2007 multiplataforma Plataforma Mozilla Propretário
PyDev (Eclipse) Fabio Zadrozny 1.3.13 multiplataforma SWT EPL
PythonCard Alex Tweedly 0.8.2 multiplataforma wxPython Licença BSD
PyScripter mmm-experts 1.7.2 / outubro de 2006 Windows MIT
Stani's Python Editor Stani 0.8.4c / 14 de fevereiro de 2008 Independente wxPython GPL
Spyder (formerly Pydee) Spyder developer community 2.3.2 / December 3, 2014 Windows, Linux, OS X PyQt4 MIT
Wing IDE Wingware 3.0.2-1 / 27 de novembro de 2007 Windows, Linux, OS X PyGTK Propretário

Aplicações[editar | editar código-fonte]

Alguns dos maiores projetos que utilizam Python são o servidor de aplicação Zope, o compartilhador de arquivos Mnet, o sítio YouTube e o cliente original do BitTorrent. Grandes organizações que usam a linguagem incluem Google[32] (parte dos crawlers), Yahoo! (para o sítio de grupos de usuários) e NASA.[33] O sistema de gerenciamento de reservas da Air Canada também usa Python em alguns de seus componentes.[34] 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,[35] Autodesk Softimage, TrueSpace e Blender.[36] Programas de edição de imagem também a usam para scripts, como o GIMP.[37] 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,[38] que produz filmes da série Star Wars usando extensivamente Python para a computação gráfica nos processos de produção dos filmes.

Referências

  1. a b c d HISTORY (em inglês) Python Software Foundation Fonte do Python. Visitado em 2008-06-05.
  2. Python 3.4.1 (em inglês) (18 de maio de 2014). Visitado em 23 de maio de 2014.
  3. a b c Guido van Rossum (Maio de 1996). Foreword for "Programming Python" (1st ed.) (em inglês) Python Software Foundation. Visitado em 12 de junho de 2008.
  4. a b The Making of Python (em inglês) Artima Developer. Visitado em 2007-03-22.
  5. a b c d Naomi Hamilton (5 de agosto de 2008). The A-Z of Programming Languages: Python (em inglês) Computerworld. Visitado em 17 de agosto de 2008.
  6. a b Why was Python created in the first place? (em inglês) Python FAQ. Visitado em 2007-03-22.
  7. LJ #37: Python 1.4 Update (em inglês). Visitado em 2007-04-29.
  8. Guido van Rossum. Computer Programming for Everybody (em inglês). Visitado em 2007-03-22.
  9. A.M. Kuchling and Moshe Zadka. What's New in Python 2.0 (em inglês). Visitado em 2007-03-22.
  10. a b History of the software (em inglês) Referência da Biblioteca Python.
  11. Jeremy Hylton. Statically Nested Scopes (em inglês). Visitado em 2007-03-22.
  12. 2 PEPs 252 and 253: Type and Class Changes (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  13. 4 PEP 255: Simple Generators (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  14. PEP 282 - A Logging System (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  15. 8 PEP 282: The logging Package (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  16. PEP 318 - Decorators for Functions and Methods (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  17. 5 PEP 318: Decorators for Functions and Methods (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  18. A.M. Kuchling (1 de outubro de 2008). What’s New in Python 2.6 (em inglês) Python Software Foundation. Visitado em 3 de outubro de 2008.
  19. Python 3.0 Release (em inglês) Python Software Foundation. Visitado em 3 de dezembro de 2008.
  20. Sarah Stokely (1 de fevereiro de 2008). Python 3.0 to be backwards incompatible (em inglês) iTnews. Visitado em 11 de junho de 2008.
  21. Georg Brandl. Make print a function (em inglês). Visitado em 3 de outubro de 2008.
  22. PEP 20 - The Zen of Python (em inglês) Python - Núcleo de Desenvolvimento. Visitado em 2010-01-15.
  23. Classes — Random Remarks (em inglês) Python Software Foundation Python Documentation.
  24. Keywords (em inglês) Manual de Referência do Python Python Software Foundation (21 de fevereiro de 2008). Visitado em 12 de setembro de 2008.
  25. What’s New In Python 3.0 (em inglês) Python Software Foundation. Visitado em 15 de janeiro de 2011.
  26. Michele Simionato. The Python 2.3 Method Resolution Order (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  27. EAFP vs LBYL (was Re: A little disappointed so far) web.archive.org. Visitado em 6 de maio de 2012. Cópia arquivada em 29 de setembro de 2007.
  28. Przemyslaw Piotrowski (Julho de 2006). Build a Rapid Web Development Environment for Python Server Pages and Oracle (em inglês) Oracle. Visitado em 11 de junho de 2008.
  29. Phillip J. Eby (7 de dezembro de 2003). PEP 333 -- Python Web Server Gateway Interface v1.0 (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  30. Guido van Rossum (5 de julho de 2001). PEP 7 -- Style Guide for C Code (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  31. Python License (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  32. Quotes about Python (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  33. Daniel G. Shafer (17 de janeiro de 2003). Python Streamlines Space Shuttle Mission Design (em inglês) Python Software Foundation. Visitado em 11 de junho de 2008.
  34. Darryl K. Taft (5 de março de 2005). Python Slithers into Systems (em inglês) eWEEK. Visitado em 11 de junho de 2008.
  35. Introduction to Maya Python API (em inglês) Documentação do Maya Autodesk. Visitado em 18 de julho de 2008.
  36. Python Scripts (em inglês) Blender. Visitado em 18 de julho de 2008.
  37. James Henstridge (16 de maio de 2006). GIMP Python Documentation (em inglês) Documentação do GIMP GIMP. Visitado em 18 de julho de 2008.
  38. Robin Rowe (1 de julho de 2002). Industrial Light & Magic (em inglês) Linux Journal. Visitado em 18 de julho de 2008.

Bibliografia[editar | editar código-fonte]

Ligações externas[editar | editar código-fonte]

Outros projetos Wikimedia também contêm material sobre este tema:
Wikcionário Definições no Wikcionário
Wikilivros Livros e manuais no Wikilivros
Wikiquote Citações no Wikiquote
Commons Categoria no Commons