Programação em Python

DSC551
 Lista de Capítulos
Capítulo 1: Coisas Muito Básicas
Capítulo 2: Condicionais
Capítulo 3: Funções
Capítulo 4: Iteração
Chapter 5: Strings
Capítulo 6: Tipos de Dados de Coletânea
Chapter 7: Advanced Functions
Chapter 8: Exception Handling
Chapter 9: Python Modules
Chapter 10: Files
Capítulo 11: Documentação
Capítulo 12: Classes
Capítulo 13: Programação CGI
 Isenção de responsabilidade

Esta nota foi escrita por C. D. Sherrill, janeiro

2010

Editado por Mohd Razif Bin Shamsuddin

 Recursos
Estas notas são baseadas em informações de várias
sources:
Aprendendo Pythonndedição, Mark Lutz e David Ascher
(O'Reilly, Sebastopol, CA, 2004) (Aprofundado. Difícil de obter
como uma leitura rápida)
“Dive Into Python,”Mark Pilgrim ([Link]
2004)
Como Pensar Como um Cientista da Computação: Aprendendo com
Python,"2ndedição, Jeffrey Elkner, Allen B. Downey, e
Chris Meyers ([Link]
Programação em Python 3: Uma Introdução Completa ao
Linguagem Python,"Mark Summerfeld (Addison-Wesley,
Boston, 2009
[Link]
 Por que Python?

Linguagem de alto nível pode fazer muito com relativamente

pequeno código
Supposedly easier to learn than its main
competitor, Perl
Relativamente popular entre as linguagens de alto nível

Suporte robusto para programação orientada a objetos

Suporte para integração com outras linguagens
 Chapter 1: Very Basic Stuff
Executando programas em python

Variáveis
Impressão
Operadores
Entrada
Comentários
Escopo
 Coisas Muito Básicas
Você pode executar programas Python a partir de arquivos, assim como
perl ou scripts shell, digitando 'python
[Link]" no terminal. O arquivo pode
conter apenas os comandos python.
Ou, pode-se invocar o programa diretamente por
digitando o nome do arquivo, "[Link]", se ele
tem como primeira linha algo como
#!/usr/bin/python (como um script de shell... funciona como
desde que o arquivo tenha permissões de execução definidas

Alternativamente, você pode entrar em um shell Python e

execute comandos python interativamente, digitando
python
 Olá, mundo!
Vamos começar! Aqui está um exemplo de um python
programa executado como um script:

#!/usr/bin/python

print "Olá, mundo"

Se isso for salvo em um arquivo [Link], então defina como executável

permissões neste arquivo (chmod u+x [Link] em
Unix/Linux), e execute-o com "./[Link]"
Quando executado, este programa imprime

Olá, mundo
 Mais sobre impressão

>>> print 'olá:', x, x**2, x**3

hello: 4 16 64
é um caractere de tabulação
>>> print "2**2 =","\t",2**2
2**2 = 4
Encerrando uma declaração de impressão com uma vírgula
suprime a nova linha, então o próximo print
statement continues on the same line
Pode imprimir em um arquivo aberto (mais tarde) assim:
imprimir >> outfile, mensagem
 Outras coisas divertidas

Exemplo [Link]
#!/usr/bin/perl
imprimir 1+3
pi = 3.1415926
imprimir pi
message = "Hello, world"
imprimir mensagem

Output:
4
3,1415926
Olá, mundo
 Tipos de variáveis

No exemplo anterior, "pi" e "mensagem" são variáveis,

mas um é um número de ponto flutuante, e o outro é uma string.
Observe que não declaramos os tipos em nosso exemplo. Python
decidiu tipos para as variáveis, no entanto.
Na verdade, "variáveis" em Python são realmente referências a objetos.
A razão pela qual não precisamos declarar tipos é que um
referência pode apontar para um tipo diferente mais tarde.

[Link]:
x=42
y=”hello”
imprimir x,y # imprime 42 olá
print x,y # imprime 42 42
 Tipos de variáveis
Exemplo [Link]:
pi = 3.1415926
message = "Hello, world"
i = 2+2

imprimir tipo(pi)
print tipo(mensagem)
imprimir tipo(i)

Output:
<tipo 'float'>
<tipo 'str'>
<tipo 'int'>
 Nomes de variáveis

Pode conter letras, números e underscores

Deve começar com uma letra
Não pode ser um dos reservados do Python
keywords: and, as, assert, break, class,
continue, def, del, elif, else, except, exec, finally,
for, from, global, if, import, in, is, lambda, not, or,
pass, print, raise, return, try, while, with, yield
 Mais sobre nomes de variáveis

Nomes que começam com um sublinhado (_V) são

não importado do módulo importar *
declaração
Nomes que começam e terminam com 2 sublinhados
são nomes especiais definidos pelo sistema (por exemplo,
__V__)
Nomes que começam com 2 sublinhados (mas
sem sublinhados finais) são locais a uma classe
(__V)
Um único sublinhado (_) por si só denota o
resultado da última expressão
 Operadores
+ adição
subtração
/ divisão
** exponenciação
% módulo (resto da divisão)
Operadores de comparação no Capítulo 2
 Operadores
Exemplo [Link]
imprimir 2*2
imprimir 2**3
imprimir 10%3
imprimir 1.0/2.0
imprimir 1/2

Output:
4
8
1
0,5
0
Note a diferença entre a divisão em ponto flutuante e
divisão inteira nas últimas duas linhas
 += mas não ++
Python incorporou operadores como +=, mas
++ (ou --) não funcionam em Python
 Conversão de tipo
int(), float(), str(), e
bool() converte para
inteiro, ponto flutuante
string e booleano
(Verdadeiro ou Falso) tipos,
respectivamente
Exemplo [Link]: Output:
imprimir 1.0/2.0 0,5
imprimir 1/2 0
imprimir float(1)/float(2) 0,5
imprimir int(3.1415926) 3
imprima str(3.1415926) 3.1415926
imprimir bool(1) Verdadeiro
imprimir bool(0) False
 Operadores que atuam em strings
Ni!Ni!Ni!
Ni!Ni!Ni!
Olá, mundo!
Olá, mundo!
 Entrada do teclado
Exemplo [Link]
i = input("Digite uma expressão matemática: ")
imprimir i
j = input("Digite a mesma expressão: ")
imprimir j

Output:
localhost(workshop)% ./[Link]
Insira uma expressão matemática: 3+2
3+2
Digite a mesma expressão: 3+2
5
 Comments
Qualquer coisa após um símbolo # é tratado como um
comentário
Isto é apenas como Perl
 Capítulo 2: Condicionais
Booleanos Verdadeiro e Falso
Operadores de Comparação e Lógicos
se, elif e else
 Booleans: True and False
>>> type (True)
<tipo 'bool'>
>>> tipo (verdadeiro)
Rastreamento (chamada mais recente por último):
Arquivo "<stdin>", linha 1, em <módulo>
NameError: name 'true' is not defined
>>> 2+2==5
Falso
Nota: Verdadeiro e Falso são do tipo bool.
a capitalização é necessária para os booleanos!
 Expressões booleanas
Uma expressão booleana pode ser avaliada como Verdadeira
ou Falso. Uma expressão avalia como Falsa se ela
é...
o constante False, o objeto None, um vazio
sequência ou coleção, ou um item numérico de
value 0
Tudo o mais é considerado Verdadeiro
 Operadores de comparação
== : é igual a?
!= : não é igual a
> : maior que
< : menor que
>= : maior ou igual a
≤ : menor ou igual a
as duas referências referem-se ao mesmo objeto?
(Veja o Capítulo 6)
 Mais sobre comparações
Comparações em 'cadeia':
>>> a = 42
0 <= a <= 99
Verdadeiro
 Operadores lógicos
and, or, not

>>> 2+2==5 ou 1+1==2

Verdadeiro
>>> 2+2==5 e 1+1==2
Falso
não(2+2==5) e 1+1==2
Verdadeiro
Nota: Não usamos &&, ||, !, como em C!
 Seções se
Example [Link]
se (1+1==2):
imprimir ("1+1==2")
Eu sempre pensei assim!
senão:
Minha compreensão de matemática deve estar errada!

Uma linha simples de if:

se (1+1==2): print("Eu consigo somar!")
 declaração elif
Equivalente de "else if" em C
Exemplo [Link]:
x=3
if (x == 1):
imprimir ("um")
elif (x == 2):
imprimir ("dois")
senão:
muitos
 Chapter 3: Functions
Definindo funções
Valores de retorno
Variáveis locais
Funções embutidas
Funções de funções
Passando listas, dicionários e palavras-chave para
funções
 Funções
Defina-os no arquivo acima do ponto em que estão.
usado
O corpo da função deve ser indentado
consistentemente (4 espaços é típico em Python)
exemplo: [Link]
def quadrado(n):
retorna n*n

O quadrado de 3 é
imprima quadrado(3)

Output:
O quadrado de 3 é 9
 A declaração def
A declaração def é executada (é por isso que
as funções têm que ser definidas antes de serem
usado)
define um objeto e atribui um nome a
referencie-o; a função poderia ser atribuída
outro nome, nomes de funções podem ser armazenados em
uma lista, etc.
Pode colocar uma declaração def dentro de uma declaração if,
etc!
 Mais sobre funções
Os argumentos são opcionais. Vários argumentos são
separados por vírgulas.
Se não houver uma instrução de retorno, então "None" é
retornou. Valores de retorno podem ser tipos simples ou
tuplas. Os valores de retorno podem ser ignorados pelo
chamador.
As funções são "sem tipo". Podem ser chamadas com
argumentos de qualquer tipo, desde que o
operações na função podem ser aplicadas ao
argumentos. Isso é considerado uma coisa boa em
Python.
 As variáveis de função são locais
Variáveis declaradas em uma função não existem fora
essa função
Exemplo [Link]
def quadrado(n):
m = n*n
retornar m

O quadrado de 3 é
imprimir quadrado(3)
imprimir m

Output:
Arquivo "./[Link]", linha 9, em <módulo>
imprimir m
NameError: name 'm' is not defined
 Escopo
Variáveis atribuídas dentro de uma função são locais a essa
chamada de função
Variáveis atribuídas no topo de um módulo são globais para
aquele módulo; só existe 'global' dentro de um módulo
Dentro de uma função, o Python tentará corresponder a uma variável
nome atribuído localmente dentro da função; se isso
falhar, tentará dentro da definição de função de fechamento (def)
declarações (se apropriado); se isso falhar, tentará
resolva o nome no escopo global (mas a variável
deve ser declarado global para que a função possa
mude isso). Se nenhum desses corresponder, o Python irá procurar
através da lista de nomes embutidos
 Exemplo de escopo

[Link]

a = 5 # global

def func(b):
c=a+b
retornar c

imprimir func(4) # dá 4+5=9

imprimir c # não definido
 Exemplo de escopo

[Link]

a = 5 # global

def func(b):
global c
c=a+b
retornar c

imprima func(4) # dá 4+5=9

imprimir c # agora está definido (9)
 Por valor / por referência

Tudo em Python é uma referência. No entanto,

note também que objetos imutáveis não são
mutável --- então mudanças para objetos imutáveis
dentro de uma função, apenas mude o que o objeto o
o nome aponta para (e não afeta o chamador,
a menos que seja uma variável global)
Para objetos imutáveis (por exemplo, inteiros, strings,
tuplas), o Python age como se fosse a passagem por valor do C

Para objetos mutáveis (por exemplo, listas), o Python age como

Em C, passagem por ponteiro; mudanças no local para
objetos mutáveis podem afetar o chamador
 Exemplo
[Link]

def f1(x,y):
x=x*1
y=y*2
imprimir x, y # 0 [1, 2, 1, 2]

def f2(x,y):
x=x*1
y[0] = y[0] * 2
imprimir x, y # 0 [2, 2]

a=0
b = [1,2]
f1(a,b)
imprimir a, b # 0 [1, 2]
f2(a,b)
imprimir a, b # 0 [2, 2]
 Múltiplos valores de retorno

Pode retornar múltiplos valores embalando-os

em uma tupla

def umdoistres(x):
retornar x*1, x*2, x*3

imprimir onetwothree(3)

3, 6, 9
 Funções Integradas
Várias funções embutidas úteis. Exemplo
[Link]

imprimir pow(2,3)
imprimir abs(-14)
imprimir max(1,-5,3,0)

Output:
8
14
3
 Funções de Funções
Exemplo [Link] Output:
def iseven(x,f): Verdadeiro
se (f(x) == f(-x)): Falso
retornar Verdadeiro
senão:
retornar Falso

def quadrado(n):
retornar(n*n)

def cubo(n):
retornar(n*n*n)

imprimir épar(2,quadrado)
imprimir épar(2,cubo)
 Argumentos padrão
Como C ou Java, pode definir uma função para fornecer um
valor padrão para um argumento se um não for fornecido
especificado

def print_error(lineno, message="erro"):

print "%s na linha %d" % (mensagem, lineno)

imprimir_erro(42)

erro na linha 42
 Funções sem valores de retorno

Todas as funções em Python retornam algo. Se um

A declaração de retorno não é dada, então por padrão,
Python retorna None
Cuidado ao atribuir uma variável ao resultado de um
função que retorna None. Por exemplo, o
a função append da lista modifica a lista, mas não
não retorna um valor:
a = [0, 1, 2]
b = [Link](3)
imprimir b
Nenhum
 Chapter 4: Iteration
loops while
laços for
função range
Controle de fluxo dentro de laços: break, continue, pass
e o 'loop else'
 enquanto
Exemplo [Link]
i=1
enquanto i < 4:
imprimir i
i += 1
Output:
1
2
3
 para
Exemplo [Link]
para i em range(3):
imprimir eu,

output:
0, 1, 2
range(n) retorna uma lista de inteiros de 0 a n-1.
range(0,10,2) retorna uma lista 0, 2, 4, 6, 8
 Controle de fluxo dentro de loops

Estrutura geral de um loop:

enquanto <declaração> (ou para <item> em <objeto>):
<declarações dentro do loop>
se <teste1>: quebrar # sair do loop agora
se <teste2>: continue # vá para o topo do loop agora
se <teste3>: passar # não faz nada!
senão:
outro tipo de declarações # se saiu do loop sem
fazer uma pausa
 Usando o 'loop else'
Uma declaração else após um loop é útil para
cuidando de um caso onde um item não é encontrado
em uma lista. Exemplo: search_items.py:

para i em range(3):
se i == 4:
eu encontrei 4!
quebrar
senão:
não me importo com
senão:
Eu procurei, mas nunca encontrei 4!
 para ... em
Usado com tipos de dados de coleção (veja o Capítulo 6)
que podem ser iterados através de (“iteráveis”):
for name in [“Mutasem”,“Micah”,“Ryan”]:
se nome[0] == “M”:
imprimir nome, "começa com um M"
senão:
print nome, "não começa com M"
Mais sobre listas e strings mais tarde
 Percursos paralelos
Se quisermos percorrer 2 listas (mais tarde) em
paralelo, pode usar zip:
A = [1, 2, 3]
B = [4, 5, 6]
para (a,b) em zip(A,B):
imprima a, "*", b, "=", a*b

output:
1*4=4
2 * 5 = 10
3 * 6 = 18
 Chapter 5: Strings
Noções básicas de strings

Sequências de escape
Fatias
Citações em bloco
Formatação
Métodos de string
 Fundamentos de String
As strings podem ser delimitadas por aspas simples ou duplas
Python usa Unicode, então as strings não estão limitadas ao ASCII
personagens
Uma string vazia é denotada por não ter nada entre
delimitadores de string (por exemplo, '')

É possível acessar elementos de strings com [], utilizando indexação

começando do zero:
"cobras"[3]
'k'
Nota: não pode ir de outra forma --- não pode definir "snakes"[3] = 'p' para
mudar uma string; strings são imutáveis
a[-1] obtém o último elemento da string a (índices negativos)
trabalhe a partir da string de trás para frente)
Strings como a = r'c:\home\[Link]' (começando com um r
caracteres antes dos delimitadores) são strings "raw" (interprete
literalmente)
 Mais noções básicas de strings

