Programando em
Python
(Claudio Esperança)
Por que programar?
 É divertido
 Melhor que usar
programas feitos por outros
 Fazer programas =
resolver quebra-cabeças
 Programação como arte
 É útil
 Programação como
ferramenta
 Pode ser aplicado a
quase qualquer atividade
 Arte / Ciência /
Filosofia / Entretenimento
Algoritmos e Programas
 Algoritmo = método para
solucionar um problema
 Estruturas de dados =
método para organizar
informações
 Programa = algoritmos +
estruturas de dados
expressos de forma a ser
entendidos pelo
computador
 Programas tipicamente
processam dados de
entrada
e produzem dados de saída
Linguagem de Programação
 Linguagem artificial com
sintaxe e semântica
bem definidos
 Usada para exprimir
programas
 Mais “técnica” do que
linguagens naturais
 Menos “técnica” do que
a linguagem nativa
dos computadores
(linguagem de máquina)
Compiladores
 Programas que traduzem
programas escritos em
linguagem de
programação para  Máquina virtual é
programas equivalentes executada separadamente
escritos em lendo
linguagem de máquina pseudo-código e
 O primeiro é chamado de interpretando-o
programa fonte, enquanto
que o
segundo é chamado de
programa objeto
Por que Python?
 Simples o suficiente para
um curso introdutório
Link-Editores  Muitos recursos
 O programa-objeto nem  Orientação a Objetos
sempre está pronto  Escalável (módulos,
para ser executado classes, controle de
 Outros trechos de código exceções)
precisam ser incluídos  Biblioteca embutida
 Bibliotecas extensa e grande número
 Subprogramas de
 Programa executável é módulos fornecidos por
montado por um terceiros
programa chamado link-  Grande variedade de
editor ou linking-loader aplicações
 Compilador normalmente  Linguagem interpretada
chama o link-editor (script)
Automaticamente  Multi-plataforma
 Grátis!
Link-Editores  Comunidade bastante
grande
O que vamos precisar
 Uma implementação da
linguagem
 http://www.python.org
 Implementação pronta
Interpretadores para baixar (windows)
 Simulam uma “máquina  Linux normalmente já
virtual” vem com python
 Programa fonte é lido, instalado
entendido e as  Um editor de textos
instruções são executadas  Qualquer editor serve
imediatamente  Ambiente IDLE inclui um
editor
 Incluído na distribuição
Windows
Python Interativo
 Rode o interpretador
Esquemas Híbridos  Digite comandos python
 Compilador gera código  Cada comando é
