




























































































Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Os melhores documentos à venda: Trabalhos de alunos formados
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Comunidade
Peça ajuda à comunidade e tire suas dúvidas relacionadas ao estudo
Descubra as melhores universidades em seu país de acordo com os usuários da Docsity
Guias grátis
Baixe gratuitamente nossos guias de estudo, métodos para diminuir a ansiedade, dicas de TCC preparadas pelos professores da Docsity
Tutorial de programação python traduzido por Python Brasil e escrito por Guido van Rossum e Frad L. Drake
Tipologia: Notas de estudo
1 / 118
Esta página não é visível na pré-visualização
Não perca as partes importantes!
http://pythonbrasil.com.br
Copyright © 2001-2004 Python Software Foundation. All rights reserved.
Copyright © 2000 BeOpen.com. All rights reserved.
Copyright © 1995-2000 Corporation for National Research Initiatives. All rights reserved.
Copyright © 1991-1995 Stichting Mathematisch Centrum. All rights reserved.
Tradução: Pedro Werneck, Osvaldo Santana Neto, José Alexandre Nalon, Felipe Lessa, Pedro de Medeiros, Rafael Almeida, Renata Palazzo, Rodrigo Senra e outros.
Revisão: Pedro Werneck, Osvaldo Santana Neto, Pedro de Medeiros.
Veja a parte final deste documento para informações mais completas sobre licenças e permissões.
Se alguma vez você já escreveu um extenso script de shell, provavelmente se sentiu assim: você adoraria adicionar mais uma característica, mas já está tão lento, e tão grande, e tão complicado; ou a nova característica implica numa chamada de sistema ou função só acessível a partir do C... Tipicamente o problema em questão não é sério o suficiente para motivar a re-escrita do script em C; talvez o problema exija cadeias de caracteres de comprimento variável ou tipos (como listas ordenadas de nomes de arquivos) que são fácilmente manipuláveis na shell, porém demandam muito esforço de implementação em C, ou talvez você nem esteja suficientemente familiarizado com C.
Outra situação: suponha que você tenha que trabalhar com diversas bibiotecas em C, e o típico ciclo escreve/compila/testa/re-compila seja muito lento. Você precisa desenvolver software de uma forma mais ágil. Ou, suponha que você escreveu um programa que precise fazer uso de uma linguagem de extensão, e você não quer projetar a linguagem, implementar e depurar um interpretador para ela, para só então estabelecer o vínculo com sua aplicação original.
Nestes casos, Python possivelmente é exatamente do que você está precisando. Python é simples de usar, sem deixar de ser uma linguagem de programação de verdade, oferecendo muito mais estruturação e suporte para programas extensos do que shell scripts oferecem. Por outro lado, Python também oferece melhor verificação de erros do que C, e por ser uma linguagem de alto nível , ela possui tipos nativos de alto nível: dicionários e vetores ( arrays ) flexíveis que lhe custariam dias para obter uma implementação eficiente em C. Devido ao suporte nativo a tipos genéricos, Python é aplicável a um domínio de problemas muito mais vasto do que Awk ou até mesmo Perl , ainda assim Python é tão fácil de usar quanto essas linguagens sob diversos aspectos.
Python permite que você organize seu programa em módulos que podem ser reutilizados em outros programas escritos em Python. A linguagem provê uma vasta coleção de módulos que podem ser utilizados como base para sua aplicação — ou como exemplos para estudo e aprofundamento. Alguns desses módulos implementam manip- ulação de arquivos, chamadas do sistema, sockets, e até mesmo acesso a bibiotecas de construção de interfaces gráficas, como Tk.
Python é uma linguagem interpretada, que pode fazer com que você economize um tempo considerável, uma vez que não há necessidade de compilação e vinculação( linking ) durante o desenvolvimento. O interpretador pode ser usado interativamente, o que torna fácil experimentar diversas características da linguagem, escrever programas “descartáveis”, ou testar funções em um desenvolvimento bottom-up. É também uma útil calculadora de mesa.
Python permite a escrita de programas compactos e legíveis. Programas escritos em Python são tipicamente mais curtos do que seus equivalentes em C ou C++, por diversas razões:
Python é extensível: se você sabe como programar em C, é fácil adicionar funções ou módulos diretamente no interpretador, seja para desempenhar operações críticas em máxima velocidade, ou para vincular programas Python a bibliotecas que só estejam disponívies em formato binário (como uma bibloteca gráfica de terceiros). Uma vez que você tenha sido fisgado, você pode vincular o interpretador Python a uma aplicação escrita em C e utilizá-la como linguagem de comandos ou extensão para esta aplicação.
A propósito, a linguagem foi batizada a partir do famoso show da BBC “Monty Python’s Flying Circus” e não tem nada a ver com repulsivos répteis. Fazer referências à citações do show na documentação não é só permitido, como também é encorajado!
Agora que você está entusiasmado com Python, vai desejar examiná-la com maior detalhe. Partindo do princípio que a melhor maneira de aprender uma linguagem é usando-a, você está agora convidado a fazê-lo com este tutorial.
No próximo capítulo, a mecânica de utilização do interpretador é explicada. Essa informação, ainda que mundana, é essencial para a experimentação dos exemplos apresentados mais tarde.
O resto do tutorial introduz diversos aspectos do sistema e linguagem Python por intermédio de exemplos. Serão abordadas expressões simples, comandos, tipos, funções e módulos. Finalmente, serão explicados alguns con- ceitos avançados como exceções e classes definidas pelo usuário.
2 Capítulo 1. Abrindo o Apetite
Observe que há uma diferença entre ‘python file’ e ‘python <file’. No último caso, chamadas do tipo input() e raw_input() serão satisfeitas a partir de file. Uma vez que file já foi inteiramente lido antes de que o script Python entrasse em execução, o programa encontrará o fim de arquivo (EOF) imediatamente. Já no primeiro caso, que é o mais frequente (provavelmente o que você quer), a entrada de dados será fornecida pelo dispositivo vinculado à entrada padrão do interpretador.
Quando um arquivo de script é utilizado, as vezes é útil ser capaz de executá-lo para logo em seguida entrar em modo interativo. Este efeito pode ser obtido pela adição do parâmetro - i antes do nome do script. (Observe que isto não irá funcionar se o script for lido a partir da entrada padrão, pelas mesmas razões explicadas no parágrafo anterior.)
Quando são de conhecimento do interpretador, o nome do script e subseqüentes parâmetros da linha de comando da shell são acessíveis ao próprio script através da variável sys.argv, que é uma lista de strings. Essa lista tem sempre ao menos um elemento; quando nenhum script ou parâmetro forem passados para o interpretador, sys.argv[0] será uma lista vazia. Quando o nome do script for ’-’ (significando entrada padrão), o conteúdo de sys.argv[0] será ’-’. Quando for utilizado -c command , sys.argv[0] conterá ’-c’. Quando for utilizado -m module , sys.argv[0] conterá o caminho completo do módulo localizado. Opções especificadas após -c command não serão consumidas pelo interpretador mas armazenadas em sys.argv.
Quando os comandos são lidos a partir do console ( tty ), diz-se que o interpretador está em modo interativo. Nesse modo ele requisita por um próximo comando através do prompt primário , tipicamente três sinais de maior-que (‘>>> ’); para linhas de continuação do comando corrente, o prompt secundário default são três pontos (‘... ’). O interpretador imprime uma mensagem de boas vindas, informando seu número de versão e uma nota legal de copyright antes de oferecer o primeiro prompt:
python Python 1.5.2b2 (#1, Feb 28 1999, 00:02:06) [GCC 2.8.1] on sunos Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
Linhas de continuação são necessárias em construções multi-linha. Como exemplo, dê uma olhada nesse comando if:
o_mundo_eh_plano = 1 if o_mundo_eh_plano: ... print "Cuidado para não cair fora dele!" ... Cuidado para não cair fora dele!
2.2 O Interpretador e seu Ambiente
Quando ocorre um erro, o interpretador imprime uma mensagem de erro e a situação da pilha (daqui em diante stack trace ). No modo interativo, retorna-se ao prompt primário; quando a entrada vem de um arquivo, o interpre- tador aborta sua execução com status de erro diferente de zero após imprimir o stack trace (Exceções tratadas por um except num bloco try não são consideradas erros neste contexto). Alguns erros são incondicionalmente fatais e causam a saída com status diferente de zero; isto se aplica a inconsistências internas e alguns casos de
4 Capítulo 2. Utilizando o Interpretador Python
exaustão de memória. Todas as mensagens de erro são escritas na saída de erros padrão ( standard error ), enquanto a saída dos demais comandos é direcionada para a saída padrão.
Teclando o caracter de interrupção (tipicamente Control-C ou DEL) no prompt primário ou secundário cancela a entrada de dados corrente e retorna-se ao prompt primário. 1 Provocando uma interrupção enquanto um comando está em execução levanta a exceção KeyboardInterrupt, a qual pode ser tratada em um bloco try.
Em sistemas UNIXBSD, scripts Python podem ser transformados em executáveis, como shell scripts, pela inclusão do cabeçalho
#! /usr/bin/env python
(Assumindo que o interpretador foi incluído do caminho de busca do usuário (PATH)) e que o script tenha a permissão de acesso habilitada para execução. O ‘#!’ deve estar no início do arquivo .Em algumas plataformas esta linha inicial deve ser finalizada no estilo UNIX-style com (‘\n’), ao invés do estlo Mac OS (‘\r’) ou mesmo a terminação típica do Windows (‘\r\n’). Observe que o caracter ‘#’ designa comentários em Python.
Para atribuir permissão de execução (plataforma Unix) ao seu script Python, utilize o comando chmod :
$ chmod +x meuscript.py
É possível usar codificação diferente de ASCII() em arquivos de código Python. A melhor maneira de fazê-lo é através de um comentário adicional logo após a linha #!:
Com essa declaração, todos os caracteres no código-fonte serão tratados como encoding , mas será possível es- crever strings Unicode diretamente. A lista de codificações possíveis pode ser encontrada na Referência da Bib- lioteca Python , na seção codecs.
Por exemplo, para escrever strings unicode incluindo o símbolo monetário para o Euro, ISO-8859-15 pode ser usado, com o símbolo tendo o valor 164. Este script exibirá o valor 8364 (Unicode correspondente ao símbolo do Euro) e retornar:
currency = u" " print ord(currency)
Se o seu editor é capaz de salvar arquivos UTF-8 com um byte order mark (conhecido como BOM), você pode usá-lo ao invés da declaração de codificação. O IDLE é capaz de fazer isto se Options/General/Default Source Encoding/UTF-8 estiver habilitado. Note que esta assinatura não é reconhecida por versões antigas (Python 2.2 e anteriores), e pelo sistema operacional para arquivos com a declaração #! (usada somente em sistemas UNIX).
Usando UTF-8 (seja através da assinatura ou de uma declaração de codificação), caracteres da maioria das línguas do mundo podem ser usados simultaneamente em strings e comentários. Não é possível usar caracteres não-ASCII em identificadores. Para exibir todos esses caracteres adequadamente, seu editor deve reconhecer que o arquivo é UTF-8, e deve usar uma fonte que tenha todos os caracteres usados no arquivo.
(^1) Um problema com o pacote Readline da GNU evita isso
2.2. O Interpretador e seu Ambiente 5
Nos exemplos seguintes, pode-se distinguir a entrada da saída pela presença ou ausência dos prompts (‘>>> ’ and ‘... ’): para repetir o exemplo, você deve digitar tudo após o prompt, quando o mesmo aparece; linhas que não começarem com o prompt são na verdade as saídas geradas pelo interpretador.
Observe que existe um segundo prompt indicando a linha de continuação de um comando com múltiplas linhas, o qual pode ser encerrado pela digitação de um linha em branco.
Muitos dos exemplos neste manual, até mesmo aqueles digitados interativamente, incluem comentários. Comen- tários em Python são delimitados pelo caracter ‘#’, e se extendem até o final da linha. Um comentário pode aparecer no início da linha, depois de um espaço em branco ou código, mas nunca dentro de uma string (literal). O delimitar de comentário dentro de uma string é interpretado como o próprio caracter.
Alguns exemplos:
SPAM = 1 # e esse é o segundo comentário
STRING = "# Este não é um comentário."
Vamos tentar alguns comandos simples em Python. Inicie o interpretador e aguarde o prompt primário, ‘>>> ’. (Não deve demorar muito.)
O interpretador atua como uma calculadora bem simples: você pode digitar uma expressão e o valor resultando será apresentado após a avaliação da expressão. A sintaxe da expressão é a usual: operadores +, - , * e / funcionam da mesma forma que em outras linguagens tradicionais (por exemplo, Pascal ou C); parênteses podem ser usados para definir agrupamentos. Por exemplo:
2+ 4
Isso é um comentário
... 2+ 4
2+2 # e um comentário na mesma linha de um comando 4 (50-5*6)/ 5
Divisão inteira retorna com aredondamento para base
... 7/ 2
7/-
O sinal de igual (‘=’) é utilizado para atribuição de um valor a uma variável. Nenhum resultado é exibido até o próximo prompt interativo:
width = 20 height = 5* width * height 900
Um valor pode ser atribuído a diversas variáveis simultaneamente:
x = y = z = 0 # Zero x, y e z x 0 y 0 z 0
Há total suporte para ponto-flutuante; operadores com operandos de diferentes tipos convertem o inteiro para ponto-flutuante:
3 * 3.75 / 1.
7.0 / 2
Números complexos também são suportados; números imaginários são escritos com o sufixo ‘j’ ou ‘J’. Números complexos com parte real não nula são escritos como ‘( real + imag j)’, ou podem ser criados pela chamada de função ‘complex( real , imag )’.
8 Capítulo 3. Uma Introdução Informal a Python
’spam eggs’ ’spam eggs’ ’doesn\’t’ "doesn’t" "doesn’t" "doesn’t" ’"Yes," he said.’ ’"Yes," he said.’ ""Yes," he said." ’"Yes," he said.’ ’"Isn\’t," she said.’ ’"Isn\’t," she said.’
Strings que contém mais de uma linha podem ser construídas de diversas maneiras. Terminadores de linha podem ser embutidos na string com barras invertidas, ex.:
oi = "Esta eh uma string longa contendo\n
diversas linhas de texto assim como voce faria em C.\n
Observe que os espaços em branco no inicio da linha são
significativos." print oi
Observe que terminadores de linha ainda precisam ser embutidos na string usando \n; a quebra de linha após a última barra de escape seria ignorada. Este exemplo produziria o seguinte resultado:
Esta eh uma string longa contendo diversas linhas de texto assim como voce faria em C. Observe que os espaços em branco no inicio da linha são significativos.
No entanto, se a tornarmos uma string “crua” ( raw ), as sequências de \n não são convertidas para quebras de linha. Tanto a barra invertida quanto a quebra de linha no código-fonte são incluídos na string como dados. Portanto, o exemplo:
oi = r"Esta eh uma string longa contendo\n
diversas linhas de texto assim como voce faria em C.\n
Observe que os espaços em branco no inicio da linha são
significativos."
print oi
teria como resultado:
Esta eh uma string longa contendo\n
diversas linhas de texto assim como voce faria em C.\n
Observe que os espaços em branco no inicio da linha são
significativos
Ou, strings podem ser delimitadas por pares de aspas tríplices: " ou ’’’. Neste caso não é necessário embutir terminadores de linha, pois o texto da string será tratado verbatim.
print """ Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to """
10 Capítulo 3. Uma Introdução Informal a Python
produz a seguinte saída:
Usage: thingy [OPTIONS] -h Display this usage message -H hostname Hostname to connect to
O interpretador imprime o resultado de operações sobre strings da mesma forma que as strings são formatadas na digitação: dentro de aspas, e com caracteres especiais embutidos em escape sequences , para mostar seu valor com precisão. A string será delimitada por aspas duplas se ela contém um único caracter de aspas simples e nenhum de aspas duplas, caso contrário a string será delimitada por aspas simples. ( O comando print, descrito posteriormente, pode ser utilizado para escrever strings sem aspas ou escape sequences .)
Strings podem ser concatenadas (coladas) com o operador +, e repetidas com *:
word = ’Help’ + ’A’ word ’HelpA’ ’<’ + word*5 + ’>’ ’
’
Duas strings literais justapostas são automaticamente concatenadas; a primeira linha do exemplo anterior poderia ter sido escrita como ‘word = ’Help”A’’; isso funciona somente com strings literais, não com expressões arbitrárias:
’str’ ’ing’ # <- This is ok ’string’ str.strip(’str’) + ’ing’ # <- This is ok ’string’ str.strip(’str’) ’ing’ # <- This is invalid File "
", line 1 str.strip(’str’) ’ing’ ^ SyntaxError: invalid syntax
Strings podem ser indexadas; como em C, o primeiro índice da string é o 0. Não existe um tipo separado para caracteres; um caracter é simplesmente uma string unitária. Assim como na linguagem Icon, substrings podem ser especificadas através da notação slice (N.d.T: fatiar): dois índices separados por dois pontos.
word[4] ’A’ word[0:2] ’He’ word[2:4] ’lp’
Índices de fatias slice seguem uma padronização útil; a omissão do primeiro índice equivale a zero, a omissão do segundo índice equivale ao tamanho da string sendo fatiada.
word[:2] # Os dois primeiros caracteres ’He’ word[2:] # Tudo exceto os dois primeiros caracteres ’lpA’
Diferentemente de C, strings não podem ser alteradas em Python. Atribuir para uma posição (índice) dentro de uma string resultará em erro:
3.1. Utilizando Python Como Uma Calculadora 11
word[-100:] ’HelpA’ word[-10] # error Traceback (most recent call last): File "
", line 1 IndexError: string index out of range
A melhor maneira de lembrar como slices funcionam é pensar nos índices como ponteiros para os espaços entre caracteres, onde a beirada esquerda do primeiro caracter é 0. Logo a beirada direita do último caracter de uma string de comprimento n tem índice n , por exemplo:
+---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -
A primeira fileira de números indica a posição dos índices 0..5 na string; a segunda fileira indica a posição dos respectivos índices negativos. Um slice de i até j consiste em todos os caracteres entre as beiradas i e j , respecti- vamente.
Para índices positivos, o comprimento do slice é a diferença entre os índices, se ambos estão dentro dos limites da string, ex, o comprimento de word[1:3] é 2.
A função interna (N.d.T: interna == built-in ) len() devolve o comprimento de uma string:
s = ’supercalifragilisticexpialidocious’ len(s) 34
See Also:
Sequências (../lib/typesseq.html) Strings, e strings Unicode, descritas na próxima seção, são exemplos de sequências e suportam as operações comuns associadas com esses objetos.
Métodos de Strings (../lib/string-methods.html) Tanto strings comuns quanto Unicode suportam um grande número de métodos para busca e transformação.
Operações de Formatação de Strings (../lib/typesseq-strings.html) As operações de formatação em que strings 8-bits e Unicode são o operando à esquerda do operador % são descritas em mais detalhes aqui.
A partir de Python 2.0 um novo tipo foi introduzido: o objeto Unicode. Ele pode ser usado para armazenar e manipular dados Unicode (veja http://www.unicode.org/) e se integra bem aos demais objetos strings pré-existentes, de forma a realizar auto-conversões quando necessário.
Unicode tem a vantagem de prover um único número ordinal para cada caracter usado em textos modernos ou antigos. Previamente, havia somente 256 números ordinais. Logo, mapeamentos entre conjuntos de caracteres e os 256 números ordinais precisavam ser indexados por códigos de página. Isso levou a uma enorme confusão especialmente no âmbito da internacionalização (tipicamente escrito como ‘i18n’ – ‘i’ + 18 caracteres + ‘n’) de software. Unicode resolve esses problemas ao definir um único código de página para todos os conjuntos de caracteres.
3.1. Utilizando Python Como Uma Calculadora 13
Criar strings Unicode em Python é tão simples quanto criar strings normais:
u’Hello World !’ u’Hello World !’
O pequeno ‘u’ antes das aspas indica a criação de uma string Unicode. Se você desejar incluir caracteres especiais na string, você pode fazê-lo através da codificação Python Unicode-Escape.
u’Hello\u0020World !’ u’Hello World !’
O código de escape \u0020 indica a inserção do caracter Unicode com valor ordinal 0x0020 (o espaço em branco) na posição determinada.
Os outros caracteres são interpretados através de seus respectivos valores ordinais diretamente para os valores ordinais em Unicode. Se você possui strings literais na codificação padrão Latin-1 que é utilizada na maioria do oeste europeu, você achará conveniente que os 256 caracteres inferiores do Unicode coincidem com os 256 caracteres inferiores do Latin-1.
Para experts, existe ainda um modo cru (N.d.T: sem processamento de caracteres escape) da mesma forma que existe para strings normais. Basta prefixar a string com ’ur’ para utilizar a codificação Python Raw-Unicode- Escape. Só será aplicado a conversão \uXXXX se houver um número ímpar de barras invertidas antes do escape ’u’.
ur’Hello\u0020World !’ u’Hello World !’ ur’Hello\u0020World !’ u’Hello\\u0020World !’
O modo cru (N.d.T: raw ) é muito útil para evitar excesso de barras invertidas, por exemplo, em expressões regu- lares.
Além dessas codificações padrão, Python oferece um outro conjunto de maneiras de se criar strings Unicode sobre uma codificação padrão.
A função interna unicode() provê acesso a todos os Unicode codecs registrados (COders and DECoders).
Alguns dos mais conhecidos codecs são : Latin-1 , ASCII , UTF-8 , and UTF-16. Os dois últimos são codificações de tamanho variável para armazenar cada caracter Unicode em um ou mais bytes. A codificação default é ASCII, que trata normalmente caracteres no intervalo de 0 a 127 mas rejeita qualquer outro com um erro. Quando uma string Unicode é impressa, escrita em arquivo ou convertida por str(), a codificação padrão é utilizada.
u"abc" u’abc’ str(u"abc") ’abc’ u"äöü" u’\xe4\xf6\xfc’ str(u"äöü") Traceback (most recent call last): File "
", line 1, in? UnicodeEncodeError: ’ascii’ codec can’t encode characters in position 0-2: ordinal not in range(128)
Para se converter uma string Unicode em uma string 8-bits usando uma codificação específica, basta invocar o método encode() de objetos Unicode passando como parâmetro o nome da codificação destino. É preferível utilizar nomes de codificação em letras minúsculas.
14 Capítulo 3. Uma Introdução Informal a Python