Type conversion:
>>> int("42")
42
>>> str(20.4)
20.4
Compare strings com o operador de igualdade, ==
(como em C e C++):
ola
>>> b ="olá"
>>> a == b
Verdadeiro
>>>location =“Chattanooga“+“Tennessee”
>>>location
Chattanooga, Tennessee
 Sequências de escape

Escape Meaning
\\ \
\' '
\” “
nova linha
\t guia
{id} unicode dbase id
\uhhhh unicode 16-bit hex
... Unicode 32-bit hex
\x dígitos hexadecimais valor hh
Byte nulo (diferente de C, não termina
string
 Citações em bloco

Strings de múltiplas linhas usam aspas triplas:

Quatro vezes vinte e sete anos
... atrás, nossos pais trouxeram à luz este
... continente, uma nova nação, concebida em
... Liberdade, e dedicada à proposição
... que todos os homens são criados iguais.
 Funções
Defina-os no arquivo acima do ponto em que estão.
usado
O corpo da função deve ser indentado
consistentemente (4 espaços é típico em Python)
exemplo: [Link]
def quadrado(n):
retorna n*n

O quadrado de 3 é
imprima quadrado(3)

Output:
O quadrado de 3 é 9
 Percorrendo uma string
Uma string é tratada como uma coleção de caracteres,
e assim tem algumas propriedades em comum com
outras coleções como listas e tuplas (veja
abaixo).
>>> para c em "cobras": print c,
...
cobrinha

'a' em "cobras"
Verdadeiro
 Fatias
Fatiar: obter uma substring da posição i até j-1:
serpentes
na
Ambos os argumentos de um slice são opcionais; a[:] fará
apenas forneça uma cópia da string a
 Exemplo de escopo

[Link]

a = 5 # global

def func(b):
global c
c=a+b
retornar c

imprima func(4) # dá 4+5=9

imprimir c # agora está definido (9)
 método substituir
Não substitui realmente (strings são imutáveis)
mas cria uma nova string com a substituição
realizado
>>> a = "abcdefg"
>>> b = [Link]('c', 'C')
>>> b
abCdefg
>>> a
abcdefg
 Mais exemplos de métodos
[Link]:
Ele achou chato e foi embora
loc = [Link](“entediante”)
a = a[:loc] + "fun"
imprimir a

b = ' and '.join([“cars”,“trucks”,“motorcycles”])

imprimir b
c = [Link]()
imprimir c

d = [Link]("e")
imprimir d

Output:
Ele achou divertido
carros e caminhões e motocicletas
["carros","e","caminhões","e","motos"]
["carros","caminhões","motocicletas"]
 Expressões Regulares
•As expressões regulares são uma forma de fazer padrões-
correspondência. O conceito básico (e a maior parte da
a sintaxe da expressão regular atual) é o
mesmo em Java ou Perl
 Sintaxe de Expressões Regulares

•Sintaxe comum de expressões regulares:

. Combina qualquer caráter, mas não a nova linha (por padrão)
^ Combina com o início de uma string
$ Matches the end of a string
* Qualquer número do que vem antes disso
+ Um ou mais do que vem antes disso
Ou
Qualquer caractere alfanumérico
\d Qualquer dígito
\s Qualquer caractere de espaço em branco

(Nota: \W corresponde a NÃO-alfanumérico, \D NÃO dígitos, etc)

[aeiou] corresponde a qualquer um de a, e, i, o, u
lixo Corresponde à string 'lixo'
 Exemplo Simples de Regexp
import re #importa o módulo de expressões regulares

infile = open("[Link]", 'r')

linhas = [Link]()
[Link]()
# substitua todos os PSI3 por PSI4
matchstr = [Link](r"PSI3",
[Link])
para linha em linhas:
linha = [Link](r'PSI4', linha)
imprimir linha,
 Exemplo Simples de Regexp
•No exemplo anterior, abrimos um arquivo e lemos tudo o que está dentro dele.
linhas (veja o próximo capítulo), e substituímos todos os PSI3
instâncias com PSI4
O módulo de expressão regular precisa ser importado
Precisamos "compilar" a expressão regular com
[Link](). O caractere "r" aqui e abaixo significa tratar
isto como uma string "bruta" (nos poupa de ter que escapar
caracteres de barra invertida com outra barra invertida)

•[Link] (re.I) é um argumento opcional. Outro

seria [Link] (re.S; ponto corresponderia a quebras de linha; por
por padrão não o faz). Outro é [Link] (re.M), que
faz ^ e $ corresponder antes e depois de cada quebra de linha em um
string
 Mais sobre Regexps
•O passo [Link]() é opcional (mais eficiente se estiver fazendo muitos regexps.

•Pode usar [Link](regex, sujeito) ou [Link](regex, sujeito) como alternativa

sintaxe
•[Link]() só procura uma correspondência no início de uma linha; não precisa
para corresponder à string inteira, apenas o começo
•[Link]() tenta encontrar uma correspondência em toda a string até que encontre uma correspondência

•[Link](regex, subject) retorna um array de todas as correspondências não sobrepostas;

alternativamente, pode fazer
para m em [Link](regex, assunto)
•Match(), search(), finditer() e findall() não suportam o terceiro opcional.
argumento de flags de correspondência de regex; pode começar regex com (?i), (?s), (?m), etc,
em vez
 [Link]()
•[Link](regex, subject) retorna um array de strings. As strings
são todas as partes do sujeito além das partes que correspondem. Se
duas correspondências são adjacentes no assunto, então split() irá
include an empty string.
•Exemplo:
line =“Upgrade the PSI3 program to PSI4. PSI3 was an
excelente programa.
matchstr = [Link](“PSI3”, line)
para i em matchstr:
imprimir i
Atualize o
>>> programa para PSI4.
foi um excelente programa.
 Funções de Objeto Match

•Search() e match() retornam um MatchObject.

Este objeto possui algumas funções úteis:
grupo(): retorna a string correspondente
iniciar(): posição inicial da partida
end(): posição final da correspondência
span(): tupla contendo o (início,fim)
posições da partida
 Exemplo de Objeto de Correspondência

line = "Now we are upgrading the PSI3 program"

matchstr = [Link]("PSI3", line)
imprimir "A partida começa no caractere ", [Link]()
imprimir "A partida termina no caractere ", [Link]()
imprima "Antes da correspondência: ", linha[0:[Link]ício()]

print "Após a correspondência:", linha[[Link]():]

 Grupos de captura

• Parênteses em uma expressão regular denotam

"grupos de captura" que podem ser acessados por
número ou pelo nome para obter a correspondência
(capturado)
Podemos nomear os grupos de captura com
(?P<name>)
Podemos também aproveitar as strings com aspas triplas
strings (que podem abranger várias linhas) para
defina a expressão regular (que pode
inclua comentários) se usarmos o [Link]
opção
 Exemplo de Grupos de Captura
infile = open("[Link]", 'r')
linhas = [Link]()
[Link]()
# string entre três aspas pode abranger várias linhas

restring = """[ \t]* # espaço em branco opcional no início

(?P<key>\w+) # nomeia a palavra correspondente 'key'

[ \t]*=[ \t]* # sinal de igual com espaço em branco opcional

(?P<value>.+) # some non-whitespace after = is 'value'

"""
matchstr = [Link](restring, [Link] | [Link])
para linha em linhas:
para correspondência em [Link](linha):

imprimir "chave =", correspondê[Link]("chave"),

print ", valor =", [Link]("value")

Capítulo 6: Tipos de Dados de Coleção

Tuplas
Listas
Dicionários
 Tuplas
Tuplas são uma coleção de itens de dados. Elas podem
ser de tipos diferentes. Tuplas são imutáveis como
strings. Listas são como tuplas, mas são mutáveis.
>>>“Tony”,“Pat”,“Stewart”
('Tony', 'Pat', 'Stewart')
Python usa () para denotar tuplas; nós poderíamos também
use (), mas se tivermos apenas um item, precisamos
use uma vírgula para indicar que é uma tupla: ("Tony",)
Uma tupla vazia é denotada por ()
É necessário colocar a tupla entre () se quisermos passá-la.
tudo junto como um argumento para uma função
 Listas
Como tuplas, mas mutáveis, e designadas por
colchetes quadrados em vez de parênteses:
[1, 3, 5, 7, 11]
[1, 3, 5, 7, 11]
>>> [0, 1, 'boom']
[0, 1, 'boom']
Uma lista vazia é []
Adicionar um item:
>>> x = [1, 2, 3]
>>> [Link]("feito")
>>> print x
[1,2,3,"feito"]
 Listas e Tuplas Contêm Objetos
Referências
Listas e tuplas contêm referências de objetos.
Como listas e tuplas também são objetos, elas podem
ser aninhado

>>> a=[0,1,2]
>>> b=[a,3,4]
>>> imprimir b
[[0,1,2],3,4]
>>> print b[0][1]
1
>>> print b[1][0]
... TypeError: objeto 'int' não é subscriptível
 Lista de exemplo

[Link]
x=[1,3,5,7,11]
imprimir x
print "x[2]=" , x[2]
x[2] = 0
Substitua 5 por 0, x = , x
[Link](13)
print "Após adicionar, x = ", x
[Link](1) # remove o 1, não o item na posição 1!!
print "Após remover o item 1, x = ", x
[Link](1,42)
imprimir "Inserir 42 no item 1, x = ", x
Output:
[1, 3, 5, 7, 11]
x[2]= 5
Substituir 5 por 0, x = [1, 3, 0, 7, 11]
Após adicionar, x = [1, 3, 0, 7, 11, 13]
Após remover o item 1, x = [3, 0, 7, 11, 13]
Insira 42 no item 1, x = [3, 42, 0, 7, 11, 13]
 Indexação
Indexação para uma lista
>>> x=[1,3,5,7,11]
>>> x[2]
5
>>> x[2]=0
>>> x
[1,3,0,7,11]
Pode indexar uma tupla da mesma forma, mas não pode
mude os valores porque as tuplas são
imutável
As fatias funcionam como para strings (lembre-se do último índice de
a fatia não está incluída
>>> x[2:4]
[0,7]
 O operador += para listas
>>> a = [1, 3, 5]
>>> a += [7] # a += 7 falha
a
[1, 3, 5, 7]
>>> a += ["o-fim"] # coloque isso também em []!
>>>a
[1, 3, 5, 7, 'the-end']
 Dicionários
Coleções não ordenadas onde os itens são
acessado por uma chave, não pela posição na lista
Como um hash em Perl
Coleção de objetos arbitrários; use objeto
referências como listas
Aninhável
Pode crescer e encolher no lugar, como listas
Concatenação, fatiamento e outras operações
que dependem da ordem dos elementos não
trabalhar em dicionários
Construção e Acesso ao Dicionário
Exemplo:
>>> jobs = {'David':'Professor',
'Sahan':'Postdoc', 'Shawn':'Grad student'}
>>> jobs['Sahan']
Pós-doutorado
Pode mudar de lugar
>>> jobs['Shawn'] = 'Postdoc'
>>> jobs['Shawn']
Pós-doutorado
Listas de chaves e valores
>>> [Link]()
['Sahan', 'Shawn', 'David'] # note order is diff
>>> [Link]()
["Pós-doutorado","Pós-doutorado","Professor"]
>>> [Link]()
[('Sahan', 'Postdoc'), ('Shawn', 'Postdoc'),
('David', 'Professor')]
 Operações Comuns de Dicionário
Excluir uma entrada (por chave)
del d['keyname']
Adicionar uma entrada
d['newkey'] = newvalue
Veja se uma chave está no dicionário
d.tem_chave('keyname') ou 'keyname' em d
método get() útil para retornar valor, mas não falhar
(retornar None) se a chave não existir (ou puder fornecer
um valor padrão)
[Link]('keyval', default)
update() mescla um dicionário com outro
(sobrescrevendo valores com a mesma chave)
[Link](d2) [a versão de dicionário de
concatenação
 Exemplo de dicionário
Passando por um dicionário por chaves:

bookauthors = {'Gone with the Wind':

Margaret Mitchell
'Aeneid': 'Virgil',
'Odyssey': 'Homer'}
para livro em autoresdelivros:
imprimir livro, 'por', autoresDoLivro[livro]

output:
E o Vento Levou de Margaret Mitchell
Aeneid by Virgil
Odisseia de Homero
Construindo dicionários a partir de listas

Se tivermos listas separadas para as chaves e

valores, podemos combiná-los em um dicionário
usando a função zip e um construtor de dicionário:

keys = ['david', 'chris', 'stewart']

values = ['504', '637', '921']
D = dicionário(zip(chaves, valores))
 More general keys
As chaves não precisam ser strings; elas podem ser quaisquer.
tipo de dado imutável, incluindo tuplas
Isso pode ser bom para representar escasso
matrizes, por exemplo
Matrix = {} iniciar um dicionário em branco
Matrix[(1,0,1)] = 0.5 # key is a tuple
Matrix[(1,1,4)] = 0.8
 Length of collections
len() retorna o comprimento de uma tupla, lista ou
dicionário (ou o número de caracteres de um
string):
>>>len(("Tony",))
1
>>>len("Tony")
4
>>>len([0, 1, 'boom'])
3
 O operador "é"
As "variáveis" do Python são realmente referências a objetos.
O operador "is" verifica se estes
as referências referem-se ao mesmobjeto (nota: poderia
tenho dois objetos idênticos que não são o
mesmo objeto...)
References to integer constants should be
idênticos. Referências a strings podem ou não
aparecer como referindo-se ao mesmo objeto. Dois
objetos idênticos e mutáveis não são necessariamente
o mesmo objeto
 [Link]
x = "hello"
y = "hello"
imprimir x é y Verdade aqui, não é necessário.

x = [1,2]
y = [1,2]
imprimir x é y Falso (mesmo sendo idêntico)
x = (1,2)
y = (1,2)
imprimir x é y Falso (mesmo que
idêntico, imutável
x = []
imprima x não é None Verdadeiro (lista, mesmo que
vazio)
 "in" operador
Para tipos de dados de coleção, o operador 'in'
determina se algo é um membro de
a coleção (e "não em" testes se não um
membro):
>>> team = (“David”,“Robert”,“Paul”)
“Howell” na equipe
Falso
“Stewart” não está na equipe
Verdadeiro
 Iteração: para ... em
Para percorrer um tipo de coleção, use for ... in
>>> números = (1, 2, 3)
>>> para i em números: imprimir i,
...
123
 Copiando coleções
Usar atribuição apenas cria uma nova referência
para a mesma coleção, por exemplo,
A = [0,1,3]
B = A B é uma referência a A. Alterar B irá
# mudar A
C = A[:] faça uma cópia
B[1] = 5
C[1] = 7
A, B, C
( [0, 5, 3], [0, 5, 3], [0, 7, 3])
Copy a dictionary with [Link]()
 Capítulo 7: Funções Avançadas
Passando listas e dicionários de palavras-chave para
funções
Funções Lambda
aplicar()
mapa()
filtrar()
reduzir()
Compreensões de lista
 Passando listas como argumentos
Listas podem ser passadas em casos onde pode haver
ser um número variável de argumentos
[Link]:
def soma(*args):
result = 0
para arg em args:
resultado += arg
retornar resultado
imprimir soma(1,2,3)
6
 Argumentos nomeados
O chamador de uma função pode colocar os argumentos
na ordem correta ("argumentos posicionais"), mas
alternativamente, alguns argumentos podem ser
designado por palavras-chave
Note: this example calls the function with the
argumentos na ordem errada, mas o
os argumentos são passados com a sintaxe de palavra-chave, então isso
não importa
def imprimir_ola(primeironome="", sobrenome=""):
print "Olá, %s %s" % (firstname, lastname)
printar_hello(sobrenome="Sherrill",
firstname="David")
Olá, David Sherrill
 Misturando palavra-chave e posicional
argumentos
Outro uso do operador * é para designar
que todos os argumentos após ele devem ser palavras-chave
argumentos
Isso é novo no Python 3?
def area(x, y, *, units="polegadas"):
imprimir x*y, "quadrado %s" % unidades

area(2,3,”centimeters”)
6 centímetros quadrados
Passando dicionários para funções
Os dicionários serão discutidos mais tarde
[Link]:
def print_dict(**kwargs):
por chave em [Link]():
print "%s = %s" % (chave, kwargs[chave])
user_info = dict(name="David", uid=593,
homedir="/home/users/david")
print_dict(**user_info) # nota: precisa de ** aqui!!
output: (note: dictionary entries are unordered)
uid = 593
name = David
homedir = /home/users/david
 Argumentos de dicionário
Nota: dicionários podem ser passados como argumentos
até mesmo funções "normais" desejando posicionais
argumentos!
[Link]:
def area(x, y, unidades="polegadas"):
print x*y, "quadrado %s" % unidades
area_info = dict(x=2, y=3, units="centimeters")
área(**informações_da_area)
output: 6 square centimeters
 Funções Lambda

Versão abreviada da declaração def, útil para

funções de "inlining" e outras situações onde
é conveniente manter o código da função
perto de onde é necessário
Pode conter apenas uma expressão na função
definição, não um bloco de declarações (por exemplo, sem if)
declarações, etc)
Uma lambda retorna uma função; o programador
pode decidir se irá ou não atribuir isso
função para um nome
 Exemplo de Lambda

Exemplo simples:

>>> def soma(x,y): return x+y

>>> ...
>>> soma(1,2)
3
sum2 = lambda x, y: x+y
>>> soma2(1,2)
3
 aplicar()
Em contextos muito gerais, você pode não saber
antecipadamente quantos argumentos precisam ser obtidos
passado para uma função (talvez a própria função
é construído dinamicamente)
A função apply() chama uma função dada com um
lista de argumentos empacotados em uma tupla:
def soma(x, y): return x+y
aplicar(soma, (3, 4))
7
Apply pode lidar com funções definidas com def ou
com lambda
 Aplicar() mais geral
Aplique pode aceitar um terceiro argumento que é um dicionário
of keyword arguments

def nomeargs(*args, **kwargs): print(args, kwargs)

args = (1.2, 1.3)
kargs = {'a': 2.1, 'b': 3.4}
aplicar(nameargs, args, kwargs)
(1.2, 1.3) {'a': 2.1000, 'b': 3.4000}
 mapa

Map chama uma função dada em cada elemento de

uma sequência
[Link]:
def dobrar(x): return x*2
a = [1, 2, 3]
imprimir mapa(dobro, a)
[2, 4, 6]
Alternatively:
imprimir mapa((lambda x: x*2), a)
[2, 4, 6]
 Mais mapa
Também é possível aplicar um mapa a funções que aceitam mais
do que um argumento; depois trabalhe com dois ou mais
listas

imprimir mapa((lambda x, y: x+y), [1,2,3], [4,5,6])

[5,7,9]
 filtro
Assim como o mapa, a função de filtro funciona em listas.
Ao contrário do map, ele retorna apenas uma lista selecionada de
items that matches some criterion.
Obtenha apenas números pares:
filtrar((lambda x: x%2==0), intervalo(-4,4))
[-4, -2, 0, 2] # lembre-se de que o intervalo não inclui o último
valor dado na faixa
 reduzir

Reduce é como map, mas reduz uma lista a um

valor único (cada operação atua sobre o resultado
da última operação e o próximo item na
lista):

reduzir((lambda x, y: x+y), [0, 1, 2, 3, 4])

10
 Compreensões de lista
Essas não são realmente funções, mas elas podem
substituir funções (ou mapas, filtros, etc)
[x**2 para x em range(9)]
[0, 1, 4, 9, 16, 25, 36, 49, 64]
[x**2 para x em range(10) se x%2 == 0]
[0,4,16,36,64]
[x+y for x in [1,2,3] for y in [100,200,300]]
[101, 201, 301, 102, 202, 302, 103, 203, 303]
 Geradores e Iteradores

Às vezes, pode ser útil retornar um único

valor de cada vez, em vez de uma sequência inteira.
Um gerador é uma função que é escrita para
retornar valores um de cada vez. O gerador pode
calcule o próximo valor, salve seu estado e então
retome de onde parou quando chamado novamente.
Sintaticamente, o gerador parece exatamente como um
função, mas ela 'produz' um valor em vez de
retornando um (uma declaração de retorno faria
termine a sequência)
 Exemplo de gerador
>>> def quadrados(x):
... para i em range(x):
... produza i**2
>>> para i em quadrados(4):
... imprimir i,
...
0149
Pode obter o próximo elemento na sequência da função next():

z = quadrados(4)
[Link]()
0
[Link]óximo()
1
 Persistência do padrão mutável
argumentos
Argumentos padrão mutáveis persistem entre
chamadas para a função (como variáveis estáticas em C)
Isso pode não ser o comportamento desejado
Caso contrário, copie o padrão no início do
função corpo para outra variável, ou mover o
expressão de valor padrão no corpo do
função
 Capítulo 8: Tratamento de Exceções
Fundamentos do tratamento de exceções
 Tratamento Básico de Exceções
Uma "exceção" é um erro (tipo reconhecido), e
"manipulação" é o que você faz quando esse erro ocorre
Sintaxe geral:
tente:
código-que-você-deseja-executar
exceto exceção1 [como variável1]:
bloco de exceção1
...
exceto exceptionN [como variávelN]:
bloco de exceçãoN
Se ocorrer um erro, se for do tipo de exceção 1, então variável1
torna-se um alias para o objeto de exceção, e então
o bloco exception1 é executado. Caso contrário, o Python tenta
tipos de exceção 2 ... N até que a exceção seja capturada, ou então
o programa para com uma exceção não tratada (uma
o rastreamento será impresso junto com o texto da exceção
O [como variável] opcional não funcionará com versões antigas do Python
 Exemplo de exceção
[Link]
tente:
i = int("snakes")
imprima "o inteiro é", i
exceto ValueError:
oops! valor inválido
 Outras exceções
EOFError é levantado no final de um arquivo
IndexError ocorre se usarmos um índice inválido
para uma string/coleção, por exemplo, se tentarmos obter
argv[1] se houver apenas um comando na linha de comando
argumento (a contagem começa do zero)
Ocorre um TypeError quando, por exemplo, comparando dois
tipos incomparáveis
 Capítulo 9: Módulos Python
Conceitos básicos de módulos

Import and from…import statements

Mudando dados em módulos
Recarregando módulos
Pacotes de módulo
__name__ and __main__
Importar como declaração
 Noções básicas do módulo

Cada arquivo em Python é considerado um módulo. Tudo

dentro do arquivo está encapsulado dentro de um namespace (que
é o nome do arquivo)
m
[Link]
se
u
a
itrP
pg
a
or,a
e
có
rm
svo
d
)im
qu
ra
iou
(tódul
e então acesse as funções ou dados daquele módulo por
prefixando com o nome do módulo, seguido de um ponto
u
m
a
rP
a
tim
p
a
o
ro
:ó
d
u
l
importar sys
(nota: sem sufixo de arquivo)
Pode importar módulos definidos pelo usuário ou algum "padrão"
módulos como sys e random
Qualquer programa em Python precisa de um arquivo "de nível superior" que
importa quaisquer outros módulos necessários
 biblioteca padrão do Python

Há mais de 200 módulos no Standard

Biblioteca
Consulte o Manual de Referência da Biblioteca Python,
incluído na instalação do Python e/ou
disponível em[Link]
 Que importa isso
Uma instrução de importação faz três coisas:
- Encontra o arquivo para o módulo dado
- Compila para bytecode
- Executa o código do módulo para construir quaisquer objetos (top-
código de nível, por exemplo, inicialização de variável

O nome do módulo é apenas um nome simples; Python usa

um caminho de busca de módulo para encontrá-lo. Ele irá buscar: (a) o
diretório do arquivo de nível superior, (b) diretórios em
variável ambiental PYTHONPATH, (c) padrão
diretórios, e (d) diretórios listados em qualquer arquivo .pth
(um diretório por linha em um arquivo de texto simples); o caminho pode
ser listado imprimindo [Link]
 O módulo sys
Imprimindo os argumentos da linha de comando,
[Link]
import sys
cmd_options = [Link]
i=0
para cmd em opções_cmd:
imprimir "Argumento ", i, "=", cmd
i += 1
output:
localhost(Capítulo8)% ./[Link] teste1 teste2
Argument 0 = ./[Link]
Argument 1 = test1
Argument 2 = test2
 O módulo random
importar aleatório

chute = [Link](1,100)
imprimir palpite
dinner = [Link]([“meatloaf”,“pizza”,
torta de frango
imprimir jantar
 Importar vs de ... importar
Importar traz um módulo inteiro; você precisa qualificar
os nomes pelo nome do módulo (por exemplo, [Link])
"importar de" copia nomes do módulo para o
módulo atual; não há necessidade de qualificá-los (nota: estes
são cópias, não links, para os nomes originais)

from module_x import junk

junk() # não módulo_x.junk()

from module_x import * # obtém tudo do nível superior

nomes do módulo_x
 Alterando dados em módulos
Reatribuindo um novo valor a um nome buscado de um
o módulo não muda o módulo, mas alterar um
variável mutável de um módulo faz:

de módulo_x importar x,y

x = 30 # não altera x em module_x

y[0] = 1 # altera y[0] em module_x
Isto funciona exatamente como funções
m
P
e
arlem
ntud
u
a
m
rnom
a
e
om
b
pa
o
vg
ld
i,q
e
a
u
riout
use import (sem "from") e qualifique a variável:
module_x.x = 30 (mas isso quebra a encapsulação de dados)
 Recarregando módulos
O código de nível superior de um módulo é executado apenas na primeira vez que o
o módulo é importado. Importações subsequentes não fazem
qualquer coisa.
A função de recarregar força um recarregamento e re-execução de um
módulo; pode usar se, por exemplo, um módulo mudar enquanto um
O programa em Python está em execução

reload recebe um objeto de módulo existente

reload(module_x) # module_x deve ter sido
# anteriormente importado
reload altera o objeto do módulo no local
reload não afeta declarações from..import anteriores
(eles ainda apontam para os objetos antigos)
 Pacotes de Módulo
Ao usar import, podemos fornecer um diretório
caminho em vez de um nome simples. Um diretório de
O código Python é conhecido como um "pacote":
importar dir1.dir2.módulo
ou
do dir1.dir2.módulo importar x
procurará um arquivo dir1/dir2/[Link]
Nota: dir1 deve estar dentro de um dos diretórios
no PYTHONPATH
Nota: dir1 e dir2 devem ser nomes simples, não
usando sintaxe específica da plataforma (por exemplo, sem C:\)
 Arquivos __init__.py de pacotes
Ao usar pacotes Python (sintaxe de caminho do diretório para
importações), cada diretório no caminho precisa ter um
__init__.py arquivo
O arquivo pode estar em branco

Se não estiver em branco, o arquivo contém código Python; a primeira vez que Python
importações através deste diretório, ele executará o código no
__init__.py arquivo
No exemplo [Link], um namespace dir1.dir2 agora
existe que contém todos os nomes atribuídos pelo __init__.py do dir2
arquivo
O arquivo pode conter uma lista '__all__' que especifica o que é
exported by default when a directory is imported with the from*
declaração
 Encapsulamento de dados

Por padrão, nomes que começam com um

o sublinhado não será copiado em uma importação
declare (eles ainda podem ser alterados se acessados)
diretamente)
Alternativamente, pode-se listar os nomes a serem
copiados na importação ao atribuí-los a uma lista
chamado __all__:
__all__ = [“x1”,“y1”,“z1”] # export only these
esta lista é lida apenas ao usar o de *
sintaxe
 __name__ and __main__
Quando um arquivo é executado como um programa de nível superior, ele é

__name__ is set to“__main__”when it starts

Se um arquivo for importado, __name__ é definido como o
nome do módulo como o importador o vê
Pode usar isto para empacotar um módulo como uma biblioteca,
mas permita que funcione de forma independente também, verificando
se __name__ == '__main__':
faça_o_que_quiser() # execute em modo independente
 Importar como

Você pode renomear um módulo (do ponto de

visão do importador) usando:
importar longmodulename como shortname,
onde shortname é o apelido para o original
module name
Usar essa sintaxe requer que você use o curto
nome depois, não o nome longo
Também pode fazer
from module import longname as name
 O recarregamento pode não afetar "de"
importações
Dos nomes de cópias, e não retém um link
voltar ao módulo original
Quando o reload é executado, ele altera o módulo, mas
nenhuma cópia que foi feita de um original
from module import XX
declaração
Se isso for um problema, importe o módulo inteiro
e use qualificação de nome (mó[Link]) em vez disso
 Capítulo 10: Arquivos
Operações básicas de arquivo
 Abrindo um arquivo
abrir(nome_arquivo, modo)
onde filename é uma string Python, e mode é
uma string Python, 'r' para leitura, 'w' para escrita, ou
'a' para anexar
 Operações básicas de arquivos

Basic operations:

outfile = open('[Link]', 'w')

infile = open('[Link]', 'r')
 Operações básicas de arquivos

Operações básicas
output = open('[Link]', 'w')
entrada = open('[Link]', 'r')
A = [Link]() # ler o arquivo inteiro em string
A = [Link](N) ler N bytes
A = [Link]() # ler próxima linha
A = [Link]() # ler arquivo em lista de
# strings
[Link](A) # Escreve a string A no arquivo
[Link](A) # Escreva lista de strings
[Link]() # Fechar um arquivo
 Redirecionando stdout
Instruções de impressão normalmente vão para stdout
("saída padrão", ou seja, a tela)
a saída padrão pode ser redirecionada para um arquivo:

importar sys
[Link] = open('[Link]', 'w')
imprimir mensagem # aparecerá em [Link]

Alternativamente, para imprimir apenas algumas coisas em um arquivo:

print >> logfile, mensagem # se logfile estiver aberto
 Exemplos de análise de arquivo
Tudo de uma vez:

infile = open("[Link]", 'r')

linhas = [Link]()
[Link]()

para linha em linhas:

imprimir linha,

Linha por linha (sintaxe de atalho evitando chamadas readline):

infile = open("[Link]", 'r')

para linha em infile

imprimir linha,

[Link]()
 Capítulo 11: Documentação
Comments
dir
Strings de documentação
 Comments
Como vimos, qualquer coisa após um caractere # é
tratado como um comentário
 dir
A função dir imprime todos os atributos de um
objeto (veja depois)

>>> import sys

>>> dir(sys)
["__displayhook__","__doc__"]
'__excepthook__', '__name__', '__stderr__',
'__stdin__', '__stdout__', '_current_frames',
'_getframe', 'api_version', 'argv',
...
>>> dir([]) # uma lista
["__adicionar__","__classe__","__contém__","..."]
["anexar","contar","estender","índice","..."]
 docstrings
Strings no topo de arquivos de módulo, no topo de funções,
e o topo das classes se torna "docstrings" que são
inserido automaticamente no atributo __doc__ do
objeto
Pode usar aspas simples ou duplas regulares para delimitar o
string, ou pode usar aspas triplas para uma string de várias linhas

ex.:
def soma(x, y):
Esta função apenas adiciona dois números
retornar x+y

imprimir soma.__doc__
Esta função apenas adiciona dois números
 Docstrings para objetos embutidos
Pode imprimir as docstrings para o Python embutido
objetos

>>> importar sys

>>> print sys.__doc__
 PyDoc
PyDoc é uma ferramenta que pode extrair as docstrings
e exibi-los de forma agradável, seja através da ajuda
comando ou via uma interface GUI/HTML
>>> ajuda(lista)
 Documentação na web
Confira [Link]
 Chapter 12: Classes
Introdução às classes
coisas
lixo
 Introdução às Classes
•Uma "classe" é um tipo de dado definido pelo usuário. Ela contém (ou
encapsula certos "dados do membro", e também tem
coisas associadas que pode fazer, ou "funções membros."
•Se uma classe é uma especialização (ou sub-tipo) de uma mais geral
classe, diz-se que herda dessa classe; isso pode dar a uma classe
acesso aos dados/métodos de membros da classe pai
•Esses conceitos gerais são basicamente os mesmos em C++, Java,
etc.
As classes estão incorporadas no Python desde o início. Para objetos-
programação orientada a objetos (ou seja, programação utilizando classes),
Python é superior nesse sentido ao Perl
 Definindo Classes
•Uma classe é definida por:
classe nomeclasse:
conjunto-de-código
ou
classe nome_da_classe(classe_base):
conjunto de códigos
A definição da classe (bloco de código) pode
contêm definições de funções membros, etc.
•classes_base conteriam quaisquer classes que
esta classe herda de
 Escopo de Dados do Membro

•Atributos de classe (dados de membro) definidos no

a definição da classe em si é comum à classe
(nota: o bloco de código em uma definição de classe
na verdade é executado na primeira vez que a definição da classe
é encontrado, e não quando objetos de classe
são instanciados)
•Atributos de classe definidos para um objeto específico de
uma certa aula é realizada apenas com isso
objeto particular (frequentemente definido usando o "self")
palavra-chave, veja abaixo)
 Exemplo de Classe
classe Estudante:

course = "CHEM 3412"

def __init__(self, nome, teste1=0, teste2=0):

[Link] = name

self.test1 = test1

self.test2 = test2

def calcular_media(self):

retornar ((self.test1 + self.test2)/2)

def imprimir_dados(self):

imprima "A nota de %s em %s é %4.1f" % \

([Link], [Link], self.calcular_media())

David = Student("David", 90, 100)

Bob = Student("Bob", 60, 80)

David.imprimir_dados()

Bob.imprimir_dados()
 Comentários sobre o Exemplo do Estudante

•Chamando uma função com o mesmo nome que o

o nome da classe cria um objeto disso
classe; a função real chamada é a __init__
função dentro da classe (__init__ é a classe
construtor
•Cada vez que o construtor é chamado, um diferente
um objeto desse tipo é criado; esses diferentes
os objetos geralmente terão membros diferentes
dados
 Comentários sobre o Exemplo do Estudante

•Observe que o nome do curso é mantido comum a todos

estudantes (todas as instâncias da classe)
No entanto, as duas notas das provas são específicas para cada um.
estudante
A palavra-chave "self" tem o mesmo papel que "this" em
C++/Java --- ele aponta para uma instância específica do
classe. É fornecido automaticamente como o primeiro
argumento para qualquer função membro de classe, e deve
ser usado ao se referir a qualquer dado/função de membro
de uma classe (mesmo que seja dados de membro compartilhados entre todos
instâncias de uma classe)
 Sobrecarga de Operadores

•Certos operadores (como ==, +, -, *) podem s

sobrecarregado para trabalhar com tipos de dados definidos pelo usuário

(classes) bem como tipos embutidos como inteiros

•Para ver se dois objetos são iguais, sobrecarregue o
operador == e implementar uma função que
pode comparar duas instâncias do seu usuário-
tipo de dado definido (classe). Isso é feito por
definindo a função __eq__ para a classe; veja
próximo exemplo
 Exemplo de ponto
classe Ponto:
def __init__(self, x=0, y=0):
self.x = x
self.y = y

def __eq__(self, outro):

retorne self.x == other.x e self.y == other.y

a = Ponto()
b = Ponto(1,1)

print a==b
 Verificação mais elegante
Nós poderíamos ser um pouco mais seguros e garantir que o
a comparação é na verdade de dois objetos de
mesmo tipo, caso contrário, retorne uma bandeira indicando
que esta comparação não é implementada pelo nosso
Classe Ponto:

se não isinstance(other, Ponto):

retornar nãoImplementado
senão
retorne self.x == outros.x e self.y == outros.y
 Sobrecarga de outras comparações

•Existem outros operadores de comparação que podemos

sobrecarga para tipos de dados definidos pelo usuário:

__lt__(self, other) x < y

__le__(self, other) x<= y
__eq__(self, other) x == y
__ne__(self, other) x != y
__ge__(self, other) x >= y
__gt__(self, other) x > y
 Sem Sobrecarga de Assinaturas de Chamadas

Em outras linguagens como C++, podemos sobrecarregar

funções membro se comportam de maneira diferente dependendo
sobre quantos argumentos (e quais tipos de
argumentos) são passados para a função
•Python não funciona assim: a última função
definido com um nome dado é aquele que será
usado
classe A:
def método(self, x):
…
def metodo(self, x, y):
esta definição substitui a anterior
 Noções básicas do módulo

Cada arquivo em Python é considerado um módulo. Tudo

dentro do arquivo está encapsulado dentro de um namespace (que
é o nome do arquivo)
m
[Link]
se
u
a
itrP
pg
a
or,a
e
có
rm
svo
d
)im
qu
ra
iou
(tódul
e então acesse as funções ou dados daquele módulo por
prefixando com o nome do módulo, seguido de um ponto
u
m
a
rP
a
tim
p
a
o
ro
:ó
d
u
l
importar sys
(nota: sem sufixo de arquivo)
Pode importar módulos definidos pelo usuário ou algum "padrão"
módulos como sys e random
Qualquer programa em Python precisa de um arquivo "de nível superior" que
importa quaisquer outros módulos necessários
 Exemplo de Herança
classe Classe1:
def __init__(self, data=0):
[Link] = data

def exibir(self):
imprimir [Link]

class Class2(Class1):
def quadrado(self):
[Link] = [Link] * [Link]

a = Classe2(5)
[Link]() # função membro específica da Classe2
[Link]() # função membro herdada da Classe1
 Sintaxe Alternativa para Chamadas de Métodos

•Em vez de chamar métodos através de seus objetos, também podemos

chame-os pelo nome da classe:
x = SomeClass()
x.metodo1()
-ou-
SomeClass.metodo1(x)
•Útil se precisarmos garantir que um construtor da superclasse
executa tão bem quanto o construtor da subclasse:
class Class2(Class1):
def __init__(self, dados):
Class1.__init__(self, dados)
...novo código para a Classe2 aqui...
 __getitem__
•Podemos sobrecarregar a sintaxe de indexação de array com __getitem__

classe testit:
def __getitem__(self, n):
retornar [Link][n]

A = testit()
[Link] =“junk”

A[1]
você
 __getattr__ and __setattr_

•Essas funções capturam referências de atributos para

uma classe. __getattr__ captura todas as tentativas de
obter um atributo de classe (via, por exemplo, [Link], etc.)
e __setattr__ captura todas as tentativas de definir um
class attribute (e.g., [Link] =“Bob”)
•Deve ter cuidado com __setattr__, porque tudo
instâncias de [Link]=valor tornam-se
self.__setattr__('attr', value), e isso pode
impedir alguém de escrever código como
[Link]=valor na definição de __setattr__!
 Usando __setattr__

Classe SomeClass:
def __setattr__(self, attr, value):
self.__dict__[attr] = value

isso evita sintaxe como [Link] = valor

que não podemos ter na definição
 __str__ and __repr__
•__str__ is meant to provide a“user friendly”representation of
a classe para impressão
__repr__ destina-se a fornecer uma string que poderia ser
interpretado como código para reconstruir a instância da classe

classe Número:
def __init__(self, dados):
[Link] = data
def __repr__(self):
retornar 'Número(%s)' % [Link]

a = Número(5)
imprimir a
Número(5)
 destrutores

•__del__ é um destrutor, que é chamado

automaticamentte quando uma instância está sendo
deletado (não está mais sendo usado, e é
o espaço é recuperado durante "lixo"
coleção")
O Python normalmente limpa a memória usada.
por uma instância automaticamente, então esse tipo de
a coisa geralmente não é necessária para colocar em um
destrutor; portanto, eles podem ser menos necessários
do que em, por exemplo, C++
 Chapter 13: CGI Programming
Introdução a programas CGI
Pacotes CGI do Python
Exemplo de script de formulário CGI
 Introdução à Programação CGI

CGI: Interface Comum de Gateway

•Normalmente precisam ser executados de
/var/www/cgi-bin em um servidor web
Padrão para scripts da Web e formulários da Web

•Saída: a primeira linha da saída precisa identificar

o texto como HTML. O resto deve (geralmente)
na verdade por HTML-formatado
Existem duas maneiras de passar informações
para um script da web: GET e POST
 Saída

Primeira linha:
imprimir "Content-type: text/html\n"# precisa \n
•Tudo o mais será repassado para
interpretação pelo navegador da web do cliente. Simples
o texto geralmente será impresso corretamente, mas tipicamente você quer
formatar como Linguagem de Marcação de Hipertexto
(HTML)
•Estas notas não explicarão HTML básico; isso
a informação é fácil de encontrar em outros lugares
 Entrada
•GET: pares de palavras-chave/valor podem vir em
através do protocolo “GET”. Eles são enviados
ao script como complementos à URL, por exemplo:
[Link]
•POST: Os dados são enviados através de um formulário que
começa com este código HTML:
<FORM method=POST action="[Link]">
 Pegadinhas de entrada GET
•Com GET, tenha cuidado porque certos
os caracteres precisam ser "escapados" se forem
ser passado na URL. Isso pode ser
feito de forma fácil e automática por

import urllib
tmpstr = '<a href="[Link]?name=s">' % \
(urllib.quote_plus(nome))
• Enquanto estamos no assunto, itens entrando em
O HTML também pode precisar ser escapado; pode fazer
isso com [Link](). Funciona na maioria, mas não
exatamente, o mesmo que urllib.quote_plus()
Exemplo de formulário
• htmlform = """ Entrada POST
»<FORM method=POST action="[Link]">
»<P>
<table>
<tr><td>Nome:</td>
<td><input type=text name=name size=40 value="%(name)s" /></td></tr>
<tr><td>Emprego:</td>
<td><input type=text name=job size=40 value="%(job)s" /></td></tr>
"<tr><td>Anos com a empresa:</td>
<td>
»<select name=anos value=%(anos)s>
<option value="1" %(anos1)s>1</option>
<option value="2" %(years2)s>2</option>
<option value="3" %(years3)s>3</option>
"> </select>
»</td></tr>
<tr><td>Gerente:</td>
> <td><input type=checkbox name=manager value="1"
%(managerchecked)s></td>
»</tr>
<tr><td><input type="submit" name="send" value="Enviar"></td>
»"""
imprimir htmlform % suppdata
 Lendo a entrada
•Python fornece um módulo unificado que pode
analisar tanto a entrada GET quanto a entrada POST (ou ambos

simultaneamente

import cgi # para analisar CGI

import cgitb # para imprimir mensagens de erro CGI
[Link]()

form = [Link]() # analisar formulário

 Lendo a entrada
•Extraindo os dados do formulário

data = {}
para campo em ('nome', 'trabalho', 'anos', 'gerente'):
se não form.tem_chave(campo):
data[field] = ""
senão:
se tipo(form[campo]) != lista:
data[field] = form[field].value
senão: # mesclar listas em string com 'e'
valores = [[Link] para x em formulário[campo]]
data[field] = ' and '.join(values)
 Lendo a entrada

Eu gosto de separar "metadados" dos dados.

'send' campo será definido se o formulário for enviado
(não é a primeira vez que o formulário é mostrado ao usuário)

suppdata = {}
para campo em ('enviar',):
se não form.tem_chave(campo):
suppdata[field] = ""
senão:
se tipo(form[field]) != lista:
suppdata[field] = form[field].value
senão:
values = [[Link] for x in form[field]]
suppdata[field] = ' and '.join(values)
 Lendo a entrada
•Preencha mais dados suplementares; consulte novamente
o formulário HTML para ver onde tudo isso vai
o formulário
se data['gerente'] == "1":
suppdata['managerchecked'] = "checked"
senão:
suppdata['managerchecked'] = ""

suppdata['years1'] = ""
suppdata['years2'] = ""
suppdata['years3'] = ""

se data['anos'] == "1":
suppdata['years1'] = "selected"
elif data['years'] == "2":
suppdata['years2'] = "selected"
elif data['anos'] == "3":
suppdata['years3'] = "selected"

# mesclar todos os dados{} em suppdata{}

[Link](dados)
O resto do script ([Link])
se (suppdata['send'] == "Enviar"):
# faça qualquer teste dos dados do formulário aqui

se (dados['nome'] == "" ou dados['trabalho'] == ""):

imprimir cabeçalho_html
imprimir htmlform % suppdata
Erro: deve preencher os campos nome e profissão!
imprimir_rodapé_html

senão:
# faça upload de dados para um banco de dados aqui
# imprimir ok para o usuário
imprimir cabeçalho_html
Adicionando dados ao banco de dados.<br />
print "nome=%s, trabalho=%s, anos=%s.<br />\n" % \
(data['name'], data['job'], data['years'])
imprimir 'É',
se (dados['gerente'] == "1"):
imprimir "um gerente.<br />\n"
senão:
não é um gerente.<br />
Novos dados submetidos!<br />
imprimir rodapé html

senão: # se não foi enviado

imprimir cabeçalho_html
imprimir htmlform % suppdata
imprimir rodapé_html