Pitão | ||
Data da primeira versão | 20 de fevereiro de 1991 | |
---|---|---|
Paradigmas | Objetivo , imperativo e funcional | |
Autor | Guido van Rossum | |
Desenvolvedores | Python Software Foundation | |
Última versão | 3.9.6 (28 de junho de 2021) | |
Versão em desenvolvimento | 3.10.0b4 (10 de julho de 2021) | |
Digitando | Digitação forte , dinâmica , pato | |
Influenciado por | ABC , C , Eiffel , ICON , Modula-3 , Java , Perl , Smalltalk , Tcl | |
Influenciado | Ruby , Groovy , Boo , Julia | |
Implementações | CPython , Jython , IronPython , PyPy | |
Escrito em | C para CPython, Java para Jython, C # para IronPython e no próprio Python para PyPy | |
Sistema operacional | Multi plataforma | |
Licença |
Licença gratuita : Python Software Foundation License |
|
Local na rede Internet | www.python.org | |
Extensão de arquivo | py, pyc, pyd, pyo, pyw, pyz e pyi | |
Python (pronunciado / p i . T ɔ / ) é uma linguagem de programação interpretada , multi paradigma e multi-plataforma . Promove programação imperativa estruturada , funcional e orientada a objetos . Possui forte tipagem dinâmica , gerenciamento automático de memória por coleta de lixo e um sistema de gerenciamento de exceções ; é, portanto, semelhante a Perl , Ruby , Scheme , Smalltalk e Tcl .
A linguagem Python é colocada sob uma licença gratuita próxima à licença BSD e funciona na maioria das plataformas de computador , de smartphones a computadores mainframe , de Windows a Unix com em particular GNU / Linux via macOS , ou mesmo Android , iOS , e também pode ser traduzido para Java ou .NET . Ele é projetado para otimizar a produtividade dos programadores, oferecendo ferramentas de alto nível e uma sintaxe fácil de usar.
Também é apreciado por alguns pedagogos que encontram nele uma linguagem onde a sintaxe, claramente separada dos mecanismos de baixo nível , permite uma iniciação fácil aos conceitos básicos de programação.
Python é uma linguagem de programação que pode ser usada em vários contextos e se adaptar a qualquer tipo de uso graças a bibliotecas especializadas. No entanto, é particularmente usado como uma linguagem de script para automatizar tarefas simples, mas tediosas, como um script que recuperaria o clima da Internet ou que se integraria a um software de design auxiliado por computador para automatizar certas sequências de ações repetitivas (consulte seção Adoção ). Ele também é usado como uma linguagem de desenvolvimento de protótipo quando um aplicativo funcional é necessário antes de otimizá-lo com uma linguagem de nível inferior. É particularmente difundido no mundo científico e tem muitas bibliotecas otimizadas para computação numérica .
No final dos anos 1980 , o programador Guido van Rossum estava envolvido no desenvolvimento da linguagem de programação ABC no Centrum voor Wiskunde en Informatica (CWI) em Amsterdã , Holanda . Em seguida, ele trabalhou na equipe do sistema operacional Amoeba , cujas chamadas de sistema eram difíceis de interagir com o shell Bourne usado como interface do usuário . Ele então acredita que uma linguagem de script inspirada no ABC poderia ser interessante como um interpretador de comandos para Amoeba.
Em 1989 , aproveitando uma semana de férias durante as férias de Natal , ele usou seu computador pessoal para escrever a primeira versão da língua. Fã da série de televisão Monty Python's Flying Circus , ele decide batizar este projeto de Python. Ele foi inspirado principalmente pelo ABC, por exemplo, para indentação como sintaxe ou tipos de alto nível, mas também do Modula-3 para tratamento de exceções , linguagem C e ferramentas UNIX .
No ano seguinte, a linguagem começou a ser adotada pela equipe do projeto Amoeba, com Guido continuando a se desenvolver principalmente nas horas vagas. DentroFevereiro de 1991, a primeira versão pública, numerada 0.9.0, é postada no fórum Usenet alt.sources. A versão mais recente lançada no CWI é Python 1.2.
Em 1995 , Van Rossum continuou seu trabalho em Python no CNRI (in) em Reston , nos Estados Unidos , onde lançou várias versões do software.
A partir de'Agosto de 1995, a equipe Python está trabalhando no NCRI no Graal, um navegador da web usando Tk . É o equivalente em Python do navegador HotJava , permitindo que você execute miniaplicativos em um ambiente seguro. A primeira versão pública, disponível em novembro, é de 0,2. Ele conduz o desenvolvimento de módulos para a biblioteca padrão como rexec , htmllib ou urllib . A versão 0.6 será a última do Graal ; é publicado emAbril de 1999.
Em 1999 , o projeto Computer Programming for Everybody (CP4E) foi lançado em conjunto entre o CNRI e a DARPA . Trata-se de usar Python como um ensinamento programação idioma . Esta iniciativa levará à criação do ambiente de desenvolvimento IDLE . No entanto, devido à falta de financiamento para o projeto pela DARPA e à saída de muitos desenvolvedores Python do NCRI (incluindo Guido van Rossum), o projeto morreu em 2000. Python 1.6 foi a última versão lançada no NCRI.
Em 2000 , a equipe principal de desenvolvimento do Python mudou-se para BeOpen.com para formar a equipe BeOpen PythonLabs . Python 2.0 é a única versão lançada em BeOpen.com. Após este lançamento, Guido Van Rossum e os outros desenvolvedores do PythonLabs se juntaram à Digital Creations (agora conhecida como Zope Corporation ).
Andrew M. Kuchling publica em Dezembro de 1999um texto chamado Python Warts , que sintetiza as queixas mais frequentes expressas contra a linguagem. Este documento terá uma influência definitiva nos desenvolvimentos futuros da língua.
Python 2.1 é uma versão derivada de Python 1.6.1 e Python 2.0. Sua licença foi renomeada como Licença Python Software Foundation . Qualquer código , documentação e especificação adicionada desde o lançamento do Python 2.1 alpha é propriedade da Python Software Foundation (PSF), uma organização sem fins lucrativos fundada em 2001, modelada a partir da Apache Software Foundation .
A fim de corrigir algumas falhas de linguagem (por exemplo, orientação a objetos com dois tipos de classes ) e para limpar a biblioteca padrão de seus elementos obsoletos e redundantes, Python optou por quebrar a compatibilidade com versões anteriores na nova versão principal, Python 3.0, publicada emdezembro 2008. Esta versão é rapidamente seguida por uma versão 3.1 que corrige os erros anteriores da versão 3.0.
Python foi projetado para ser uma linguagem legível. Tem como objetivo ser visualmente limpo. Por exemplo, ele tem menos construções sintáticas do que muitas linguagens estruturadas, como C , Perl ou Pascal . Os comentários são indicados pelo caractere cruzado (#).
Os blocos são identificados pela indentação em vez de colchetes como C ou C ++ ; ou begin ... endcomo em Pascal ou Ruby . Aumentar o recuo marca o início de um bloco e reduzir o recuo marca o final do bloco atual. Por convenção (atualmente PEP8), o recuo é geralmente de quatro espaços em Python.
Função fatorial em C | Função fatorial em Python |
---|---|
int factorielle(int n) { if (n < 2) { return 1; } else { return n * factorielle(n - 1); } } | def factorielle(n): if n < 2: return 1 else: return n * factorielle(n - 1) |
Nota: O recuo pode ser alterado ou removido na versão C sem alterar seu comportamento. Da mesma forma, a função Python pode ser escrita com uma expressão condicional. No entanto, o recuo correto torna mais fácil detectar erros quando vários blocos estão aninhados e, portanto, facilita a eliminação desses erros. É por isso que é preferível indentar programas em C. A versão curta seria escrita da seguinte forma:
Função fatorial em C | Função fatorial em Python |
---|---|
int factorielle(int n) { return n < 2 ? 1 : n * factorielle(n - 1); } | def factorielle(n): return n * factorielle(n - 1) if n > 1 else 1 |
Palavras-chave reservadas da linguagem Python são fornecidas na lista de keyword.kwlistmódulos keyword.
As palavras-chave de Python 2.7.5 são: and, as, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while, with, yield.
A partir do Python 3.0, printe execnão são mais palavras-chave de linguagem, mas funções de módulo builtins. São adicionados a palavras-chave: True, False, Nonee nonlocal. Os três primeiros já estavam presentes nas versões anteriores, mas não são mais editáveis (a atribuição anterior True = 1era possível). nonlocalfoi introduzido pelo PEP 3104, e permite, em uma função definida dentro de outra função, modificar uma variável de um nível de escopo superior . Antes disso, apenas variáveis locais para a função e globais (nível de módulo) eram modificáveis. Porém, era possível, e ainda é sem a palavra-chave nonlocal, modificar um objeto atribuído a uma variável de um nível de escopo superior, por exemplo, uma lista com o método append- isso é obviamente impossível para um objeto imutável .
Tipos básicosOs tipos básicos em Python são relativamente abrangentes e poderosos. Existem, entre outros:
Objetos iteráveis são repetidos da forseguinte forma:
for element in objet_iterable: traiter(element)Para uma sequência de caracteres, a iteração prossegue caractere por caractere.
É possível derivar classes de tipos básicos para criar seus próprios tipos. Você também pode criar seus próprios tipos de objetos iteráveis sem herdar os iteráveis básicos usando o protocolo de iteração da linguagem.
Programação funcionalPython permite a programação em um estilo funcional . Ele também tem compreensões de lista e, mais geralmente, entendimentos podem produzir geradores, dicionários ou conjuntos . Por exemplo, para construir a lista de quadrados de números naturais menores que 10, podemos usar a expressão:
liste = [x**2 for x in range(10)] # liste = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]A lista de números pares :
liste = [entier for entier in range(10) if entier % 2 == 0] # liste = [0, 2, 4, 6, 8]Uma tabela de passagem das letras do alfabeto para seu código ASCII :
{chr(n): n for n in range(65, 91)}O conjunto de letras em uma palavra (produz o conjunto {'r', 'c', 'd', 'b', 'a'}):
s = "abracadabra" {c for c in s}Uma compreensão pode consistir em vários loops e filtros, e há uma correspondência com o código realizando o mesmo cálculo usando instruções fore if :
Compreensão | Código equivalente |
---|---|
[ i + j if i != j else 0 for i in range(n) if i % 2 != 0 for j in range(n) if j % 3 != 0 ] | a = [] for i in range(n): if i % 2 != 0: for j in range(n): if j % 3 != 0: a.append(i + j if i != j else 0) |
Uma forma limitada de função anônima é possível:
lambda x: x + 2As funções lambda podem ser definidas inline e usadas como argumentos em expressões funcionais:
filter(lambda x: x < 5, une_liste)retornará uma lista composta dos elementos de a_list menor que 5. O mesmo resultado pode ser obtido com
[x for x in une_liste if x < 5]Os lambdas do Python apenas admitem expressões e não podem ser usados como funções anônimas generalizadas; mas em Python, todas as funções são objetos, portanto, podem ser passados como argumentos para outras funções e chamados quando necessário. De fato, uma função definida com def pode ser criada dentro de outra função e assim obtemos uma definição de função em uma variável local, por exemplo:
def filtre_inferieur_a_5(une_liste): def mon_filtre(x): # variable locale mon_filtre return x < 5 return filter(mon_filtre, une_liste)Uma função local pode modificar o ambiente da função que a criou, graças à palavra-chave nonlocal(ver Desligamento (TI) ):
def accum(pas): total = 0 def ajoute(n): nonlocal total total += n * pas return total return ajouteAssim, é possível criar vários acumuladores, cada um referindo-se ao seu total. É possível acessar o ambiente de uma função local usando o atributo __closure__.
Programação de objetosTodos os tipos básicos, funções, instâncias de classes (os objetos "clássicos" das linguagens C ++ e Java ) e as próprias classes (que são instâncias de metaclasses) são objetos.
Uma classe é definida com a palavra-chave class. As classes Python suportam a herança múltipla ; não há sobrecarga estática como em C ++, ou restrições de herança como é o caso em Java (uma classe implementa várias interfaces e herda de uma única classe), mas o mecanismo dos argumentos opcionais e por palavra-chave é mais geral e mais flexível . Em Python, o atributo de um objeto pode fazer referência a uma instância ou variável de classe (geralmente um método). É possível ler ou modificar um atributo dinamicamente com as funções:
Exemplo de duas classes simples:
class Personne: def __init__(self, nom, prenom): self.nom = nom self.prenom = prenom def presenter(self): return self.nom + " " + self.prenom class Etudiant(Personne): def __init__(self, niveau, nom, prenom): Personne.__init__(self, nom, prenom) self.niveau = niveau def presenter(self): return self.niveau + " " + Personne.presenter(self) e = Etudiant("Licence INFO", "Dupontel", "Albert") assert e.nom == "Dupontel" Métodos especiais e definição de operadoresPython fornece um mecanismo elegante e orientado a objetos para definir um conjunto predefinido de operadores: qualquer objeto Python pode receber os chamados métodos especiais.
Esses métodos, começando e terminando com dois sublinhados , são chamados ao usar um operador no objeto: +(método __add__), +=(método __iadd__), [](método __getitem__), ()(método __call__), etc. Métodos como __repr__e __str__permitem definir a representação de um objeto no interpretador interativo e sua renderização com a função de impressão .
As possibilidades são numerosas e estão descritas na documentação do idioma.
Por exemplo, podemos definir a adição de dois vetores bidimensionais com a seguinte classe:
class Vector2D: def __init__(self, x, y): # On utilise un tuple pour stocker les coordonnées self.coords = (x, y) def __add__(self, other): # L'instruction a+b sera résolue comme a.__add__(b) # On construit un objet Vector2D à partir des coordonnées propres à l'objet, et à l'autre opérande return Vector2D(self.coords[0]+other.coords[0], self.coords[1]+other.coords[1]) def __repr__(self): # L'affichage de l'objet dans l'interpréteur return "Vector2D(%s, %s)" %self.coords a = Vector2D(1, 2) b = Vector2D(3, 4) print(a + b) # Vector2D(4, 6) GeradoresA palavra-chave yieldusada em uma função torna possível transformá-la em um gerador. Chamar essa função retorna um objeto do tipo gerador , que pode ser usado em um loop for, por exemplo.
Em cada chamada, o gerador executa seu processamento até encontrar a palavra-chave yield, retorna o valor da expressão yielde, na próxima chamada, retoma seu fluxo logo após o yield. Por exemplo, para calcular a sequência de Fibonacci , podemos escrever:
def gen_fibonacci(): """Générateur de la suite de Fibonacci""" a, b = 0, 1 while True: yield a # Renvoie la valeur de "a", résultat de l'itération en cours a, b = b, a + b fi = gen_fibonacci() for i in range(20): print(next(fi))O módulo itertoolspermite que você manipule os geradores. Por exemplo, para extrair os primeiros 10 elementos do gerador anterior:
import itertools list(itertools.islice(gen_fibonacci(), 10)) # renvoie [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]Desde o Python 3.3, é possível produzir um gerador a partir de uma função recursiva, graças à sintaxe yield from, que apareceu no PEP 380 e que “delega” o cálculo a um sub-gerador. O exemplo a seguir calcula as permutações das rainhas correspondentes às soluções do problema das oito rainhas estendidas a um tabuleiro de xadrez de tamanho n × n.
def queens(n): a = list(range(n)) up = [True] * (2 * n - 1) down = [True] * (2 * n - 1) def sub(i): for k in range(i, n): j = a[k] p = i + j q = i - j + n - 1 if up[p] and down[q]: if i == n - 1: yield tuple(a) else: up[p] = down[q] = False a[i], a[k] = a[k], a[i] yield from sub(i + 1) up[p] = down[q] = True a[i], a[k] = a[k], a[i] yield from sub(0) sum(1 for a in queens(8)) # Nombre de solutions, renvoie 92Um construtor pode ter a mesma aparência de uma função que retorna uma lista, mas ao contrário de uma lista que contém todos os seus elementos, um construtor calcula seus elementos um por um .
Assim, o teste 36 in [n * n for n in range(10)]será realizado sobre a lista calculada integralmente, enquanto que em 36 in (n * n for n in range(10)), que utiliza um gerador, o cálculo dos quadrados para assim que for encontrado 36. Podemos nos convencer disso substituindo-o n * npor uma chamada de função que produza um efeito de borda , por exemplo, uma exibição na tela.
Graças ao uso intensivo de dicionários (container associativo desenvolvido com tabelas hash ), Python permite explorar os diversos objetos da linguagem ( introspecção ) e em certos casos modificá-los ( intercessão ).
A digitação não é verificada na compilação. Python usa a digitação duck : em tempo de execução, se um método invocado em um objeto tem a mesma assinatura de um método declarado neste objeto, então o último método é executado. Portanto, a invocação de um método que não existe em um objeto falhará, o que significa que o objeto em questão não é do tipo correto. Apesar da falta de tipagem estática, o Python é fortemente tipado, proibindo operações sem sentido (por exemplo, adicionar um número a uma string) em vez de tentar silenciosamente convertê-lo em uma forma significativa. Python fornece funções para transformar variáveis em outro tipo:
points = 3.2 # points est du type float print("Tu as " + points + " points !") # Génère une erreur de typage points = int(points) # points est maintenant du type int (entier), sa valeur est arrondie à l'unité inférieure (ici 3) print("Tu as " + points + " points !") # Génère une erreur de typage points = str(points) # points est maintenant du type str (chaîne de caractères) print("Tu as " + points + " points !") # Plus d'erreur de typage, affiche 'Tu as 3 points !'Python também fornece um mecanismo de tipagem estática para atributos de classe usando a API de características ou o padrão de design dos decoradores .
AnotaçõesDesde a versão 3.0, Python oferece anotação de variáveis em funções (introduzidas no PEP 3107). Isso permite tornar o código mais legível sem atuar como uma solução de tipagem estática, pois nada obriga a seguir essas anotações.
def hello(name: str) -> str: return "Hello {} !".format(name) hello("Alice") # Appel suggéré par les annotations hello(True) # Appel non conforme mais tout à fait fonctionnelAlém disso, desde a versão 3.5, Python oferece o módulo de digitação (introduzido no PEP 484).
from typing import List def split_string(string: str) -> List[str]: return string.split(" ") CompilaçãoÉ possível realizar uma análise estática de módulos Python com ferramentas como Pylint, mypy ou PyChecker. Sem exigir execução, essas ferramentas detectam falhas ou construções obsoletas. Por exemplo, uma classe que herda de uma classe abstrata e que não redefine métodos abstratos, ou variáveis usadas antes de serem declaradas, ou atributos de instância declarados fora do método __init__.
Também é possível gerar um código intermediário Python ( bytecode ).
Ferramentas como PyInstaller ou outras mais específicas como cx_Freeze em Unix , Windows e macOS , py2app em macOS e py2exe em Windows permitem "compilar" um programa Python na forma de um executável compreendendo o programa e um interpretador Python.
O programa não roda mais rápido (não é compilado como código de máquina), mas isso simplifica muito sua distribuição, especialmente em máquinas onde o interpretador Python não está instalado.
Em Python, tudo é um objeto , no sentido de que uma variável pode conter uma referência a todos os elementos tratados pela linguagem: números, métodos, módulos, etc. . No entanto, antes da versão 2.2, classes e instâncias de classe eram um tipo especial de objeto, o que significava que era, por exemplo, impossível derivar sua própria subclasse do objeto de lista .
MétodosO modelo de objeto do Python é inspirado no do Modula-3. Entre esses empréstimos está a obrigação de declarar a instância do objeto atual, convencionalmente denominado self , como o primeiro argumento dos métodos, e a cada vez que desejamos acessar um dado desta instância no corpo deste método. Esta prática não é natural para programadores vindos, por exemplo, de C ++ ou Java, a profusão de si mesmo sendo muitas vezes criticada como sendo uma poluição visual que atrapalha a leitura do código. Pelo contrário, os promotores do self explícito acreditam que evita o uso de convenções de nomenclatura para dados de membros e que simplifica tarefas como chamar um método da superclasse ou resolver desambiguação entre dados de membros.
Python reconhece três tipos de métodos:
A linguagem tem suporte muito limitado para encapsulamento . Não há, como em Java por exemplo, controle de acessibilidade por palavras-chave como protectedou private.
A filosofia do Python é diferenciar conceitualmente o encapsulamento da ocultação de informações. O mascaramento de informações visa evitar o uso fraudulento, é uma preocupação da segurança do computador . O módulo bastião da biblioteca padrão, que não é mais mantido nas últimas versões da linguagem, possibilitou controlar o acesso aos atributos de um objeto no âmbito de um ambiente de execução restrito.
O encapsulamento é um problema de desenvolvimento de software. O slogan dos desenvolvedores Python é que somos todos adultos consentindo aqui . Eles consideram que basta indicar, por meio de convenções escritas, as partes públicas das interfaces e que cabe aos usuários dos objetos obedecer a essas convenções ou assumir suas responsabilidades. O costume é prefixar membros privados com um sublinhado. A linguagem também permite o uso de um sublinhado duplo para evitar colisões de nomes, prefixando automaticamente o nome dos dados com o da classe onde está definido.
A utilização da função property()permite definir propriedades que visam interceptar, por meio de métodos, os acessos a um membro de dados. Isso torna desnecessário definir acessadores sistematicamente e ocultar dados como é comum em C ++, por exemplo.
HerançaPython suporta herança múltipla . Desde a versão 2.3, utiliza o algoritmo C3 (en) , derivado da linguagem Dylan , para resolver a ordem de resolução de métodos ( MRO ). As versões anteriores usavam um algoritmo de passagem profunda que causava problemas no caso de uma relíquia de diamante .
Python tem uma grande biblioteca padrão , fornecendo ferramentas adequadas para muitas tarefas diversas. O número de módulos na biblioteca padrão pode ser aumentado com módulos específicos escritos em C ou Python.
A biblioteca padrão é particularmente bem projetada para escrever aplicativos que usam a Internet, com um grande número de formatos e protocolos padrão suportados (como MIME e HTTP ). Módulos para a criação de interfaces gráficas e manipulação de expressões regulares também são fornecidos. Python também inclui uma estrutura para teste de unidade ( unittestanteriormente PyUnit antes da versão 2.1) para criar suítes de testes abrangentes.
Embora cada programador possa adotar suas próprias convenções para escrever código Python, Guido van Rossum disponibilizou um guia, referido como "PEP 8". Publicado em 2001, ainda está sendo mantido para adequá-lo às mudanças de idioma. O Google também oferece um guia.
Python possui vários módulos disponíveis para a criação de software com interface gráfica . O mais comum é o Tkinter . Este módulo é adequado para muitas aplicações e pode ser considerado suficiente na maioria dos casos. No entanto, outros módulos foram criados para poder vincular o Python a outras bibliotecas de software (" kit de ferramentas "), para obter mais funcionalidades, para melhor integração com o sistema operacional utilizado, ou simplesmente para poder usar o Python com sua biblioteca favorita. De fato, alguns programadores acham o uso do Tkinter mais doloroso do que outras bibliotecas. Esses outros módulos não fazem parte da biblioteca padrão e, portanto, devem ser obtidos separadamente.
Os principais módulos que fornecem acesso às bibliotecas GUI são Tkinter e Pmw (megawidgets Python) para Tk , wxPython para wxWidgets , PyGTK para GTK + , PyQt e PySide para Qt e finalmente FxPy para FOX Toolkit . Há também uma adaptação da biblioteca SDL : Pygame , um binding do SFML : PySFML, bem como uma biblioteca escrita especialmente para Python: Pyglet (en) .
Também é possível criar aplicativos Silverlight em Python na plataforma IronPython .
Guido van Rossum é o autor principal de Python, e seu papel como tomador de decisões central permanente de Python é humoristicamente reconhecido pelo título de “ Ditador Benevolente pela Vida ” ( BDFL). Desde ajulho de 2018, Guido van Rossum declarou-se em férias permanentes de seu cargo na BDFL. Ele também cancelou sua candidatura para o conselho diretor da língua emnovembro de 2019.
Ele é auxiliado por uma equipe de desenvolvedores principais que têm acesso de gravação ao repositório CPython e coordenam na lista de discussão python-dev. Eles trabalham principalmente com a linguagem básica e a biblioteca. Eles ocasionalmente recebem contribuições de outros desenvolvedores Python por meio da plataforma de gerenciamento de bugs Roundup , que substituiu o SourceForge .
Os usuários ou desenvolvedores de bibliotecas de terceiros usam uma variedade de outros recursos. A principal mídia generalista em torno do Python é o fórum da Usenet de língua inglesa comp.lang.python.
Alusões ao Monty Python são bastante comuns. Os tutoriais do Python costumam usar as palavras spam e eggs como uma variável metassintaxe . Esta é uma referência ao esboço do Monty Python Spam , onde dois clientes tentam pedir uma refeição usando um cartão que contém presunto enlatado da marca SPAM em praticamente todos os pratos. Este esboço também foi usado como referência para denotar e-mails não solicitados .
Várias empresas ou organizações mencionam em seu site oficial que usam Python:
Python também é a linguagem de comando para um grande número de software livre:
E comercial:
Python é usado como linguagem de programação no ensino médio e superior, especialmente na França. Desde 2013, é ministrado ali, ao mesmo tempo que o Scilab , a todos os alunos das aulas preparatórias de ciências como parte do núcleo comum (ciência da computação para todos). Anteriormente, o ensino de ciência da computação era limitado a uma opção em MP, com instrução em linguagem Caml ou Pascal . Esta opção ainda existe, mas Pascal foi abandonado a partir da sessão de competições de 2015, então apenas Caml permanece neste ensino. Os primeiros testes de competição na linguagem Python também são os da sessão de 2015.
Além da versão de referência, chamada CPython (porque escrita em linguagem C ), existem outros sistemas implementando a linguagem Python:
Essas outras versões não se beneficiam necessariamente de toda a biblioteca de funções escrita em C para a versão de referência, nem das últimas evoluções de linguagem.
Diferentes distribuições estão disponíveis, que às vezes incluem muitos pacotes dedicados a um determinado domínio:
Estas não são implementações diferentes da linguagem Python: elas são baseadas em CPython, mas vêm com várias bibliotecas pré-instaladas.
Versão | Data de lançamento | Fim do suporte | Novas chegadas |
---|---|---|---|
1,5 (0,2) | 3 de janeiro de 1998 | 13 de abril de 1999 |
|
1,6 | 5 de setembro de 2000 | Setembro de 2000 |
|
2.0 | 16 de outubro de 2000 | 22 de junho de 2001 |
|
2,1 | 15 de abril de 2001 | 9 de abril de 2002 |
|
2,2 | 21 de dezembro de 2001 | 30 de maio de 2003 |
|
2,3 | 29 de junho de 2003 | 11 de março de 2008 | |
2,4 | 30 de novembro de 2004 | 19 de dezembro de 2008 |
|
2,5 | 19 de setembro de 2006 | 26 de maio de 2011 |
|
2,6 | 1 ° de outubro de 2008 | 24 de agosto de 2010 (atualizações de segurança até 29 de outubro de 2013) |
|
2,7 | 3 de julho de 2010 | 1 ° de janeiro de 2020 |
|
3,0 | 3 de dezembro de 2008 | 13 de fevereiro de 2009 |
Veja PEP 3100 para detalhes |
3,1 | 27 de junho de 2009 | 12 de junho de 2011 (atualizações de segurança até Junho de 2012) |
|
3,2 | 20 de fevereiro de 2011 | 13 de maio de 2013 (atualizações de segurança até 20 de fevereiro de 2016) |
|
3,3 | 29 de setembro de 2012 | 8 de março de 2014 (atualizações de segurança até 29 de setembro de 2017) |
|
3,4 | 16 de março de 2014 | 9 de agosto de 2017 (atualizações de segurança até 18 de março de 2019) |
|
3,5 | 13 de setembro de 2015 | 8 de agosto de 2017 (atualizações de segurança até 13 de setembro de 2020) |
|
3,6 | 23 de dezembro de 2016 | 24 de dezembro de 2018 (atualizações de segurança até dezembro de 2021) |
|
3,7 | 31 de janeiro de 2018 | 27 de junho de 2020 (atualizações de segurança até Junho de 2023) |
|
3,8 | 14 de outubro de 2019 | Abril de 2021 (atualizações de segurança até Outubro de 2024) |
|
3,9 | 5 de outubro de 2020 | Maio de 2022 (atualizações de segurança até Outubro de 2025) |
|
As propostas de aprimoramento do Python (ou PEP: Proposta de aprimoramento do Python ) são documentos textuais que pretendem ser o caminho para o aprimoramento do Python e preceder todas as suas modificações. Um PEP é uma proposta de orientação para o desenvolvimento (processo PEP) , uma proposta técnica (Standard Track PEP) ou uma recomendação simples ( Informational PEP ). O PEP mais conhecido é o PEP 8 por seu guia de estilo de código.
Em 2009, é a versão 3 do Python, que substitui cada vez mais a versão 2 (o projeto era originalmente chamado de "Python 3000" ou "Py3K"), sem compatibilidade com a série de versões 2.x, a fim de eliminar as fragilidades do o idioma. A diretriz do projeto era "reduzir a redundância do Python removendo métodos obsoletos". Python 3.0a1, a primeira versão alfa, foi lançada em31 de agosto de 2007, e há um PEP que detalha as mudanças planejadas, bem como uma página para orientar os programadores na escolha do Python 2 ou 3.
Calculadoras destinadas a alunos do ensino médio (incluindo Casio , NumWorks , Texas Instruments ...) e que suportam o trabalho de Python em Python 3. Essas calculadoras podem trocar programas com computadores pessoais .
FilosofiaO Python 3 foi desenvolvido com a mesma filosofia de suas versões anteriores, portanto, qualquer referência à filosofia do Python também se aplicaria à versão 3. No entanto, a linguagem acabou acumulando vários métodos redundantes. Na tentativa de remover a redundância na linguagem e seus módulos, Python 3 segue a diretriz Python “Deve haver apenas um método que seja ideal e natural para tudo”.
Python 3 continua sendo uma linguagem multiparadigma. Os programadores ainda terão a escolha entre orientação a objetos, programação estruturada, programação funcional e outros paradigmas; O Python 3 deve ser usado de maneira mais natural do que nas versões 2.x, embora printexija o uso de parênteses, ao contrário do Python 2.
Planejamento e compatibilidadePython 3.0a1, a primeira versão alfa do Python 3.0, foi lançada em 31 de agosto de 2007. As versões 2.xe 3.x do Python serão lançadas em paralelo por vários ciclos de desenvolvimento, durante os quais a série 2.x permanecerá principalmente para compatibilidade, incluindo alguns recursos importados do Python 3.x. O PEP 3000 contém mais informações sobre o processo de lançamento de uma versão.
Como o Perl 6 , o Python 3.0 quebra a compatibilidade com versões anteriores (compatibilidade com versões anteriores). O uso de código escrito para a série 2.x não é garantido com Python 3.0. Este último traz mudanças fundamentais, como a mudança completa para Unicode e por isso uma distinção necessária entre strings e objetos "bytes". A tipagem dinâmica associada a certos métodos em objetos semelhantes a dicionário torna uma transição perfeita do Python 2.x para o Python 3.0 muito complicada. Uma ferramenta chamada "2to3" traduz a maior parte das versões 2.x para versões 3.x e indica as áreas do código que precisam ser finalizadas com comentários e avisos especiais. Em seu pré-lançamento, 2to3 parece ter sucesso francamente em conseguir uma tradução correta. Como parte da migração de Python 2.x para Python 3.x, o PEP 3000 recomenda manter o código original como base para modificações e traduzi-lo para a plataforma 3.x usando 2to3.
O Python 2.6 fornece um começo para compatibilidade com versões anteriores, bem como um modo "preventivo" que deve aumentar a conscientização sobre possíveis problemas de transição para a mudança para Python 3.
Existem versões do Python adequadas para Android e iPhone na versão 2.5 ou 2.6. Disponível em iOS Jailbreak no iOS graças às "ferramentas de configuração", e no Android graças ao SL4A que ainda dá a possibilidade de fazer pequenas interfaces gráficas graças ao módulo "android" e que permite enviar SMS , ligar a câmara, ou para vibrar o telefone. As próximas linhas mostram como fazer isso:
droid = android.Android() # client lié au serveur local lancé par l'application SL4A # pour contrôler un téléphone distant à l'adresse 192.168.0.5, avec SL4A lancé sur le port 9887 # il suffit de faire : android.Android('192.168.0.5', 9887) droid.vibrate(2.5) # fait vibrer le téléphone (local ou distant) pendant 2.5 secondesUma versão de Python em terminais Blackberry foi lançada emJunho de 2012, para o sistema BlackBerry OS 10. Uma versão mais leve foi lançada emsetembro de 2012, chamada de "BlackBerry-Tart", por causa de um trocadilho em inglês: " a" tart "é mais leve que uma" pie " ", em referência à tradicional " apple pie ". É baseado no Python 3.2.2.