Learn Scratch 05

Instituto Federal de Educação, Ciência e Tecnologia da Paraíba
Campus de Campina Grande

Curso: Tecnologia em Telemática Semestre: 1°
Período
Disciplina: Algoritmos e Lógica de Programação
Letivo:
Tutorial de python versão 3.1 2010.1
Python é fácil de aprender, poderosa linguagem de programação. Tem eficientes

estruturas de dados de alto nível e uma abordagem simples, mas eficazes para a programação
orientada a objeto. sintaxe elegante Python e tipagem dinâmica, juntamente com a sua
natureza interpretada, tornam uma linguagem ideal para scripting e desenvolvimento rápido
de aplicações em muitas áreas, na maioria das plataformas.
O interpretador Python e extensa biblioteca padrão estão disponíveis gratuitamente

em formato binário ou fonte para todas as principais plataformas do site Python,
http://www.python.org/, e pode ser distribuído gratuitamente. O mesmo site também contém
distribuições e referências para muitos módulos de terceiros Python livre, programas e
ferramentas e documentação adicional.
O interpretador Python pode ser facilmente estendido com novas funções e tipos de
dados implementados em C ou C + + (ou outros idiomas que pode ser chamado de C). Python
também é indicado como uma linguagem de extensão para aplicações personalizável.
Este tutorial introduz o leitor informalmente aos conceitos básicos e as

características da linguagem Python e do sistema. Ela ajuda a ter um interpretador Python útil
para hands-on experiência, mas todos os exemplos são auto-suficientes, de modo que o
tutorial pode ser lido off-line também.
Para obter uma descrição de objetos padrão e módulos, consulte o Python Standard
Library. O Python Language Reference dá uma definição mais formal da língua. Para escrever
extensões em C ou C + +, leia Extendendo e incorporação do interpretador Python e Python / C
API Reference Manual. Há também vários livros abrangendo Python em profundidade.
Este tutorial não pretende ser abrangente e cobrir todas as características

individuais, ou mesmo todos os recursos usados. Em vez disso, ele introduz muitas das
características mais marcantes do Python, e lhe dará uma boa idéia do sabor da linguagem e
estilo. Depois de lê-lo, você será capaz de ler e escrever módulos Python e programas, e você
estará pronto para aprender mais sobre a biblioteca Python vários módulos descrita na norma
Python Library.
O Glossário também vale a atravessar.
TUTORIAL PYTHON 3.1 Português

* 1. Abrindo seu apetite
* 2. Usando o interpretador Python
o 2.1. Invocando o Interpretador
+ 2.1.1. Argumento passando
+ 2.1.2. Interactive Mode
o 2.2. O Intérprete e Seu Ambiente
+ 2.2.1. Tratamento de erro
+ 2.2.2. Executável Scripts Python
+ 2.2.3. O código-fonte Encoding
+ 2.2.4. O arquivo de inicialização Interactive
* 3. Uma Introdução Informal a Python
o 3.1. Usando Python como uma calculadora
+ 3.1.1. Números
+ 3.1.2. Strings
+ 3.1.3. Sobre Unicode
+ 3.1.4. Listas
o 3.2. Primeiros passos rumo a programação
* 4. Mais Ferramentas de Controle de Fluxo
o 4.1. if
o 4.2. para instruções
o 4.3. A função range ()
o 4.4. break e continue, e mais cláusulas de Loops
o 4.5. passar Demonstrações
o 4.6. Definindo Funções
o 4.7. Mais sobre Definição de Funções
+ 4.7.1. Argumento Valores Default
+ 4.7.2. Argumentos palavra-chave
+ 4.7.3. Arbitrário listas de argumento
+ 4.7.4. Descompactando listas de argumento
+ 4.7.5. Lambda Forms
+ 4.7.6. Documentação Strings
o 4.8. Intermezzo: Estilo de Codificação
* 5. Estruturas de Dados
o 5.1. Mais informações sobre listas
+ 5.1.1. Usando Listas como pilhas
+ 5.1.2. Usando listas de filas
+ 5.1.3. Lista de compreensões
+ 5.1.4. Compreensões lista aninhada
o 5.2. A declaração del
o 5.3. Tuplas e Sequências
o 5.4. Sets
o 5.5. Dicionários
o 5.6. Looping Técnicas
o 5.7. Mais informações sobre as Condições

o 5.8. Comparando Sequências e Outros Tipos
* 6. Módulos
o 6.1. Mais informações sobre os módulos
+ 6.1.1. Execução de módulos de scripts
+ 6.1.2. O Caminho Módulo Pesquisa
+ 6.1.3. "Elaboração" Python arquivos
o 6.2. Standard Módulos
o 6.3. A função Dir ()
o 6.4. Pacotes
+ 6.4.1. * Importação de um pacote
+ 6.4.2. Referências pacote intra-
+ 6.4.3. Pacotes em vários diretórios
* 7. Entrada e Saída
o 7.1. Criadores de formatação de saída
+ 7.1.1. Old seqüência de formatação
o 7.2. Leitura e escrita de arquivos
+ 7.2.1. Métodos de objetos File
+ 7.2.2. O módulo pickle
* 8. Erros e Exceções
o 8.1. Erros de sintaxe
o 8.2. Exceções
o 8.3. Tratamento de Exceções
o 8.4. Levantando Exceções
o 8.5. Exceções definidas pelo usuário
o 8.6. Definindo Ações de Limpeza
o 8.7. Predefinidos Clean-up Ações
* 9. Classes
o 9.1. Uma palavra sobre nomes e objetos
o 9.2. Scopes e Python Namespaces
+ 9.2.1. Exemplo Escopos e Espaços
o 9.3. Um primeiro olhar em Classes
+ 9.3.1. Classe A sintaxe de definição
+ 9.3.2. Classe de objetos
+ 9.3.3. Instância Objects
+ 9.3.4. Método Objects
o 9.4. Random Observações
o 9.5. Herança
+ 9.5.1. Herança múltipla
o 9.6. Private Variáveis
o 9.7. Miudezas
o 9.8. Exceções são classes Too
o 9.9. Iterators
o 9.10. Geradores
o 9.11. Generator Expressions
* 10. Breve Passeio da biblioteca padrão

o 10.1. Interface do sistema operacional
o 10.2. Arquivo Wildcards
o 10.3. Argumentos da Linha de Comando
o 10.4. Erro de redirecionamento de saída e término do programa
o 10.5. String Pattern Matching
o 10.6. Matemática
o 10.7. Acesso à Internet
o 10.8. Datas e horários
o 10.9. Compressão de dados
o 10h10. Medição de Desempenho
o 10,11. Controle de Qualidade
o 10.12. Baterias Incluídas
* 11. Breve Passeio da Biblioteca Padrão - Parte II
o 11.1. Saída de formatação
o 11.2. Templating
o 11.3. Trabalhando com dados binários Record Layouts
o 11.4. Multi-threading
o 11.5. Logging
o 11.6. Referências Weak
o 11.7. Ferramentas para trabalhar com listas
o 11.8. Decimal Floating Point Arithmetic
* 12. E agora?
* 13. Interactive Edição de entrada e de substituição História
o 13.1. Line Edição
o 13.2. História de substituição
o 13.3. Teclas
o 13.4. Alternativas para o interpretador interativo
* 14. Questões aritméticas em ponto flutuante: Limitações e
o 14.1. Representação de erro .
1. Abrindo seu apetite
Se você faz muito trabalho em computadores, eventualmente você achar que há alguma tarefa
que você gostaria de automatizar. Por exemplo, talvez você queira realizar uma pesquisa e
substituir por um grande número de arquivos de texto, ou renomear e reorganizar um monte
de arquivos de fotos em um caminho complicado. Talvez você gostaria de escrever um
pequeno banco de dados personalizado, ou um aplicativo GUI especializado, ou um simples
jogo.
Se você for um desenvolvedor de software profissional, você pode ter que trabalhar com
vários C / C bibliotecas / Java, mas encontrar a usual escrever / compile / teste / re-compile
ciclo é muito lento. Talvez você está escrevendo um conjunto de testes para tal uma biblioteca
e encontrar escrever o código de teste uma tarefa tediosa. Ou talvez você tenha escrito um

programa que poderia usar uma linguagem de extensão, e você não quer para conceber e
implementar uma nova linguagem para sua aplicação.
Python é apenas a língua para você.
Você pode escrever um script shell Unix ou Windows arquivos em lote para algumas dessas
tarefas, mas scripts shell são melhores movendo arquivos e alterar dados de texto, não é bem
adequado para aplicações gráficas e jogos. Você pode escrever um C / C / programa em Java,
mas pode levar muito tempo de desenvolvimento para obter ainda um projecto de programa
de primeira. Python é simples de usar, disponível para Windows, Mac OS X e sistemas
operacionais Unix, e vai ajudá-lo a começar o trabalho feito mais rapidamente.
Python é simples de usar, mas é uma linguagem de programação, oferecendo muito mais
estrutura e apoio a grandes programas de shell scripts ou arquivos em lote pode oferecer. Por
outro lado, Python também oferece a verificação de erros muito mais do que C, e sendo uma
linguagem de muito alto nível, tem tipos de dados de alto nível, integrada, tais como matrizes
flexíveis e dicionários. Devido ao seu carácter mais geral de tipos de dados Python é aplicável a
um domínio de problema muito maior do que Awk ou até mesmo Perl, mas muitas coisas são,
pelo menos, tão fácil em Python como em outras línguas.
Python permite dividir seu programa em módulos que podem ser reutilizados em outros
programas Python. Ele vem com uma grande coleção de módulos-padrão que você pode usar
como base de seus programas - ou como exemplos para começar a aprender a programar em
Python. Alguns destes módulos oferecem coisas como arquivo I / O chamadas de sistema,
sockets, e até mesmo interfaces de toolkits de interface gráfica do usuário como Tk.
Python é uma linguagem interpretada, que você pode economizar tempo considerável durante
o desenvolvimento do programa porque não compilação e ligação é necessária. O intérprete
pode ser usado interativamente, o que torna a experiência mais fácil com as características da
linguagem, escrever programas usar e deitar fora, ou para testar as funções durante o
desenvolvimento do programa de baixo para cima. É também uma calculadora de mesa à mão.
Python permite que os programas a serem gravados e lidos de forma compacta. Programas
escritos em Python são tipicamente muito menor do que equivalente C, C, ou de programas
Java, por várias razões:
* Os tipos de alto nível, os dados permitem que você expresse operações complexas em
uma única instrução;
* Agrupamento declaração é feita por identação ao invés de início e término entre
parênteses;
* As declarações nenhuma variável ou argumento são necessárias.
Python é extensível: se você sabe programar em C é fácil adicionar uma nova função interna
ou módulo para o intérprete, seja para desempenhar operações críticas em máxima
velocidade, ou para vincular programas Python a bibliotecas que só poderá ser em formato

binário (como uma biblioteca de gráficos específicos do fornecedor). Uma vez que você está
realmente viciado, você pode vincular o interpretador Python em um aplicativo escrito em C e
utilizá-lo como uma extensão ou uma linguagem de comando para o aplicativo.
By the way, a linguagem é nomeado após o show da BBC "Monty Python's Flying Circus" e não
tem nada a ver com répteis. Fazendo referências a esquetes de Monty Python na
documentação não é apenas permitido, é encorajado!
Agora que você está todo animado sobre Python, você vai querer examiná-lo em alguns
detalhes. Desde que a melhor maneira de aprender uma língua é usá-lo, o tutorial convida-o a
brincar com o interpretador Python que você lê.
No próximo capítulo, a mecânica de usar o interpretador é explicada. Esta informação é

bastante mundano, mas essencial para experimentar os exemplos mostrados posteriormente.
O resto do tutorial introduz várias características da linguagem Python e do sistema através de

exemplos, começando com simples expressões, declarações e tipos de dados, através de
funções e módulos e, finalmente, tocar em cima de conceitos avançados como exceções e
classes definidas pelo usuário.
2. Usando o interpretador Python

2.1. Invocando o Interpreter
O interpretador Python é geralmente instalado em / usr/local/bin/python3.1 sobre aquelas

máquinas onde se encontra disponível, colocando / usr / local / bin no caminho de seu shell do
Unix pesquisa torna possível para iniciá-lo, digitando o comando
python3.1
para o shell. [1] Desde a escolha do diretório onde vive o intérprete é uma opção de
instalação, outros locais são possíveis, verifique com seu guru local de Python ou
administrador do sistema. (Ex.: / usr / local / python é uma localização alternativa popular.)
Em máquinas Windows, a instalação do Python é normalmente colocado em C: \ Python31,

mas você pode alterar isso quando você estiver executando o instalador. Para adicionar esse
diretório ao seu caminho, você pode digitar o seguinte comando no prompt de comando em
uma caixa de DOS:
% Path set path =%; C: \ python31
Digitar um caractere de fim-de-arquivo (Control-D em Unix, Control-Z em Windows) para as

causas primárias prompt do interpretador a sair com um status de saída zero. Se isso não
funcionar, você pode sair do interpretador, digitando o seguinte comando: quit ().

O intérprete de recursos de edição de linha geralmente não são muito sofisticados. Em Unix,
quem instalou o intérprete pode ter habilitado o suporte para a biblioteca readline GNU, que
adiciona mais elaborado edição interactiva e histórico. Talvez o mais rápido verificar se a
edição de linha de comando é suportado está digitando Control-P para o Python primeiro
prompt que você começa. Se ele apita, tem edição de linha de comando, ver apêndice
Interactive Input Editando História e substituição de uma introdução para as chaves. Se nada
parece acontecer, ou se ^ P é ecoado, edição de linha de comando não está disponível, você só
vai poder usar backspace para remover caracteres da linha atual.
O intérprete atua tanto como o shell do Unix: quando chamado com entrada padrão
conectado a um dispositivo tty, ele lê e executa comandos interativamente; quando chamado
com um argumento de nome de arquivo ou com um arquivo como entrada padrão, ele lê e
executa um script que arquivo.
Uma segunda maneira de começar o intérprete de comando python-c [arg] ..., que executa a
instrução (s) no comando, análoga à opção c do shell. Uma vez que geralmente contêm
declarações Python espaços ou outros caracteres que são especiais para o shell, que é
geralmente aconselhada para citar comando em sua totalidade com aspas simples.
Alguns módulos Python são também úteis como scripts. Estes podem ser chamados usando o
módulo python-m [arg] ..., que executa o arquivo de origem para o módulo como se você
tivesse escrito o seu nome completo na linha de comando.
Observe que há uma diferença entre o arquivo python e <python arquivo. Neste último caso,
as solicitações de entrada do programa, como chamar sys.stdin.read (), são cumpridos de
arquivo. Uma vez que este arquivo já foi lido até o fim pelo analisador antes de o programa
inicia a execução, o programa vai encontrar fim-de-arquivo imediatamente. No primeiro caso
(que é geralmente o que você quiser) estão satisfeitos a partir de qualquer arquivo ou
dispositivo está conectado à entrada padrão do interpretador Python.
Quando um arquivo de script é utilizado, às vezes é útil para ser capaz de executar o script e
depois entrar em modo interativo. Isso pode ser feito passando-i antes do script. (Isso não
funciona se o script é lida da entrada padrão, pela mesma razão, como explicado no parágrafo
anterior).
2.1.1. Argumento passando
Quando conhecido o intérprete, o nome do script e depois argumentos adicionais são

passados para o script no sys.argv variável, que é uma lista de strings. Seu comprimento é pelo
menos um, quando nenhum script e nenhum argumento é dado, sys.argv [0] é uma seqüência
vazia. Quando o nome do script é dada como '-' (significando entrada padrão), sys.argv [0] é
definido como '-'. Quando o comando-c é usado, sys.argv [0] é definido como 'c'. Quando o
módulo-M é usado, sys.argv [0] é definido como o nome completo do módulo localizado.
Opções encontradas após o comando-c ou-m módulo não são consumidos pelo
processamento do interpretador Python é opção, mas deixou em sys.argv para o comando ou

módulo de manusear.
2.1.2. Interactive Mode
Quando os comandos são lidos a partir de um terminal, o intérprete está a ser dito em modo
interativo. Neste modo, ela pede para o próximo comando do prompt primário, geralmente
três maior do que sinais (>>>); para linhas de continuação pede com o prompt secundário, por
padrão, três pontos (...). O interpretador imprime uma mensagem de boas vindas informando
seu número de versão e um aviso de direitos autorais antes de imprimir o primeiro prompt:
$ Python3.1
Python 3.1 (Py3k, 12 de setembro de 2007, 00:21:02)
[GCC 3.4.6 20060404 (Red Hat 3.4.6-8]) em linux2
Digite "help", "copyright", "credits" ou "licença" para mais informações.
>>>
Linhas de continuação são necessárias quando entrar em um multi-line construir. Como

exemplo, dê uma olhada nesta declaração quando:
>> The_world_is_flat> = 1
>>> The_world_is_flat se:
... print ("Tenha cuidado para não cair!")
...
Tenha cuidado para não cair!
2.2. The Interpreter e Seu Ambiente

2.2.1. Tratamento de erro
Quando ocorre um erro, o interpretador imprime uma mensagem de erro e um rastreamento

de pilha. No modo interativo, em seguida, retorna ao prompt primário, quando a entrada vem
de um arquivo, ele sai com um status de saída diferente de zero após imprimir o stack trace.
(Exceções tratadas por um salvo cláusula em uma declaração tentar não são erros neste
contexto.) Alguns erros são incondicionalmente fatais e causam a saída com uma saída
diferente de zero, isto aplica-se a inconsistências internas e alguns casos de falta de memória.
Todas as mensagens de erro são escritas para o fluxo de erro padrão; saída normal de
comandos executados é escrito na saída padrão.
Digitando o caráter de interrupção (normalmente Control-C ou DEL) à cancela primária ou

secundária prompt de entrada e retorna ao prompt primário. [2] Escrever uma interrupção
enquanto um comando está sendo executado levanta a exceção KeyboardInterrupt, que pode
ser manipulado por um try.
2.2.2. Scripts Python executáveis
Em sistemas Unix BSD'ish, scripts Python podem ser feitas diretamente executáveis, como
shell scripts, colocando a linha

#! / Usr / bin / env python3.1
(Assumindo que o intérprete está no PATH do usuário) no início do script e dar o arquivo de
um modo executável. O #! devem ser os dois primeiros caracteres do arquivo. Em algumas
plataformas, essa primeira linha deve terminar com uma linha no estilo Unix final ('\ n'), e não
um Windows ('\ n \ r') que termina linha. Observe que o hash, ou a libra, o caráter, "#", é
usado para iniciar um comentário em Python.
O script pode ser dado um modo executável, ou permissão, usando o comando chmod:
$ Chmod + x myscript.py
Em sistemas Windows, não há noção de um modo "executável". O instalador do Python

associa automaticamente arquivos. Py com python.exe de modo que um clique duplo sobre
um arquivo Python irá executá-lo como um script. A extensão também pode ser. Pyw, nesse
caso, a janela do console, que normalmente aparece é suprimida.
2.2.3. O código-fonte Encoding
Por padrão, os arquivos-fonte em Python são tratados como codificados em UTF-8. Em que a
codificação, os caracteres da maioria das línguas do mundo podem ser usados
simultaneamente em strings literais, os identificadores e comentários - apesar de a biblioteca
padrão usa apenas caracteres ASCII para identificadores, uma convenção que qualquer código
portátil deve seguir. Para exibir todos esses caracteres corretamente, seu editor deve
reconhecer que o arquivo é UTF-8, e deve usar uma fonte que suporta todos os caracteres no
arquivo.
Também é possível especificar uma codificação diferente para os arquivos fonte. Para fazer
isso, coloque mais uma linha de comentário especial direita após o #! linha para definir o
arquivo de origem de codificação:
# -*- Coding: -*- encoding
Com essa declaração, tudo no arquivo de origem será tratado como tendo a codificação em
vez de codificação UTF-8. A lista de codificações possíveis pode ser encontrada na Biblioteca
de Referência Python, na seção codecs.
Por exemplo, se o seu editor de escolha não suporta UTF-8 arquivos codificados e insiste em
usar alguma outra codificação, por exemplo, Windows 1252, você pode escrever:
# -*- Coding: cp-1252 -*-
e ainda utilizar todos os caracteres da personagem Windows-1252 em conjunto os arquivos de

origem. O comentário de codificação especial deve ser na primeira ou segunda linha dentro do
arquivo.
2.2.4. O arquivo de inicialização Interactive