para uma máquina virtual executado imediatamente
(pseudo-código) [cancer]~> python
Python 2.4.1 (#1, May 16 2005, 15:19:29)
[GCC 4.0.0 20050512 (Red Hat 4.0.0-5)] on  Simples: números (int, long,
linux2
Type "help", "copyright", "credits" or float, complex) e cadeias
"license" for more information. de caracteres (strings)
>>> print "alo!"
alo!  Compostos: listas,
>>> dicionários, tuplas e conjuntos
 Tipos definidos pelo
Executando um programa
usuário: são correspondentes a
Python
classes (orientação objeto)
 Escreva um programa
python Variáveis
 Invoque o interpretador  São nomes dados a áreas de
para executá-lo memória
[cancer]~> cat prog.py
print "alo!"  Nomes podem ser
[cancer]~> python prog.py compostos de algarismos,letras
alo!
Python: ou _
Executando um programa Tipos Básicos  O primeiro caractere não
Python pode ser um algarismo
 Interfaces gráficas Python como calculadora  Palavras reservadas (if,
normalmente já associam  O Interpretador python pode while, etc) são proibidas
os ser usado como  Servem para:
sufixos .py e .pyc com o calculadora  Guardar valores
 Por exemplo, as quatro intermediários
interpretador
operações aritméticas são  Construir estruturas de
denotadas pelos símbolos dados
 + adição  Uma variável é modificada
 subtração usando o comando de
 * multiplicação atribuição:
 / divisão Var = expressão
 É possível também atribuir a
>>> 10
10 várias variáveis
>>> # Um comentário é precedido do caracter simultaneamente:
"#"
... # Comentários são ignorados pelo var1,var2,...,varN =
interpretador
... 10+5
expr1,expr2,...,exprN
15
>>> 10-15 # Comentários podem aparecer Variáveis
também após código >>> a=1
-5 >>> a
>>> 10*3 1
30 >>> a=2*a
>>> 10/3 >>> a
3 2
>>> 10/-3 # Divisão inteira retorna o piso >>> a,b=3*a,a
-4 >>> a,b
>>> 10%3 # Resto de divisão inteira (6, 2)
simbolizado por % >>> a,b=b,a
1 >>> a,b
(2, 6)
Tipos de dados
 São categorias de valores Variáveis
que são processados de  Variáveis são criadas
forma semelhante dinamicamente e destruídas
 Por exemplo, números quando não mais necessárias,
inteiros são processados de por exemplo, quando
forma diferente dos números saem fora de escopo (veremos
de ponto flutuante isso mais tarde)
(decimais) e dos números  O tipo de uma variável
complexos muda conforme o valor
 Tipos primitivos: são atribuído, i.e., int, float, string,
aqueles já embutidos no núcleo etc.
da linguagem
 Não confundir com  Hexadecimal: preceder
linguagens sem tipo dígitos de 0x
 Ex.:  Octal: preceder dígitos de 0
>>> a ="1"  Ex.:
>>> b = 1
>>> 022
>>> a+b
18
Traceback (most recent call last):
File "<stdin>", line 1, in ?
>>> 0x10
16
TypeError: cannot concatenate 'str' and 'int'
>>> 0x1f
objects 31
Números Números de ponto flutuante
 Há vários tipos numéricos  São implementados como os
que se pode usar em python double's da linguagem C –
 Int: números inteiros de tipicamente usam 2 palavras
precisão fixa  Constantes têm que possuir
 1 , 2 , 15 , 19 um ponto decimal ou serem
 Long: números inteiros escritas em notação científica
de precisão arbitrária com a letra “e” (ou “E”)
 1L , 10000L , -9999999L precedendo a potência de 10
 Floats: números racionais  Ex:
de precisão variável >>> 10 # inteiro
10
 1.0 , 10.5 , -19000.00005 >>> 10.0 # ponto flutuante
, 15e-5 10.0
>>> 99e3
 Complex: números 99000.0
complexos >>> 99e-3
0.099000000000000005
 1+1j , 20j , 1000+100J
Números complexos
Números inteiros  Representados com dois
 Os ints têm precisão fixa números de ponto flutuante:
ocupando tipicamente uma um para a
palavra de memória parte real e outro para a parte
 Em PC's são tipicamente imaginária
representados com 32 bits  Constantes são escritas
(de 2311 como uma soma sendo que a
a 232) parte
 Os números inteiros de imaginária tem o sufixo j ou J
precisão arbitrária (longs) são  Ex.:
armazenados em tantas >>> 1+2j
palavras quanto necessário (1+2j)
>>> 1+2j*3
 Constantes do tipo long têm (1+6j)
o sufixo L ou l >>> (1+2j)*3
(3+6j)
 Longs são manipulados bem >>> (1+2j)*3j
mais lentamente que ints (6+
3j)
 Quando necessário, cálculos
usando ints são Strings
convertidos para longs  São cadeias de caracteres
>>> a=2**30 # Potenciação
 Constituem outro tipo
>>> a fundamental do python
1073741824
>>> b=a*1000
 Constantes string são
>>> b escritas usando aspas simples
1073741824000L
ou duplas
>>> b/1000
1073741824L  Ex.: "a" ou 'a'
 O operador “+” pode ser
 Constantes podem ser usado para concatenar strings
escritas com notação idêntica à  Ex.: "a"+"b" é o mesmo
usada em C que "ab"
 O operador “*” pode ser
usado para repetir strings
 Ex.: "a"*10 é o mesmo
que "aaaaaaaaaa"
 Python usa a tabela de
caracteres default do S.O.
 Ex.: ASCII, UTF8
 Caracteres não imprimíveis
podem ser expressos usando
notação
“barrainvertida”
(\)
 \n é o mesmo que new line
 \r é o mesmo que carriage
return
 \t é o mesmo que tab
 \b é o mesmo que
backspace
 \\ é o mesmo que \
 \x41 é o mesmo que o
caractere cujo código
hexadecimal é
41 (“A” maiúsculo)
>>> "ab\rd"
'ab\rd'
>>> print "ab\rd" # print exibe chars não
imprimíveis
db
>>> print "abc\td"
abc d
>>> print "abc\nd"
abc
d
>>> print "abc\\nd"
abc\nd
>>> print "ab\bc"
ac
>>> print "\x41\xA1"
Aí
 A notação barrainvertida
(\) pode ser desabilitada
desde que a constante string
seja precedida por um r
(erre minúsculo)
 São chamadas strings raw
(cruas)
 Ex.:
>>> print "abc\ncd\tef"
abc
cd ef
>>> print r"abc\ncd\tef"
abc\ncd\tef
 Constantes string podem ser
escritas com várias linhas
desde que as aspas não sejam
fechadas e que cada
linha termine com uma barra
invertida
 Ex.:
>>> print "abcd\n\
... efgh\n\
'cde'
>>> a[:]
segundo
... ijk" 'abcde'  O operador and retorna o
abcd
efgh
>>> a[-1:]
'e'
primeiro operando se for
ijk >>> a[:-1] vista como falso, caso
>>> print "abcd\ 'abcd'
... efgh\
contrário retorna o segundo
... ijk"  Operadores relacionais
abcdefghijk Expressões booleanas
>>>  Também chamadas são avaliados antes de not,
expressões lógicas que é avaliado antes de
 Também é possível escrever  Resultam em verdadeiro and, que é avaliado antes
constantes string em várias (True) ou falso (False) de or
linhas  São usadas em comandos >>> 0 or 100
incluindo as quebras de linha condicionais e de repetição 100
usando três aspas como  Servem para analisar o
>>> False or 100
100
delimitadores estado de uma computação e >>> "abc" or 1
 Ex.: permitir escolher
'abc'
>>> print """ >>> 1 and 2
Um tigre o próximo passo 2
dois tigres >>> 0 and 3
três tigres"""
 Operadores mais usados 0
Um tigre  Relacionais: > , < , ==, !=, >>> False and 3
dois tigres False
três tigres
>=, <= >>> 1 and 2 or 3
>>> print '''abcd  Booleanos: and, or, not 2
efgh''' >>> 0 or 2 and 3
abcd
 Avaliação feita em 3
efgh “Curtocircuito” >>> 1 and not 0
True
 Expressão avaliada da
Strings – Índices esquerda para a direita  Além dos operadores, é
 Endereçam caracteres  Se o resultado (verdadeiro possível usar funções para
individuais de uma string ou falso) puder ser computar valores
 Notação: string[índice] determinado sem  As funções podem ser
 O primeiro caractere tem avaliar o restante, este é definidas:
índice 0 retornado imediatamente  Pelo programador (veremos
 O último caractere tem
+ tarde)
índice 1 >>> 1==1
True  Em módulos da biblioteca
 Ex.: >>> 1==2 padrão
>>> a = "abcde" False
>>> 1==1 or 1==2  Por default: são as funções
>>> a[0] True embutidas (builtin)
'a' >>> 1==1 and 1==2
False  Na verdade, fazem parte do
>>> a[-1] >>> 1<2 and 2<3 módulo __builtins__, que é
'e' True
>>> not 1<2 sempre
Strings – Fatias (slices)
False importado em toda aplicação
>>> not 1<2 or 2<3
 Notação para separar True  Ex.:
trechos de uma string
>>> not (1<2 or 2<3)  abs(x) retorna o valor
False
 Notação: >>> "alo" and 1 absoluto do número x
string[índice1:índice2]
1  chr(x) retorna uma string
>>> "alo" or 1
 Retorna os caracteres desde 'alo' com um único caractere cujo
o de índice1 (inclusive) até código ASCII é x
 As constantes True e False  ord(s) retorna o código
o de índice2 (exclusive)
são apenas símbolos ASCII do caractere s
 Se o primeiro índice é
convenientes
omitido, é assumido 0
 Qualquer valor não nulo é >>> abs (10)
 Se o último índice é 10
visto como verdadeiro >>> abs (-19)
omitido, é assumido o fim da enquanto que 0 (ou False) é 19
string >>> chr (95)
visto como falso '_'

>>> a
 O operador or retorna o >>> chr (99)
'c'
'abcde' primeiro operando se for >>> ord ('a')
>>> a[0:2]
'ab'
vista como verdadeiro, caso 97

>>> a [2:] contrário retorna o

Importando módulos “q” para retornar ao  De dentro do interpretador
 Muitas funções importantes interpretador. python:
são disponibilizadas em >>> execfile ("fibo.py")
Entre com um numero 5
módulos da biblioteca padrão Python: 1123
 Ex.: o módulo math tem >>>
Comandos Básicos Primeiros
funções transcendentais como passos em programação
print
sin, cos, exp e outras  Até agora só vimos como
 Forma geral: print
 Um módulo pode conter não computar algumas
expr,expr,...
só funções mas também expressões simples
 Os valores das expressões
variáveis ou classes  Expressões são escritas e
são escritos um após o outro
 Por exemplo, o módulo computadas imediatamente
sem
math define a constante pi  Variáveis podem ser usadas
pular de linha:
 Para usar os elementos de para valores temporários
>>> print "1.001 ao quadrado
um módulo, podese  Um programa típico
é ",1.001**2
usar o entretanto usa vários tipos de
1.001 ao quadrado é 1.002001
comando import construções tais como:
 Se o comando terminar com
 Formatos:  Comandos condicionais
vírgula, o próximo print
 import modulo  Comandos de repetição
escreverá
 from modulo import  Definição e uso de
na mesma linha. Por exemplo:
nome,...,nome procedimentos (subprogramas) >>> a, b = 0, 1
 from modulo import *  Definição e uso de classes e >>> while b < 1000:
... print b,
objetos (programação OO) ... a, b = b, a+b
 Por exemplo: ...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610
 from math import * Primeiros passos em 987
# importa todos os elementos programação
do módulo math input
 from math import sin  O programa que computa
# importa apenas a função sin elementos da série de
 import math Fibonacci
# importa o módulo math termina quando atinge um
como um todo elemento com valor superior a
# (todos os elementos têm que uma
ser citados constante
# precedidos por math.) Programas armazenados  Podemos tornar o programa
>>> import math
 À medida que os programas mais flexível se ao usuário for
>>> a = sin(30) vão se tornando mais permitido estipular o valor
Traceback (most recent call last):
File "<stdin>", line 1, in ?
complicados, máximo
NameError: name 'sin' is not defined é mais interessante guardálos  O comando input permite
>>> a = math.sin(30)
>>> from math import sin
em arquivos e executálos perguntar ao usuário um valor
>>> a = sin(30) quando necessário (normalmente é atribuído a
>>> print a
-0.988031624093
 Arquivo fibo.py (use um uma variável)
>>> a = sin(radians(30)) editor de textos como o do  Formato: input(pergunta)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
IDLE):  onde pergunta é uma string
NameError: name 'radians' is not defined # Série de Fibonacci: opcional que será exibida para
a, b = 0, 1
>>> from math import *
>>> a = sin(radians(30)) while b < 10: indicar o valor que se espera
>>> a print b (i.e., prompt)
a, b = b, a+b
0.49999999999999994  Exemplo:
>>> a = input("Entre com um numero: ")
Explorando Módulos Formas de Executar Entre com um numero: 19
>>> import math um Programa >>> print a
>>> help(math.cos) 19
Help on built-in function cos in module math:
 Digite python fibo.py no seu
cos(...) shell, ou raw_input
cos(x)
Return the cosine of x (measured in radians).
 Clique no ícone do arquivo,  É semelhante ao input, mas
(END) ou não tenta interpretar o
 Pressionase  De dentro do editor IDLE, que foi digitado como uma
selecione Run Module (F5), ou expressão
 O resultado é simplesmente Entre com um numero:-2  Se o número é 2200,
-2 é negativo
uma string com o texto Obrigado! sabemos que teremos dois M's
digitado na
 Ex.:  Exemplo 2 representação em romanos
>>> nome = raw_input ("Entre seu nome: ")  a = input("Entre com um numero:")
Entre seu nome: Claudio Esperança if a < 0:  Sabemos que há M's se o
>>> print nome print a," é negativo" número é maior ou igual a
Claudio Esperança else:
>>> nome print a," é zero ou positivo" 1000
'Claudio Esperan\xe7a' print "Obrigado!"  Sempre que um milhar for
 Execução 1:
Entre com um numero:2 computado, subtrair 1000 do
while 2 é zero ou positivo número
 Repete uma seqüência de Obrigado!
 Execução 2:  Um processamento
comandos enquanto uma dada Entre com um numero:-2 semelhante é feito para outros
expressão -2 é negativo
Obrigado! algarismos
booleana é avaliada como romanos, por exemplo:
verdadeira  Exemplo 3  Se o número é maior ou
 Formato:  a = input("Entre com um numero:") igual que 500, acrescentar 'D'
if a < 0:
while expressão: print a," é negativo"  Se o número é maior que
comando elsif a==0:
900, acrescentar 'CM'
print a," é zero"
... else:
comando print a," é positivo"
 DICA: processando um
print "Obrigado!"
 Exemplo:  Execução 1: número entre 1 e 9
>>> a = 10 Entre com um numero:0 if num >= 9:
>>> while a>8: 0 é zero romano = romano + "IX"
... print a, Obrigado! num = num-9
... a = a-1  Execução 2: if num >= 5:
... Entre com um numero:2 romano = romano + "V"
10 9 2 é positivo num = num-5
Obrigado! if num >= 4:
Laços Infinitos romano = romano + "IV"
num = num - 4
 Como em todo comando de Exercício: algarismos while num >= 1:
repetição, é importante romanos romano = romano + "I"
num = num – 1
evitar os chamados “laços  Fazer um programa que
infinitos” escreva a representação em Exercício: números primos
 Ex.: algarismos romanos de um  Fazer um programa que
>>> a = 10 número inteiro positivo decida se um número positivo
>>> while a>8:
... print a,  O usuário deve entrar com dado é primo ou não
... a = a+1 um número (input)  Entrada: número inteiro
...
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24  O resultado deve ser positivo
25 26 impresso no console (print)  Saída: diagnóstico de
27 28 29 30 31 32 33 ...
 Exemplo de execução: primalidade do número
if Entre com um numero  Exemplos de execução:
 É o comando condicional positivo: 1985  Entre com um número
por excelência Em algarismos romanos: inteiro positivo: 169
 Formatos: MCMLXXXV 169 é múltiplo de 13
 Entre com um número
 Algoritmo inteiro positivo: 983
 A representação em 983 é primo
romanos é uma string à qual é
acrescentada uma letra por vez  Um número natural é primo
 Inicialmente, uma string se é divisível apenas por
vazia si mesmo ou pela unidade
 Examinar as sucessivas  Isto sugere o seguinte
 Exemplo 1 potências de 10 algoritmo:
 a = input("Entre com um numero:")
if a < 0:  Por exemplo, a letra 'M'  Se o número é 1, então não
print a," é negativo" corresponde à casa dos é primo
print "Obrigado!"
 Execução 1: milhares  Se o número é 2, então é
Entre com um numero:2
Obrigado!
primo
 Execução 2:  Caso contrário,
 Seja d um possível divisor,
cujo valor é inicialmente 2
 Repetir
 Se o resto da divisão do
número por d é zero, então o
número não
é primo
 Caso contrário, incrementar
d  São arranjos seqüenciais de
 Se d é igual ou maior que o
número, então terminar
repetição
diagnosticando o número
como primo
Python::
Listas
Estruturas de dados
 Maneira de organizar dados
de maneira a facilitar seu
acesso
 Algumas formas são
clássicas:
 Listas
 Arrays (vetores e matrizes)
 Tuplas (registros)
 Árvores
 Linguagens freqüentemente
possuem primitivas para
construção dessas E.D.
 Estruturas de dados
embutidas
 Outras E.D. mais complexas
podem ser construídas
combinando as E.D. clássicas
Estrutura de dados abstrata
 É uma especificação
matemática que define uma
coleção
de dados e uma série de
operações sobre ela
 É abstrata porque não
especifica como as operações
são
feitas mas somente os dados de
entrada e o resultado
 Numa linguagem de
programação, essa coleção de
operações é chamada de
interface ou API (Application
Programming Interface)
 Usuários da e.d.a devem se
preocupar com a interface e
não com a implementação, que
pode mudar com o tempo
 A implementação de uma
e.d.a. requer cuidados quanto à
correção e a eficiência da
mesma
Listas
informações mais simples
 Caracterizamse
por permitir o acesso eficiente
aos seus
elementos em ordem
seqüencial
 A definição clássica de uma
lista como estrutura de dados
abstrata compreende:
 Operação de construção de
uma lista vazia
 Operação que testa se uma
dada lista é vazia
 Operação para obter o
primeiro elemento de uma lista
 Uma operação para
adicionar um novo elemento
no início
de uma lista
 Operação para retirar o
elemento inicial de uma lista
Listas em Python
 A estrutura conhecida como
lista (list, em inglês) em
Python é bastante mais geral
do que e.d.a. lista
clássica
 Na verdade, pode ser vista
como uma implementação
tanto de listas como de arrays
 Além de acesso seqüencial,
suportam também acesso
direto através de índices
 Listas são variedades de
seqüências assim como
strings e portanto têm APIs
semelhantes
 Podem ser indexadas e
fatiadas
 Podem ser concatenadas (+)
e repetidas
 Entretanto, há diferenças
importantes entre listas e
strings
 Seqüência genérica X de
seqüência de caracteres
 Elementos de listas podem
ser alterados
individualmente mas os de
strings, não
 Listas constituem o tipo de
agregação de dados mais
versátil e comum da linguagem
Python
 Podem ser usadas para
implementar estruturas de
dados mais complexas como
matrizes e árvores, por
exemplo
Listas: constantes e índices
 Uma constante do tipo lista
é escrita entre colchetes
com os elementos separados
por vírgula:
[] # lista vazia
[1,2] # lista com 2 elementos
 Os elementos de uma lista
podem ser de qualquer
tipo, inclusive listas. Ex.:
lista = [1, 'a', 2+3j, ['ab', 'CD']]
 Os elementos de uma lista
podem ser acessados por
índices como strings
 O primeiro elemento tem
índice 0
 O último elemento tem
índice 1
>>> lista = [1, 'a', 2+3j, ['ab', 'CD']]
>>> lista [0]
1
>>> lista [2]
(2+3j)
>>> lista [3]
['ab', 'CD']
>>> lista [-1]
['ab', 'CD']
>>> lista [0] = 2
>>> lista
[2, 'a', (2+3j), ['ab', 'CD']]
Listas: Concatenação e
Repetição
 O operador + pode ser usado
para concatenação e o
operador * para repetição
>>> lista = [0]*4
>>> lista
[0, 0, 0, 0]
>>> lista = lista + [1]*3
>>> lista
[0, 0, 0, 0, 1, 1, 1]
Deletando elementos
 O operador del pode ser
usado para remover
elementos de uma lista  Obs.: Esta notação só existe  No uso de estruturas de
 Ex.: nas versões de Python a dados, às vezes é importante
>>> lista partir da 2.3 preencher uma posição com
[1, 2, 3, ['ab', 'CD']]
>>> del lista [2] um valor “não válido”
>>> lista  Exemplo  A melhor opção para esse
[1, 2, ['ab', 'CD']] >>> a = ['a', 2, 3, 'd', 'x']
>>> del lista [2][1] >>> a [:3:2] uso é empregar o valor
>>> lista ['a', 3] especial None
[1, 2, ['ab']] >>> a [::-1]
['x', 'd', 3, 2, 'a']  Não faz parte de tipo
Listas: fatias (slices) nenhum
 A notação de fatias também  Se um incremento de fatia é  É melhor que usar 0, [] ou
pode ser usada, inclusive diferente de 1, uma uma string vazia
para atribuição: atribuição à fatia deve ter o  Útil para criar uma lista
>>> lista = [1, 'a', 2+3j, ['ab', 'CD']] mesmo número de “vazia” mas com um número
>>> lista [1:]
['a', (2+3j), ['ab', 'CD']] elementos: conhecido de posições. Ex.:
>>> lista [:1] >>> l = [1,2,3,4,5] >>> lista = [None]*5
[1] >>> l [0::2] = ['x','y','z'] >>> lista
>>> lista [1:2] >>> l [None, None, None, None, None]
['a'] ['x', 2, 'y', 4, 'z']
>>> lista [0:-1] >>> l [0::2] = [6,7]
[1, 'a', (2+3j)] Traceback (most recent call last): Len,, min e max
File "<pyshell#17>", line 1, in -toplevell  len (lista) retorna o número
[0::2] = [6,7]
Listas: atribuição a fatias ValueError: attempt to assign sequence of size de elementos de lista
 A atribuição a uma fatia 2  min (lista) e max (lista)
to extended slice of size 3
requer que o valor atribuído retornam o menor/maior
seja uma seqüência Operador “in” elemento de lista
(uma lista ou uma string, por  Permite saber se um  Ex.:
>>> lista = [1, 2, 9, 3, 4]
exemplo) elemento pertence a uma lista >>> min (lista)
 A atribuição substitui os  Serve também para strings 1
>>> len (lista)
elementos da fatia pelos da  Ex.: 5
seqüência >>> lista = [1, 'a', 'bc'] >>> max (lista)
>>> lista = [1, 'y', ['ab', 'CD']] >>> 1 in lista 9
>>> lista [1:1] = ['z'] True >>> max (['a', 'b', 'c'])
>>> lista >>> 2 in lista 'c'
[1, 'z', 'y', ['ab', 'CD']] False
>>> lista [1:3] = [['x']] >>> 'b' in lista
>>> lista False min e max
[1, ['x'], ['ab', 'CD']] >>> 'b' in lista[2]  Na verdade, min e max
>>> lista [1:-1]= [2,3,4] True
>>> lista >>> 'bc' in 'abcd' podem ser usados também com
[1, 2, 3, 4, ['ab', 'CD']] True vários argumentos ao invés de
>>> lista [:2] = 'xyz' uma lista
>>> lista
['x', 'y', 'z', 3, 4, ['ab', 'CD']]
Inicializando listas  Ex.:
 Não é possível atribuir a >>> min (1,2,3,4)
1
Incrementos em Fatias uma posição inexistente de >>> max (3,4,5)
 É possível usar um terceiro uma lista 5
>>> vetor = [] >>> max ([],[1],['a'])
número na notação de >>> vetor [0] = 1 ['a']
fatias designando o incremento Traceback (most recent call last):
File "<pyshell#21>", line 1, in -toplevelvetor
 Default é 1 , ou seja, toma [0] = 1 A função list
os elementos de um em um IndexError: list assignment index out of range  Pode ser usada para
do menor para o maior índice  Se uma lista vai ser usada converter uma string numa
 Podese como um array, isto é, vai lista
usar qualquer número inteiro conter um número  É útil pois uma lista pode
diferente de 0 predeterminado de elementos, ser modificada, mas uma
 a[0:10:2] retorna uma lista é string, não
com os 10 primeiros elementos conveniente iniciála  Para fazer a transformação
>>> vetor = [0]*10
de a tomados de 2 em 2 (5 >>> vetor [0] = 3 inversa, podese
elementos, no máximo) >>> vetor usar o método join
[3, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 a[5:0:-1] retorna uma lista (veremos métodos mais tarde)
com os 5 primeiros elementos Usando None  Ex.:
de a tomados da esquerda para  >>> lista = list('alo')
a direita  >>> lista
 ['a', 'l', 'o']
 >>> lista[1]='xx'
 >>> lista
 ['a', 'xx', 'o']
 >>> ''.join(lista)
 'axxo'
A função range
 Retorna uma progressão
aritmética de inteiros numa
lista
 Forma geral: range (início,
parada, incremento)
 início (opcional) é o
primeiro valor a ser gerado
(default: 0)
 parada é o limite da
progressão: a progressão
termina no
último valor antes de parada
 incremento (opcional) é o
passo da progressão (default:1)
 Ex.:
>>> range(3)
[0, 1, 2]
>>> range(2,5,2)
[2, 4]
>>> range(5,2,-2)
[5, 3]
Comando for
 Permite iterar sobre os
elementos de uma lista
 Forma geral: for var in lista
: comandos
 Os comandos são repetidos
para cada valor de lista
 Durante a repetição, var
possui o valor corrente da lista
 Uma grande utilidade da
função range é construir a
lista de iteração
 Ex.:
>>>for i in range(1,7): print i,
123456
Comparando listas
 Listas são comparadas
lexicograficamente
 Se duas listas são iguais até
os késimos
elementos, o
resultado da comparação
depende da comparação
entre os (k+1)ésimos
elementos
 Se alguma das listas tem  Não vimos ainda
somente k elementos, então programação OO, mas alguns
esta é a pontos
menor devem ser enfatizados
 Duas listas são iguais se e  Listas possuem métodos que
somente se têm o mesmo podem ser aplicados a elas
comprimento e todos os  Um método é semelhante a
elementos de mesma posição uma função, mas são
são iguais invocados de forma diferente:
 Uma lista é maior que um objeto.método(args)
número mas menor que  Ex.: lista.reverse() inverte a
uma string ordem dos elementos
 Não me pergunte por quê! da lista
 Para saber todos os métodos
>>> [1,2] < [2, 3]
True de listas, escreva
>>> [1,2] < [1, 2, 3] help(list)
True
>>> [1,2] != [1,2]
False Alguns métodos da classe list
>>> min([[1],[2,3],[3,4],[]])  append(elemento)
[]
>>> max([[1],[2,3],[3,4],[]])  Acrescenta o elemento no
[3, 4] fim da lista
>>> min(0,[],"")
0 >>> max(0,[],"")  Observe que a operação
'' altera a lista, e não
simplesmente retorna uma lista
Variáveis do tipo list
modificada
 Uma variável do tipo lista
 Ex.:
na verdade contém uma >>> lista = [1,2]
referência para um valor do >>> lista.append(3)
>>> lista
tipo lista [1, 2, 3]
 Atribuir uma variável a >>> lista.append([4,5])
>>> lista
outra, cria uma nova referência [1, 2, 3, [4, 5]]
mas não uma nova lista
 Para se criar um novo valor,  count(elemento)
podese  Retorna quantas vezes o
usar uma elemento aparece na lista
expressão que retorne o valor  Ex.:
desejado >>> [1,2,3,1,2,3,4].count(1)
2
 Para saber se duas variáveis  extend(lista2)
se referem ao mesmo  Acrescenta os elementos de
valor podese lista2 ao final da lista
usar o operador is  OBS.: Altera a lista ao invés
de retornar a lista alterada
>>> a = b = [1,2,3]
>>> c = a  Ex.:
>>> d = c[:] >>> lista=[1,2]
>>> a is b >>> lista.extend([3,4])
True >>> lista
>>> c is b [1, 2, 3, 4]
True
>>> d is c
 index(elemento)
False
>>> a [1]=5  Retorna o índice da primeira
>>> b
ocorrência de elemento na
[1, 5, 3]
>>> d lista
[1, 2, 3]
 Um erro ocorre se elemento
não consta da lista
A Classe list
 Ex.:
 Uma lista é na verdade um
>>> lista = [9,8,33,12]
objeto de uma classe chamada >>> lista.index(33)
list 2
>>> lista.index(7)  sort(cmp=None, key=None,  O argumento key especifica
Traceback (most recent call last):
File "<pyshell#3>", line 1, in -toplevellista. reverse=False) uma função aplicada a cada
index(7)  Ordena a lista elemento
ValueError: list.index(x): x not in list
 Os argumentos são  Se for passada uma função f,
 insert(indice, elemento) opcionais. Por default, a lista é em vez de ordenar os
 insere elemento na lista na ordenada crescentemente elementos
posição indicada por índice  Ex.: baseado em seus valores v,
>>> lista = [9,8,7,1,4,2] ordena baseado em f(v)
 Ex.: >>> lista.sort()
>>> lista = [0,1,2,3] >>> lista  Ex.:
>>> lista.insert(1,'dois') [1, 2, 4, 7, 8, 9] >>> lista = ['abc','de','fghi']
>>> lista >>> lista.sort(key=len)
[0, 'dois', 1, 2, 3] >>> lista
 Como o extend, altera a  sort(cmp=None, key=None, ['de', 'abc', 'fghi']
lista ao invés de retornar a reverse=False)
lista  É possível obter a ordem Matrizes
 O valor retornado é None! inversa, passando True para o  Listas podem ser usadas
 Atribuições a fatias servem argumento reverse para guardar matrizes
para a mesma finalidade  Ex.:  Por exemplo, podemos criar
>>> lista = [9,8,7,1,4,2] uma matrizidentidade
mas são menos legíveis >>> lista.sort(reverse=True)
>>> lista = [0,1,2,3] >>> lista de
>>> lista [1:1] = ['dois'] [9, 8, 7, 4, 2, 1] 3x3 com o código:
>>> lista  OBS.: A notação acima m = []
[0, 'dois', 1, 2, 3]
permite passar um argumento for i in range(3):
m.append([0]*3)
 pop(índice) sem m[i][i]=1
 Remove da lista o elemento especificar os anteriores, mas  Obs.: Não é boa idéia iniciar
na posição índice e o retorna poderíamos ter escrito: uma matriz assim:
>>> lista = [9,8,7,1,4,2] m = [[0]*3]*3
 Se índice não for >>> lista.sort(None,None,True) for i in range(3): m[i][i]=1
mencionado, é assumido o >>> lista print m
[9, 8, 7, 4, 2, 1]  Resultado:[[1, 1, 1], [1, 1,
último
 Ex.: 1], [1, 1, 1]]
 sort(cmp=None, key=None,
>>> lista = [1,2,3,4]  (Por quê?)
>>> lista.pop() reverse=False)
4  O argumento cmp especifica
>>> lista Exercícios
[1, 2, 3] uma função de comparação  Escreva um programa que
>>> lista.pop(1)  É uma função que o sort
2 intercale os elementos de
>>> lista chama para definir se um duas listas l1 e l2
[1, 3] elemento é  Exemplo: para l1 = [1,2,3] e
anterior ou posterior a outro l2 =
 remove(elemento)
 A função a ser passada tem ['a','b','c','d','e'], o programa
 Remove da lista o primeiro
a forma comp(elem1,elem2) e deve
elemento igual a elemento
deve computar a lista
 Se não existe tal elemento,
retornar um inteiro negativo [1,'a',2,'b',3,'c','d','e']
um erro é gerado
caso elem1 seja anterior a  Escreva um programa para
 Ex.:
>>> lista = ['oi', 'alo', 'ola'] elem2, computar o produto de
>>> lista.remove('alo') positivo caso elem2 seja duas matrizes m1 e m2
>>> lista
['oi', 'ola'] anterior a elem1 e zero se tanto
>>> lista.remove('oba') faz  Escreva um programa para
Traceback (most recent call last):
File "<pyshell#24>", line 1, in -toplevellista.  Ex.: computar o triângulo de
remove('oba') >>> def compara(elem1,elem2):
ValueError: list.remove(x): x not in list return elem1%10 - elem2%10 Pascal até a linha n, onde n é
>>> compara(100,22) um valor inteiro
-2
 reverse() >>> lista=[100,22,303,104] positivo lido da linha de
 Inverte a ordem dos >>> lista.sort(compara) comando
>>> lista
elementos da lista [100, 22, 303, 104]  Lembrese
 Ex.: que o elemento na iésima
>>> lista=[1,2,3]  sort(cmp=None, key=None, linha e jésima
>>> lista.reverse()
>>> lista reverse=False) coluna do triângulo de Pascal
[3, 2, 1] contém o número de
combinações de i elementos j a A função tuple  Um template pode ser
j  Assim como a função list aplicado aos diversos valores
 O triângulo deve ser posto constrói uma lista a partir de uma tupla para construir
numa lista onde o iésimo de uma seqüência qualquer, a uma string formatada
elemento é uma lista com a função tuple constrói  Ex.:
iésima uma tupla a partir de uma >>> template = "%s tem %d anos"
>>> tupla = ('Pedro', 10)
linha do triângulo seqüência qualquer >>> template % tupla
 Ex: >>> list("abcd") 'Pedro tem 10 anos'
['a', 'b', 'c', 'd']  Obs: mais tarde veremos
Quantas linhas? 7 >>> tuple("abcd")
[[1], [1, 1], [1, 2, 1], [1, 3, 3, ('a', 'b', 'c', 'd') que o operador de
>>> tuple([1,2,3]) formatação também pode ser
1], [1, 4, 6, 4, 1], [1, 5, 10, 10, (1, 2, 3)
5, 1], [1, 6, 15,20, 15, 6, 1]] >>> list((1,2,3)) aplicado a dicionários
[1, 2, 3]
Python:
Tuplas e Strings Anatomia das especificações
Quando usar tuplas
de
 Em geral, tuplas podem ser
Tuplas formato
substituídas com
 São estruturas de dados  Caracter %
vantagem por listas
parecidas com listas, mas com  Flags de conversão
 Entretanto, algumas
a (opcionais):
construções em Python
particularidade de serem  indica
requerem tuplas ou seqüências
imutáveis alinhamento à esquerda
imutáveis, por
 Tuplas são seqüências e,  + indica que um sinal deve
exemplo:
assim como listas, podem ser preceder o valor convertido
 Tuplas (ao contrário de
indexadas e fatiadas, mas não é  “ ” (um branco) indica que
listas) podem ser usadas como
possível modificálas um espaço deve preceder
chaves de dicionários
 Um valor do tipo tupla é números
 Funções com número
uma série de valores separados positivos
variável de argumentos
por  0 indica preenchimento à
acessam
vírgulas e entre parênteses esquerda com zeros
os argumentos por meio de
>>> x = (1,2,3)  Comprimento mínimo do
>>> x tuplas
campo (opcional)
(1, 2, 3)  O operador de formatação
>>> x [0]  O valor formatado terá este
1 aceita tuplas, mas não listas comprimento no mínimo
>>> x [0]=1
...  Se igual a * (asterisco), o
TypeError: object does not support item O operador de formatação
comprimento será lido da tupla
Assignment  Strings suportam o operador
 Um “.” (ponto) seguido pela
% que, dada uma string
 Uma tupla vazia se escreve precisão (opcional)
especial
()  Usado para converter as
(template) e um valor, produz
 Os parênteses são opcionais casas decimais de floats
uma string formatada
se não provocarem  Se aplicado para strings,
 O formato geral é
ambigüidade indica o comprimento máximo
 template % valor
 Uma tupla contendo apenas  Se igual a *, o valor será
 O template é uma string
um elemento deve ser escrita lido da tupla
entremeada por códigos de
com  Caracter indicador do tipo
formatação
uma vírgula ao final de formato
 Um código de formatação é
 Um valor entre parênteses
em geral composto do caracter
sem vírgula no final é Tipos de formato
% seguido de uma letra
meramente  d, i Número inteiro escrito
descritiva do tipo do valor a
uma expressão: em decimal
>>> (10) formatar (s para string, f para
 o Número inteiro sem sinal
10 float, d para inteiro, etc)
>>> 10, escrito em octal
(10,)  Exemplo:
>>> (10,) >>> '====%d====' % 100  u Número inteiro sem sinal
(10,) '====100====' escrito em decimal
>>> 3*(10+3) >>> '====%f====' % 1
39 '====1.000000===='  x Número inteiro sem sinal
>>> 3*(10+3,) escrito em hexadecimal
(13, 13, 13) Formatando tuplas (minúsculas)
 X Número inteiro sem sinal print "%-*s%*s" % (len_itens, "Item", >>> s.find("parcela")
len_precos, -1
escrito em hexadecimal "Preço") >>> "parte" in s
(maiúsculas) print "-"*(len_itens+len_precos) True
for i in range(len(itens)): >>> s.find("parte",6)
 e Número de ponto flutuante print "%-*s%*.2f" % (len_itens, itens[i], 15
escrito em notação científica len_precos, precos[i]) >>> s.find("parte",6,12)
-1
('e' minúsculo)
Exemplo: resultados
 E Número de ponto -------------------------- Striings:: método jjoiin
flutuante escrito em notação Item Preço  join(seqüência)
--------------------------
científica ('E' maiúsculo) Abacate 2.13  Retorna uma string com
 f, F Número de ponto Limão 0.19 todos os elementos da
Tangerina 1.95
flutuante escrito em notação Melancia 0.87 seqüência concatenados
convencional Laranja da China 12.00  Obs: Os elementos da
 g Mesmo que e se expoente seqüência têm que ser strings
é maior que 4. O Módulo String
 A string objeto é usada
Caso contrario, igual a f  Manipulação de strings é
como separador entre os
 G Mesmo que E se expoente uma atividade freqüente
elementos
é maior que 4. em programas Python
 Ex.:
Caso contrario, igual a F  Existe um módulo chamado >>> "/".join(("usr","bin","python"))
 c Caractere único (usado string que contém 'usr/bin/python'
>>> "Q".join((1,2,3,4,5))
com inteiro ou string de uma grande quantidade de ...
tamanho 1) funcionalidades para TypeError: sequence item 0: expected string,
int found
 r String (entrada é qualquer trabalhar com strings >>> "Q".join(('1','2','3','4','5'))
objeto Python que é convertido  Para usálas: '1Q2Q3Q4Q5'

usando a from string import *

 Entretanto, strings Strings: métodos lower e
função repr) upper
pertencem à classe str e a
maior  lower()
Exemplos
>>> "Numero inteiro: %d" % 55 parte do que existe no módulo  Retorna a string com todos
'Numero inteiro: 55'
string aparece como os caracteres maiúsculos
>>> "Numero inteiro com 3 casas: %3d" % 55
'Numero inteiro com 3 casas: 55' métodos da classe str convertidos para minúsculos
>>> "Inteiro com 3 casas e zeros a esquerda:  upper()
%03d" % 55
'Inteiro com 3 casas e zeros a esquerda: 055' Striings:: método fiind  Retorna a string com todos
>>> "Inteiro escrito em hexadecimal: %x" %  find (substring, inicio, fim) os caracteres minúsculos
55
'Inteiro escrito em hexadecimal: 37'  Retorna o índice da primeira convertidos para maiúsculos
>>> from math import pi ocorrência de substring  Ex.:
>>> "Ponto flutuante: %f" % pi >>> print "Esperança".upper()
'Ponto flutuante: 3.141593'  inicio e fim são opcionais e ESPERANÇA
>>> "Ponto flutuante com 12 decimais:
%.12f" % pi
indicam os intervalos de >>> print "Pé de Laranja Lima".lower()
pé de laranja lima
'Ponto flutuante com 12 decimais: índices onde a busca será
3.141592653590'
>>> "Ponto flutuante com 10 caracteres:
efetuada Strings: método replace
%10f" % pi  Os defaults são 0 e o  replace(velho,novo,n)
'Ponto flutuante com 10 caracteres: 3.141593'
>>> "Ponto flutuante em notacao cientifica:
comprimento da string,  Substitui as instâncias da
%10e" % pi respectivamente substring velho por novo
'Ponto flutuante em notacao cientifica:
3.141593e+00'
 Caso substring não apareça  Se n for especificado,
>>> "String com tamanho maximo definido: na string, é retornado 1 apenas n instâncias são
%.3s" % "Pedro"
'String com tamanho maximo definido: Ped'
 Observe que o operador in trocadas
pode ser usado para dizer  Caso contrário, todas as
Exemplo: Imprimindo uma se uma substring aparece numa instâncias são trocadas
tabela string  Ex.:
itens = ["Abacate", "Limão", "Tangerina", >>> s = "quem parte e reparte, fica com a
"Melancia", maior
"Laranja da China"] Strings: método find parte"
precos = [2.13, 0.19, 1.95, 0.87, 12.00] (exemplo) >>> s.replace("parte","parcela")
len_precos = 10 # Coluna de precos tem 10 >>> s = "quem parte e reparte, fica com a 'quem parcela e reparcela, fica com a maior
caracteres maior parcela'
# Achar a largura da coluna de itens parte" >>> s.replace("parte","parcela",2)
len_itens = len(itens[0]) >>> s.find("parte") 'quem parcela e reparcela, fica com a maior
for it in itens : len_itens = 5 parte'
max(len_itens,len(it)) >>> s.find("reparte")
# Imprimir tabela de precos 13
print "-"*(len_itens+len_precos) Strings:: método split
 split(separador)
 Retorna uma lista com as
substrings presentes entre
cópias
da string separador
 Faz o contrário do método
join
 Se separador não for
especificado, é assumido
seqüências de
caracteres em branco, tabs ou
newlines
 Ex.:
>>> s = "xxx yyy zzz xxx yyy zzz"
>>> s.split()
['xxx', 'yyy', 'zzz', 'xxx', 'yyy', 'zzz']
>>> s.split('xxx')
['', ' yyy zzz ', ' yyy zzz']
Strings: método strip
 strip(ch)
 Retorna a string sem
caracteres iniciais ou finais que
estejam
na string ch
 Se ch não for especificada,
retira caracteres em branco
 Podese
também usar rstrip() para
retirar caracteres à
direita (final) ou lstrip() para
retirar caracteres à esquerda
(início)
 Ex.:
>>> " xxx afdsfa ".strip()
'xxx afdsfa'
>>> "xxx yyy zzz xxx".strip("xy ")
'zzz'
>>> " xxx ".rstrip()
' xxx'
Strings: método translate
 translate(trans)
 Retorna uma cópia da string
onde os caracteres são
substituídos de acordo com a
tabela de tradução trans
 trans é uma string com 256
caracteres, um para cada
possível código de oito bits
 Ex.: se trans tem 'X' na
posição 65 (correspondente ao
caractere
ASCII 'A'), então, na string
retornada, todos os caracteres
'A'
terão sido substituídos por 'X'
 Na verdade, as tabelas de
tradução são normalmente
construídas com a função
maketrans do módulo
string
Função string..maketrans
 maketrans (velho, novo)
 retorna uma tabela de
tradução onde os caracteres em
velho são substituídos pelos
caracteres em novo
 Ex.:
>>> from string import maketrans
>>> trans = maketrans('qs', 'kz')
>>> s = "que surpresa: quebrei a cara"
>>> s.translate(trans)
'kue zurpreza: kuebrei a cara'
Python::
Dicionários
Dicionários
 São estruturas de dados que
implementam mapeamentos
 Um mapeamento é uma
coleção de associações entre
pares de valores
 O primeiro elemento do par
é chamado de chave e o outro
de
conteúdo
 De certa forma, um
mapeamento é uma
generalização da
idéia de acessar dados por
índices, exceto que num
mapeamento os índices (ou
chaves) podem ser de
qualquer tipo imutável
Chaves vs.. Índices
 Considere que queiramos
representar um caderno de
telefones
 Uma solução é ter uma lista
de nomes e outra de telefones
 Telefone de nome[i]
armazenado em telefone[i]
 Acrescentar “Joao” com
telefone “20122232”:
nome+= “Joao”
telefone+=“20122232”
 Para encontrar o telefone de
“Joao”:
Tel =
telefone[nome.index[“Joao”]]
 Dicionários tornam isso
mais fácil e eficiente
telefone[“Joao”] = “20122232”
Tel = telefone[“Joao”]
Criando dicionários
 Uma constante do tipo
dicionário é escrita
{ chave1:conteúdo1, ...
chaveN:conteúdoN}
 Uma variável do tipo
dicionário pode ser “indexada”
da
maneira habitual, isto é,
usando colchetes
 O conteúdo associado a uma
chave pode ser alterado
atribuindose
àquela posição do dicionário
 Novos valores podem ser
acrescentados a um dicionário
fazendo atribuição a uma
chave ainda não definida
 Não há ordem definida entre
os pares chave/conteúdo de
um dicionário
Exemplo
>>> dic = {"joao":100,"maria":150}
>>> dic["joao"]
100
>>> dic["maria"]
150
>>> dic["pedro"] = 10
>>> dic
{'pedro': 10, 'joao': 100, 'maria': 150}
>>> dic = {'joao': 100, 'maria': 150, 'pedro':
10}
>>> dic
{'pedro': 10, 'joao': 100, 'maria': 150}
Dicionários não têm ordem
 As chaves dos dicionários
não são armazenadas em
qualquer ordem específica
 Na verdade, dicionários são
implementados por tabelas de
espalhamento (Hash Tables)
 A falta de ordem é
proposital
 Diferentemente de listas,
atribuir a um elemento de um
dicionário não requer que a
posição exista previamente
X = []
X [10] = 5 # ERRO!
...
Y = {}
Y [10] = 5 # OK!
A função dict
 A função dict é usada para  Retorna um outro dicionário  keys() retorna uma lista com
construir dicionários e requer com os mesmos pares todas as chaves do
como parâmetros: chave/conteúdo dicionário
 Uma lista de tuplas, cada  Observe que os conteúdos  values() retorna uma lista
uma com um par não são cópias, mas apenas com todos os valores do
chave/conteúdo, referências para os mesmos dicionário
ou valores  Ex.:
 Uma seqüência de itens no >>> x = {"Joao":[1,2], "Maria":[3,4]} >>> dic.items()
>>> y = x.copy() [('Joao', 'a'), ('Maria', 'b')]
formato chave=valor >>> y ["Pedro"]=[5,6] >>> dic.keys()
 Nesse caso, as chaves têm >>> x ["Joao"] += [3] ['Joao', 'Maria']
>>> print x >>> dic.values()
que ser strings, mas são {'Joao': [1, 2, 3], 'Maria': [3, 4]} ['a', 'b']
escritas sem >>> print y
{'Pedro': [5, 6], 'Joao': [1, 2, 3], 'Maria': [3, 4]}
Aspas Método pop
Método fromkeys  pop (chave)
Exemplo  fromkeys(lista,valor)  Obtém o valor
>>> d = dict([(1,2),('chave','conteudo')])
 Retorna um novo dicionário correspondente a chave e
>>> d[1]
2 cujas chaves são os elementos remove o par
>>> d['chave']
de lista e cujos valores são chave/valor do dicionário
'conteudo'
>>> d = dict(x=1,y=2) todos iguais a valor  Ex.:
>>> d['x'] >>> d = {'x': 1, 'y': 2}
1  Se valor não for >>> d.pop('x')
>>> d = dict(1=2,3=4) especificado, o default é None 1
SyntaxError: keyword can't be an expression >>> d
>>> {}.fromkeys([2,3])
{'y': 2}
{2: None, 3: None}
Formatando com Dicionários # Podemos usar o nome da classe ao invés
 O operador de formatação
# de um objeto: Método popitem
>>> dict.fromkeys(["Joao","Maria"],0)
quando aplicado a dicionários {'Joao': 0, 'Maria': 0}  popitem()
requer que os valores das  Retorna e remove um par
chaves apareçam entre Método get chave/valor aleatório do
parênteses antes do código de  get(chave,valor) dicionário
formatação  Obtém o conteúdo de chave  Pode ser usado para iterar
 O conteúdo armazenado no  Não causa erro caso chave sobre todos os elementos do
dicionário sob aquela chave é não exista: retorna valor dicionário
substituído na string de  Se valor não for  Ex:
especificado chaves >>> d
formatação {'url': 'http://www.python.org', 'spam': 0,
 Ex: inexistentes retornam 'title': 'Python Web Site'}
None >>> d.popitem()
>>> dic = { "Joao":"a", "Maria":"b" } ('url', 'http://www.python.org')
>>> s = "%(Joao)s e %(Maria)s"  Ex.: >>> d
>>> s % dic >>> dic = { "Joao":"a", "Maria":"b" } {'spam': 0, 'title': 'Python Web Site'}
'a e b' >>> dic.get("Pedro")
>>> print dic.get("Pedro")
Método clear None Método update
 clear()
>>> print dic.get("Joao")  update(dic)
a
 Remove todos os elementos >>> print dic.get("Carlos","N/A")  Atualiza um dicionário com
do dicionário
N/A os elementos de outro
 Ex.:  Os itens em dic são
Método has_key adicionados um a um ao
>>> x = { "Joao":"a", "Maria":"b" }
>>> y = x  has_key(chave) dicionário
>>> x.clear()  dic.has_key(chave) é o original
>>> print x,y
{} {} mesmo que chave in dic  É possível usar a mesma
 Diferente de atribuir {} à  Ex.: sintaxe da função dict para
>>> dic = { "Joao":"a", "Maria":"b" }
variável: >>> dic.has_key("Joao") especificar dic
>>> x = { "Joao":"a", "Maria":"b" } True
>>> y = x >>> dic.has_key("Pedro")
 Ex.:
>>> x = {} >>> x = {"a":1,"b":2,"c":3}
False
>>> print x,y >>> y = {"z":9,"b":7}
{} {'Joao': 'a', 'Maria': 'b'} >>> x.update(y)
Métodos items,, keys e values >>> x
{'a': 1, 'c': 3, 'b': 7, 'z': 9}
Método copy  items() retorna uma lista >>> x.update(a=7,c="xxx")
 copy() com todos os pares >>> x
{'a': 7, 'c': 'xxx', 'b': 7, 'z': 9}
chave/conteúdo do dicionário
Python:
Funções
Abstração
 É uma técnica de
programação que nos permite
pensar
num problema em diversos
níveis
 A idéia é que quando
estamos pensando num
problema
macroscopicamente, não
estamos preocupado com
minúcias
 Dividir para conquistar:
 Um problema é dividido em
diversos subproblemas
 As soluções dos
subproblemas
são combinadas numa
solução do problema maior
Programação Estruturada
 É uma disciplina de
programação que incorpora o
princípio de “Dividir para
Conquistar”
 (Programação Orientada a
Objetos é outra...)
 Programas são divididos em
subprogramas
 Cada subprograma
é invocado por meio de um
identificador e uma lista de
entradas
 Permite especificar como
um problema pode ser
resolvido em
geral
 O mesmo subprograma
pode ser invocado para
resolver
diversos problemas de mesma
natureza mas com valores
específicos diferentes
 Os resultados computados
por um subprograma
podem ser
combinados com os de outros
subprogramas
Definindo funções
 Em Python, subprogramas
têm o nome de funções
 Formato geral:
def nome (arg, arg, ... arg):  É possível no código de uma
comando função ler o conteúdo de uma
... variável global
comando  Para alterar uma variável
 Onde: global, ela precisa ser
 nome é o nome da função declarada
 args são especificações de no corpo da função usando o
argumentos da função comando global
 Uma função pode ter 0, 1 ou
mais argumentos Exemplo
 comandos contêm as >>> def f():
print a
instruções a ser executadas >>> a = 1
quando a >>> f()
1
função é invocada >>> def f():
a=5
>>> f()
Resultado de funções >>> print a
 Uma função tipicamente 1
>>> def f():
computa um ou mais valores global a
 Para indicar o valor a ser a=5
>>> f()
devolvido como o resultado da >>> print a
função, usase 5
o comando return, que tem o
formato Argumentos de funções
return expressão  Argumentos (ou
 onde a expressão é opcional parâmetros) são como
e designa o valor a ser variáveis que
retornado recebem seus valores iniciais
 Ao encontrar o comando do chamador
return, a função termina  Essas variáveis, assim como
imediatamente e o controle do outras definidas dentro da
programa volta ao ponto função são ditas locais, isto é,
onde a função foi chamada só existem no lugar onde
 Se uma função chega a seu foram definidas
fim sem nenhum valor de  Ao retornar ao ponto de
retorno ter sido especificado, o chamada, as variáveis locais
são
valor de retorno é None
descartadas
Exemplo  Se uma função define n
>>> def f(): argumentos, a sua chamada
return deve
>>> print f()
None incluir valores para todos eles
>>> def f():  Exceção: argumentos com
return "Oi"
>>> print f() valores default
Oi
>>> def f(nome):
return "Oi, "+nome+"!" Exemplo
>>> print f("Joao") >>> def f(x):
Oi, Joao! return x*x
>>> print f(10)
100
Variáveis locais e globais >>> print x
 Variáveis definidas em ....
NameError: name 'x' is not defined
funções são locais, isto é, só >>> print f()
podem ....
TypeError: f() takes exactly 1 argument (0
ser usadas nas funções em que given)
foram definidas
 Variáveis definidas fora de Argumentos default
funções são conhecidas como  É possível dar valores
variáveis globais default a argumentos
 Se o chamador não uma variável global, esta não é
especificar valores para esses alterada
argumentos, os defaults são  Ex.:
usados >>> def f(x):
x=5
 Formato: >>> a = 1
def nome (arg1=default1, ..., >>> f (a)
>>> print a
argN=defaultN)
1  Note que quando
 Se apenas alguns passamos uma variável do tipo
argumentos têm default, esses
lista
devem como parâmetro, estamos
ser os últimos
passando uma referência para
 Se não fosse assim, haveria um valor do tipo lista
ambigüidade na passagem de
 Nesse caso, alterar o
Argumentos parâmetro pode influenciar no
 Se o último argumento de
uma definição de função
começa com * , os todos os
valores passados a partir
daquele são postos numa tupla
 Ex.:
>>> def imprime(nome,*atributos):
... print nome,atributos
...
>>> imprime ('a',1,2,'b')
a (1, 2, 'b')
>>> def media(*valores):
... total=0.0
... for x in valores: total+=x
... return total/len(valores)
...
>>> media(1,2,3,4)
2.5

“valor”
Exemplo Lista de parâmetros variável
da variável global
>>> def (2)
f(nome,saudacao="Oi",pontuacao="!!"):  Na verdade, o “valor” da
return saudacao+","+nome+pontuacao  Se o último argumento de
variável do tipo lista é uma
>>> print f("Joao") uma definição de função
Oi,Joao!! referência que não muda
>>> print f("Joao","Parabens") começa com ** , os todos os
 Este caso é idêntico a
Parabens,Joao!! valores passados usando
>>> print f("Joao","Ah","...") termos duas variáveis se
Ah,Joao... chaves a partir daquele são
referindo ao
postos num dicionário
Exemplo mesmo valor
 Ex.:
>>> def >>> def f(a,b,**c):
f(nome,saudacao="Oi",pontuacao="!!"): Exemplo print a, b, c
return saudacao+","+nome+pontuacao >>> def f(x): >>> f(1,2,3)
>>> print f("Joao") x[:] = [5] ...
Oi,Joao!! >>> a = [1] TypeError: f() takes exactly 2 arguments (3
>>> print f("Joao","Parabens") >>> f(a) given)
Parabens,Joao!! >>> a >>> f(1,2,x=3)
>>> print f("Joao","Ah","...") [5] 1 2 {'x': 3}
Ah,Joao... >>> b = a
>>> b[:] = [7]
Lista de parâmetros variável
Passando argumentos com >>> a
[7] (3)
nomes
 É possível passar os valores
 É possível passar os Documentando Funções de uma tupla para preencher
argumentos sem empregar a  Ao invés de usar parâmetros
ordem comentários para descrever o posicionais de uma função
de definição desde que se que uma função, é bastando para isso precedêla
nomeie cada valor passado mais vantajoso usar docstrings de *
com  Uma constante string escrita  Um dicionário podem ser
o nome do argumento logo após o cabeçalho da usado para preencher
correspondente função parâmetros por chave
 Ex.: (comando def)
>>> def bastando para isso precedêlo
f(nome,saudacao="Oi",pontuacao="!!"):  Permite o acesso à de **
return saudacao+","+nome+pontuacao documentação a partir do  É preciso tomar cuidado
>>> print f(saudacao="Valeu",nome="Joao")
Valeu,Joao!! interpretador, para não abusar!
Alterando parâmetros usando a notação função .  Ex.:
 É possível alterar __doc__ >>> def f(a,b,*c,**d):
>>> def fat(n): print a,b,c,d
parâmetros? ... "Retorna o fatorial de n." >>> f(*[1,2,3,4,5])
 Sim e não ... for i in range(n-1,1,-1): n*=i 1 2 (3, 4, 5) {}
... return n >>> f(**{"a":1,"b":2,"c":3,"d":4})
 Como o parâmetro é uma ... 1 2 () {'c': 3, 'd': 4}
variável local, ele pode ser >>> fat(4) >>> f(1,2,3,**{"d":1})
24 1 2 (3,) {'d': 1}
alterado sem problemas >>> print fat.__doc__ >>> f(1,2,3,**{"a":1})
 Entretanto, se um parâmetro Retorna o fatorial de n. ...
TypeError: f() got multiple values for keyword
recebe um valor que vem de argument 'a'
Lista de parâmetros variável
Passando funções x=1  Semelhante à prova de
print vars()
 Nomes de funções podem >>> vars() teoremas por indução
ser manipulados como {'f': <function f at 0xb6e7f56c>, '__builtins__':  Casos simples: O teorema é
<module '__builtin__' (built-in)>, '__name__':
variáveis e '__main__', '__doc__': None} verdadeiro trivialmente
mesmo como argumentos de >>> f()  Casos genéricos: são
{'x': 1}
funções provados assumindose
 Para saber se um nome se Funções definidas em que todos os
refere a uma função, use o funções casos mais simples também
predicado callable()  Funções podem ser são verdadeiros
 Ex.: definidas dentro de funções Função recursiva
>>> def f(g):  Implementa um algoritmos
return g(5)  Se uma função g é definida
>>> def h(x): dentro de uma função f, ela recursivo onde a solução dos
return x*x casos
>>> f(h) tem acesso ao seu próprio
25 escopo (em primeiro lugar) e genéricos requerem chamadas
>>> m = h à própria função
>>> callable(m) também ao escopo de f
True  Ex.:  Uma função recursiva é a
>>> f(m) >>> def f(x): maneira mais direta (mas não
25 def g(y): return x*y
return g(2) necessariamente a melhor) de
Escopo >>> print f(4) se resolver problemas de
8
 Escopo é o nome que se dá natureza
ao conjunto de nomes Funções definidas em recursiva ou para implementar
acessíveis de funções (2) estruturas de dados recursivas
um determinado ponto de um  Observe que, se uma função  Considere, por exemplo, a
programa g foi definida dentro de outra definição da seqüência de
 Também é chamado de função f, então, se g é Fibonacci:
espaço de nomes ou armazenada numa variável ou  O primeiro e o segundo
namespace transmitida para outra função termo valem 0 e 1,
 Um programa começa em ela carrega com si os valores respectivamente
um escopo (chamado escopo do  O iésimo
global) escopo de f (mas não o escopo termo é a soma do (i1)
enquanto que cada função global). Ex: ésimo
acrescenta um escopo próprio >>> x = 2 e o (i2)
>>> def f(y):
(local) def g(z): return x*y*z
ésimo
 Módulos e classes também return g termo
>>> h = f(3) >>> def fib(i):
definem escopos >>> print h(1) if i==1: return 0
 Ao se fazer acesso a um 6 elif i==2: return 1
>>> x = 3 else: return fib(i-1)+fib(i-2)
nome, todos os escopos, do >>> print h(1) >>> for i in range(1,11):
mais 9 print fib(i),
0 1 1 2 3 5 8 13 21 34
interno para o mais externo,
são consultados. Python:
Recursão Exemplo: Busca binária
 Isto explica por que definir  Um exemplo clássico de
uma variável numa função recursão é o algoritmo
Recursão
pode conhecido
 É um princípio muito
fazer com que uma variável como busca binária que é
poderoso para construção de
global deixe de ser acessível algoritmos usado para pesquisar um valor
 A solução de um problema é em
Função vars() uma lista ordenada
dividido em
 O dicionário obtido com a  Chamemos de imin e imax
 Casos simples:
função vars() pode ser os índices mínimo e máximo
 São aqueles que podem ser
usado para ter acesso a todas da
resolvidos trivialmente
as variáveis definidas num lista onde a busca será feita
 Casos gerais:
escopo. Ex.:  Inicialmente, imin = 0 e
>>> vars()  São aqueles que podem ser
{'__builtins__': <module '__builtin__' (built- resolvidos compondo soluções imax = len(lista)-1
in)>,
'__name__': '__main__', '__doc__': None} de  O caso base corresponde a
>>> def f(): casos mais simples imin == imax
 Então, ou o valor é igual a
lista [imin] ou não está na lista
 Senão, podemos dividir o
intervalo de busca em dois
 Seja meio = (imin+imax)/2
 Se o valor é maior que lista
[meio] , então ele se encontra
em
algum dos índices entre
meio+1 e imax
 Caso contrário, deve se
encontrar em algum dos
índices
entre e
Busca binária:
implementação
def testa(lista,valor):
def busca_binaria(imin,imax):
if imin==imax: return imin
else:
meio=(imax+imin)/2
if valor>lista[meio]:
return busca_binaria(meio+1,imax)
else:
return busca_binaria(imin,meio)
i = busca_binaria(0,len(lista)-1)
if lista[i]==valor:
print valor,"encontrado na posicao",i
else:
print valor,"nao encontrado"
>>> testa([1,2,5,6,9,12],3)
3 nao encontrado
>>> testa([1,2,5,6,9,12],5)
Recursão
5 encontrado na posicao 2
iinfiiniita
 Assim como nos casos dos
laços de repetição, é preciso
cuidado
para não escrever funções
infinitamente recursivas
 Ex.:
def recursiva(x):
if f(x): return True
else: return recursiva(x)
 Uma função recursiva tem
que
 Tratar todos os casos
básicos
 Usar recursão apenas para
tratar casos garantidamente
mais
simples do que o caso corrente
 Ex.:
def recursiva(x):
if f(x): return True
elif x==0: return False
else: return recursiva(x-1)
Eficiência de funções
recursivas
 Quando uma função é
chamada, um pouco de
memória é
usado para guardar o ponto de
retorno, os argumentos e
variáveis locais
 Assim, soluções iterativas
são normalmente mais
eficientes do que soluções
recursivas equivalentes
 Isto não quer dizer que
soluções iterativas sempre
sejam
preferíveis a soluções
recursivas
 Se o problema é recursivo
por natureza, uma solução
recursiva é mais clara, mais
fácil de programar e,
freqüentemente, mais eficiente
Pensando recursivamente
 Ao invés de pensar
construtivamente para para
obter uma
solução, às vezes é mais
simples pensar em termos de
uma prova indutiva
 Considere o problema de
testar se uma lista a é uma
permutação da lista b
 Caso básico: a é uma lista
vazia
 Então a é permutação de b
se b também é uma lista vazia
 Caso básico: a[0] não
aparece em b
 Então a não é uma
permutação de b
 Caso genérico: a[0] aparece
em b na posição i
 Então a é permutação de b
se a[1:] é uma permutação de
b do
qual foi removido o elemento
na posição i Exemplo: Testa
permutações
def e_permutacao(a,b):
"""
Retorna True sse a lista a é uma
permutação da lista b
"""
if len(a) == 0 : return len(b)==0
if a[0] in b:
i = b.index(a[0])
return e_permutacao(a[1:],b[0:i]+b[i+1:])
return False
>>> e_permutacao([1,2,3],[3,2,1])
True
>>> e_permutacao([1,2,3],[3,3,1])
False
>>> e_permutacao([1,2,3],[1,1,2,3])
False
>>> e_permutacao([1,1,2,3],[1,2,3])
False
Estruturas de dados
recursivas
 Há estruturas de dados que
são inerentemente recursivas,
já
que sua própria definição é
recursiva
 Por exemplo, uma lista pode
ser definida recursivamente:
 [] é uma lista (vazia)
 Se A é uma lista e x é um
valor, então A+[x] é uma lista
com
x como seu último elemento
 Esta é uma definição
construtiva, que pode ser usada
para
escrever funções que criam
listas
 Uma outra definição que
pode ser usada para analisar
listas é:
 Se L é uma lista, então:
 L == [] , ou seja, L é uma
lista vazia, ou
 x = L.pop() torna L uma
lista sem seu último elemento
x
 Esta definição não é tão útil
em Python já que o comando
permite iterar facilmente sobre
os elementos Exemplo:
Subseqüênciia
def e_subseq(a,b):
""" Retorna True sse a é subseqüência de b,
isto é, se todos os elementos a[0..n-1] de a
aparecem em b[j(0)], b[j(1)]... b[j(n-1)]
onde j(i)<j(i+1) """
if a == []:
# Lista vazia é subseqüência de qq lista
return True
if a[0] not in b:
return False
return e_subseq (a[1:], b[b.index(a[0])+1:])
Encontrando a recorrência
 Alguns problemas não se
apresentam naturalmente como
recursivos, mas pensar
recursivamente provê a
solução
 Tome o problema de
computar todas as permutações
de
uma lista
 Assumamos que sabemos
computar todas as permutações
de uma lista sem seu primeiro
elemento x
 Seja perm uma dessas  Se n é 1, então a solução é
permutações trivial
 Então, a solução do global  Caso contrário,
contém todas as listas obtidas  Usase
inserindo x em todas as o algoritmo para mover n1
possíveis posições de perm discos de A para C usando
Exemplo: computar todas as B como sobressalente
permutações de uma lista  Movese
def permutacoes(lista): o disco restante de A para B
""" Dada uma lista, retorna uma lista de listas,
onde cada elemento é uma permutação da lista  Usase
original """ o algoritmo para mover n1
if len(lista) == 1: # Caso base
return [lista] discos de C para B usando
primeiro = lista[0] A como sobressalente Torres
resto = lista [1:]
resultado = [] de Hanói: Implementação
for perm in permutacoes(resto): def hanoi(n,origem,destino,temp):
for i in range(len(perm)+1): if n>1: hanoi(n-1,origem,temp,destino)
resultado += \ mover(origem,destino)
[perm[:i]+[primeiro]+perm[i:]] if n>1: hanoi(n-1,temp,destino,origem)
return resultado def mover(origem,destino):
Torres de Hanói print “Mover de“, origem, “para”,\
“destino”
 Jogo que é um exemplo  Com um pouco mais de
clássico trabalho, podemos redefinir a
de problema recursivo função mover para que ela nos
 Consiste de um tabuleiro dê uma representação
com 3 “gráfica” do movimento dos
pinos no qual são encaixados
discos
discos de tamanho decrescente
 A idéia é mover os discos de Torres de Hanói: Exemplo
um
pino para outro sendo que:
 Só um disco é movimentado
por vez
 Um disco maior nunca pode
ser posto sobre um menor

Torres de Hanói: Algoritmo

 A solução é simples se
supusermos existir um
algoritmo
capaz de mover todos os
discos menos um do pino de
origem para o pino
sobressalente
 O algoritmo completo para
mover n discos do pino de
origem A para o pino de
destino B usando o pino
sobressalente C é