Quando você usa Python interativamente, é frequentemente útil para ter um padrão
comandos executados toda vez que o intérprete é iniciado. Você pode fazer isso definindo
uma variável de ambiente denominada PYTHONSTARTUP com o nome de um arquivo
contendo os comandos de start-up. Isso é semelhante ao. Característica do perfil do shell do
Unix.
Este arquivo é somente leitura em sessões interativas, e não quando Python lê comandos de
um script, e não quando o / dev / tty é dado como a fonte explícita de comandos (que de outra
forma se comporta como uma sessão interativa). Ele é executado no mesmo namespace onde
comandos interativos são executadas, de modo que os objetos que ele define ou importação
podem ser usados sem qualificação na sessão interativa. Você também pode alterar as
instruções sys.ps1 e sys.ps2 neste arquivo.
Se você quiser ler um arquivo adicional start-up do diretório atual, você pode programar isso
no global start-up de arquivos usando o código como se os.path.isfile ('. Pythonrc.py): exec
(open (' . pythonrc.py). read ()). Se você quiser usar o arquivo de inicialização em um script,
você deve fazer isso de forma explícita no script:
OS importação
filename = os.environ.get ('PYTHONSTARTUP)
se filename e os.path.isfile (filename):
exec (open (filename). read ())
Notas de Rodapé
[1] Em Unix, o interpretador Python 3.x é instalado por padrão, não com o python executável
nomeado, para que não entre em conflito com o Python 2.x instalado simultaneamente
executável.
[2] Um problema com o pacote GNU Readline pode impedir isso.
3. Uma Introdução Informal a Python ¶
Nos exemplos a seguir, a entrada e saída são distinguidos pela presença ou ausência de avisos
(>>> e ...): a repetir o exemplo, você deve digitar tudo após o prompt linhas, quando aparece o
prompt; que não começam estão com uma saída rápida do interpretador. Observe que um
prompt secundário em uma linha por si só em um exemplo significa que você deve digitar uma
linha em branco, o que é usado para terminar um comando multi-linha.
Muitos dos exemplos neste manual, inclusive aqueles inscritos no prompt interativo inclui,
comenta. Comentários em Python começar com o cardinal, #, e se estendem até o final da
linha física. Um comentário pode aparecer no início de uma linha ou na sequência de espaços
em branco ou código, mas não dentro de uma seqüência literal. Um personagem hash dentro
de uma seqüência literal é apenas um personagem de hash. Desde que os comentários são
para esclarecer código e não são interpretados pelo Python, que pode ser omitido quando se
digita em exemplos.

Alguns exemplos:
# Este é o primeiro comentário

SPAM = 1 # e esse é o segundo comentário
# ... e agora uma terceira!
STRING = "# Isto não é um comentário."
3.1. Usando Python como uma calculadora ¶
Vamos tentar alguns comandos simples em Python. Inicie o interpretador e aguarde o prompt
primário,>>>. (Não deve demorar muito.)
3.1.1. Números ¶
O interpretador atua como uma calculadora simples: você pode digitar uma expressão para ele
e ele irá escrever o valor. A sintaxe da expressão é simples: os operadores +, -, * e / funcionam
como na maioria dos outros idiomas (por exemplo, Pascal ou C); parênteses podem ser usados
para o agrupamento. Por exemplo:
>>> 2 +2
4
>>> # Este é um comentário
... 2 2
4
>>> 2 +2 # e comentário sobre a mesma linha de código
4
>>> (50-5 * 6) / 4
5,0
Frações>>> 05/08 # não são perdidos quando dividindo inteiros
1,6
Nota: Você não pode ver exatamente o mesmo resultado; resultados de ponto flutuante
podem diferir de uma máquina para outra. Falaremos mais tarde sobre como controlar a
aparência da saída de ponto flutuante. Veja também Floating Point Arithmetic: Problemas e
limitações para uma ampla discussão de algumas das sutilezas de números de ponto flutuante
e suas representações.
Para fazer uma divisão inteira e obter um resultado inteiro, descartando qualquer resultado
fracionário, não há outro operador, / /:
>>> # Integer retorna a divisão do piso:

... 7 / / 3
2
>>> 7 / -3
-3

O ('=') sinal de igual é usado para atribuir um valor a uma variável. Depois disso, nenhum
resultado é exibido antes do próximo prompt interativo:
>> Largura> = 20
>> Altura> = 5 * 9
>>> 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
Variáveis devem ser "definidos" (atribuído um valor) antes que eles possam ser usados, ou um
erro ocorrerá:
>>> # Tentar acessar uma variável indefinida

... n
Traceback (chamada mais recente passada):
Arquivo "<stdin>", line 1, <module>
n NameError: 'nome' não está definido
Não há suporte completo para ponto flutuante, os operadores com operandos de tipo misto
converter o inteiro operando em ponto flutuante:
>>> 3 * 3,75 / 1,5

7,5
>>> 7.0 / 2
3,5
Números complexos também são suportados; números imaginários são escritas com um sufixo
de j ou números de J. Complexo com um componente diferente de zero real são escritos como
(real + imagj), ou pode ser criado com o complexo (real, imag função).
>>> 1j * 1J
(-1 0 j)
>>> 1j * complexas (0, 1)
(-1 0 j)
>>> 3 +1 j * 3

(3 +3 j)
>>> (3 +1 j) * 3
(9 +3 j)
>>> (1 +2 j) / (1 +1 j)
(1,5 0,5 j)
Números complexos são sempre representados por dois números de ponto flutuante, a parte
real e imaginária. Para extrair estas peças de um número complexo z, z.real uso e z.imag.
>>> A = 1,5 0,5 j

>> A.real>
1,5
>>> A.imag
0,5
As funções de conversão para ponto flutuante e inteiro (float (), (int)) não funcionam para
números complexos - não existe uma maneira correta de converter um número complexo para
um número real. Use abs (z) para obter sua magnitude (como um float) ou z.real para obter
sua parte real:
>>> A = 3,0 4,0 j

>>> Float (a)
Arquivo "<stdin>", line 1, in?
TypeError: não é possível converter complexo flutuar; abs utilização (z)
>> A.real>
3,0
>>> A.imag
4,0
>> Abs> (a) # sqrt (a.real a.imag ** ** 2 + 2)
5,0
No modo interativo, a última expressão impressa é atribuído à variável _. Isto significa que
quando você estiver usando o Python como uma calculadora de mesa, é um pouco mais fácil
para continuar os cálculos, por exemplo:
>> Fiscal> = 12,5 / 100

>>> Preço = 100,50
>>> * O preço imposto
12,5625
>> Preço> _ +
113.0625
>> Volta> (_, 2)
113,06

Esta variável deve ser tratado como somente leitura pelo usuário. Não explicitamente atribuir
um valor a ela - você deve criar uma variável independente local com o mesmo nome
mascarando o built-in variável com seu comportamento mágico.
3.1.2. Strings ¶
Além dos números, Python também pode manipular strings, que pode ser expresso de várias
maneiras. Eles podem ser colocados entre aspas simples ou aspas duplas:
spam>>> 'ovos'
Ovos spam '
t \>>> 'não' "
"Não"
>>> "Não"
"Não"
>>> "Sim", disse ele.
"Sim", disse ele.
>>> "\" Sim \ ", disse ele."
"Sim", disse ele.
">>> 'T Isn \'", disse ela.
"Isn t \ '", disse ela.
O interpretador imprime o resultado das operações de string da mesma forma como eles são
digitados para a entrada: aspas dentro, e com aspas e outros caracteres estranhos escapou por
barras invertidas, para mostrar o valor exacto. A corda é colocada entre aspas duplas se a
cadeia contém uma aspa simples e não aspas duplas, então é entre aspas simples. Mais uma
vez, a função print () produz a saída mais legível.
literais String pode abranger várias linhas de várias maneiras. Continuação linhas podem ser
utilizadas, com uma barra invertida como o último caracter da linha, indicando que a próxima
linha é uma continuação lógica da linha:
Olá = "Esta é uma cadeia bastante longa contendo \ n \

várias linhas de texto exatamente como você faria em C. \ n \
Note-se que os espaços em branco no início da linha é \
significativa. "
print (Olá)
Note-se que novas linhas ainda precisam ser embutidos na string usando \ n; a nova linha após
a barra invertida é descartado. Esse exemplo imprime o seguinte:
Esta é uma cadeia bastante longa contendo

várias linhas de texto exatamente como você faria em C.
Note-se que os espaços em branco no início da linha é significativo.

Ou, strings podem ser cercados em um par de correspondência triple-aspas: "" ou'''. Fim de
linhas não precisam ser escapados ao usar triple-aspas, mas elas serão incluídas na seqüência.
print ("" "

Uso: thingy [OPTIONS]
H-Apresentação de mensagem de esse uso
-H Hostname hostname para conectar-se
"" ")
produz o seguinte resultado:
Uso: thingy [OPTIONS]

H-Apresentação de mensagem de esse uso
-H Hostname hostname para conectar-se
Se fizermos uma seqüência literal "string" crua, seqüências \ n não são convertidas em novas
linhas, mas a barra invertida ao final da linha, eo caractere de nova linha na fonte, são
incluídos na string como dados. Assim, o exemplo:
Olá = r "Esta é uma cadeia bastante longa contendo \ n \

várias linhas de texto quanto você faria em C. "
print (Olá)
seria de impressão:
Esta é uma cadeia bastante longa contendo \ n \

várias linhas de texto quanto você faria em C.
Strings podem ser concatenadas (coladas) com o operador +, e repetidas com *:
>> Palavra => 'Ajuda' + 'A'

>> Palavra>
"HelpA '
palavra>>> '<' + * 5 + '>'
"<HelpAHelpAHelpAHelpAHelpA> '
Dois literais string próximas umas das outras são automaticamente concatenadas; a primeira
linha acima também poderia ter sido escrito palavra Help = '' A ', o que só funciona com dois
literais, não com expressões de seqüência arbitrária:
ing str>>> '' # <- Esta é ok

'String'
str>>> '. strip () ing +' # <- Esta é ok
'String'

str>>> '. strip ()' ing '# <- Esta é inválido
'Str'. Strip () 'ing'
^
SyntaxError: invalid syntax
Strings podem ser subscritos (indexado); como no C, o primeiro caractere de uma string tem
índice (index) 0. Não há nenhum tipo de caráter independente, um personagem é
simplesmente uma seqüência de caracteres de tamanho único. Como na linguagem de
programação Ícone, substrings podem ser especificadas com a notação de slice: dois índices
separados por dois pontos.
>> Palavra> [4]

'A'
>> Palavra> [00:02]
'Ele'
>> Palavra> [02:04]
'Lp'
Slice índices têm padrões útil; uma omitido assume primeiro índice a zero, uma omitido
assume segundo índice para o tamanho da string a ser cortado.
>>> [Palavra: 2] # Os dois primeiros caracteres

'Ele'
>> Palavra> [2: Tudo #], exceto os dois primeiros caracteres
"LpA '
Ao contrário de uma string C, strings Python não pode ser mudado. Atribuir para uma posição
indexados nos resultados da seqüência de caracteres em uma mensagem de erro:
>> Palavra> [0] = 'x'

objeto str TypeError: 'não dá suporte a atribuição item
>>> [Palavra: 1] = "Splat"
objeto str TypeError: 'não dá suporte a atribuição fatia
No entanto, a criação de uma nova seqüência com o conteúdo combinado é fácil e eficiente:
>>> 'X' + palavra [1]:

"XelpA '
palavra>> "Splat '+ [4]
"SplatA '

Aqui está uma invariante útil de operações fatia: s [: i] + s [i:] é igual a s.
>>> [Palavra: 2] + word [2:]

"HelpA '
>>> [Palavra: 3] + palavra [3]:
"HelpA '
índices slice degenerados são tratados normalmente: um índice que é muito grande passa a
ter o tamanho da corda, um limite superior menor que o limite inferior retorna uma string
vazia.
>> Palavra> [1:100]

"Elpa"
>>> Palavra [10]:
''
>> Palavra> [02:01]
''
Índices podem ser números negativos, para iniciar a contagem a partir da direita. Por exemplo:
>> Palavra> [-1] # O último personagem

'A'
>> Palavra> [-2] # O passado-mas-um caráter
'P'
>> Palavra> [-2:] # Os dois últimos caracteres
'Pa'
>>> [Palavra: -2] # Tudo exceto os dois últimos caracteres
"Hel"
Mas observe que -0 é realmente o mesmo que 0, por isso ele não contar da direita!
>> Palavra> [-0] # (uma vez que é igual a 0 -0)

'H'
Out-of-range fatia índices negativos são truncados, mas não tente fazer isso em um único
elemento (fatia ou não) os índices:
>>> Palavra [-100:]

"HelpA '
>> Palavra> [-10] erro #
IndexError: índice seqüência fora de alcance

Uma maneira de lembrar como slices trabalho é pensar como os índices que apontam entre os
personagens, com a extremidade esquerda do primeiro caractere numerado 0. Então, a
margem direita do último caractere de uma string de n caracteres tem índice n, por exemplo:
+---+---+---+---+---+
||He|p|l|A|
+---+---+---+---+---+
012345
-5 -4 -3 -2 -1
A primeira linha de números dá a posição do 0 ... 5 índices na seqüência, a segunda linha

apresenta os índices negativos correspondentes. A fatia de i até j consiste em todos os
caracteres entre as arestas rotuladas I e J, respectivamente.
Para índices não-negativo, o comprimento de uma fatia é a diferença entre os índices, se

ambos estão dentro dos limites. Por exemplo, o comprimento da palavra [1:3] é 2.
A built-in função len () retorna o comprimento de uma string:
>>> S = "supercalifragilisticexpialidocious '

>> Len> (s)
34
Veja também
Seqüência Tipos - str, bytes, ByteArray, lista, tupla, intervalo

Strings são exemplos de tipos de seqüência, e apoiar as operações comuns suportados por
esses tipos.
String Métodos
Strings suportam um grande número de métodos de transformações de base e busca.
Seqüência de formatação
Informações sobre string de formatação com str.format () é descrito aqui.
String Old operações de formatação
As operações de formatação de idade chamado quando cordas e cadeias de caracteres
Unicode são o operando à esquerda do operador% são descritas em mais detalhes aqui.
3.1.3. Sobre ¶ Unicode
Começando com Python 3.0 todas as strings Unicode apoio (ver http://www.unicode.org/).
Unicode tem a vantagem de fornecer um número ordinal para cada personagem em cada
script usado em textos antigos e modernos. Anteriormente, havia apenas 256 caracteres
ordinais possível para script. Textos eram tipicamente vinculados a uma página de código que
mapeou os ordinais para caracteres script. Isso levou à confusão muito especialmente no que
diz respeito à internacionalização (geralmente escrito como i18n - 'i' + 18 caracteres n '+') do

software. Unicode resolve esses problemas ao definir uma página de código para todos os
scripts.
Se você desejar incluir caracteres especiais em uma string, você pode fazer isso usando a
codificação Python Unicode-Escape. O exemplo a seguir mostra como:
>>> "Olá \ u0020World!

"Olá Mundo!"
A seqüência de escape \ u0020 indica a inserção de caracteres Unicode com valor ordinal
0x0020 (o espaço) na posição determinada.
Outros personagens são interpretados por meio de seus respectivos valores ordinais
diretamente como ordinais em Unicode. Se você possui strings literais na codificação padrão
Latin-1 que é usado em muitos países ocidentais, você vai achar conveniente que a menor de
256 caracteres Unicode são os mesmos que os 256 caracteres Latin-1.
Para além destas codificações padrão, Python oferece um conjunto de outras formas de
criação de cadeias de caracteres Unicode com base em uma codificação conhecido.
Para converter uma string em uma seqüência de bytes utilizando uma codificação específica,
objetos string fornecer um encode (), método que leva um argumento, o nome da codificação.
nomes em minúsculas para codificações são preferidos.
>>> "Apfel". Encode ('utf-8')

b 'x84pfel \ XC3 \'
3.1.4. Listas ¶
Python sabe que um número de tipos de dados compostos, utilizadas para agrupar outros
valores. O mais versátil é a lista, que pode ser escrita como uma lista de valores separados por
vírgula (itens) entre colchetes. Os itens da lista não precisa ter todos o mesmo tipo.
spam>>> a = [',' ovos ', 100, 1234]

>>> A
spam [',' ovos ', 100, 1234]
Como os índices de string, índices lista começa em 0, e as listas podem ser cortados,
concatenadas e assim por diante:
>>> A [0]
«Spam»
>>> A [3]
1234
>>> A [-2]

100
>>> A 1 [: -1]
['Ovos', 100]
>>> A [:] 2] bacon + [', 2 * 2
spam [',' ovos ',' bacon ', 4]
>>> 3 * a [: 3] Boo + ['!]
spam [',' ovos ', 100' spam ',' ovos ', 100' spam ',' ovos ', 100' Boo! ']
Ao contrário de cordas, que são imutáveis, é possível mudar elementos individuais da lista:
>>> A
spam [',' ovos ', 100, 1234]
>>> A [2] = a [2] + 23
>>> A
spam [',' ovos ', 123, 1234]
Atribuição de fatias também é possível, e isso pode até mesmo alterar o tamanho da lista ou
limpá-la inteiramente:
>>> # Substituir alguns itens:

... um [00:02] = [1, 12]
>>> A
[1, 12, 123, 1234]
>>> # Remova alguns:
... a] [00:02 = []
>>> A
[123, 1234]
>>> # Inserir alguns:
... a] [1:1 = Bletch [',' xyzzy ']
>>> A
[123, "Bletch ',' xyzzy ', 1234]
>>> # Inserir (uma cópia) de si mesmo no início
>>> A [: 0] = a
>>> A
[123, "Bletch ',' xyzzy ', 1234, 123, Bletch', xyzzy ', 1234]
>>> # Limpar a lista: substituir todos os itens de uma lista vazia
>>> A [:] = []
>>> A
[]
A built-in função len () também se aplica às listas:
>>> A = ['a', 'b', 'c', 'd']

>> Len> (a)
4

É possível aninhar listas (criar listas contendo outras listas), por exemplo:
>>> Q = [2, 3]
> P> = [1, q, 4]
>> Len> (p)
3
> P>> [1]
[2, 3]
> P>> [1] [0]
2
Você pode acrescentar algo ao final da lista:
> P>> [1]. Append ('xtra')

> P>
[1, [2, 3, 'xtra'], 4]
>>> Q
[2], 3, 'xtra'
Note-se que no último exemplo, p [1] e q realmente se referem ao mesmo objeto! Voltaremos
ao objeto semântica mais tarde.
3.2. Primeiros passos rumo a programação ¶
Naturalmente, nós podemos utilizar Python para tarefas mais complicadas do que somar dois
e dois juntos. Por exemplo, podemos escrever uma primeira sub-seqüência da série de
Fibonacci da seguinte forma:
>>> # Série de Fibonacci:

... # A soma de dois elementos define o próximo
... a, b = 0, 1
>>> While b <10:
... print (b)
... a, b = b, a + b
...
1
1
2
3
5
8
Este exemplo introduz diversas novas funcionalidades.

A primeira linha contém uma atribuição múltipla: as variáveis a e b simultaneamente
recebem os novos valores 0 e 1. Na última linha deste é usado novamente, demonstrando que
as expressões do lado direito são avaliadas antes de qualquer das atribuições lugar. As
expressões do lado direito são avaliadas da esquerda para a direita.
*
O laço while é executado enquanto a condição (aqui: b <10) continua a ser verdade. Em
Python, como em C, qualquer valor diferente de zero inteiro é verdade; zero é falso. A
condição também pode ser uma string ou lista de valores, na verdade qualquer sequência
nada, com um comprimento de zero é verdadeiro, seqüências vazias são falsas. O teste
utilizado no exemplo é uma comparação simples. Os operadores de comparação padrão são
escritos da mesma forma como no C: <(menor que),> (maior que), == (igual), <= (menor ou
igual),> = (maior ou igual a) e! = (não igual).
*
O corpo do loop é recuado: recuo Python é a maneira de agrupar comandos. Python não
(ainda!) Fornecer uma facilidade de edição inteligente de entrada de linha, então você tem
que digitar um separador ou espaço (s) para cada linha recuada. Na prática, você vai preparar
a entrada mais complicado para Python com um editor de texto, a maioria dos editores de
texto têm uma facilidade de auto-travessão. Quando uma instrução composta é inserida de
forma interactiva, que deve ser seguido por uma linha em branco para indicar a conclusão
(uma vez que o analisador não é possível adivinhar quando você digitou a última linha). Note
que cada linha dentro de um bloco de base deve ser recuado no mesmo montante.
*
A função print () escreve o valor da expressão (s) é dado. Ela difere de apenas escrever a
expressão que você quer escrever (como fizemos nos exemplos anteriores calculadora) na
forma como ele lida com várias expressões, quantidades ponto flutuante e strings. Strings são
impressas sem aspas, e um espaço é inserido entre itens, para que você possa formatar as
coisas bem, como este:
>>> I = 256 * 256

>>> Print ('O valor de i é, i)
O valor de i é 65.536
O fim-chave pode ser usada para evitar a quebra de linha após a saída ou a saída final com
uma seqüência diferente:
>>> A, b = 0, 1
>>> While b <1000:
... print (b, end = ')
... a, b = b, a + b
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

4. Mais Ferramentas de Controle de Fluxo
Além da afirmação, enquanto apenas introduziu, Python sabe as demonstrações usuais de

controle de fluxo conhecido de outras línguas, com algumas reviravoltas.
4.1. if
Talvez o tipo de instrução mais conhecida é a declaração. Por exemplo:
>>> X = int (input ("Por favor insira um número inteiro:"))

Introduza um número inteiro: 42
>>> If x <0:
... x = 0
... print ('Negativo mudou para zero')
... elif x == 0:
... print ('Zero')
... elif x == 1:
... print ('Single')
... else:
... print ('Mais')
...
Mais
Pode haver zero ou mais partes elif, e outra parte é opcional. elif A palavra-chave "é a
abreviação de 'else if', e é útil para evitar identação excessiva. Uma se ... elif ... elif ... seqüência
é um substituto para o switch ou caso as declarações encontradas em outras línguas.
4.2. Instruções For

A instrução em Python difere um pouco do que poderá ser usado em C ou Pascal. Ao invés de
sempre interagindo através de uma progressão aritmética de números (como em Pascal), ou
dando ao usuário a capacidade de definir tanto o passo de iteração e condição de parada
(como C), Python para declaração itera sobre os itens de uma sequência (uma lista ou uma
seqüência de caracteres), na ordem em que aparecem na seqüência. Por exemplo (sem
trocadilhos):
>>> Medida algumas seqüências:

... ] A = [gato ',' janela ', defenestrate'
>>> For x in a:
... print (x, len (x))
...
Cat 3
janela do 6
defenestrate 12

Não é seguro para modificar a seqüência que está sendo iterada no loop (isso só pode
acontecer para os tipos de seqüência mutáveis, como listas). Se você precisar modificar a lista
que você está iterando (por exemplo, para duplicar itens selecionados), você deve iterar sobre
uma cópia. A notação de slice faz presente particularmente conveniente:
>>> For x in a [:]: # faz uma cópia fatia de toda a lista

... if len (x)> 6: a.insert (0, x)
...
>>> A
] Defenestrate [',' gato ',' janela ',' defenestrate '
4.3. A função range ()
Se você precisa fazer para iterar sobre uma seqüência de números, o built-in função gama ()
vem a calhar. Ele gera progressões aritméticas:
>>> For i in range (5):

... print (i)
...
0
1
2
3
4
O ponto final dado não faz parte da lista gerada; intervalo (10) gera 10 valores, os índices
legais para os itens de uma seqüência de comprimento 10. É possível deixar iniciar o intervalo
em outro número, ou para especificar um incremento diferente (mesmo negativa, às vezes
isso é chamado de passo "):
range (5, 10)

5a9
intervalo (0, 10, 3)

0, 3, 6, 9
intervalo (-10, -100, -30)

-10, -40, -70
Para iterar sobre os índices de uma seqüência, você pode combinar range () e len () como
segue:
>>>] A = ['Maria', 'tinha', 'a', 'pouco', cordeiro '

>>> For i in range (len (a)):

... print (i, a [i])
...
0 Mary
1 teve
2-A
3 pequenas
4 cordeiro
Na maioria dos casos, no entanto, é conveniente usar a enumerar () função, consulte Looping
Técnicas.
Uma coisa estranha que acontece se você acabou de imprimir um intervalo:
>>> Print (intervalo) (10)

intervalo (0, 10)
Em muitas maneiras o objeto retornado por range () se comporta como se fosse uma lista, mas
na verdade não é. É um objeto que retorna os itens sucessivos da seqüência desejada quando
você iterar sobre ele, mas ele realmente não fazer a lista, economizando espaço.
Dizemos que um objeto é iteráveis, ou seja, como um destino adequado para as funções e as
construções que esperam algo de que eles podem obter itens sucessivos até que a oferta está
esgotada. Vimos que a instrução for é como um iterador. A lista () função é outra, que cria
listas de iterables:
>>> Lista (intervalo (5))

[0, 1, 2, 3, 4]
Mais tarde veremos mais funções que iterables retorno e tomar iterables como argumento.
4.4. break e continue, e mais cláusulas de Loops ¶
A instrução break, como no C, irrompe do menor para que encerram ou while.
A instrução continue, também emprestado do C, continua com a próxima iteração do loop.
Declarações Loop pode ter uma cláusula else, que é executado quando o laço se encerra por
exaustão da lista (com a) ou quando a condição se torne falsa (com tempo), mas não quando o
laço é encerrado por um comando break. Isto é exemplificado pelo ciclo seguinte, que procura
por números primos:
>>> For n in range (2, 10):

... para x no intervalo (2, n):
... se n% x == 0:
... print (n, 'é igual', x, * ', / n / x)
... quebrar

... else:
... # Loop caiu completamente sem encontrar um factor
... print (n, 'é um número primo ")
...
2 é um número primo
4 * 2 é igual a 2
6 é igual a 2 * 3
8 é igual a 2 * 4
9 é igual a 3 * 3
4.5. Demonstrações passar ¶
A declaração de passar não faz nada. Pode ser utilizado quando é necessária uma declaração
sintaticamente, mas o programa não requer nenhuma ação. Por exemplo:
>>> While True:

... pass # Busy esperar para interrupção de teclado (Ctrl + C)
...
Isto é comumente usado para a criação de classes mínimas:
>>> Class MyEmptyClass:

... passar
...
Outra passagem lugar pode ser usado como um lugar é detentor de uma função ou órgão
subordinado quando você está trabalhando no novo código, permitindo-lhe manter-se pensar
em um nível mais abstracto. O passe é ignorado:
>> Initlog def> (* args):

... pass # Lembre-se de implementar isso!
...
4.6. ¶ Definindo Funções
Podemos criar uma função que escreve a série de Fibonacci para um limite arbitrário:
>> Def fib> (n): # escrever série de Fibonacci até n

... "" "Mostra uma série de Fibonacci até n." ""
... a, b = 0, 1
... enquanto o n <:
... print (a, fim = ')

... a, b = b, a + b
... print ()
...
>>> # Agora, chamar a função que acabamos de definir:
... FIB (2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
A palavra-chave def introduz uma definição de função. Deve ser seguido do nome da função
eo parêntesis lista de parâmetros formais. Os depoimentos que formam o corpo do início da
função na linha seguinte, e deve ser recuado.
A primeira instrução do corpo da função pode ser opcionalmente uma seqüência literal, esta
string é literal string a função de documentação, ou docstring. (Mais sobre docstrings podem
ser encontradas na seção Documentação Strings.) Existem ferramentas que utilizam docstrings
para produzir automaticamente online ou a documentação impressa, ou para permitir que o
usuário navegar interativamente por meio de código, é boa prática incluir docstrings no código
que você escreve, então faça disso um hábito.
A execução de uma função de introduzir uma nova tabela de símbolos utilizados para as
variáveis locais da função. Mais precisamente, olhar todas as atribuições de variáveis em uma
loja de função o valor na tabela de símbolos local, referências Considerando primeira variável
na tabela de símbolos local, em seguida, nas tabelas de símbolo do local que encerram funções
e, em seguida na tabela de símbolos global e, finalmente, no tabela de built-in nomes. Assim,
as variáveis globais não podem ser diretamente atribuído um valor dentro de uma função (a
não ser chamado em uma declaração global), embora possam ser referenciadas.
Os parâmetros reais (argumentos) para uma chamada de função são introduzidos na tabela de
símbolos local da função chamada quando é chamado, portanto, argumentos são passados
usando a chamada por valor (onde o valor é sempre uma referência de objeto, e não o valor da
objeto). [1] Quando uma função chama outra função, a tabela de símbolos do novo local é
criado para esse convite.
A definição da função introduz o nome da função na tabela de símbolos corrente. O valor do

nome da função tem um tipo que é reconhecido pelo interpretador como uma função definida
pelo usuário. Este valor pode ser atribuído a outro nome que também pode ser usado como
uma função. Isto serve como um mecanismo geral renomear:
>> Fib>
fib <função em 10042ed0>
>>> F = fib
>>> F (100)
0 1 1 2 3 5 8 13 21 34 55 89
Vindo de outras línguas, você pode fib objeto que não é uma função, mas um processo, uma
vez que não retorna um valor. Na verdade, até mesmo funções sem uma declaração de

retorno não retornar um valor, embora um pouco aborrecido. Esse valor é chamado None (é
um embutido no nome). Escrevendo o valor None é normalmente suprimido pelo intérprete,
se não seria o único valor por escrito. Você pode ver se você realmente quer usar print ():
>> Fib> (0)

>>> Print (fib (0))
Nenhum
É muito simples escrever uma função que retorna uma lista dos números da série de Fibonacci,
ao invés de imprimi-lo:
>> Def> fib2 (n): # retorno da série de Fibonacci até n

... "" "Retorna uma lista contendo a série de Fibonacci até n." ""
... resultado = []
... a, b = 0, 1
... enquanto o n <:
... result.append (a) # veja abaixo
... a, b = b, a + b
... resultado de retorno
...
>>> = F100 fib2 (100) # chamá-lo
>>> # F100 escrever o resultado
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Este exemplo, como de costume, demonstra algumas características novas:
* O retorno instrução retorna com um valor de uma função. retornar sem expressão
Nenhum argumento retorna. Cair no final de uma função também retorna None.
* A declaração result.append (a) chama um método do objeto da lista de resultado. Um
método é uma função que "pertence" a um objeto e é chamada obj.methodname, onde obj é
um objeto (pode ser uma expressão), e methodname é o nome de um método que é definido
pelo tipo do objeto. Diferentes tipos definir métodos diferentes. Métodos de tipos diferentes
podem ter o mesmo nome sem causar ambigüidade. (É possível definir os tipos de objeto e
métodos próprios, utilizando-se classes, consulte Classes) O método append () mostrado no
exemplo está definido para objetos de lista, que acrescenta um novo elemento no final da
lista. Neste exemplo, é equivalente ao resultado = + resultado [a], mas mais eficiente.
4.7. Mais sobre Definição de Funções ¶
Também é possível definir funções com um número variável de argumentos. Existem três
formas, que podem ser combinados.
4.7.1. Valores padrão de argumentos ¶
A forma mais útil é para especificar um valor padrão para um ou mais argumentos. Isso cria
uma função que pode ser chamado com menos argumentos do que é definido para permitir.

Por exemplo:
ask_ok def (prompt, tentativas = 4, queixa = 'Sim ou não, por favor! "):
enquanto True:
entrada ok = (prompt)
ok se em ('y', vós ',' yes '):
retornar True
ok se em ('n', 'não', nop ',' Não '):
retornar False
tentativas = tentativas - 1
se tentativas 0 <:
levantar IOError ('user refusenik ")
denúncia print ()
Esta função pode ser chamado de várias maneiras:
* Dando apenas o argumento obrigatório: ask_ok ('Você realmente deseja sair? ")
* Dando um dos argumentos opcionais: ask_ok ('OK para substituir o arquivo? ", 2)
* Ou até mesmo dando a todos os argumentos: ask_ok ('OK para substituir o arquivo? ", 2,'
Come on, apenas sim ou não!)
Este exemplo também introduz a palavra-chave no. Isso testa se uma seqüência contém um
certo valor.
Os valores default são avaliados no momento da definição de função no âmbito definindo, de

modo que
i=5
def f (arg = i):

print (arg)
i=6
(F)
será impresso 5.
AVISO IMPORTANTE: O valor padrão é avaliada apenas uma vez. Isso faz uma diferença
quando o padrão é um objeto mutável como uma lista de dicionários, ou mais instâncias de
classes. Por exemplo, a seguinte função acumula os argumentos passados em chamadas
subsequentes:
def f (a =[]):, L
L.append (a)
retorno L

print (f) (1)
print (f) (2)
print (f) (3)
Isto irá imprimir
[1]
[1, 2]
[1, 2, 3]
Se você não quer que o padrão a ser compartilhada entre as chamadas subseqüentes, você
pode escrever a função assim:
def f (a, L = None):

se L é: Nenhum
L = []
L.append (a)
retorno L
4.7.2. Argumentos Palavra ¶
Funções também podem ser chamados usando argumentos-chave da chave = valor formulário.
Por exemplo, a função do seguinte:
papagaio def (tensão, estado = 'a duras', a ação voom = ', type = "Blue norueguês"):
print ("- Este papagaio não ação", end = ')
print ("se você colocar" tensão ", volts por ele.")
print ("- Lovely plumagem, o", tipo)
print ("- É", "Estado"! ")
poderia ser chamado em qualquer uma das seguintes maneiras:
papagaio (1000)
papagaio (action = "VOOOOOM, tensão = 1000000)
parrot ('a' mil, estado = 'empurrando para cima as margaridas ")
parrot ('a' milhões ', desprovida de vida "," salto ")
mas as chamadas seguinte tudo seria inválido:
papagaio () # exigido argumento ausente

Papagaio (tensão = 5.0 a seguir, 'morto') # argumento não-palavra-chave palavra-chave
papagaio (110, tensão = 220) # valor duplicado para o argumento
parrot (actor = 'John Cleese palavra-chave') # desconhecido

Em geral, uma lista de argumentos deve ter argumentos posicionais seguido por todos os
argumentos-chave, onde as palavras devem ser escolhidos de entre os nomes de parâmetro
formal. Não é importante se um parâmetro formal tem um valor padrão ou não. Nenhum
argumento pode receber um valor mais de uma vez - os nomes dos parâmetros formais
correspondendo a argumentos posicionais não podem ser usados como palavras-chave na
mesma chama. Aqui está um exemplo que falhar devido a esta restrição:
>> Função def> (a):

... passar
...
>>> Função (0, a = 0)
TypeError: () função tem vários valores para o argumento-chave "a"
Quando um parâmetro formal final do formulário ** denominação está presente, ele recebe
um dicionário (veja Mapeamento de Tipos - dict) contendo todos os argumentos-chave, exceto
para aqueles que corresponde a um parâmetro formal. Isto pode ser combinado com um
parâmetro formal do nome * formulário (descrito na próxima subseção), que recebe uma
tupla contendo os argumentos posicionais além da lista de parâmetro formal. (* Nome deve
ocorrer antes ** nome.) Por exemplo, se definir uma função como esta:
cheeseshop def (tipo, os argumentos *, ** palavras-chave):

print ("- Você tem algum" tipo "?")
print ("- Eu sinto muito, todos nós estamos fora", tipo)
por arg em argumentos: print (arg)
print ("-" * 40)
Teclas ordenadas = (keywords.keys ())
por kw em chaves: print (kw, "", palavras-chave [kW])
Poderia ser chamado assim:
cheeseshop ("Limburger", "É muito corrimento, senhor."

"É realmente muito, muito corrimento, senhor."
lojista = "Michael Palin",
client = "John Cleese",
sketch = "Cheese Shop Sketch")
e é claro que iria imprimir:
- Você tem algum Limburger?

- Sinto muito, estamos todos de Limburger
É muito corrimento, senhor.
É realmente muito, muito corrimento, senhor.
----------------------------------------

cliente: John Cleese
lojista: Michael Palin
sketch: Cheese Shop Sketch
Note que a lista de nomes de argumento-chave é criado por ordenar o resultado das palavras-
chave dicionário de teclas () método antes de imprimir o seu conteúdo, se isso não for feito, a
ordem na qual os argumentos são impressos é indefinido.
4.7.3. Listas de argumentos arbitrários ¶
Finalmente, menos freqüentemente usado é opção para especificar que uma função pode ser
chamada com um número arbitrário de argumentos. Esses argumentos serão embrulhados em
uma tupla (ver Tuples e seqüências). Antes do número variável de argumentos, zero ou mais
argumentos normais podem ocorrer.
write_multiple_items def (arquivo, separador, * args):

file.write (separator.join (args))
Normalmente, esses argumentos variádicas serão os últimos na lista de parâmetros formais,

até porque colher todos os argumentos de entrada restantes que são passados para a função.
Todos os parâmetros formais que ocorrem após o parâmetro args * são argumentos por
palavra-chave apenas, o que significa que eles só podem ser utilizados como palavras-chave
em vez de argumentos posicionais.
>> Concat def> (* args, ="/"): setembro

... sep.join retorno (args)
...
>> Concat> ("terra", "Marte", "Venus")
»Terra / Marte / Vênus '
>> Concat> ("terra", "Marte", "Vênus", =".") setembro
"Earth.mars.venus '
4.7.4. Argumento Desembalar Lista ¶
A situação inversa ocorre quando os argumentos já estão numa lista ou tupla, mas precisa ser
descompactado para uma chamada de função que exige separar argumentos posicionais. Por
exemplo, o built-in range () função espera começar a separar e parar de argumentos. Se eles
não estão disponíveis separadamente, escreva a chamada de função com o operador *- para
descompactar os argumentos de uma lista ou tupla:
> Lista> (gama (3, 6)) # chamada normal com argumentos distintos
[3, 4, 5]
>>> Args = [3, 6]
> Lista> (intervalo (* args)) # chamada com argumentos descompactado a partir de uma lista
[3, 4, 5]

Da mesma forma, os dicionários podem entregar chave argumentos com o operador **-:
>> Papagaio def> (tensão, estado = 'a duras ", action =" voom "):
... print ("- Este papagaio não ação", end = ')
... print ("se você colocar" tensão ", volts por ele." end = ')
... print ("E", estado! ")
...
>>> D = (tensão ":" quatro milhões "," Estado ":" sangrando "arrendado", "ação": "VOOM")
>> Papagaio> (** d)
- Este papagaio não VOOM se você colocar quatro milhões de volts por ele. demised
sangrando E é!
4.7.5. Lambda Forms ¶
Por demanda popular, algumas características comumente encontradas em linguagens de

programação funcional como Lisp foram adicionados ao Python. Com a palavra-chave lambda,
funções anônimas pequenas podem ser criados. Aqui está uma função que retorna a soma dos
seus dois argumentos: lambda a, b: a + b. formas de Lambda pode ser usado sempre que a
função objetos são obrigatórios. Eles são sintaticamente restrita a uma única expressão.
Semanticamente, são apenas açúcar sintático para a definição de função normal. Como
definições de função aninhada, formas lambda pode variáveis de referência a partir do âmbito
contendo:
>> Make_incrementor def> (n):

... lambda retornar x: x + n
...
>>> F = make_incrementor (42)
>>> F (0)
42
>>> F (1)
43
4.7.6. Strings de Documentação ¶
Aqui estão algumas convenções sobre o conteúdo ea formatação de seqüências de

documentação.
A primeira linha deve ser sempre um resumo curto e conciso da finalidade do objeto. Para
resumir, não deveria explicitar o nome do objeto ou do tipo, uma vez que estes estão
disponíveis por outros meios (exceto se o nome passa a ser um verbo que descreve a operação
de uma função). Esta linha deve começar com uma letra maiúscula e termina com um ponto.
Se houver mais linhas na string de documentação, a segunda linha deve ser branco,
visualmente separar o resumo do resto da descrição. As linhas a seguir devem ser um ou mais
parágrafos descrevendo as convenções de chamada do objeto, seus efeitos colaterais, etc

O interpretador Python não tira recuo da linha multi-literais string em Python, assim
ferramentas que documentação do processo que tira o recuo se desejado. Isso é feito usando
a seguinte convenção. A primeira linha não-branco após a primeira linha da seqüência
determina a quantidade de recuo para a cadeia toda documentação. (Nós não podemos usar a
primeira linha, uma vez que é geralmente adjacente à abertura da string entre aspas para que
seu recuo não é aparente na seqüência literal). Whitespace "equivalente" a este recuo é,
então, retirados do início de todas as linhas da string . Linhas que são recuadas menos não
deveria ocorrer, mas se ocorrer todos os espaços a sua liderança devem ser retirados.
Equivalência de branco deve ser testada após a expansão de guias (de 8 espaços,
normalmente).
Aqui está um exemplo de um docstring multi-linha:
>> Minha_funcao def> ():

... "" Não fazer nada, mas documentá-la.
...
... Não, realmente, ele não faz nada.
... "" "
... passar
...
>>> Print (my_function.__doc__)
Não fazer nada, mas documentá-la.
Não, realmente, ele não faz nada.
4.8. Intermezzo: Codificação ¶ Estilo
Agora que você está prestes a escrever mais, as partes mais complexas do Python, é um bom
momento para falar sobre o estilo de codificação. A maioria das línguas pode ser escrito (ou
mais concisa, formatado), em estilos diferentes, alguns são mais legíveis do que outras. Tornar
mais fácil para os outros a ler o seu código é sempre uma boa idéia, e adotando um estilo
agradável de codificação ajuda tremendamente para isso.
Para Python, PEP 8 emergiu como o guia de estilo que mais aderem a projectos, que promove
uma leitura muito agradável e olhos estilo de codificação. Todo desenvolvedor Python deve lê-
lo em algum momento, aqui estão os pontos mais importantes extraídos para você:
Use indentação de 4 espaços, e sem abas.
4 espaços são um bom compromisso entre o recuo pequeno (permite uma maior
profundidade de assentamento) e recuo de grande porte (mais fácil de ler). Tabs introduzir
confusão, e é melhor ficar de fora.

*
Quebrar linhas de modo que não excedam 79 caracteres.
Isso ajuda os usuários com telas pequenas e torna possível ter vários arquivos de código
lado a lado em telas maiores.
*
Use linhas em branco para separar as funções e classes, e grandes blocos de código dentro
de funções.
*
Quando possível, colocar os comentários em uma linha própria.

*
Use docstrings.
*
Use espaços em torno de operadores e após uma vírgula, mas não diretamente dentro
bracketing construções: a = f (1, 2) + g (3, 4).
*
Nome suas classes e funções de forma consistente, a convenção é usar CamelCase para
aulas e lower_case_with_underscores para funções e métodos. Sempre use "eu" como o nome
para o argumento primeiro método (ver Um primeiro olhar em classes para mais informações
sobre classes e métodos).
*
Não use fantasia codificações se o seu código é feito para ser usado em ambientes
internacionais. padrão do Python, UTF-8, ou mesmo em ASCII melhor trabalho em qualquer
caso.
*
Da mesma forma, não utilizar caracteres não-ASCII em identificadores se houver apenas a

menor chance de pessoas falando uma língua diferente vai ler ou manter o código.
Notas de Rodapé
[1] Na verdade, chamada por referência de objeto seria uma melhor descrição, pois, se um
objeto mutável é passado, o chamador vai ver todas as mudanças o receptor faz para ele (itens
inseridos em uma lista).
5. Estruturas de Dados
Este capítulo descreve algumas coisas que você já aprendeu em mais detalhes, e adiciona
algumas coisas novas também.

5.1. Mais informações sobre listas ¶
A lista de tipo de dados tem alguns métodos mais. Aqui estão todos os métodos de objetos da
lista:
list.append (x)
Adicionar um item ao fim da lista, equivalente a uma len [(a): [] = x].
list.extend (L)
Estender a lista anexando todos os itens da lista fornecida, equivalente a uma len [(a):] = L.
list.insert (i, x)
Inserir um item em uma determinada posição. O primeiro argumento é o índice do elemento
que antes de inserir, de forma a.insert (0, x) insere na frente da lista, e a.insert (len (a), x) é
equivalente a a.append ( x).
list.remove (x)
Remove o primeiro item da lista cujo valor é x. É um erro se não houver esse item.
list.pop ([i])
Remove o item na posição dada na lista, e devolvê-lo. Se nenhum índice é especificado,
a.pop () remove e retorna o último item na lista. (Os colchetes em torno do eu na assinatura
do método indicam que o parâmetro é opcional, e não que você deve digitar colchetes nessa
posição. Você verá essa notação com frequência na Referência da Biblioteca Python.)
list.index (x)
Retornar ao índice na lista do primeiro item cujo valor é x. É um erro se não houver esse
item.
list.count (x)
Retorna o número de vezes que x aparece na lista.
list.sort ()
Ordenar os itens da lista, no lugar.
list.reverse ()
Reverter os elementos da lista, no lugar.
Um exemplo que utiliza a maior parte da lista de métodos:
>>> A = [66,25, 333, 333, 1, 1234,5]

>>> Print (a.count (333), a.count (66,25), a.count ('x'))
210
>> A.insert> (2, -1)
>>> A.append (333)

>>> A
[66,25, 333, 1, 333, 1, 1234,5, 333]
>> A.index> (333)
1
>> A.remove> (333)
>>> A
[66,25, -1, 333, 1, 1234,5, 333]
>> A.reverse> ()
>>> A
[333, 1234,5, 1, 333, -1, 66,25]
>> A.sort> ()
>>> A
[-1, 1, 66,25, 333, 333, 1234,5]
5.1.1. Usando Listas como pilhas ¶
A lista de métodos de fazê-lo muito fácil de usar uma lista como uma pilha, onde o último
elemento adicionado é o primeiro elemento recuperado ("last-in, first-out"). Para adicionar um
item ao topo da pilha, use append (). Para recuperar um item do topo da pilha use pop () sem
um índice explícito. Por exemplo:
>>> Pilha = [3, 4, 5]

>>> Stack.append (6)
>>> Stack.append (7)
>>> Pilha
[3, 4, 5, 6, 7]
>>> Stack.pop ()
7
>>> Pilha
[3, 4, 5, 6]
>>> Stack.pop ()
6
>>> Stack.pop ()
5
>>> Pilha
[3, 4]
5.1.2. Usando listas de filas ¶
Também é possível usar uma lista como uma fila, onde o primeiro elemento adicionado é o
primeiro elemento recuperado ("first-in, first-out"), no entanto, as listas não são eficientes
para essa finalidade. Enquanto acrescenta e aparece a partir do final da lista são rápidos,
fazendo inserções ou aparece desde o início de uma lista é lenta (porque todos os outros
elementos têm de ser desviado por um).

collections.deque usar para implementar uma fila, que foi projetado para ter acrescenta
rápido e pops de ambas as extremidades. Por exemplo:
>>> A partir de colecções deque de importação

>> Fila> = deque (["Eric", "John", "Michael"])
>>> Queue.append ("Terry") # Terry chega
>>> Queue.append ("Graham") # Graham chega
>> Queue.popleft> () # O primeiro a chegar agora sai
'Eric'
>> Queue.popleft> () # O segundo a chegar agora sai
'João'
>> Fila> fila # restante por ordem de chegada
deque (["Michael", "Terry", "] Graham)
5.1.3. Compreensões Lista ¶
compreensões Lista fornecem uma maneira concisa para criar listas de seqüências. As
aplicações comuns estão a fazer listas, onde cada elemento é o resultado de algumas
operações aplicadas a cada membro da seqüência, ou criar uma subsequência dos elementos
que satisfazem uma certa condição.
A compreensão lista é constituída de suportes que contém uma expressão seguida de uma
cláusula para, em seguida, zero ou mais para se ou cláusulas. O resultado será uma lista
resultante da avaliação da expressão no contexto da e para as cláusulas que se seguem. Se a
expressão para se avaliar uma tupla, ele deve estar entre parênteses.
Aqui vamos dar uma lista de números e retornar uma lista de três vezes cada número:
>>> Vec = [2, 4, 6]

>>> [3 * x para x no vec]
[6, 12, 18]
Agora nós temos um pouco mais extravagante:
>>> [[X, x ** 2] para x em vec]

[[2, 4], [4, 16], [6, 36]]
Aqui nós aplicamos uma chamada de método para cada item em uma seqüência:
Fruta]>> freshfruit> = banana [',' loganberry ',' paixão '

>>> Weapon.strip [() para a arma em freshfruit]
] Banana [',' loganberry ',' paixão '
Usando a cláusula que se pode filtrar o fluxo:

>>> [3 * x para x no vec se x> 3]
[12, 18]
>>> [3 * x para x no vec if x <2]
[]
Tuplas podem muitas vezes ser criado sem a sua parênteses, mas não aqui:
>>> [X, x ** 2 de x em vec] Erro # - parênteses necessários para tuplas

[X, x ** 2 for x in vec]
^
>>> [(X, x ** 2) para x em vec]
[(2, 4), (4, 16), (6, 36)]
Aqui estão alguns nested loops e comportamento extravagante outros:
>>> Vec1 = [2, 4, 6]

>>> Vec2 = [4, 3, -9]
>>> [X * y para x em vec1 para y em vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [X + y para x em vec1 para y em vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [Vec1 [i] * vec2 [i] for i in range (len (vec1))]
[8, 12, -54]
compreensões lista pode ser aplicada a expressões complexas e funções aninhadas:
>>> [Str (round (355 / 113, i)) for i in range (1, 6)]
['3 .1 ', '3 0,14, 0,142 '3', '3 0,1416, 0,14159 '3 ']
5.1.4. Compreensões lista aninhada ¶
Se você tem estômago para isso, compreensões lista podem ser aninhados. Eles são uma
ferramenta poderosa, mas - como todos os instrumentos poderosos - eles precisam ser usados
com cuidado, se em tudo.
Considere o seguinte exemplo de uma matriz 3x3 realizada como uma lista contendo três
listas, uma lista por linha:
>> Esteira> = [
... [1, 2, 3]
... [4, 5, 6]
... [7, 8, 9]
... ]

Agora, se quiser trocar as linhas e colunas, você pode usar uma lista de compreensão:
>>> Print ([[linha [i] para a linha em] mat for i in [0, 1, 2]])
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
Especial cuidado deve ser tomado para a compreensão lista aninhada:
Para evitar a apreensão quando compreensões lista de nidificação, lido da direita para a
esquerda.
Uma versão mais detalhada desse trecho mostra o fluxo explicitamente:
for i in [0, 1, 2]:

para a linha em esteira:
print (linha [i], final = "")
print ()
No mundo real, você deve preferir funções embutidas para demonstrações de fluxo de
complexos. O zip () função seria fazer um grande trabalho para este caso de uso:
>>> Lista (zip (MAT *))

[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
Veja Desembalar argumento listas para obter detalhes sobre o asterisco nesta linha.
5.2. A declaração ¶ del
Existe uma maneira de remover um item de uma lista dada o seu índice ao invés de seu valor:
o comando del. Isso difere da pop () método que retorna um valor. A declaração del também
pode ser utilizado para remover fatias de uma lista ou limpar a lista inteira (o que fizemos
anteriormente pela atribuição de uma lista vazia para a fatia). Por exemplo:
>>> A = [-1, 1, 66,25, 333, 333, 1234,5]

>>> Del a [0]
>>> A
[1, 66,25, 333, 333, 1234,5]
>>> Del a [02:04]
>>> A
[1, 66,25, 1234,5]
>>> Del a [:]
>>> A
[]
del também pode ser usado para apagar as variáveis inteiras:

>>> Del a
Referenciando o nome de um futuro é um erro (pelo menos até que outro valor é atribuído a
ele). Nós vamos encontrar outros usos para del mais tarde.
5.3. Tuplas e Sequências ¶
Nós vimos que listas e strings possuem muitas propriedades comuns, tais como indexação e
operações de slicing. Eles são dois exemplos de tipos de dados sequencial (ver seqüência Tipos
- str, bytes, ByteArray, lista, tupla, intervalo). Desde que Python é uma linguagem em
evolução, tipos de dados de seqüência de outros podem ser adicionados. Existe também um
outro padrão de seqüência tipo de dados: a tupla.
Uma tupla consiste em uma série de valores separados por vírgulas, por exemplo:
>>> T = 12345, 54321, 'Olá!'

>>> T [0]
12345
>>> T
(12345, 54321, 'Olá!')
>>> # Tuplas podem ser aninhadas:
... u = t (1, 2, 3, 4, 5)
>>> U
((12345, 54321, 'Olá!'), (1, 2, 3, 4, 5))
Como você vê, em tuplas de saída são sempre colocados entre parênteses, a fim de que tuplas
aninhados são interpretados corretamente, elas podem ser de entrada, com ou sem
parênteses, embora muitas vezes parênteses são necessários de qualquer forma (se a tupla é
parte de uma expressão maior).
Tuplas têm muitos usos. Por exemplo: (x, y) pares de coordenadas, registros de funcionários de
um banco de dados, etc Tuples, como strings, são imutáveis: não é possível atribuir valores a
itens individuais de uma tupla (você pode simular o mesmo efeito com corte e concatenação,
embora). Também é possível criar tuplas que contêm objetos mutáveis, como listas.
Um problema especial é a construção de tuplas contendo 0 ou 1 itens: a sintaxe tem certos

truques para acomodar esses. tuplas vazias são construídas por um par de parênteses vazios;
uma tupla com um item é construído seguindo um valor com uma vírgula (que não é suficiente
para colocar um único valor entre parênteses). Feio, mas eficaz. Por exemplo:
>>> Vazio = ()
>> Singleton => 'Olá', # <- note trailing comma
>>> Len (vazio)
0
>> Len> (singleton)
1

>> Singleton>
('Olá',)
A declaração t = 12345, 54321, 'Olá!' é um exemplo de embalagem tupla: os valores 12345,

54321 e "Olá!" são empacotados juntos em uma tupla. A operação inversa também é possível:
>>> X, y, z = t
Isso se chama, apropriadamente, o desempacotamento de sequência e trabalha para qualquer

seqüência no lado direito. Seqüência descompactar requer que há tantas variáveis no lado
esquerdo do sinal de igual como há elementos na seqüência. Note-se que a atribuição múltipla
é realmente apenas uma combinação de embalagem e desembalagem tupla seqüência.
5.4. Define ¶
Python também inclui um tipo de dados para conjuntos. Um conjunto é uma coleção não
ordenada, sem elementos duplicados. utilizações básicas incluem a adesão de ensaio e
eliminar entradas duplicadas. Definir os objetos também apoiar as operações matemáticas
como união, intersecção, diferença e diferença simétrica.
Chaves ou o set () função pode ser usada para criar jogos. Nota: Para criar um conjunto vazio
que você tem que usar set (), não (), o último cria um dicionário vazio, uma estrutura de dados
que vamos discutir na próxima seção.
Aqui está uma breve demonstração:
>> Cesto> = (maçã ',' laranja ', a maçã', 'pêra', laranja ',' banana ')
>>> Print (cesta)
(Laranja ', banana', 'pera, maçã')
]>> Fruta => Apple [',' laranja ', a maçã', 'pêra', laranja ',' banana '
>> Fruta => set (cesta) # criar um jogo sem duplicatas
>> Fruto>
(Laranja ', pêra', 'maçã', banana ')
>> Fruto> = (laranja ',' maçã ') # sintaxe () é equivalente a [] para listas
>> Fruto>
(Laranja ', a maçã')
laranja>>> 'no sector das frutas # teste rápido adesão
Verdadeiro
crabgrass>>> 'no sector das frutas
Falso
>>> # Demonstrar conjunto de operações sobre as cartas originais de duas palavras

...
>>> Um jogo = ("Abracadabra")
>>> B = set ('alacazam)
>>> A # letras originais em um

('A', 'r', 'b', 'c', 'd')
>>> A - b # letras de uma, mas não em b
(R ',' d ',' b ')
>>> A | b # cartas ou a ou b
('A', 'c', 'r', 'd', 'b', 'm', 'z', 'l')
>>> A & b # em letras a e b
('A', 'c')
>>> A ^ b # letras a ou b, mas não tanto
(R ', m' d ',' b ',' ',' z ',' l ')
Tal como para as listas, há uma compreensão de conjunto sintaxe:
>>> A = (x em x de "abracadabra" se x não em 'ABC')

>>> A
(R ',' d ')
5.5. Dicionários ¶
Outro tipo de dados útil construída em Python é o dicionário (veja Mapeamento de Tipos -
dict). Os dicionários são encontrados às vezes em outras línguas como "memórias associativas"
ou "arrays associativos". Ao contrário de seqüências, que são indexados por uma série de
números, dicionários são indexados por chaves, que pode ser de qualquer tipo imutável;
strings e números sempre podem ser as chaves. Tuplas podem ser usadas como chaves se
contiverem apenas strings, números ou tuplas, se uma tupla contém um objeto mutável,
directa ou indirectamente, não pode ser usado como uma chave. Você não pode usar as listas
como chaves, uma vez que as listas podem ser modificadas no local usando as atribuições do
índice, as atribuições fatia, ou métodos como append () e estender ().
É melhor pensar em um dicionário como um conjunto desordenado de-chave: valor pares, com
a exigência de que as chaves são únicas (dentro de um dicionário). Um par de chaves cria um
dicionário vazia: (). Colocar uma lista separada por vírgulas de chaves: pares de valor dentro
das chaves acrescenta chave inicial: valor pares para o dicionário, este é também o caminho
dicionários são escritos na saída.
As principais operações em um dicionário são armazenar um valor com alguns dos principais e
extrair o valor dado a chave. Também é possível apagar uma chave: valor par com del. Se você
armazenar usando uma chave que já está em uso, o antigo valor associado com essa chave é
esquecido. É um erro para extrair um valor usando uma chave inexistente.
lista Performing (d.keys ()) em um dicionário retorna uma lista de todas as teclas usadas no
dicionário, em ordem arbitrária (se você quiser classificados, basta usar classificado (d.keys ())
em vez). [1] Para verificar se uma única chave está no dicionário, use a palavra-chave no.
Aqui está um pequeno exemplo usando um dicionário:

>> Tel> = (jack ': 4098,' sape ': 4139)
]>>> Tel ['guido' = 4,127
>> Tel>
(Sape ': 4139,' guido ': 4127,' jack ': 4098)
]>>> Tel ['Jack'
4098
]>>> Del tel ['sape'
]>>> Tel ['Irv' = 4,127
>> Tel>
(Guido ': 4127 ", Irv': 4127, 'jack': 4098)
>>> Lista (tel.keys ())
] Irv [',' guido 'jack'
>>> Classificado (tel.keys ())
] Guido [',' Irv 'jack'
guido>>> 'no tel
Verdadeiro
jack>>> 'não' no tel
Falso
O dict () construtor constrói dicionários diretamente a partir de seqüências de pares chave-

valor:
>> Dict> ([Sapé ('', 4139), ('guido', 4127), ('Jack', 4098)])

(Sape ': 4139,' jack ': 4098,' guido ': 4127)
Além disso, compreensões dict pode ser usado para criar dicionários de chave arbitrária e
expressões de valor:
>>> (X: x ** 2 for x in (2, 4, 6))

(2: 4, 4: 16, 6: 36)
Quando as chaves são strings simples, às vezes é mais fácil especificar os pares usando
argumentos-chave:
>> Dict> (SAPE = 4139, Guido = 4127, Jack = 4098)

(Sape ': 4139,' jack ': 4098,' guido ': 4127)
5.6. ¶ Looping Técnicas
Quando o loop dicionários, o valor da chave e podem ser recuperados correspondentes ao

mesmo tempo usando os itens () método.
>>> Cavaleiros = ("Gallahad": "o 'puro' robin ':' bravos ')

>>> Para k v, em knights.items ():
... print (k, v)

...
Gallahad pura
robin o bravo
Quando o loop através de uma seqüência, o índice de posição eo valor correspondente pode
ser recuperada, ao mesmo tempo usando a função () enumerar.
]>>> For i, v em enumerar toe (['tic' tac ','):

... print (i, v)
...
0 tic
1 tac
Dois dedos
Para loop por duas ou mais seqüências ao mesmo tempo, as entradas podem ser emparelhado
com o zip () função.
]>>> Perguntas = [nome ',' busca 'de cor' favorito '

>>> Respostas = Lancelot [',' o Santo Graal ','] 'azul
>>> Para q, em um zip (perguntas, respostas):
... print ('Qual é a sua (0)? É (1).. formato (q, a))
...
Qual é seu nome? É Lancelot.
Qual é a sua missão? É o Santo Graal.
Qual é a sua cor favorita? Ela é azul.
Para loop em uma seqüência no sentido inverso, em primeiro lugar especificar a seqüência
para a frente e depois chamar a função () invertidas.
>>> For i in invertida (range (1, 10, 2)):

... print (i)
...
9
7
5
3
1
Para loop em uma seqüência na ordem de classificação, use o classificado () função que
retorna uma nova lista de classificados, deixando inalterada a fonte.
]>> Cesto> = maçã [',' laranja ', a maçã', 'pêra', laranja ',' banana '
>>> For f in classificado (conjunto (cesta)):
... print (f)
...

maçã
banana
laranja
pera
5.7. Mais informações sobre as Condições
As condições utilizadas no tempo e if podem conter quaisquer operadores, não só as

comparações.
Os operadores de comparação in e não em verificar se um valor ocorre (não ocorre) em uma

seqüência. Os operadores é e não é comparar se dois objetos são realmente o mesmo objeto,
o que importa apenas para objetos mutáveis como listas. Todos os operadores de comparação
possuem a mesma prioridade, que é menor que a de todos os operadores numéricos.
Comparações podem ser encadeadas. Por exemplo, a <b == c testa se uma é menor que b e b
resto é igual a c.
Comparações podem ser combinadas usando os operadores booleanos AND e OR, e os

resultados de uma comparação (ou de qualquer outra expressão Boolean) pode ser anulado
com não. Estes possuem menor prioridade que os operadores de comparação, entre eles, não
tem a prioridade mais alta ou mais baixa e, de modo que A e não B ou C é equivalente a (A e
não (B)) ou C. Como sempre, os parênteses podem ser usados para expressar a composição
desejada.
Os operadores booleanos AND e OR são chamados operadores de curto-circuito: os seus

argumentos são avaliados da esquerda para a direita, ea avaliação pára logo que o resultado é
determinado. Por exemplo, se A e C são verdadeiros mas B é falsa, A e B e C não avalia a
expressão C. Quando utilizado como um valor geral e não como um valor booleano, o valor de
retorno de um operador de um curto-circuito é a última argumento avaliados.
É possível atribuir o resultado de uma comparação ou outra expressão booleana a uma

variável. Por exemplo,
>>> String1, string2, string3 =''', Trondheim', 'Hammer Dance'

>> Non_null> = string1 ou string2 ou string3
>> Non_null>
»Trondheim»
Observe que em Python, diferentemente de C, a atribuição não pode ocorrer dentro de

expressões. Programadores C podem resmungar sobre isso, mas evita uma classe comum de
problemas encontrados em programas C: digitar = numa expressão quando == se destina.
5.8. Comparando Sequências e Outros Tipos ¶
Sequência de objetos podem ser comparados a outros objetos com o tipo de seqüência. A

comparação lexicográfica utiliza ordenação: em primeiro lugar os dois primeiros itens são
comparados, e se diferem, este determina o resultado da comparação, se eles forem iguais,
nos próximos dois itens são comparados, e assim por diante, até que uma seqüência está
esgotado. Se dois itens a serem comparados são próprias seqüências do mesmo tipo, a
comparação lexicográfica é realizada de forma recursiva. Se todos os itens de comparar duas
seqüências iguais, as seqüências são consideradas iguais. Se uma seqüência inicial é uma sub-
seqüência da outra, a menor seqüência é menor (menos) um. Lexicográfica encomendas de
strings usa o número codepoint Unicode para a ordem de caracteres individuais. Alguns
exemplos de comparações entre sequências do mesmo tipo:
(1, 2, 3) <(1, 2, 4)
[1, 2, 3] <[1, 2, 4]
'ABC' <C '<' 'Pascal' Python '<'
(1, 2, 3, 4) <(1, 2, 4)
(1, 2) <(1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) <(1, 2, ('ABC', 'a'), 4)
Note que os objetos comparação de diferentes tipos com <e> é legal, desde que os objetos
têm métodos de comparação apropriada. Por exemplo, os tipos numéricos mistos são
comparados de acordo com seu valor numérico, de modo 0 é igual a 0,0, etc Caso contrário, ao
invés de fornecer uma ordenação arbitrária, o intérprete irá levantar uma exceção TypeError.
Notas de Rodapé
[1] d.keys Calling () irá retornar um objeto de exibição dicionário. Ele suporta operações como
teste de adesão e de iteração, mas seu conteúdo não é independente do dicionário original - é
apenas uma exibição.
7. Entrada e Saída ¶
Existem várias maneiras de apresentar o resultado de um programa, os dados podem ser

impressos em forma legível, ou escritos em um arquivo para uso futuro. Este capítulo vai
discutir algumas das possibilidades.
7.1. Criadores de saída formatação ¶
Até agora nós encontramos duas maneiras de gravar valores: declarações expressão ea função
print (). (A terceira maneira é utilizar o método write () de objetos de arquivo, o arquivo de
saída padrão pode ser referenciado como sys.stdout. Consulte a Biblioteca de Referência para
obter mais informações sobre este assunto.)
Muitas vezes você quer mais controle sobre a formatação de sua saída do que simplesmente
imprimindo valores separados por espaços. Existem duas maneiras de formatar a sua saída, a
primeira maneira é fazer tudo a seqüência de tratar-se, usando cordas de corte e
concatenação você pode criar qualquer layout que você pode imaginar. A seqüência padrão
módulo contém algumas operações úteis para cordas estofo para uma largura determinada

coluna, que serão discutidos em breve. A segunda maneira é usar o str.format () método.
O módulo string contém uma classe de modelo que oferece ainda uma outra maneira para
substituir valores em strings.
Uma questão permanece, naturalmente: como você converter valores para strings? Por sorte,
Python possui maneiras de converter qualquer valor em uma string: passá-lo para o repr () ou
str () funções.
A função STR () destina-se a devolver as representações de valores que são bastante legível,
enquanto repr () é utilizado para gerar representações que podem ser lidos pelo interpretador
(ou será uma força SyntaxError se não é a sintaxe equivalente). Para objetos que não têm uma
representação específica para o consumo humano, str () irá retornar o mesmo valor que repr
(). Muitos valores, tais como números ou estruturas como listas e dicionários, têm a mesma
representação usando a função. Strings e números de ponto flutuante, em particular, tem
duas representações distintas.
Alguns exemplos:
>>> S = "Olá, mundo".

>> Str> (s)
"Olá, mundo".
>> Repr> (s)
'Olá, mundo ".
>> Str> (1.0/7.0)
0,142857142857 '0 '
>> Repr> (1.0/7.0)
,14285714285714285 '0 '
>>> X = 10 * 3,25
>>> Y = 200 * 200
>>> S = "O valor de x é" + repr (x) + ', e Y é' + repr (y) +'...'
>>> Print (s)
O valor de x é 32.5, e Y é 40 mil ...
>>> # O repr () de uma string string adiciona aspas e barras invertidas:
... Olá = "Olá, \ n mundo
>>> Ois = repr (Olá)
>>> Print (hellos)
"Olá, \ n mundo
>>> # O argumento para repr () pode ser qualquer objeto Python:
... repr ((x, y, spam (',' ovos ')))
"(32.5, 40000, ('spam', 'ovos'))"
Aqui estão duas maneiras de escrever uma tabela de quadrados e cubos:
>>> For x in range (1, 11):

... print (repr (x) rjust. (2), repr (x * x) rjust. (3), end = ')
... # Note o uso de 'final' na linha anterior
... print (repr (x * x * x) rjust (4).)
...
111
248
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> For x in range (1, 11):

... print ('(d) (00:02 01:03 02:04 d) (d). formato (x, x * x, x * x * x))
...
111
248
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
(Note que no primeiro exemplo, um espaço entre cada coluna foi acrescentada pelo modo de
impressão () funciona: ele sempre adiciona espaço entre seus argumentos.)
Este exemplo demonstra o rjust () de objetos String, que direito justifica uma string em um
campo de largura dada por preenchimento com espaços à esquerda. Há ljust métodos
semelhantes () e (centro). Esses métodos não escrever nada, basta retornar uma nova
seqüência. Se a seqüência de entrada é muito longo, não truncar, mas devolvê-lo inalterado, o
que vai bagunçar a sua coluna lay-out, mas isso é geralmente melhor do que a alternativa, que
seria mentir sobre um valor. (Se você realmente quiser truncamento você sempre pode
adicionar uma operação de corte, como x.ljust em (n) []: n).
Há um outro método, zfill (), que pastilhas de uma seqüência numérica na esquerda com zeros.
Ela compreende cerca de mais e menos sinais:
>>> '12 '. Zfill (5)

'00012 '

>>> '-3,14. Zfill (7)
"-003,14 '
>>> '3 0,14159265359. Zfill (5)
'3 0,14159265359 "
Basic uso do str.format () método parecido com este:
>>> Print ("Nós somos o que dizer) (formato "{}!"'. ('cavaleiros', 'Ni'))
Nós somos os cavaleiros que dizem "Ni!"
Os suportes e os personagens dentro deles (campos formato chamado) são substituídos por
objetos que são passados para o método format (). Um número entre parênteses pode ser
usada para se referir à posição do objeto passado para o método format ().
>>> Print ('(0) e (1)'. Formato ('spam', 'ovos'))

spam e os ovos
>>> Print ('(1) e (0)'. Formato ('spam', 'ovos'))
ovos e spam
Se os argumentos de palavras-chave são usadas no método format (), seus valores são
referidos usando o nome do argumento.
>>> Print ("Este alimento é (()) adjetivo.. (Formato

... alimentos = 'spam', adjetivo = "absolutamente horrível"))
Este spam é absolutamente horrível.
argumentos posicionais e podem ser combinadas arbitrariamente:
>>> Print ("A história de (0), (1), e (outra).. Formato (" Bill "," Manfred ",
outros = "Georg '))
A história de Bill, Manfred e Georg.
! Um "(aplicar ascii ()), '!' S (aplicar str ()) e '! R" (aplicar repr ()) pode ser usado para converter
o valor antes de ser formatado:
>> Matemática> Importar

>>> Print ('O valor de PI é aproximadamente formato {}.'. (math.pi))
O valor de PI é aproximadamente 3,14159265359.
>>> Print ('O valor de PI é aproximadamente (!) R.. Formato (math.pi))
O valor de PI é de aproximadamente 3,141592653589793.
Um opcional ': especificador e formato pode acompanhar o nome do campo. Isto permite um
maior controle sobre como o valor é formatado. O exemplo a seguir trunca Pi três casas depois
da vírgula.

>>> Print ('O valor de PI é de cerca de (0: 0,3 m).. Formato (math.pi))
Passa um número inteiro após a ':' fará com que esse campo deve ser um número mínimo de
caracteres de largura. Isso é útil para fazer tabelas bonita.
>> Tabela> = ('Sjoerd': 4127, 'Jack': 4098 ", BCAD ': 7678)
>>> Para o nome, telefone table.items ():
... print ('(00:10) ==> d (01:10). formato (nome, telefone))
...
Jack ==> 4098
BCAD ==> 7678
Sjoerd ==> 4127
Se você tem uma seqüência de formato realmente muito tempo que você não quer dividir,
seria bom se você pode as variáveis de referência a ser formatado pelo nome em vez de
posição. Isso pode ser feito simplesmente passando o dicionário e usar [] 'entre colchetes' para
ter acesso as chaves
>>> Print ('Jack: (0 [Jack]: d); Sjoerd: (0 [Sjoerd]: d);
"BCAD: (0 [BCAD]: d) 'formato. (Tabela))
Jack: 4098; Sjoerd: 4127; BCAD: 8637678
Isso também pode ser feito passando a tabela como argumentos palavras-chave com o "**"
notação.
>>> Print ('Jack: (Jack: d); Sjoerd: (Sjoerd: d); BCAD: (BCAD: d)' formato. (** Tabela))
Jack: 4098; Sjoerd: 4127; BCAD: 8637678
Isso é particularmente útil em combinação com o novo built-in vars () função, que retorna um
dicionário contendo todas as variáveis locais.
Para uma visão completa da seqüência de formatação com str.format (), consulte Formatar
String Syntax.
7.1.1. Old seqüência de formatação ¶
O operador% também pode ser usado para formatação de string. Ele interpreta o argumento
deixou bem como um sprintf () estilo seqüência de formato a ser aplicado ao argumento de
direito, e retorna a string resultante desta operação de formatação. Por exemplo:

>>> Print ('O valor de PI é aproximadamente 5.3f%. Math.pi%)

Desde str.format () é muito novo, um monte de código Python ainda usa o operador%. Porém,
como este velho estilo de formatação acabará por ser retirada da linguagem, str.format ()
geralmente deve ser usado.
Mais informações podem ser encontradas na formatação Cadeia Velha seção de Operações.
7,2. Ler e gravar arquivos ¶
open () retorna um objeto de arquivo, e é mais comumente usado com dois argumentos:
nome do arquivo (abrir, mode).
>>> F = open ('/ tmp / workfile', 'w')
O primeiro argumento é uma string contendo o nome do arquivo. O segundo argumento é

outra string contendo alguns caracteres que descrevem a forma na qual o arquivo será usado.
modo pode ser 'r' quando o arquivo só será lido, 'w' apenas por escrito (um arquivo existente
com o mesmo nome será apagado), e 'a' abre o arquivo para acrescentar, todos os dados
gravados no arquivo é automaticamente adicionado ao final. 'R +' abre o arquivo tanto para
leitura e escrita. O argumento mode é opcional, 'r' será assumido se for omitido.
Normalmente, os arquivos são abertos em modo texto, isto é, ler e escrever strings do e para o
arquivo, que são codificados em uma codificação específica (sendo o padrão UTF-8). 'B'
anexado ao modo de abrir o arquivo em modo binário: agora, os dados são lidos e escritos na
forma de objetos de bytes. Este modo deve ser usado para todos os arquivos que não contêm
texto.
No modo texto, o padrão é converter finais de linha específica da plataforma (\ n em Unix, \ r \

n no Windows) para apenas \ n na leitura e \ n de volta aos finais de linha específica da
plataforma sobre a escrita. Esta alteração nos bastidores para arquivo de dados é muito bem
para arquivos de texto, mas irá corromper os dados binários como aquele em JPEG ou arquivos
EXE. Tenha muito cuidado ao usar o modo binário ao ler e gravar esses arquivos.
7.2.1. Métodos de objetos de arquivo ¶
O restante dos exemplos nesta seção irá assumir que um arquivo chamado f objeto já foi
criado.
Para ler o conteúdo de um arquivo, chamado f.read (tamanho), que tem uma certa quantidade
de dados e retorna como uma seqüência de bytes ou objeto. tamanho é um argumento
numérico opcional. Quando o tamanho for omitido ou negativo, todo o conteúdo do arquivo
será lido e retornado, que é o seu problema se o arquivo é o dobro de memória da sua
máquina. Caso contrário, a maioria dos bytes de tamanho são lidos e devolvidos. Se o final do
arquivo foi atingido, f.read () irá retornar uma string vazia ('').
>> F.read> ()

'Este é o arquivo inteiro. \ N'
>> F.read> ()
''
f.readline () lê uma única linha do arquivo, um caractere de nova linha (\ n) é deixado no final
da cadeia, e só é omitida na última linha do arquivo se o arquivo não termine em uma nova
linha . Isso faz com que o valor de retorno inequívoca, se f.readline () retorna uma string vazia,
o fim do arquivo foi atingido, enquanto uma linha em branco é representado por '\ n', uma
string contendo apenas uma única newline.
>> F.readline> ()
"Esta é a primeira linha do arquivo. \ N '
>> F.readline> ()
"Segunda linha do arquivo \ n"
>> F.readline> ()
''
f.readlines () retorna uma lista contendo todas as linhas de dados no arquivo. Se lhe for dada
uma sizehint parâmetro opcional, lê-se que muitos bytes do arquivo e mais o suficiente para
completar uma linha e retorna as linhas a partir daí. Isto é frequentemente usado para
permitir a leitura eficiente de um arquivo grande de linhas, mas sem ter que carregar o arquivo
inteiro na memória. Apenas linhas completas serão devolvidos.
>> F.readlines> ()
Esse ['é a primeira linha do arquivo. \ N "," Segunda linha do arquivo \ n']
Uma abordagem alternativa às linhas de leitura é de varrer o objeto de arquivo. Esta é a

memória eficiente, rápido, e leva a mais simples código:
>>> Para a linha em f:

... print (linha, end ='')
...
Esta é a primeira linha do arquivo.
Segunda linha do arquivo
A alternativa é simples, mas não prevê como controle de grão fino. Uma vez que as duas
abordagens gerir linha buffering diferente, eles não devem ser misturados.
f.write (string) escreve o conteúdo da string para o arquivo, retornando o número de

caracteres escritos.
>>> F.write ("Este é um n \ test ')

15
Para escrever algo diferente de uma string, ele precisa ser convertido para uma string em

primeiro lugar:
>>> Valor = ('a resposta', 42)

>>> S = str (valor)
>>> F.write (s)
18
f.tell () retorna um inteiro que a posição atual do arquivo objeto no arquivo, medida em bytes
desde o início do arquivo. Para alterar a posição do objeto arquivo, f.seek uso (offset,
from_what). A posição é calculado a partir adicionar offset a um ponto de referência, o ponto
de referência é selecionado pelo argumento from_what. Um valor de 0 from_what medidas
desde o início do arquivo, um usa a posição do arquivo corrente, e 2 usa o final do arquivo
como ponto de referência. from_what pode ser omitido e padrões a 0, com o início do arquivo
como ponto de referência.
+>>> F = open ('/ tmp / workfile', 'rb')

>>> F.write (b'0123456789abcdef)
16
>> F.seek> (5) # Vai para o sexto byte no arquivo
5
>> F.read> (1)
b'5 '
>> F.seek> (-3, 2) # Vai para o terceiro byte antes do fim
13
>> F.read> (1)
b'd '
Em arquivos de texto (que foram abertos sem ab na seqüência mode), apenas procura em
relação ao início do arquivo são permitidos (com a exceção de busca para o arquivo final com
muito procurar (0, 2)).
Quando você é feito com um arquivo, f.close call () para fechá-lo e liberar os recursos do
sistema ocupado pelo arquivo aberto. Depois de chamar f.close (), tenta usar o objeto de
arquivo automaticamente falhar.
>>> F.close ()
>> F.read> ()
ErroNumeroRuim: operação de E / S em arquivo fechado
É uma boa prática de usar a palavra-chave com ao lidar com objetos de arquivo. Isto tem a
vantagem de que o arquivo é fechado corretamente após a conclusão da sua suite, mesmo se
uma exceção é levantada no caminho. Também é muito menor do que a escrita equivalente
try-finally blocos:

>>> Com open ('/ tmp workfile /', 'r') como f:
... f.read read_data = ()
>>> F.closed
Verdadeiro
objetos de arquivo tem alguns métodos adicionais, tais como isatty () e truncate () que são
utilizados com menos frequência, consulte a Referência da Biblioteca de um guia completo
para o arquivo de objetos.
7.2.2. O pickle Módulo ¶
Strings podem ser facilmente escritas e lidas de um arquivo. Números demorar um pouco mais
de esforço, já que o método read () retorna apenas strings, que terão de ser passados para
uma função como int (), que recebe uma string como '123 'e retorna seu valor numérico 123.
No entanto, quando você deseja salvar os tipos de dados mais complexos, como listas,
dicionários, ou instâncias de classe, as coisas ficam muito mais complicadas.
Ao invés de ter os utilizadores estejam constantemente escrevendo e depurando código para

salvar os tipos de dados complexos, Python fornece um módulo padrão chamado picles. Este é
um módulo surpreendente que pode ter praticamente qualquer objeto Python (até mesmo
algumas formas de código Python!) E convertê-lo para uma representação string; este
processo é chamado de decapagem. Reconstruindo o objeto da representação em string é
chamado unpickling. Entre decapagem e unpickling, a seqüência que representa o objeto pode
ter sido armazenado em um arquivo ou dados, ou enviadas através de uma conexão de rede
para uma máquina distante.
Se você tem um objeto x, e um objeto arquivo f que foi aberto para escrita, a maneira mais
simples de picles do objeto em apenas uma linha de código:
pickle.dump (x, f)
Para unpickle o objeto novamente, se f é um objeto de arquivo que foi aberto para leitura:
pickle.load x = (f)
(Há outras variantes deste, quando utilizado de decapagem muitos objetos ou quando você
não quiser gravar os dados em conserva em um arquivo, consulte a documentação completa
para a salmoura na Biblioteca de Referência Python).
pickle é a forma padrão de tornar objetos Python que podem ser armazenados e reutilizados
por outros programas ou por uma invocação futura do mesmo programa, o termo técnico para
isso é um objeto persistente. Porque pickle é tão amplamente utilizado, vários autores que
escrevem extensões Python tomar cuidado para garantir que novos tipos de dados, tais como
as matrizes podem ser adequadamente conservado e unpickled.

8. Erros e Exceções ¶
Até agora, as mensagens de erro não ter sido mais do que o indicado, mas se você já tentou os
exemplos que você provavelmente já viu algum. Existem (pelo menos) dois tipos distintos de
erros: erros de sintaxe e exceções.
8.1. Erros de sintaxe ¶
erros de sintaxe, também conhecida como análise de erros, são talvez o tipo mais comum de
queixa que você começa quando você ainda está aprendendo Python:
>>> While True print ('Olá mundo')

enquanto impressão True ('Olá Mundo')
^
O parser repete a linha de falta e exibe uma pequena seta "apontando para o primeiro ponto
na linha onde o erro foi detectado. O erro é causado por (ou pelo menos detectado em) o
token anterior a seta: no exemplo, o erro é detectado na função print (), uma vez que (':')
cólon está faltando antes. Nome do arquivo eo número da linha são impressos para que você
saiba onde procurar em caso de entrada veio de um script.
8.2. Exceções ¶
Mesmo que uma declaração ou expressão está sintaticamente correta, pode causar um erro
quando uma tentativa é feita para executá-lo. Os erros detectados durante a execução são
chamados exceções e não são incondicionalmente fatais: em breve você vai aprender como
lidar com eles em programas Python. A maioria das exceções não são tratadas por programas,
no entanto, resultar em mensagens de erro como mostrado aqui:
>>> 10 * (1 / 0)
ZeroDivisionError: int divisão por zero ou modulo
>>> 4 * 3 + spam
NameError spam: 'nome' não está definido
>>> 2 "+ 2
TypeError: Não é possível converter 'int' objeto str implicitamente
A última linha da mensagem de erro indica o que aconteceu. As exceções vêm em diferentes
tipos, eo tipo é impresso como parte da mensagem: os tipos no exemplo são
ZeroDivisionError, NameError e TypeError. A seqüência de caracteres impressos como o tipo

de exceção é o nome do built-in exceção que ocorreu. Isso é verdadeiro para todas as built-in
exceções, mas não precisa ser verdade para exceções definidas pelo usuário (embora seja uma
convenção útil). nomes de exceção padrão são construídos em identificadores (não reservados
palavras-chave).
O resto da linha de base fornece detalhes sobre o tipo de exceção e que o causou.
A parte anterior da mensagem de erro apresenta o contexto onde a exceção aconteceu, sob a
forma de uma stack. Em geral, contém uma stack anúncio linhas de código, no entanto, não vai
exibir as linhas de leitura da entrada padrão.
Built-in listas de exceções do built-in exceções e seus significados.

8.3. Exceções Manipulação ¶
É possível escrever programas que tratam exceções selecionado. Veja o exemplo a seguir, que
pede ao usuário para a entrada até que um inteiro válido tenha sido inscrito, mas permite que
o usuário interrompa o programa (usando Control-C ou qualquer que seja o sistema
operacional suporte); nota que uma interrupção gerada pelo usuário é sinalizado aumentando
a exceção KeyboardInterrupt.
>>> While True:

... tente:
... x = int (input ("Por favor insira um número:"))
... quebrar
... exceto ErroNumeroRuim:
... print ("Oops! que havia um número válido. Tente novamente ...")
...
A instrução try funciona da seguinte maneira.
* Em primeiro lugar, a cláusula de tentar (a declaração (s) entre a tentar exceto palavras-
chave) é executado.
* Se nenhuma exceção ocorrer, a cláusula de exceção é ignorado e execução da instrução é
tentar terminar.
* Se ocorrer uma exceção durante a execução da cláusula try, o restante da cláusula é
ignorado. Então, se seu tipo de jogos a exceção nomeado após a palavra, exceto, a cláusula de
exceção é executado, e, em seguida, a execução continua após o try.
* Se ocorrer uma exceção que não coincide com a exceção nomeado na cláusula, exceto, é
passada para tentar exterior declarações, se nenhum manipulador for encontrado, ele é uma
exceção não tratada ea execução pára com uma mensagem como mostrado acima.
A instrução try pode ter mais de uma cláusula de exceção, para especificar manipuladores para
exceções diferentes. No máximo um manipulador será executado. Manipuladores de apenas
lidar com exceções que ocorrem na cláusula tentar correspondente, e não em outros
manipuladores de tentar mesmo comunicado. Uma cláusula except pode nomear várias

exceções como uma tupla entre parênteses, por exemplo:
... exceto (RuntimeError, TypeError, NameError):

... passar
A última cláusula except pode omitir o nome da exceção (s), para servir como um curinga. Use
isto com extrema cautela, pois é fácil para mascarar um verdadeiro erro de programação desse
jeito! Também pode ser usado para imprimir uma mensagem de erro e, em seguida, re-raise a
exceção (que permite que um chamador para tratar a exceção como bem):
import sys
tente:
f = open (myfile.txt ')
s = f.readline ()
int i = (s.strip ())
exceto IOError como errar:
print ("erro de I / O: (0)". format (err))
exceto ErroNumeroRuim:
print ("Não foi possível converter dados para um número inteiro.")
exceto:
print ("Erro inesperado", sys.exc_info () [0])
levantar
A tentativa ... exceto declaração tem uma cláusula else opcional, que, quando presentes,
devem seguir todas as cláusulas de excepção. É útil para o código que deve ser executado se a
cláusula de tentar não levantar uma exceção. Por exemplo:
por arg em sys.argv [1]:

tente:
f = open (arg, 'r')
IOError exceto:
print ('Não é possível abrir', arg)
else:
print (arg, 'tem', len (f.readlines ()), "linhas")
f.close ()
A utilização da cláusula else é melhor do que adicionar código adicional para a cláusula try,
pois evita a captura acidentalmente uma exceção que não foi suscitada pelo código que está
sendo protegida pela tentativa ... exceto declaração.
Quando uma exceção ocorre, ela pode ter um valor associado, também conhecido como
argumento da exceção. A presença eo tipo do argumento depende do tipo de exceção.
A cláusula except pode especificar uma variável depois do nome da exceção. A variável é

ligado a uma instância de exceção com os argumentos armazenados em instance.args. Por
conveniência, a instância de exceção define __str__ () para os argumentos podem ser
impressas diretamente, sem ter de referência. Args. Também se pode instanciar uma exceção
antes de elevá-lo e adicionar os atributos a ele, como desejado.
>>> Tente:
... aumentar a Exception ('spam', 'ovos')
... salvo exceções como inst:
... print (tipo (inst)) # a instância de exceção
... print (inst.args) # argumentos armazenados em arquivos. args
... inst print () # __str__ permite args a ser impresso diretamente,
... # Mas pode ser substituído em subclasses de exceção
... x, y = inst.args descompactar args #
... print ('x =', x)
... print ('y =', y)
...
'Exception'> <class
(Spam ',' ovos ')
(Spam ',' ovos ')
x = spam
y = ovos
Se uma exceção tem argumentos, eles são impressos como a última parte («pormenor») da
mensagem para exceções não tratadas.
manipuladores de exceção não apenas lidar com exceções, se ocorrer de imediato na cláusula
try, mas também quando eles ocorrem dentro de funções que são chamados (mesmo que
indiretamente) da cláusula try. Por exemplo:
>>> This_fails def ():

... x = 1 / 0
...
>>> Tente:
... this_fails ()
... exceto ZeroDivisionError como errar:
... print ('tratamento de erros em tempo de execução:' err)
...
Tratamento de erros em tempo de execução: int divisão por zero ou modulo
8.4. ¶ Levantando Exceções
O comando raise permite que o programador forçar uma exceção especificada ocorrer. Por
exemplo:
>>> Levantar NameError ('HiThere)

NameError: HiThere
O único argumento para aumentar indica a exceção a ser levantada. Este deve ser um
exemplo, uma exceção ou uma classe de exceção (uma classe que deriva de Exception).
Se você precisa determinar se uma exceção foi levantada, mas não pretendem lidar com isso,
uma forma mais simples de elevar a declaração permite que você re-raise a exceção:
>>> Tente:
... levantar NameError ('HiThere)
... exceto NameError:
... print ('Uma excepção voaram!')
... levantar
...
Uma excepção voaram!
NameError: HiThere
8.5. Exceções definidas pelo usuário ¶
Os programas podem nomear seus próprios exceções, criando uma nova classe de exceção
(ver classes para classes mais sobre Python). Exceções devem ser tipicamente derivada da
classe Exception, direta ou indiretamente. Por exemplo:
>>> Class MyError (exceção):

... def __init__ (self, valor):
... = valor self.value
... def __str__ (self):
... repr retorno (self.value)
...
>>> Tente:
... levantar MyError (2 * 2)
... exceto MyError como e:
... print ('My exceção ocorreu, o valor: ", e.value)
...
Meu exceção ocorreu, o valor: 4
>>> Levantar oops MyError (!)
__main__.MyError: "opa!"
Neste exemplo, o __init__ (padrão) de exceção foi substituído. O novo comportamento

simplesmente cria o atributo value. Isto substitui o comportamento padrão de criar o atributo
args.
classes de exceção pode ser definido o que fazer alguma coisa nenhuma outra classe pode
fazer, mas geralmente são mantidos simples, muitas vezes, apenas oferecendo uma série de
atributos que permitem que a informação sobre o erro para ser extraído por manipuladores de
exceção. Ao criar um módulo que pode levantar vários erros distintos, uma prática comum é
criar uma classe base para exceções definidas por aquele módulo, e subclasse que criar classes
de exceção específica para as condições de erro diferentes:
Erro de classe (exceção):

"" "Classe base para exceções neste módulo." "
passar
InputError classe (erro):

"Exceção" levantada por erros na entrada.
Atributos:
expressão - expressão de entrada em que ocorreu o erro
mensagem - explicação do erro
"" "
def __init__ (self, expressão, mensagem):

expressão self.expression =
Mensagem self.message =
TransitionError classe (erro):

"" "Gerado quando uma operação tenta uma transição de estado que não é
permitido.
Atributos:
estado anterior - no início da transição
próximo estado - tentaram de novo
explicação mensagem - por que a transição específica não é permitida
"" "
def __init__ (self, anterior, próximo, mensagem):

self.previous = anterior
self.next = próximo
Mensagem self.message =
A maioria das exceções são definidas com nomes que terminam em "erro", semelhante à
nomeação de exceções padrão.
Muitos módulos padrão definir suas próprias exceções para relatar erros que possam ocorrer

nas funções que definem. Mais informações sobre as classes são apresentadas nas classes
capítulo.
8.6. Definindo Ações de Limpeza ¶
A instrução try possui outra cláusula opcional que se destina a definir as acções de limpeza que
deve ser executado em todas as circunstâncias. Por exemplo:
>>> Tente:
... levantar KeyboardInterrupt
... finalmente:
... print ('Adeus, mundo!')
...
Adeus, mundo!
KeyboardInterrupt
A cláusula finally é sempre executado antes de deixar a instrução try, se uma exceção ocorreu
ou não. Quando uma exceção ocorreu na tentativa cláusula e não tem sido tratado por uma
cláusula de exceção (ou que tenha ocorrido em uma cláusula de excepção ou outra), é re-raise
após a cláusula finally foi executado. A cláusula finally também é executado "na maneira para
fora", quando qualquer outra cláusula do try é deixada por uma pausa, continuar ou voltar
comunicado. Um exemplo mais complicado:
>> Dividir def> (x, y):

... tente:
... resultado = x / y
... exceto ZeroDivisionError:
... print ("divisão por zero!")
... else:
... print ("resultado é", resultado)
... finalmente:
... print ("finalmente cláusula de execução")
...
>> Divisão> (2, 1)
resultado é de 2,0
execução finalmente cláusula
>> Divisão> (2, 0)
divisão por zero!
>> Divisão> ("2", "1")
File "<stdin>", linha 3, em dividir
TypeError: tipo operando sem suporte (s) para /: str 'e' str '

Como você pode ver, a cláusula finally é executado em qualquer caso. O TypeError levantadas,
dividindo duas cordas não é tratado pela cláusula de exceção e, portanto, re-raise após a
cláusula finally foi executado.
Em aplicações do mundo real, a cláusula finally é útil para a liberação de recursos externos
(como arquivos ou conexões de rede), independentemente da utilização do recurso foi bem
sucedida.
8.7. Predefinidos Clean-up Ações ¶
Alguns objetos definir padrão de limpeza ações a serem realizadas quando o objeto não é mais
necessária, independentemente de haver ou não a operação utilizando o objeto sucedido ou
não. Veja o exemplo a seguir, que tenta abrir um arquivo e impressão do seu conteúdo para a
tela.
para a linha em aberto (myfile.txt "):

linha de impressão ()
O problema com este código é que ele deixa o arquivo aberto por um período de tempo
indeterminado após esta parte do código é executado. Esta não é uma questão em scripts
simples, mas pode ser um problema para as aplicações maiores. A declaração permite com
objetos como arquivos para ser usado de uma forma que garante que eles estão sempre
limpos rapidamente e corretamente.
com open (myfile.txt ") como f:

para a linha em f:
Após a instrução é executada, o arquivo f está sempre fechada, mesmo que um problema foi
encontrado ao processar as linhas. Objetos que, como arquivos, fornecer pré-limpeza ações
indicam isso em sua documentação.
9. Classes ¶
mecanismo classe Python's adiciona classes para o idioma com um mínimo de nova sintaxe e
semântica. É uma mistura de mecanismos equivalentes encontrados em C + + e Modula-3.
Como é verdadeiro para os módulos, classes em Python não colocar uma barreira absoluta
entre definição e usuário, mas sim contar com a gentileza do usuário para não "quebrar a
definição." As características mais importantes das classes são mantidos com plenos poderes,
porém: o mecanismo de herança de classe permite múltiplas classes base, uma classe derivada
pode substituir os métodos de sua classe ou classes base, e um método pode chamar o
método de uma classe base com o mesmo nome. Os objetos podem conter uma quantidade
arbitrária de dados.
Na terminologia de C + +, normalmente membros da classe (incluindo os membros de dados)

são públicos (exceto veja abaixo variáveis privadas), e todas as funções membro são virtual.

Como em Modula-3, não existem atalhos para referenciar membros do objeto de seus
métodos: a função de método é declarado com um primeiro argumento explícito que
representa o objeto, que é fornecido implicitamente pela chamada. Como em Smalltalk,
classes em si são objetos. Isso fornece a semântica para importação e renomeação. Ao
contrário do C + + e Modula-3, construído em tipos podem ser utilizados como classes base
para a extensão por parte do utilizador. Além disso, como em C + +, a maioria dos operadores
internos com uma sintaxe especial (operadores aritméticos, subscripting etc) podem ser
redefinidos para instâncias de classe.
(Sem universalmente aceite terminologia para falar sobre as aulas, vou fazer uso ocasional de
Smalltalk e os termos C + +. Gostaria de usar Modula-3 termos, uma vez que sua semântica
orientada a objetos estão mais próximos aos do Python do C + +, mas eu espero que alguns
leitores ter ouvido falar dele.)
9.1. Uma palavra sobre nomes e objetos ¶
Objetos tem individualidade e vários nomes (em vários âmbitos) pode ser vinculado ao mesmo
objeto. Isto é conhecido como aliasing em outras línguas. Isso geralmente não é apreciado em
um primeiro olhar sobre Python, e pode ser ignorada quando se trata de tipos básicos
imutáveis (números, strings, tuplas). Entretanto, aliasing tem um efeito possivelmente
surpreendente sobre a semântica do código Python envolvendo objetos mutáveis como listas,
dicionários, ea maioria dos outros tipos. Isso geralmente é usado para o benefício do
programa, uma vez que se comportam como aliases ponteiros em alguns aspectos. Por
exemplo, passando um objeto é mais barato uma vez que apenas um ponteiro é passado pela
aplicação, e se a função modifica um objeto passado como argumento, o chamador vai ver a
mudança - isso elimina a necessidade de dois argumentos diferentes mecanismos de passagem
como em Pascal .
9.2. Scopes e Python Namespaces ¶
Antes de introduzir classes, primeiro eu tenho que lhe dizer algo sobre as regras do Python
alcance. As definições de classe jogar alguns truques com namespaces, e você precisa saber
como âmbitos e espaços para o trabalho para entender completamente o que está
acontecendo. Aliás, o conhecimento sobre este assunto é útil para qualquer programador
avançado em Python.
Vamos começar com algumas definições.
Um espaço de nomes é um mapeamento de nomes para objetos. A maioria dos namespaces

são actualmente implementados como dicionários Python, mas isso normalmente não é visível
em qualquer meio (exceto para o desempenho), e pode mudar no futuro. Exemplos de
espaços de nomes são: o conjunto de built-in nomes (funções como abs (), e construíram-nos
nomes de exceção), os nomes globais em um módulo e os nomes locais em uma chamada de
função. Em certo sentido, o conjunto de atributos de um objeto também formam um
namespace. A coisa importante a saber sobre namespaces é que não há absolutamente
nenhuma relação entre nomes em diferentes espaços de nomes, por exemplo, dois módulos
diferentes podem definir uma função de maximizar sem confusão - usuários dos módulos

devem prefixo com o nome do módulo.
By the way, eu uso a palavra atributo para qualquer nome que se segue um ponto - por
exemplo, no z.real expressão real, é um atributo do objeto z. Estritamente falando, referências
para nomes em módulos são referências a atributos: na expressão modname.funcname,
modname é um objeto módulo e funcname é um atributo do mesmo. Neste caso, não
acontece de ser um simples mapeamento entre os atributos do módulo e os nomes globais
definidos no módulo: eles compartilham o mesmo espaço para nome! [1]
Atributos podem ser somente leitura ou escrita. Neste último caso, a atribuição de atributos é
possível. Módulo atributos são graváveis: você pode escrever modname.the_answer = 42.
gravável atributos também podem ser excluídos com o comando del. Por exemplo, del
modname.the_answer irá remover o the_answer atributo do objeto nomeado por modname.
Namespaces são criados em momentos diferentes e têm vidas diferentes. O namespace que
contém os nomes de built-in é criado quando o interpretador Python é iniciado, e nunca é
excluída. O espaço para nome global para um módulo é criado quando a definição de módulo
for lido, normalmente, namespaces módulo também durar até o interpretador sai. Os
comandos executados pela invocação de nível superior do intérprete, quer ler de um arquivo
script ou interativamente, são considerados parte de um módulo chamado __main__, então
eles têm o seu próprio namespace global. (O sistema de nomes realmente vivem também em
um módulo, o que é chamado builtins).
O espaço local para uma função é criada quando a função é chamada, e apagado quando a
função retorna ou levanta uma exceção que não é tratado dentro da função. (Na verdade, o
esquecimento seria a melhor maneira de descrever o que realmente acontece). Naturalmente,
chamadas recursivas cada um tem seu próprio namespace local.
Um escopo é uma região textual de um programa Python onde um espaço de nomes é

diretamente acessível. "Directamente acessível" significa que uma referência não qualificada
para um nome tentativas para encontrar o nome do namespace.
Embora escopos sejam determinados estaticamente, eles são usados dinamicamente. A

qualquer momento durante a execução, há pelo menos três escopos aninhados cujo
namespaces são directamente acessíveis:
* O âmbito mais íntimo, que é procurado em primeiro lugar, contém os nomes de locais
* Os escopos das funções de inclusão, que procurou iniciar com o âmbito mais próximo,
juntando, contém não-local, mas também nomes de não-global
* O alcance próximo para a última contém nomes globais do módulo atual
* O alcance ultraperiféricas (procurou passado) é o namespace que contém embutido em
nomes
Se um nome for declarado global, então todas as referências e atribuições de ir diretamente

para o alcance global do meio contendo os nomes do módulo. Para religar variáveis

encontradas fora do âmbito mais íntimo, a declaração não-local pode ser usado, se não
declarada não-locais, as variáveis são read-only (uma tentativa de escrever a tal variável vai
simplesmente criar uma nova variável local, no âmbito mais íntimo, deixando a variável de
nome idêntico exterior inalterado).
Normalmente, o escopo local referencia os nomes locais da função (textualmente) atual. Fora
as funções, as referências de âmbito local, o mesmo namespace como o escopo global:
namespace do módulo. As definições de classe ainda espaço para um outro local no âmbito
local.
É importante perceber que escopos são determinados textualmente: o alcance global de uma
função definida em um módulo que é namespace módulo, não importa de onde ou por que
alias a função é chamada. Por outro lado, a busca para os nomes reais é feito dinamicamente,
em tempo de execução - no entanto, a definição da linguagem está evoluindo para a resolução
de nomes estáticos, em "compilar" o tempo, portanto, não dependem de resolução de nome
dinâmico! (Na verdade, as variáveis locais já estão determinadas estaticamente).
A peculiaridade especial de Python é que - se nenhuma instrução global está em vigor - as

atribuições de nomes de sempre ir para o âmbito mais íntimo. Atribuições não copiam dados -
apenas nomes vincular a objetos. O mesmo é verdadeiro para exclusões: a declaração del x
remove a ligação de x do espaço de nomes referenciado pelo escopo local. Na verdade, todas
as operações que introduzem novos nomes usam o âmbito local: em particular, as declarações
de importação e vincular as definições da função módulo ou nome da função no âmbito local.
A declaração global pode ser usado para indicar que as variáveis especial ao vivo no âmbito
global e deve ser rebote lá, a declaração indica que as variáveis não-locais particular viver em
um escopo delimitador e deve ser rebote lá.
9.2.1. Scopes e Namespaces ¶ Exemplo
Este é um exemplo que demonstra como fazer referência a diferentes âmbitos e espaços para
nome, e como global e não local afetar obrigatório variável:
scope_test def ():

do_local def ():
= spam spam "local"
do_nonlocal def ():
nonlocal spam
= spam spam "não-local"
do_global def ():
spam global
= spam spam "global"
teste de spam spam = ""

do_local ()
print ("Depois de atribuição local:" spam)

do_nonlocal ()
print ("Depois de atribuição não-local", spam)
do_global ()
print ("Depois de atribuição global", spam)
scope_test ()
print ("Em âmbito global: spam"),
A saída do código de exemplo é:
Após a atribuição local: spam teste

Após a atribuição nonlocal: spam nonlocal
Após a atribuição global: spam nonlocal
Em âmbito global spam: global
Note como a atribuição de local (que é o padrão) não se alterou scope_test de ligação de
spam. A atribuição nonlocal mudou scope_test de ligação de spam, ea atribuição global mudou
o nível de módulo de ligação.
Você também pode ver que não havia nenhuma ligação anterior de spam antes da atribuição
global.
9.3. Um primeiro olhar em Classes ¶
Classes introduzir um pouco da nova sintaxe, três novos tipos de objetos e uma semântica
nova.
9.3.1. Definição de classe ¶ Syntax
A forma mais simples de definição de classe parecido com este:
ClassName classe:
<statement-1>
.
.
.
<statement-N>
As definições de classe, como definições de função (declarações def) devem ser executados
antes que tenham qualquer efeito. (Você pode conseguir colocar uma definição de classe em
um galho de uma instrução if ou dentro de uma função.)
Na prática, as declarações dentro de uma definição de classe serão geralmente as definições

de função, mas outras declarações são permitidas, e às vezes útil - nós vamos voltar a isso mais
tarde. As definições de função dentro de uma classe normalmente tem uma forma peculiar de
lista de argumentos, ditada pelas convenções de chamada para os métodos - de novo, isso é
explicado mais tarde.

Quando uma definição de classe é inserido, um espaço novo é criado e usado como o âmbito
local - assim, todas as atribuições para as variáveis locais vão para esse novo espaço. Em
especial, a função de ligar as definições do nome da nova função aqui.
Quando uma definição de classe é deixada normalmente (via o fim), um objeto da classe é
criada. Este é basicamente um invólucro em torno do conteúdo do espaço criado pela
definição da classe, nós vamos aprender mais sobre os objetos da classe na próxima seção. O
escopo original local (o que na prática, pouco antes da definição da classe foi inscrito) é
reintegrado, eo objeto classe é ligado aqui para o nome da classe indicado no cabeçalho de
definição de classe (ClassName no exemplo).
9.3.2. Objetos da classe ¶
Classe suporte a objetos dois tipos de operações: referências a atributos e instanciação.
referências atributo usar a sintaxe padrão utilizada para todas as referências a atributos em
Python: obj.name. nomes de atributos válidos são todos os nomes que estavam no namespace
da classe quando o objeto classe foi criada. Assim, se a definição da classe era assim:
Classe MyClass:
"" "Um exemplo simples de classe" ""
i = 12345
def m (self):
return 'Olá Mundo'
e, em seguida, MyClass.i MyClass.f são referências a atributos válidos, retornando um inteiro e

um objeto função, respectivamente. Atributos de classe também pode ser atribuído, portanto,
você pode alterar o valor de MyClass.i pela cessão. __doc__ é também um atributo válido, que
retorna a docstring pertencentes à classe: "Um exemplo simples de classe".
instanciação da classe usa a notação de função. Basta fingir que o objeto de classe é uma
função sem parâmetros, que retorna uma nova instância da classe. Por exemplo (assumindo
que a classe acima):
x = MyClass ()
cria uma nova instância da classe e atribui a esse objeto para a variável local x.
A operação de instanciação ("calling" um objeto de classe) cria um objeto vazio. Muitas classes
preferem criar objetos personalizados com as instâncias de um determinado estado inicial.
Portanto, uma classe pode definir um método especial chamado __init__ (), como este:
def __init__ (self):

self.data = []

Quando uma classe define um __init__ () método, instanciação de classe automaticamente
invoca __init__ () para a instância da classe recém-criada. Assim, neste exemplo, uma nova
instância inicializada pode ser obtida por:
x = MyClass ()
Naturalmente, o __init__ () método pode ter argumentos para uma maior flexibilidade. Nesse
caso, os argumentos para a instanciação de classe são passadas para __init__ (). Por exemplo,
>>> Complexo de classe:

... def __init__ (self, realpart, imagpart):
... self.r = realpart
... self.i = imagpart
...
>>> X = Complex (3,0, -4,5)
>> X.r> x.i
(3,0, -4,5)
9.3.3. Objetos Instância ¶
Agora o que podemos fazer com objetos exemplo? As operações só compreendida por
exemplo, os objetos são referências a atributos. Existem dois tipos de nomes de atributos
válidos, atributos de dados e métodos.
dados correspondem aos atributos variáveis "instância" em Smalltalk, e aos membros de

dados "em C + +. atributos de dados não precisam ser declarados; como variáveis locais,
primavera, em existência quando eles são primeiro atribuídos. Por exemplo, se x é a instância
de MyClass criada acima, o seguinte pedaço de código irá imprimir o valor 16, sem deixar
rastro:
x.counter = 1
enquanto x.counter <10:
x.counter x.counter = 2 *
x.counter print ()
del x.counter
O outro tipo de instância de referência é um atributo do método. Um método é uma função

que "pertence a" um objeto. (Em Python, o termo método não é exclusivo para as instâncias
das classes: outros tipos de objetos podem ter métodos também. Por exemplo, os objetos da
lista de métodos chamados anexar, inserir, remover, classificar, e assim por diante. No
entanto, na discussão a seguir, vamos usar o método prazo exclusivamente para significar os
métodos de objetos de instância de classe, salvo indicação em contrário).
nomes de método válido de um objeto instância dependem de sua classe. Por definição, todos
os atributos de uma classe que são objetos de função correspondente definir métodos de suas

instâncias. Assim, em nosso exemplo, xf é uma referência método válido, pois MyClass.f é uma
função, mas não é xi, já MyClass.i não é. Mas xf não é a mesma coisa que MyClass.f - é um
objeto de método, não um objeto função.
9.3.4. Objetos Método ¶
Normalmente, um método é chamado logo após ele está vinculado:
x.f ()
No exemplo MinhaClasse, irá retornar a string 'Olá Mundo'. No entanto, não é necessário
chamar um método imediatamente: XF é um objeto do método, e pode ser guardado e
chamado em um momento posterior. Por exemplo:
xf = x.f
enquanto True:
print (xf ())
continuará a imprimir Olá mundo até o fim dos tempos.
O que exatamente acontece quando um método é chamado? Você pode ter notado que xf ()
foi chamado sem um argumento acima, embora a definição da função de f () Foi especificado
um argumento. O que aconteceu com o argumento? Certamente Python levanta uma exceção
quando uma função que requer um argumento é chamado sem nenhuma - nem mesmo se o
argumento é usado realmente ...
Na verdade, você pode ter adivinhado a resposta: o que há de especial sobre os métodos é
que o objeto é passado como primeiro argumento da função. No nosso exemplo, a chamada xf
() é exatamente equivalente a MyClass.f (x). Em geral, chamar um método com uma lista de n
argumentos é equivalente a chamar a função correspondente com uma lista de argumentos
que é criado através da inserção de objeto do método antes do primeiro argumento.
Se você ainda não entendo como os métodos de trabalho, um olhar sobre a implementação
talvez possa esclarecer a questão. Quando um atributo de instância é referenciado que os
dados não é um atributo, sua classe é procurada. Se o nome indica um atributo de classe
válido que seja um objeto função, um objeto método é criado por embalagem (ponteiros para)
o objeto de instância e apenas a função de objeto encontradas juntas em um objeto abstrato:
é o objeto do método. Quando o objeto método é chamado com uma lista de argumentos,
uma lista de argumento novo é construído a partir do objeto de instância e a lista de
argumentos, eo objeto função é chamada com a lista argumento novo.
9.4. Observações Random ¶
Dados atributos substituir atributos do método com o mesmo nome, para evitar conflitos de
nomes acidentais, que possam causar difícil de encontrar falhas em programas grandes, é
aconselhável usar algum tipo de convenção que minimize a possibilidade de conflitos.
convenções possíveis incluem nomes de capitalização método, prefixando dados de nomes de

atributos com uma pequena seqüência única (talvez apenas um underscore), ou usando os
verbos e substantivos para os métodos para os atributos dos dados.
Atributos de dados podem ser referenciados por métodos, bem como por usuários comuns
("clientes") de um objeto. Em outras palavras, as classes não servem para implementar tipos
puramente abstratos de dados. De fato, nada em Python torna possível executar ocultar dados
- é tudo baseado em convenção. (Por outro lado, a implementação Python, escrita em C, pode
esconder completamente detalhes de implementação e controle de acesso a um objeto, se
necessário, o que pode ser utilizado por extensões a Python escritas em C.)
Clientes devem utilizar atributos de dados com cuidado - os clientes podem bagunçar
invariantes mantidos pelos métodos utilizados para carimbar sobre os atributos dos seus
dados. Observe que os clientes podem adicionar dados atributos próprios de uma instância de
objeto sem afetar a validade dos métodos, desde que sejam evitados conflitos de nome - de
novo, uma convenção de nomeação pode poupar muitas dores de cabeça aqui.
Não existe atalho para referenciar atributos de dados (ou outros métodos!) A partir de
métodos. Acho que isso realmente aumenta a legibilidade dos métodos: não há chance de
confundir as variáveis locais e variáveis de instância quando olhando através de um método.
Muitas vezes, o primeiro argumento de um método é chamado self. Isto nada mais é do que
uma convenção: a auto-nome não tem absolutamente nenhum significado especial em
Python. Note, no entanto, que por não seguir a convenção de seu código pode ser menos
legível para outros programadores de Python, e também é concebível que um programa
navegador de classe pode ser escrito que depende de uma convenção desse tipo.
Qualquer objeto função que é um atributo de classe define um método para instâncias da
classe. Não é necessário que a definição da função é textualmente incluído na definição de
classe: a atribuição de um objeto função a uma variável local da classe também está ok. Por
exemplo:
# Função definida fora da classe

def f1 (self, x, y):
min de retorno (x, x + y)
Classe C:
f = f1
g def (self):
return 'Olá Mundo'
h=g
Agora f, g e h são todos os atributos da classe C que se referem à função de objetos e,

conseqüentemente, são todos os métodos de instâncias de C - H ser exatamente equivalente a
g. Note-se que esta prática geralmente só serve para confundir o leitor de um programa.

Os métodos podem chamar outros métodos utilizando atributos do método do argumento
self:
Saco de classe:
def __init__ (self):
self.data = []
def add (self, x):
self.data.append (x)
def addtwice (self, x):
self.add (x)
self.add (x)
Métodos podem referenciar nomes globais da mesma forma que funções ordinárias. O escopo
global associado a um método é o módulo que contém a definição de classe. (A classe em si
nunca é usado como um âmbito global.) Apesar de raramente se encontra um bom motivo
para utilizar dados globais em um método, existem muitos usos legítimos do escopo global:
por um lado, as funções e módulos importados no escopo global podem ser usados por
métodos, bem como funções e classes definidas no mesmo. Normalmente, a classe que
contém o método é definido em si mesmo neste âmbito global, e na próxima seção, vamos
encontrar algumas boas razões para que um método que deseja referenciar sua própria classe.
Cada valor é um objeto e, portanto, tem uma classe (também chamado de seu tipo). É
armazenado como object.__class__.
9.5. Herança ¶
Naturalmente, um recurso de linguagem não seria digna desse nome "classe" sem o apoio de
herança. A sintaxe para uma definição de classe derivada se parece com isto:
DerivedClassName classe (BaseClassName):

<statement-1>
.
.
.
<statement-N>
O BaseClassName nome deve ser definido em um escopo contendo a definição da classe

derivada. No lugar de um nome de classe base, outras expressões arbitrárias também são
permitidos. Isso pode ser útil, por exemplo, quando a classe base é definida em outro módulo:
DerivedClassName classe (modname.BaseClassName):
Execução de uma definição de classe derivada procede da mesma para uma classe base.
Quando o objeto da classe é construído, a classe base é lembrada. Isto é usado para resolver
referências de atributo: se um atributo requisitado não for encontrado na classe, o produto de
busca para procurar na classe base. Essa regra é aplicada recursivamente se a classe base é

derivado de outra classe.
Não há nada de especial sobre instanciação de classes derivadas: DerivedClassName () cria

uma nova instância da classe. Método referências são resolvidos da seguinte forma: o atributo
da classe correspondente é procurado, descendo ao longo da cadeia de classes base, se
necessário, eo método de referência é válida se este gera uma função de objeto.
As classes derivadas podem substituir os métodos de suas classes base. Porque os métodos
não têm privilégios especiais quando invocam outros métodos do mesmo objeto, um método
de uma classe base que chama um outro método definido na classe base mesmo pode acabar
chamando um método de uma classe derivada que substitui-lo. (Para os programadores C + +:
todos os métodos em Python são efetivamente virtual).
Um método de substituição de uma classe derivada pode, de facto, querem estender ao invés
de simplesmente substituir o método de classe base do mesmo nome. Há uma maneira
simples para chamar o método da classe base diretamente: basta ligar
BaseClassName.methodname (self, arguments). Esta é ocasionalmente útil para os clientes
também. (Note que isto só funciona se a classe base é acessível BaseClassName como no
âmbito global.)
Python tem duas funções internas que trabalham com a herança:
* Use isinstance () para verificar se uma instância do tipo: isinstance (OBJ, int) será
verdadeiro somente se obj.__class__ está int ou alguma classe derivada de int.
* Use issubclass () para verificar a herança de classe: issubclass (bool, int) é verdade, pois
bool é uma subclasse de int. No entanto, issubclass (float, int) é falsa, já que flutuam não é
uma subclasse de int.
9.5.1. ¶ Herança Múltipla
Python suporta uma forma de herança múltipla também. A definição de classe com múltiplas
classes base parecido com este:
DerivedClassName classe (Base1, Base2, Base3):

<statement-1>
.
.
.
<statement-N>
Para a maioria dos fins, nos casos mais simples, você pode pensar na busca de atributos
herdados de uma classe-mãe, em profundidade, da esquerda para a direita, não procura duas
vezes na mesma classe em que existe uma sobreposição na hierarquia. Assim, se um atributo
não é encontrado em DerivedClassName, é procurado em Base1, então (recursivamente) nas
classes de base de Base1, e se ele não foi encontrado lá, ele foi procurado em Base2, e assim

por diante.
Na verdade, ele é um pouco mais complexo do que isso, o método muda para a resolução
dinamicamente para suportar chamadas de cooperativas de super (). Esta abordagem é
conhecida em outros idiomas herança múltipla como método de chamada da próxima e é mais
poderoso do que a chamada super encontrados em outras línguas herança única.
Dynamic ordenação é necessária porque as relações todos os casos de herança múltipla

apresentam um ou mais diamantes (onde pelo menos uma das classes pai podem ser
acessados através de vários caminhos a partir da classe mais inferior). Por exemplo, todas as
classes herdam de objeto, portanto, qualquer caso de herança múltipla é mais que um
caminho para chegar a objeto. Para manter as classes de base que está sendo acessado mais
de uma vez, o algoritmo dinâmico lineariza a ordem de pesquisa de uma forma que preserva a
esquerda para a direita ordenação especificada em cada classe, que chama cada um dos pais
apenas uma vez, e que é monótona (o que significa que uma classe pode ser subclasse sem
afetar a ordem de precedência de seus pais). Tomados em conjunto, essas propriedades
tornam possível criar classes confiável e extensível com herança múltipla. Para mais detalhes,
consulte http://www.python.org/download/releases/2.3/mro/.
9.6. Variáveis privadas ¶
"Private" variáveis de instância que não podem ser acessados com exceção de dentro de um
objeto, não existem no Python. No entanto, existe uma convenção que é seguido pela maioria
código Python: um nome prefixado com um sublinhado (_spam, por exemplo) deve ser tratada
como uma parte não-públicas da API (se é uma função, um método ou um membro de dados) .
Deve ser considerado um detalhe de implementação e estão sujeitas a alterações sem aviso
prévio.
Dado que existe um caso de uso válido para os membros da classe-privadas (ou seja, evitar
conflitos de nomes com os nomes definidos pelas subclasses), não há suporte limitado para
esse mecanismo, chamado desconfiguração nome. Qualquer identificador do __spam forma
(pelo menos dois underscores, no máximo, um sublinhado à direita) é textualmente
substituído _classname__spam, onde classname é o nome da classe atual com os principais
sublinhado (s) descascada. Esta deturpação é feito sem levar em conta a posição sintática do
identificador, enquanto ela ocorre dentro da definição de uma classe.
Note que as regras são mangling projetados principalmente para evitar acidentes, ainda é
possível acessar ou modificar uma variável que é considerada privada. Isso pode até ser útil em
circunstâncias especiais, como no depurador.
Observe que o código passado para exec (), eval () ou execfile () não considera o nome da
classe da classe invocando a classe atual, que é semelhante ao efeito do cômputo global, cujo
efeito é igualmente limitado a código que foi byte-compilado em conjunto. A mesma restrição
aplica-se a getattr (), setattr () e delattr (), bem como quando __dict__ referência direta.
9.7. Odds and Ends ¶

Às vezes é útil ter um tipo de dados semelhante ao Pascal "record" ou "C" struct ", bem como
a agregação de alguns itens de dados nomeados. Uma definição de classe vazia vai fazer muito
bem:
Empregado de classe:
passar
john = Employee () # Cria um registro de funcionário vazio
# Preencha os campos do registro

john.name = "John Doe"
john.dept = 'laboratório de informática "
john.salary = 1000
Um pedaço de código Python que espera um determinado tipo abstrato de dados muitas vezes
pode ser transmitida de uma classe que emula os métodos desse tipo de dados em vez disso.
Por exemplo, se você tiver uma função que alguns formatos de dados de um objeto arquivo,
você pode definir uma classe com os métodos read () e readline () que recebem os dados de
um buffer string em vez disso, e passá-lo como um argumento.
objetos método Instância atributos, também: m.__self__ é o objeto exemplo, com o método
m (), e m.__func__ é o objeto função correspondente ao método.
9.8. Exceções são classes Too ¶
Exceções definidas pelo usuário são identificadas por classes. Usando este mecanismo, é
possível criar hierarquias extensíveis de exceções.
Há dois novos válido (semântica) formulários para a declaração levantar:
aumentar a Classe
levantar Instância
Na primeira forma, a classe deve ser uma instância de tipo ou de uma classe derivada dela. A
primeira forma é um atalho para:
levantar (classe)
Uma classe em uma cláusula except é compatível com uma exceção se for da mesma classe ou
de uma classe base do mesmo (mas não o contrário - uma cláusula de anúncio, exceto uma
classe derivada não é compatível com uma classe de base). Por exemplo, o código a seguir será
impresso B, C, D, nesta ordem:
Classe B (exceção):
passar

C (classe B):
passar
Classe D (C):
passar
para c em B [, C, D]:
tente:
levantar c ()
exceto D:
print ("D")
C, exceto:
print ("C")
exceto B:
print ("B")
Note que, se as cláusulas de excepção foram invertidos (com exceção B em primeiro lugar),
teria impresso B, B, B - a primeira correspondência, excepto cláusula é acionada.
Quando uma mensagem de erro é impressa para uma exceção não tratada, nome da classe da
exceção é impresso, então uma vírgula e um espaço e, finalmente, a exemplo convertido em
uma string usando o built-in função str ().
9.9. Iterators ¶
Até agora você já deve ter notado que a maioria dos objetos recipiente pode ser enrolada
sobre o uso de uma instrução for:
para o elemento em [1, 2, 3]:

elemento de impressão ()
para o elemento (1, 2, 3):
elemento de impressão ()
para a chave ('one': 1, 'dois': 2):
print (chave)
para char em "123":
print (char)
para a linha em aberto (myfile.txt "):
Este estilo de acesso, é claro, conciso e prático. O uso de iteradores permeia e unifica Python.
Nos bastidores, a declaração de chamadas iter () no objeto de recipiente. A função retorna um
objeto iterador que define o __next__ (método) que acessa elementos no recipiente um de
cada vez. Quando não houver mais elementos, __next__ () gera uma exceção StopIteration
que diz o loop para terminar. Você pode chamar o __next__ () usando o método builtin next (),
esse exemplo mostra como tudo funciona:
>>> S = 'abc'

>>> Ele = iter (s)
>>> Ele
objeto <iterator em 0x00A1DB50>
>>> Próximo (it)
'A'
>>> Próximo (it)
'B'
>>> Próximo (it)
'C'
>>> Próximo (it)

próximo (it)
StopIteration
Tendo em vista os mecanismos por trás do protocolo iterador, é fácil adicionar um

comportamento iterador para suas aulas. Definir um __iter__ () método que retorna um
objeto com um __next__ () método. Se a classe define __next__ (), então __iter__ () pode
apenas retornar self:
classe Reverse:
"Iterator para looping em uma seqüência para trás"
def __init__ (self, dados):
self.data dados =
self.index = len (dados)
def __iter__ (self):
retorno auto
def __next__ (self):
se self.index == 0:
levantar StopIteration
self.index = self.index - 1
retorno self.data [self.index]
>>> Para char in Reverse ("spam"):

... print (char)
...
m
um
p
s
9.10. Geradores ¶
Generators são uma ferramenta simples e poderosa para a criação de iteradores. Eles são

escritos como funções regulares, mas usar a declaração de rendimento, sempre que quiser
retornar dados. Cada vez que next () é chamado a isso, o gerador recomeça de onde parou (ele
se lembra de todos os valores de dados e que declaração foi executado pela última vez). Um
exemplo mostra que os geradores podem ser trivialmente fácil de criar:
def inverter (dados):

para o índice na faixa de (len (dados) -1, -1, -1):
dados de produtividade [índice]
>>> Para char no reverso ('golf'):

... print (char)
...
f
l
o
g
Qualquer coisa que pode ser feito com geradores também pode ser feito com a classe
iteradores base, como descrito na seção anterior. O que torna tão compacto geradores é que o
__iter__ () e __next__ () são criados automaticamente.
Outra característica importante é que as variáveis locais e estaduais de execução são salvos
automaticamente entre as chamadas. Isso fez com que a função mais fácil de escrever e muito
mais claro do que uma abordagem usando variáveis de instância como self.index e self.data.
Além disso, a criação de método automático e estado do programa de poupança, quando

geradores de terminar, eles automaticamente aumentar StopIteration. Em conjunto, estas
características tornam mais fácil criar iteradores sem mais esforço do que escrever uma função
regular.
9.11. Expressões Generator ¶
Alguns geradores simples podem ser codificados sucintamente como expressões usando uma
sintaxe semelhante à compreensões lista, mas com parênteses, em vez de colchetes. Estas
expressões são concebidas para situações onde o gerador é usado imediatamente por uma
função de inclusão. Gerador de expressões são mais compactos e menos versáteis do que as
definições gerador completo e tendem a ser mais amigável do que a memória compreensões
lista equivalente.
Exemplos:
>> Soma> (i * i for i in range (10)) # soma dos quadrados

285
>>> Xvec = [10, 20, 30]

>>> Yvec = [7, 5, 3]

>> Soma> (x * y para x, y em zip (xvec, yvec)) # produto escalar
260
>>> From matemática pi importação, o pecado

>>> Sine_table = (x: sin (x * pi/180) para x no intervalo (0, 91))
>>> Unique_words = set (palavra por linha na página de palavra em line.split ())
>> Valedictorian> = max (student.gpa (, student.name) para estudantes graduados em)
>>> Dados = 'golf'
10. Breve Passeio da Biblioteca Standard ¶

10.1. ¶ Operating System Interface
O módulo de OS oferece dezenas de funções para interagir com o sistema operacional:
>> Import OS>

>> Os.system> (hora 00:02)
0
>>> Os.getcwd () Return # diretório de trabalho atual
'C: \ Python31'
>>> Os.chdir ('/ server / accesslogs)
Certifique-se de usar o import os estilo em vez de importar OS *. Isto irá manter os.open () de
sombreamento do built-in função open () que opera de forma muito diferente.
A built-in dir () e help () são funções úteis como auxiliares para o trabalho interativo com os
módulos de grande porte como os:
>> Import OS>

>>> Dir (os)
<returns uma lista de todos functions> módulo
>>> Ajuda (os)
<returns página de uma extensa manual criado a partir de docstrings> module's
Para arquivo de diário e as tarefas de gerenciamento de diretórios, o módulo shutil fornece

uma interface de alto nível que é mais fácil de usar:
>> Shutil importação>

>> Shutil.copyfile> ('data.db, archive.db')
>> Shutil.move> ('/ build / executáveis, installdir')
10.2. Arquivo Wildcards ¶

O módulo de glob fornece uma função para fazer listas de arquivo a partir de pesquisas curinga
diretório:
>> Glob importação>

>> Glob.glob> ("*. py")
] Primes.py [',' random.py, quote.py '
10.3. Argumentos de linha de comando ¶
scripts de utilidade comum, muitas vezes precisam processar os argumentos da linha de

comando. Estes argumentos são armazenados no atributo do módulo sys é argv como uma
lista. Por exemplo, os resultados de saída após a execução de python demo.py um, dois, três
na linha de comando:
>> Import sys>

>>> Print (sys.argv)
demo.py [',' um ',' dois ',' três ']
O módulo getopt processos sys.argv usando as convenções do getopt Unix () função. linha de
processamento mais poderosos e flexíveis de comando é fornecida pelo módulo optparse.
10.4. Erro de redirecionamento de saída e ¶ Rescisão Programa
O módulo sys também tem atributos para stdin, stdout e stderr. O último é útil para emitir
avisos e mensagens de erro para torná-los visíveis mesmo quando stdout foi redirecionado:
>>> Sys.stderr.write ('Warning, log file not found a partir de uma nova \ n')
Warning, log file not found iniciar um novo
A maneira mais direta para encerrar um script é a utilização sys.exit ().

10.5. String Pattern Matching ¶
O módulo re fornece ferramentas de expressão regular para processamento de cadeia

avançada. Para adequação complexo e manipulação, as expressões regulares oferecem
sucinta, soluções otimizadas:
>> Voltar a importar>

>> Re.findall> (r '\ bf [az] *', 'que o pé ou a mão mais rápido caiu')
pé [',' caiu ',' mais rápido ']
re.sub>>> (r '(\ b [az] +) \ 1' r '\ 1' gato 'no o chapéu')
'Gato no chapéu'
Quando apenas simples recursos são necessários, os métodos de string são preferidos porque
são mais fáceis de ler e debug:
chá>>> "para muito". replace ('muito', 'dois')

"Chá para dois"
10.6. Matemática ¶
O módulo math oferece acesso às funções subjacentes biblioteca C para matemática de ponto
flutuante:

>> Math.cos> (math.pi / 4)
,70710678118654757
>> Math.log> (1024, 2)
10,0
O módulo random fornece ferramentas para fazer a seleção aleatória:
>>> Import random

]>> Random.choice> (maçã [',' pera, banana ")
'Maçã'
>> Random.sample> (range (100), 10) # amostragem sem reposição
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>> Random.random> () # random float
,17970987693706186
>> Random.randrange> (6) # inteiro aleatório escolhido intervalo (6)
4
O projeto <http://scipy.org> SciPy tem muitos outros módulos para cálculos numéricos.
10.7. Acesso à Internet ¶
Há uma série de módulos de acesso à internet e protocolos de internet de processamento.

Dois dos mais simples são urllib.request para recuperar dados de URLs e smtplib para enviar e-
mail:
>>> From urlopen importação urllib.request

>>> Para a linha de urlopen ('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
... = linha line.decode ('utf-8') # descodificar os dados binários para texto.
... Se 'EST' em linha ou "EDT" na linha: # olhar para Eastern Time
... linha de impressão ()
<BR> Novembro 25, EST 21:43:32
>> Smtplib importação>

>>> Servidor = smtplib.SMTP ('localhost')
>> Server.sendmail> ('soothsayer@example.org', 'jcaesar@example.org,
... "" "Para: jcaesar@example.org
... De: soothsayer@example.org

...
... Cuidado com os idos de março.
... "" ")
>>> Server.quit ()
(Note que o segundo exemplo tem um servidor de mail funcionando em localhost).

10.8. Datas e horários ¶
O módulo datetime fornece classes para manipulação de datas e horários em simples e

complexos caminhos. Embora a data ea hora aritmética é suportado, o foco da aplicação é
eficiente na extração de membro para a formatação de produção e manipulação. O módulo
também oferece suporte a objetos que estão cientes fuso horário.
datas>>> # são facilmente construídos e formatados

>>> A partir da data de importação datetime
>>> Agora date.today = ()
>>> Agora
datetime.date (2003, 12, 2)
>> Now.strftime> ("% m-% d-% Y% d% b% Y% é um A no dia% d de% B")
'12-02-03. 02 de dezembro de 2003 é uma terça-feira no dia 02 de Dezembro.
>>> # Aritmética datas do calendário de apoio

>> Aniversário> = date (1964, 7, 31)
>> Idade> = agora - aniversário
>> Age.days>
14368
10.9. Data Compression ¶
arquivamento de dados comum e formatos de compressão são suportados por módulos,

incluindo: zlib, gzip, bz2, zipfile e tarfile.
>> Zlib importação>

>>> S = "bruxa que tem que bruxas relógio de pulso"
>> Len> (s)
41
>>> T = zlib.compress (s)
>> Len> (t)
37
>>> Zlib.decompress (t)
"Bruxa que tem que bruxas relógio de pulso"
>>> Zlib.crc32 (s)
226805979
10.10. ¶ Performance Measurement

Alguns usuários Python desenvolver um profundo interesse em conhecer o desempenho
relativo de diferentes abordagens para o mesmo problema. Python fornece uma ferramenta
de medição que responde a essas perguntas imediatamente.
Por exemplo, pode ser tentador usar a embalagem e desembalagem característica tupla em
vez da abordagem tradicional para trocar argumentos. O módulo timeit rapidamente
demonstra uma vantagem de desempenho modesto:
>>> From timeit importação Timer

>>> Timer ('t = a; a = b, b = t', 'a b = 1; = 2'). Timeit ()
0,57535828626024577
timeit>>> Timer ('a, b = b, a', 'a, b = 1; = 2) ().
,54962537085770791
Em contraste com timeit o nível de granularidade fina, o perfil e os módulos pstats fornecer
ferramentas para a identificação de pontos críticos em tempo grandes blocos de código.
10.11. ¶ Controle de Qualidade
Uma abordagem para o desenvolvimento de software de alta qualidade é escrever testes para
cada função, uma vez que é desenvolvido e para executar esses testes frequentemente
durante o processo de desenvolvimento.
O docTest módulo fornece uma ferramenta para verificação e validação de um módulo de

testes docstrings incorporado em um programa. Construção do teste é simples como corte-e-
colar uma chamada típica, juntamente com seus resultados no docstring. Isso melhora a
documentação, fornecendo ao utilizador com um exemplo e permite que o docTest módulo
para garantir que o código continua fiel à documentação:
def média (valores):

"" "Calcula a média aritmética de uma lista de números.
>>> Print (média ([20, 30, 70]))

40,0
"" "
soma de retorno (valor) / len (valores)
docTest importação
doctest.testmod () # validar automaticamente os testes embutido
O unittest módulo não é tão fácil como o docTest módulo, mas permite um conjunto mais
abrangente de testes para ser mantido em um arquivo separado:
unittest importação

TestStatisticalFunctions classe (unittest.TestCase):
test_average def (self):

self.assertEqual (média ([20, 30, 70]), 40,0)
self.assertEqual (round ((média [1, 5, 7]), 1), 4.3)
self.assertRaises (ZeroDivisionError, média, [])
self.assertRaises (TypeError, média 20, 30, 70)
unittest.main () # chamada da linha de comando chama todos os testes
10.12. Baterias Incluídas
Python tem um "baterias incluídas" filosofia. Este é o melhor visto através das capacidades
sofisticadas e robustas de seus pacotes de maiores dimensões. Por exemplo:
* A xmlrpc.client e módulos xmlrpc.server fazer procedimento de execução remota de

chamadas para uma tarefa quase trivial. Apesar dos nomes dos módulos, sem conhecimento
directo ou a manipulação de XML é necessário.
* O pacote email é uma biblioteca para gerenciar mensagens de email, incluindo MIME e
outros documentos mensagem RFC 2822-based. Ao contrário smtplib e poplib que realmente
enviar e receber mensagens, o pacote email tem um conjunto de ferramentas completo para a
construção ou a decodificação de mensagens complexas estruturas (incluindo anexos) e para a
execução de codificação e os protocolos Internet cabeçalho.
* A xml.dom e pacotes xml.sax fornecer suporte robusto para a análise deste popular
formato de intercâmbio de dados. Da mesma forma, o módulo csv suporte direto lê e grava
em um formato de banco de dados comum. Juntos, estes módulos e pacotes simplificam muito
o intercâmbio de dados entre aplicações em Python e outras ferramentas.
* A internacionalização é apoiado por uma série de módulos incluindo gettext, locale, eo
pacote de codecs.
11. Breve Passeio da Biblioteca Padrão - Parte II
Esta segunda turnê abrange os módulos mais avançados que suportam as necessidades de
programação profissional. Estes módulos raramente ocorrem em scripts pequenos.
11.1. Saída de formatação ¶
O módulo reprlib fornece uma versão de repr () customizada para displays abreviada de
grandes contentores ou profundamente aninhadas:
>> Reprlib importação>

>> Reprlib.repr> (set ('supercalifragilisticexpialidocious'))
"Set c (['a', '', 'd', 'E', 'f', 'g', ...])"
O módulo pprint oferece um controle mais sofisticado do que objetos de impressão tanto
built-in e definidos pelo usuário de forma que seja legível pelo intérprete. Quando o resultado

é mais do que uma linha, a impressora "bonito", acrescenta quebras de linha e recuo a revela
mais claramente a estrutura de dados:
>> Pprint importação>

>>> T = [[[[' preto, ciano '],' branco ', verde [', 'vermelho']], magenta [[',
... ']' Amarelo 'azul']]]
...
>> Pprint.pprint> (t, largura = 30)
] [[[[' Preto, ciano ",
"Branco",
verde [',' vermelho ']]
magenta [[','] 'amarelo,
«Azul»]]]
O módulo textwrap pontos formatos de texto para ajustar a largura determinada tela:
>> Textwrap importação>

>>> Doc = "" "O envoltório () é apenas como preenchimento () exceto que ela retorna
... uma lista de strings em vez de uma seqüência grande de novas linhas para separar
... as linhas envolvidas. "
...
>>> Print (textwrap.fill (DOC, width = 40))
O envoltório () é apenas como preenchimento ()
exceto que ela retorna uma lista de strings
em vez de uma seqüência grande de novas linhas
para separar as linhas quebradas.
O módulo locale acessa um banco de dados de formatos de dados específicos da cultura. O

atributo de agrupamento da função localidade de formato fornece uma maneira direta de
formatar números com separadores de grupo:
>> Localidade de importação>

>> Locale.setlocale> (locale.LC_ALL "English_United States.1252)
"States.1252 English_United '
>> Conv => locale.localeconv () # obter um mapeamento das convenções
>>> X = 1.234.567,8
>> Locale.format> ("% d", x, agrupando = True)
'1, 234,567 '
>> Locale.format_string> ("% s% .* f", (] currency_symbol [conv ',
... frac_digits '[conv'], x), agrupando = True)
'$ 1,234,567.80'
11.2. Templating ¶
O módulo string inclui uma classe de modelo versátil, com uma sintaxe simplificada adequado

para a edição por usuários finais. Isso permite aos usuários personalizar suas aplicações sem
ter que alterar a aplicação.
O formato utiliza nomes de espaço reservado formado por $ com identificadores válidos
Python (caracteres alfanuméricos e sublinhados). Cercando o espaço com aparelhos permite
que ele seja seguido por mais letras alfanumérico sem espaços intermediários. Escrevendo $
cria um único escapou $:
>>> From string Template importação

>>> T = Template ("$ () vila folk enviar $ 10 a US $ causar. ')
>> T.substitute> (aldeia = 'Nottingham' causa, = 'o fundo de vala)
"Nottinghamfolk enviar 10 dólares para o fundo de vala.
O substituto () O método gera um KeyError quando um marcador não é fornecido em um

dicionário ou um argumento de palavra-chave. Para aplicações de mala direta estilo, dados
fornecidos pelo usuário pode ser incompleta e safe_substitute () método pode ser mais
apropriado - ele vai deixar espaços reservados inalterada se os dados estão em falta:
>>> T = Modelo de retorno ("o item de R $ para US $ proprietário. ')

>>> D = dict (item = 'andorinha sem carga ")
>> T.substitute> (d)
...
KeyError: 'dono'
>> T.safe_substitute> (d)
«Voltar a andorinha, para US $ proprietário.
subclasses modelo pode especificar um delimitador personalizado. Por exemplo, um lote

renomeação de utilidade por um browser foto pode optar pelo uso de sinais por cento para os
espaços reservados, como a data atual, o número de seqüência de imagens, ou formato de
arquivo:
>> Tempo> Importar, os.path

>>> Img_1074.jpg photofiles = ['', 'img_1076.jpg', 'img_1077.jpg']
>>> Class BatchRename (Modelo):
... delimitador = '%'
>> Fmt> = input ('Entre estilo rename (% d-% data% SEQNUM n-f-format):')
Digite estilo rename (% d-% data% SEQNUM n-f-format): Ashley_% n% f
>>> T = BatchRename (FMT)

>> Data> = time.strftime% ('d% b% y')
>>> For i, nome em enumerar (photofiles):
... base, ext = os.path.splitext (filename)
... t.substitute newname = (d = data, n = i, f = ext)
... print ('(0) -> (1)' formato. (filename, newname))

img_1074.jpg -> Ashley_0.jpg
Outra aplicação para templating é separar a lógica do programa a partir de detalhes de

múltiplos formatos de saída. Isto torna possível substituir os modelos personalizados para
arquivos XML, os relatórios de texto simples, HTML e relatórios web.
11.3. Trabalhando com dados binários Record Layouts ¶
A estrutura do módulo fornece pack () e unpack (), funções para trabalhar com formatos de
registro de comprimento variável binária. O exemplo a seguir mostra como um loop através de
informações de cabeçalho em um arquivo ZIP sem o uso do módulo zipfile. códigos Pack "H" e
"I" representam dois e quatro números unsigned byte, respectivamente. Os "<" indica que eles
são de tamanho padrão e em pouco endian byte order:
importação struct
= dados myfile.zip ('open', 'rb'). read ()

start = 0
for i in range (3): # show os cabeçalhos 3 primeiros arquivos
+ Start = 14
struct.unpack fields = ('<IIIHH, dados [iniciar: iniciar 16])
crc32, comp_size, uncomp_size, filenamesize, extra_size = Campos
+ Start = 16
[Dados filename = start: + start filenamesize]
+ Start = filenamesize
[Dados extra = start: + start extra_size]
print (nome, hex (CRC32), comp_size, uncomp_size)
+ + Start = extra_size comp_size # saltar para o próximo cabeçalho
11.4. Multi-threading ¶
Threading é uma técnica de separação de tarefas que não são seqüencialmente dependentes.
Tópicos podem ser utilizados para melhorar a capacidade de resposta dos aplicativos que
aceitam a entrada do usuário, enquanto outras tarefas executadas em segundo plano. Um
caso de uso relacionado está sendo executado I / O em paralelo com os cálculos em outro
segmento.
O código a seguir mostra como o alto nível de segmentação módulo pode executar tarefas em
background enquanto o programa principal continua a ser executado:
segmento de importação, zipfile

AsyncZip classe (threading.Thread):
def __init__ (self, infile, outfile):
threading.Thread.__init__ (self)
self.infile = infile
self.outfile = outfile
def execute (auto):
f = zipfile.ZipFile w (self.outfile, '', zipfile.ZIP_DEFLATED)
f.write self.infile ()
f.close ()
print ('zip fundo terminados em: ", self.infile)
background = AsyncZip ('mydata.txt, myarchive.zip')

background.start ()
print ('O programa principal continua a ser executado em primeiro plano.')
background.join () # Aguarde a tarefa em segundo plano para terminar

print ('programa principal esperou até o fundo foi feito.')
O principal desafio de aplicações multi-threaded está coordenando threads que compartilham

dados ou outros recursos. Para esse fim, o módulo de segmentação fornece um número de
primitivas de sincronização, incluindo bloqueios, eventos, variáveis de condição, e os
semáforos.
Embora essas ferramentas são poderosas, erros de projeto menores pode resultar em
problemas que são difíceis de reproduzir. Assim, a abordagem preferida para coordenação de
tarefas é concentrar todo o acesso a um recurso em um único segmento e, em seguida, usar o
módulo fila para alimentar esse segmento com pedidos de outros segmentos. Aplicações
usando objetos da fila de discussão inter-comunicação ea coordenação são mais fáceis de
design, mais legível, e mais confiável.
11.5. Log ¶
O módulo de registro oferece um completo e flexível sistema de registro. Na sua forma mais
simples, as mensagens de log são enviadas para um arquivo ou sys.stderr:
registro de importação
logging.debug ("As informações de depuração)
logging.info ("Mensagem informativa)
logging.warning ("Aviso: arquivo de configuração% s não encontrado ',' server.conf)
logging.error ('Erro')
logging.critical ("erro crítico - fechar ')
Isso produz o seguinte resultado:
AVISO: root: Atenção: server.conf arquivo de configuração não encontrado

ERROR: root: Erro
CRÍTICA: root: Erro crítico - fechar
Por padrão, as mensagens informativas e depuração são suprimidos eo produto é enviado para
o erro padrão. Outras opções de saída incluem roteamento de mensagens através de e-mail,
datagramas, tomadas ou a um servidor HTTP. Novos filtros pode selecionar diferentes
roteamento baseado em prioridade da mensagem: DEBUG, INFO, aviso, erro, e crítica.
O sistema de registro pode ser configurado diretamente ou Python pode ser carregado de um
usuário do arquivo de configuração editáveis personalizados registro sem alterar o pedido.
11.6. Referências Weak ¶
Python tem gerenciamento automático de memória (contagem de referência para a maioria

dos objetos e coleta de lixo para eliminar ciclos). A memória é liberada logo após a última
referência que tenha sido eliminada.
Esta abordagem funciona bem para a maioria das aplicações, mas ocasionalmente há uma
necessidade de rastrear objetos apenas enquanto estão sendo usados por outra coisa.
Infelizmente, apenas segui-los cria uma referência que torna permanente. O módulo weakref
fornece ferramentas para seguir objetos sem criar uma referência. Quando o objeto não é
mais necessário, ele é automaticamente removido de uma tabela weakref e um callback é
acionado para objetos weakref. Aplicações típicas incluem cache objetos que são caros para
criar:
>> Weakref importação> gc

>>> Class A:
... def __init__ (self, valor):
... = valor self.value
... def __repr__ (self):
... str retorno (self.value)
...
>>> A = A (10) # cria uma referência
>>> D = weakref.WeakValueDictionary ()
>>> D] ['principal' = a # não criar uma referência
>>> D ['principal'] # buscar o objeto se ele ainda está vivo
10
>>> Del a # remover a referência de um
>> GC.Collect> () # executa a coleta de lixo imediatamente
0
>>> D ['principal'] # entrada foi removido automaticamente
Arquivo "<stdin>", line 1, <module>
primário "d ['] # entrada foi removido automaticamente
File "C: /" python31/lib/weakref.py, a linha 46, em __getitem__
self.data o = [] (chave)

KeyError: «primárias»
11.7. Ferramentas para trabalhar com listas ¶
Muitas das necessidades da estrutura de dados pode ser satisfeita com o built-in tipo de lista.
No entanto, às vezes há a necessidade de implementações alternativas com diferentes trade-
offs de desempenho.
O módulo fornece uma matriz (matriz) objeto que é como uma lista que armazena apenas
dados homogêneos e armazena-la mais compacta. O exemplo a seguir mostra uma matriz de
números armazenados como dois bytes sem sinal de números binários (código de tipo "H") ao
invés do usual 16 bytes por entrada para as listas regulares de objetos int Python:
>>> Array de array de importação

>>> A = array ('H', [4000, 10, 700, 22222)]
>> Soma> (a)
26932
>>> A [1:3]
array ('H', [10, 700])
O módulo de coleções fornece um deque () que o objeto é como uma lista com acrescentará
mais rápido e aparece do lado esquerdo, mas pesquisas mais lento no meio. Estes objetos são
adequados para a implementação de filas e largura pesquisas primeira árvore:
>>> A partir de colecções deque de importação

>>> D = deque (["task1", "task2", "Tarefa3"])
>>> D.append ("task4")
>>> Print ("handling", d.popleft ())
Manipulação task1
unsearched deque = ([starting_node])

breadth_first_search def (unsearched):
node = unsearched.popleft ()
de m em gen_moves (nó):
se is_goal (m):
m retorno
unsearched.append m ()
Além de implementações lista alternativa, a biblioteca também oferece outras ferramentas,

como o módulo bissetriz com funções para manipulação de listas ordenadas:
>> Bissetriz de importação>

>>> Ordenar = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
>> Bisect.insort> (pontuação, (300, 'ruby'))
>> Ordenar>

[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]
O módulo heapq fornece funções para a execução pilhas com base em listas regular. O menor
valor de entrada é sempre mantido na posição zero. Isso é útil para aplicativos que acessar
repetidamente o menor elemento, mas não quero correr uma lista completa de classificação:
>>> From heapq heapify importação, heappop, heappush

>>> Dados = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
>> Heapify> (dados) # reorganizar a lista em ordem heap
>> Heappush> (dados, -5) # adiciona uma nova entrada
>>> [Heappop (dados) for i in range (3)] # buscar os três menores entradas
[-5, 0, 1]
11.8. Decimal Floating Point Arithmetic ¶
O módulo decimal oferece um tipo de dados Decimal para aritmética de ponto flutuante
decimal. Comparado com o built-in float execução de ponto flutuante binário, a classe é
especialmente útil para
* Aplicações financeiras e de outras aplicações que exigem representação decimal exata,

* O controle sobre a precisão,
* O controle sobre o arredondamento para atender aos requisitos legais ou regulamentares,
* Acompanhamento de importantes casas decimais, ou
* aplicações onde o usuário espera dos resultados para coincidir com cálculos feitos à mão.
Por exemplo, o cálculo de um imposto de 5% em uma carga de telefone 70 cêntimos dá

resultados diferentes em ponto flutuante decimal e binário de ponto flutuante. A diferença se
torna significativa quando os resultados são arredondados para o cêntimo mais próximo:
>>> De importação decimal *

>> Volta> (Decimal (0,70 '0 ') * Decimal ('1 .05'), 2)
Decimal (0,74 '0 ')
>> Volta> (0,70 * 1,05, 2)
0,73
O resultado decimal mantém um zero à direita, automaticamente inferir quatro importância

lugar de multiplicands com dois significado local. Decimal reproduz a matemática como feito à
mão e evita problemas que podem surgir quando em ponto flutuante binário não podem
representar exatamente as quantidades decimais.
permite a exata representação da classe Decimal para realizar cálculos modulo e testes de
igualdade que são impróprios para ponto flutuante binário:
>> Decimal> (0,00 '1 'Decimal)% ("0,10")

Decimal (0,00 '0 ')

>>> 1,00% 0,10
,09999999999999995
>> Soma> ([Decimal ('0 .1 ') * 10]) == decimal ('1 .0')

Verdadeiro
>> Soma> ([0.1] * 10) == 1,0
Falso
O módulo fornece aritmética decimal com tanta precisão como necessário:
>> GetContext> (). Prec = 36

>> Decimal> (1) / Decimal (7)
Decimal (.142857142857142857142857142857142857 '0 ')
12. E agora?
Lendo este tutorial provavelmente tem reforçado o seu interesse em utilizar Python - você
deve estar ansioso para aplicar Python para resolver seus problemas do mundo real. Onde
você deve ir para saber mais?
Este tutorial é parte da documentação do Python set. Alguns outros documentos que constam
no:
A biblioteca padrão Python:
Você deve navegar por este manual, o que dá completo (embora resumido) material de
referência sobre os tipos, funções e os módulos da biblioteca padrão. A distribuição padrão do
Python inclui uma grande quantidade de código adicional. Existem módulos para ler correio
Unix, recuperar documentos via HTTP, gerar números aleatórios, analisar as opções de linha de
comando, escrever programas CGI, compactar os dados, e muitas outras tarefas. Skimming
através da Biblioteca de Referência lhe dará uma idéia do que está disponível.
*
Instalando Python Módulos explica como instalar módulos externos escritas por outros
usuários Python.
*
A linguagem Python Referência: Uma explicação detalhada da sintaxe e semântica do

Python. É leitura pesada, mas é útil como um guia completo para a linguagem em si.
Mais recursos Python:

* Http://www.python.org: Os principais Python site. Ele contém código, documentação, e
ponteiros para páginas relacionadas com Python na web. Este site é espelhada em vários
lugares ao redor do mundo, como Europa, Japão e Austrália, um espelho pode ser mais rápido
que o site principal, dependendo da sua localização geográfica.
* Http://docs.python.org: Rápido acesso à documentação do Python.
* Http://pypi.python.org: O Python Package Index, anteriormente também apelidado de
Cheese Shop, é um índice criado pelo usuário módulos Python que estão disponíveis para
download. Uma vez que você começar a liberar o código, você pode registrá-lo aqui para que
outros possam encontrá-lo.
* Http://aspn.activestate.com/ASPN/Python/Cookbook/: The Cookbook Python é uma
coleção considerável de exemplos de código, os módulos maiores e scripts úteis.
Particularmente notáveis contribuições são recolhidas em um livro também intitulado Python
Cookbook (O'Reilly & Associates, ISBN 0-596-00797-3).
* Http://scipy.org: O projeto científico Python inclui módulos para o cálculo da matriz rápido
e manipulações além de uma série de pacotes para coisas tais como álgebra linear, Fourier
transforma, solvers não-linear, as distribuições de números aleatórios, análise estatística e,
como .
Para questões relacionadas com Python e relatórios de problemas, você pode postar no
comp.lang.python newsgroup, ou enviá-los para a lista de discussão em python-
list@python.org. O grupo de notícias e lista de clientes passam pelo gateway, assim as
mensagens enviadas para um serão encaminhados automaticamente para o outro. Há cerca de
120 lançamentos por dia (com picos de até várias centenas), perguntando (e responder)
questões, sugerindo novas funcionalidades, e anunciando novos módulos. Antes de postar,
não se esqueça de verificar a lista de Frequently Asked Questions (também chamada de FAQ),
ou procurá-lo no diretório Misc / distribuição do código fonte do Python. arquivos da lista
estão disponíveis em http://mail.python.org/pipermail/. A FAQ responde muitas das questões
que vêm de novo e de novo, e já pode conter a solução para seu problema.
13. Interactive Edição de entrada e ¶ Substituição História
Algumas versões do interpretador Python edição de apoio da linha de corrente de entrada e

de substituição da história, similar às facilidades encontradas na Korn shell eo shell GNU Bash.
Este é implementado usando a biblioteca GNU Readline, que suporta edição no estilo Emacs e
vi-estilo. Essa biblioteca possui sua própria documentação que não vou duplicar aqui, no
entanto, os princípios são facilmente explicados. A edição interativa e história aqui descritas
são opcionalmente disponíveis no Cygwin versões de Unix e do intérprete.
Este capítulo não documenta as facilidades de edição do pacote de Mark Hammond

PythonWin ou o ambiente baseado em Tk, IDLE, distribuído com o Python. O recall da história
da linha de comando que funciona dentro de caixas de DOS no Windows NT e algumas outras
DOS e Windows sabores ainda outra besta.
13.1. ¶ Line Edição
Se for suportado, edição de linha de entrada é ativo sempre que o interpretador imprime um

prompt primário ou secundário. A atual linha pode ser editada usando os caracteres de
controle convencionais Emacs. Os mais importantes são: CA (Control-A-) move o cursor para o
início da linha, até o fim CE, CB move uma posição para a esquerda, CF, à direita. Backspace
apaga o caractere à esquerda do cursor, CD personagem à sua direita. CK mata (apaga) o resto
da linha à direita do cursor, CY puxa para trás a última seqüência mortos. C-sublinhado desfaz
a última alteração feita, ele pode ser repetido para efeito cumulativo.
13.2. ¶ Substituição História
História de substituição funciona da seguinte maneira. Todas as linhas de entrada não-vazio

emitidos são salvas em um buffer de história, e quando um alerta é dado novo que você está
posicionado em uma nova linha na parte inferior desta reserva. CP move uma linha para cima
(para trás) no buffer de histórico, CN movimentos para baixo. Qualquer linha no buffer de
histórico podem ser editados e um asterisco aparece na frente do prompt para marcar uma
linha alterada. Pressionando a tecla Return passa a linha actual para o intérprete. CR inicia
uma busca incremental reverso; CS inicia uma pesquisa para a frente.
13.3. Teclas ¶
As teclas e alguns outros parâmetros da biblioteca Readline pode ser personalizado, colocando
os comandos em um arquivo de inicialização chamado ~ /. Inputrc. Teclas tem a forma
Nome-chave: nome da função-
ou
"String": função de nome
e opções podem ser definidas com
definir o valor, nome da opção
Por exemplo:
# Eu prefiro a edição vi-style:

definir o modo de edição vi-
# Edit usando uma única linha:

conjunto de rolagem horizontal, de modo On
# Rebind algumas chaves:

Meta h: para trás matar palavra
\ "C-u": o argumento universal
\ "C-x \ r C": re-leitura init-file
Note-se que o padrão obrigatório para Tab em Python é inserir um caractere de tabulação em
vez de padrão Readline a função nome completo. Se você insistir, você pode substituir esse

pondo
Tab: completo
em seu ~ /. inputrc. (É claro, isso torna mais difícil a continuação linhas recuadas tipo se você
está acostumado a usar Tab para essa finalidade).
Complementação automática de variáveis e nomes de módulo está disponível opcionalmente.

Para habilitá-lo no modo interativo do intérprete, adicione o seguinte ao seu arquivo de
inicialização: [1]
rlcompleter de importação, readline

readline.parse_and_bind ('tab: complete')
Esta liga-se a tecla Tab para a função de conclusão, de modo a apertar a tecla Tab duas vezes
sugere complementos, que olha para nomes declaração Python, variáveis local atual, e os
nomes disponíveis módulo. Para expressões pontilhada como string.a, ele irá avaliar a
expressão até o "final". e então sugerir conclusões a partir dos atributos do objeto resultante.
Observe que isso pode executar um código definido pelo aplicativo, se um objeto com um
__getattr__ () é parte da expressão.
Um arquivo de inicialização mais capaz pôde olhar como este exemplo. Observe que isso exclui
os nomes que cria uma vez que eles não são mais necessários, o que é feito desde o arquivo de
inicialização é executado no mesmo espaço de nomes como os comandos interativos, e
remover os nomes evita criar efeitos colaterais no ambiente interativo. Você pode achar que é
conveniente manter alguns dos módulos importados, como os, que acabam por ser necessário
na maioria das sessões com o intérprete.
# Adicione preenchimento automático e um arquivo histórico de comandos armazenados no

seu Python
# Interpretador interativo. Requer Python 2.0 + readline. Autocomplete é
# Vinculado à tecla Esc por padrão (você pode alterá-lo - ver docs readline).
#
# Armazene o arquivo em ~ / pystartup. E definir uma variável de ambiente para apontar
# Para isso: "export PYTHONSTARTUP = / home / user / .pystartup" em bash.
#
# Note que PYTHONSTARTUP * não * expandir "~", então você tem que colocar no
# Caminho completo para o diretório home.
atexit importação
OS importação
readline importação
rlcompleter importação
historyPath = os.path.expanduser ("~/. pyhistory ")

save_history def (historyPath = historyPath):
readline importação
historyPath (readline.write_history_file)
se os.path.exists historyPath ():

historyPath (readline.read_history_file)
atexit.register (save_history)
del OS, atexit, readline, rlcompleter, save_history, historyPath
13.4. Alternativas para o interpretador interativo
Esta facilidade é um enorme passo em frente em comparação com as versões anteriores do

intérprete, no entanto, alguns desejos são deixados: Seria bom se a indentação foram
sugeridos em linhas de continuação (o parser sabe se um token travessão é necessário seguir).
O mecanismo de completação pode usar a tabela do intérprete símbolo. Um comando para
verificar (ou mesmo sugerir) parênteses correspondentes, citações, etc, também seria útil.
Uma alternativa melhor intérprete interativo que tem sido em torno de algum tempo é
IPython, que apresenta a conclusão de tabulação, objeto de exploração e gestão avançada da
história. Também pode ser completamente personalizado e incorporado em outros aplicativos.
Outro ambiente interativo é reforçada similar bpython.
Notas de Rodapé
[1] Python executará o conteúdo de um arquivo identificado pela variável de ambiente
PYTHONSTARTUP quando você iniciar um interpretador interativo.

Learn Scratch 05

Enviado por

Dados do documentoclique para ver informações do documentopython

Dados do documentoclique para ver informações do documento

Direitos autorais:

Formatos disponíveis

Learn Scratch 05

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Learn Scratch 05

Enviado por

Direitos autorais:

Formatos disponíveis

Instituto Federal de Educação, Ciência e Tecnologia da Paraíba

Campus de Campina Grande

Python é fácil de aprender, poderosa linguagem de programação. Tem eficientes

O interpretador Python e extensa biblioteca padrão estão disponíveis gratuitamente

Este tutorial introduz o leitor informalmente aos conceitos básicos e as

Este tutorial não pretende ser abrangente e cobrir todas as características

O Glossário também vale a atravessar.

TUTORIAL PYTHON 3.1 Português

TUTORIAL PYTHON 3.1 Português

TUTORIAL PYTHON 3.1 Português

1. Abrindo seu apetite

TUTORIAL PYTHON 3.1 Português

Python é apenas a língua para você.

TUTORIAL PYTHON 3.1 Português

No próximo capítulo, a mecânica de usar o interpretador é explicada. Esta informação é

O resto do tutorial introduz várias características da linguagem Python e do sistema através de

2. Usando o interpretador Python

O interpretador Python é geralmente instalado em / usr/local/bin/python3.1 sobre aquelas

Em máquinas Windows, a instalação do Python é normalmente colocado em C: \ Python31,

% Path set path =%; C: \ python31

Digitar um caractere de fim-de-arquivo (Control-D em Unix, Control-Z em Windows) para as

TUTORIAL PYTHON 3.1 Português

Quando conhecido o intérprete, o nome do script e depois argumentos adicionais são

TUTORIAL PYTHON 3.1 Português

Linhas de continuação são necessárias quando entrar em um multi-line construir. Como

2.2. The Interpreter e Seu Ambiente

Quando ocorre um erro, o interpretador imprime uma mensagem de erro e um rastreamento

Digitando o caráter de interrupção (normalmente Control-C ou DEL) à cancela primária ou

TUTORIAL PYTHON 3.1 Português

Em sistemas Windows, não há noção de um modo "executável". O instalador do Python

# -*- Coding: -*- encoding

# -*- Coding: cp-1252 -*-

e ainda utilizar todos os caracteres da personagem Windows-1252 em conjunto os arquivos de

TUTORIAL PYTHON 3.1 Português

3. Uma Introdução Informal a Python ¶

TUTORIAL PYTHON 3.1 Português

# Este é o primeiro comentário

3.1. Usando Python como uma calculadora ¶

>>> # Integer retorna a divisão do piso:

TUTORIAL PYTHON 3.1 Português

Um valor pode ser atribuído a diversas variáveis simultaneamente:

>>> # Tentar acessar uma variável indefinida

>>> 3 * 3,75 / 1,5

TUTORIAL PYTHON 3.1 Português

>>> A = 1,5 0,5 j

>>> A = 3,0 4,0 j

>> Fiscal> = 12,5 / 100

TUTORIAL PYTHON 3.1 Português

Olá = "Esta é uma cadeia bastante longa contendo \ n \

Esta é uma cadeia bastante longa contendo

TUTORIAL PYTHON 3.1 Português

print ("" "

produz o seguinte resultado:

Uso: thingy [OPTIONS]

Olá = r "Esta é uma cadeia bastante longa contendo \ n \

Esta é uma cadeia bastante longa contendo \ n \

Strings podem ser concatenadas (coladas) com o operador +, e repetidas com *:

>> Palavra => 'Ajuda' + 'A'

# -- Coding: -- encoding

# -- Coding: cp-1252 --