Lista de guia rapidos

Operaes com Listas:

Operao
Descrio
x in s
1 se x estiver contido em s, caso contrrio 0.
n not in s
1 se x no estiver contido em s, caso contrrio 0.
s+t
concatenao de s + t.
s*n
n cpias de s concatenado.
s[i]
elemento cujo ndice i, primeiro ndice 0.
s[i:j]
seqencia de elementos entre os ndices i e j.
len(s)
nmeros de elementos da seqncia (comprimento).
min(s)
menor valor da seqncia.
max(s)
maior valor da seqncia.
s[i] = j
substitui um elemento.
s[i:j] = t
substitui um grupo de elementos.
del s[i]
remove o elemento da posio i.
del s[i:j]
remove um grupo de elementos.
s.append(x)
adiciona um elemento (no final da lista).
s.extend(x)
adiciona uma lista (ao final da lista).
s.count(x)
retorna o nmero de vezes que um elemento est presente na lista
s.index(x)
retorna o menor ndice do elemento.
s.insert(i,x)
insere o elemento x na posio i.
s.pop([i])
retira um elemento da posio i. Padro i = -1.
s.remove(x)
remove um elemento.
s.reverse()
inverte a ordem da lista.
s.sort([cmpfunc])
ordena a lista.
Exemplos:
>>> a = [1,2,3]
>>> s = [1,2,3]
>>> t = [4,5,6]
>>> x = 2
>>> x in s
True
>>> x not in s
False
>>> s + t
[1, 2, 3, 4, 5, 6]
>>> s * 2
[1, 2, 3, 1, 2, 3]
>>> s[2]
3
>>> s[1:3]
[2, 3]
>>> len(s)
3
>>> min(s)
1

1
>>> max(s)
3
>>> a = [1,2,3,4]
>>> a[1] = 10
>>> a
[1, 10, 3, 4]
>>> a.append(30)
>>> a
[1, 10, 3, 4, 30]
>>> a.extend([90,32])
>>> a
[1, 10, 3, 4, 30, 90, 32]
>>> a.index(30)
4
>>> a.reverse()
>>> a
[32, 90, 30, 4, 3, 10, 1]
>>> a.pop()

P3ListasResumoAula
MarcoAndreLopesMendes
>>> quadradoMagico = ['Ronaldo', 'Kaka','Ronaldinho', 'Adriano']
>>> quadraMagico
>>> type(quadradoMagico)
<type 'list'>
>>> for jogador in quadradoMagico:
print jogador
Ronaldo
Kaka
Ronaldinho
Adriano
>>> len(quadradoMagico)

4
>>> for i in range(len(quadradoMagico)):
print quadradoMagico[i]
Ronaldo
Kaka
Ronaldinho
Adriano
>>> range(len(quadradoMagico))
[0, 1, 2, 3]
>>> range(4)
[0, 1, 2, 3]
>>> q = quadradoMagico
>>> jogador
'Adriano'
>>> len(q)
4
>>> print q[0]
Ronaldo
>>> print q[1]
Kaka
>>> print q[2]
Ronaldinho
>>> print q[3]
Adriano
>>> q[4]
Traceback (most recent call last):
File "<pyshell#25>", line 1, in -toplevelq[4]
IndexError: list index out of range
>>> for i in range(len(quadradoMagico)):
print i, quadradoMagico[i]
0 Ronaldo
1 Kaka
2 Ronaldinho
3 Adriano
>>> q
['Ronaldo', 'Kaka', 'Ronaldinho', 'Adriano']
>>> for i in range(len(quadradoMagico)):
if quadradoMagico[i][0] == 'R': print i, quadradoMagico[i]
0 Ronaldo
2 Ronaldinho
>>> for i in range(len(quadradoMagico)):
if quadradoMagico[i][0] == 'R': print i, quadradoMagico[i]
KeyboardInterrupt
>>> for jogador in q:
if jogador[0] == 'R':
print jogador
Ronaldo
Ronaldinho
>>> quadradoMagico.sort()
>>> for jogador in q:
print jogador
Adriano

Kaka
Ronaldinho
Ronaldo
>>> quadradoMagico.reverse()
>>> for jogador in q:
print jogador
Ronaldo
Ronaldinho
Kaka
Adriano
>>> for i in range(len(quadradoMagico)):
print i, quadradoMagico[i]
0 Ronaldo
1 Ronaldinho
2 Kaka
3 Adriano
>>> jogador
'Adriano'
>>> jogador in quadradoMagico
True
>>> jogador = 'Bianca'
>>> jogador in quadradoMagico
False
>>>
>>>
>>> for jogador in q:
if jogador[0:2] == 'Ro':
print jogador
Ronaldo
Ronaldinho
>>> q.append('Ricardinho')
>>> len(q)
5
>>> q
['Ronaldo', 'Ronaldinho', 'Kaka', 'Adriano', 'Ricardinho']
>>> for jogador in q:
if jogador[0] == 'R':
print jogador
Ronaldo
Ronaldinho
Ricardinho
>>> for jogador in q:
if jogador[0:2] == 'Ro':
print jogador
Ronaldo
Ronaldinho
>>> len(q)
KeyboardInterrupt
>>> for jogador in q:
print jogador
Ronaldo
Ronaldinho

Kaka
Adriano
Ricardinho
>>> q.sort()
>>> q
['Adriano', 'Kaka', 'Ricardinho', 'Ronaldinho', 'Ronaldo']
>>> for jogador in q:
print jogador
Adriano
Kaka
Ricardinho
Ronaldinho
Ronaldo
>>> q[0] = 'Adriano Imperador'
>>> q
['Adriano Imperador', 'Kaka', 'Ricardinho', 'Ronaldinho', 'Ronaldo']
>>> q[1] = 'Principe' + ' ' + q[1]
>>> q
['Adriano Imperador', 'Principe Kaka', 'Ricardinho', 'Ronaldinho', 'Ronaldo']
>>> for jogador in q:
print jogador
Adriano Imperador
Principe Kaka
Ricardinho
Ronaldinho
Ronaldo
>>> q[2] = 'Romrio'
>>> q
['Adriano Imperador', 'Principe Kaka', 'Rom\xe1rio', 'Ronaldinho', 'Ronaldo']
>>> for jogador in q:
print jogador
Adriano Imperador
Principe Kaka
Romrio
Ronaldinho
Ronaldo
>>> q[2] += "Vov"
>>> q
['Adriano Imperador', 'Principe Kaka', 'Rom\xe1rioVov\xf4', 'Ronaldinho', 'Ronaldo']
>>> for jogador in q:
print jogador
Adriano Imperador
Principe Kaka
RomrioVov
Ronaldinho
Ronaldo
>>> q[2] = "Vovo Romario"
>>> q
['Adriano Imperador', 'Principe Kaka', 'Vovo Romario', 'Ronaldinho', 'Ronaldo']
>>> for jogador in q:
print jogador
Adriano Imperador
Principe Kaka
Vovo Romario
Ronaldinho

Ronaldo
>>> q[3] += ' Gacho'
>>> for jogador in q:
print jogador
Adriano Imperador
Principe Kaka
Vovo Romario
Ronaldinho Gacho
Ronaldo
>>> q[4] += ' Bolao'
>>> for jogador in q:
print jogador
Adriano Imperador
Principe Kaka
Vovo Romario
Ronaldinho Gacho
Ronaldo Bolao
>>>
>>>
>>>
>>>
>>>
>>>
>>> q.sort()
>>> for jogador in q:
print jogador
Adriano Imperador
Principe Kaka
Ronaldinho Gacho
Ronaldo Bolao
Vovo Romario
>>> len(q)
5
>>> jogador = q[0]
>>> jogador
'Adriano Imperador'
>>> n = jogador.split()
>>> n
['Adriano', 'Imperador']
>>> q[0] = n[1] + ' ' + n[0]
>>> q
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Ronaldo Bolao', 'Vovo Romario']
>>> for jogador in q:
print jogador
Imperador Adriano
Principe Kaka
Ronaldinho Gacho
Ronaldo Bolao
Vovo Romario
>>> q[0].split()
['Imperador', 'Adriano']
>>> q[0].split()[0]
'Imperador'
>>> nome = q[0]
>>> nome
'Imperador Adriano'
>>> nomeS = nome.split()

>>> nomeS
['Imperador', 'Adriano']
>>> nomeS[0]
'Imperador'
>>> for jogador in quadradoMagico:
print jogador
Imperador Adriano
Principe Kaka
Ronaldinho Gacho
Ronaldo Bolao
Vovo Romario
>>> q
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Ronaldo Bolao', 'Vovo Romario']
>>> quadradoMagico
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Ronaldo Bolao', 'Vovo Romario']
>>> copia = quadradoMagico[:]
>>> copia
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Ronaldo Bolao', 'Vovo Romario']
>>> copia.pop()
'Vovo Romario'
>>> copia
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Ronaldo Bolao']
>>> q
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Ronaldo Bolao', 'Vovo Romario']
>>> quadradoMagico
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Ronaldo Bolao', 'Vovo Romario']
>>> for jogador in quadradoMagico:
nomeSeparado = jogador.split()
print nomeSeparado[0]
Imperador
Principe
Ronaldinho
Ronaldo
Vovo
>>> copia.pop()
KeyboardInterrupt
>>> for jogador in quadradoMagico:
print jogador.upper()
IMPERADOR ADRIANO
PRINCIPE KAKA
RONALDINHO GACHO
RONALDO BOLAO
VOVO ROMARIO
>>>
KeyboardInterrupt
>>> for i in range(len(quadradoMagico)):
print i, quadradoMagico[i]
0 Imperador Adriano
1 Principe Kaka
2 Ronaldinho Gacho
3 Ronaldo Bolao
4 Vovo Romario
>>> for i in range(len(quadradoMagico)):
print i, quadrad
KeyboardInterrupt
>>> for jogador in quadradoMagico:

KeyboardInterrupt
>>> for i in range(len(quadradoMagico)):
q[i] = q[i].lower()
print q[i]
imperador adriano
principe kaka
ronaldinho gacho
ronaldo bolao
vovo romario
>>> for jogador in quadradoMagico: print jogador
imperador adriano
principe kaka
ronaldinho gacho
ronaldo bolao
vovo romario
>>> q
['imperador adriano', 'principe kaka', 'ronaldinho ga\xfacho', 'ronaldo bolao', 'vovo romario']
>>> for jogador in quadradoMagico: print jogador.title()
Imperador Adriano
Principe Kaka
Ronaldinho Gacho
Ronaldo Bolao
Vovo Romario
>>> for jogador in quadradoMagico: print jogador.capitalize()
Imperador adriano
Principe kaka
Ronaldinho gacho
Ronaldo bolao
Vovo romario
>>> for i in range(len(quadradoMagico)):
q[i] = q[i].title()
print q[i]
Imperador Adriano
Principe Kaka
Ronaldinho Gacho
Ronaldo Bolao
Vovo Romario
>>> len(q)
5
>>>
>>>
>>>
>>> for jogador in quadradoMagico: print jogador
KeyboardInterrupt
>>> for i in range(len(quadradoMagico)):
print q[i]
Imperador Adriano
Principe Kaka
Ronaldinho Gacho
Ronaldo Bolao
Vovo Romario
>>> for i in range(len(quadradoMagico)):
print i, q[i]

0 Imperador Adriano
1 Principe Kaka
2 Ronaldinho Gacho
3 Ronaldo Bolao
4 Vovo Romario
>>> q.append('Edson Arantes do Nascimento')
>>> q
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Ronaldo Bolao', 'Vovo Romario', 'Edson Arantes do
Nascimento']
>>> for jogador in quadradoMagico:
nomeSeparado = jogador.split()
print nomeSeparado[0]
Imperador
Principe
Ronaldinho
Ronaldo
Vovo
Edson
>>>
>>>
>>> for jogador in quadradoMagico:
nomeSeparado = jogador.split()
print nomeSeparado[-1]
Adriano
Kaka
Gacho
Bolao
Romario
Nascimento
>>> for jogador in quadradoMagico:
nomeSeparado = jogador.split()
print nomeSeparado[1]
Adriano
Kaka
Gacho
Bolao
Romario
Arantes
>>> q
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Ronaldo Bolao', 'Vovo Romario', 'Edson Arantes do
Nascimento']
>>> for jogador in quadradoMagico:
nomeSeparado = jogador.split()
print nomeSeparado[-1]
Adriano
Kaka
Gacho
Bolao
Romario
Nascimento
>>> for jogador in quadradoMagico:
nomeSeparado = jogador.split()
print nomeSeparado[0], nomeSeparado[-1]
Imperador Adriano

Principe Kaka
Ronaldinho Gacho
Ronaldo Bolao
Vovo Romario
Edson Nascimento
>>> q.append('Marco Andre Lopes Mendes')
>>>
>>> for jogador in quadradoMagico:
nomeSeparado = jogador.split()
print nomeSeparado[-1]
Adriano
Kaka
Gacho
Bolao
Romario
Nascimento
Mendes
>>> for jogador in quadradoMagico:
nomeSeparado = jogador.split()
print nomeSeparado[0]
Imperador
Principe
Ronaldinho
Ronaldo
Vovo
Edson
Marco
>>> for jogador in quadradoMagico:
nomeSeparado = jogador.split()
print nomeSeparado[0], nomeSeparado[-1]
Imperador Adriano
Principe Kaka
Ronaldinho Gacho
Ronaldo Bolao
Vovo Romario
Edson Nascimento
Marco Mendes
>>> for i in range(len(quadradoMagico)):
print i, q[i]
0 Imperador Adriano
1 Principe Kaka
2 Ronaldinho Gacho
3 Ronaldo Bolao
4 Vovo Romario
5 Edson Arantes do Nascimento
6 Marco Andre Lopes Mendes
>>> i = 0
>>> while 1 < len(q):
print q[i]
i += 1
Imperador Adriano
Principe Kaka
Ronaldinho Gacho
Ronaldo Bolao
Vovo Romario
Edson Arantes do Nascimento

Marco Andre Lopes Mendes

Traceback (most recent call last):
File "<pyshell#183>", line 2, in -toplevelprint q[i]
IndexError: list index out of range
>>> while i < len(q):
print q[i]
i += 1
>>> i = 0
>>> while i < len(q):
print q[i]
i += 1
Imperador Adriano
Principe Kaka
Ronaldinho Gacho
Ronaldo Bolao
Vovo Romario
Edson Arantes do Nascimento
Marco Andre Lopes Mendes
>>> while i < len(q):
print q[i]
i += 1
KeyboardInterrupt
>>> i
7
>>> i = 0
>>> while i < len(q):
print i, q[i]
i += 1
0 Imperador Adriano
1 Principe Kaka
2 Ronaldinho Gacho
3 Ronaldo Bolao
4 Vovo Romario
5 Edson Arantes do Nascimento
6 Marco Andre Lopes Mendes
>>> range(7)
[0, 1, 2, 3, 4, 5, 6]
>>>
>>> q
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Ronaldo Bolao', 'Vovo Romario', 'Edson Arantes do
Nascimento', 'Marco Andre Lopes Mendes']
>>> del quadradoMagico[4]
>>> for jogador in quadradoMagico:
nomeSeparado = jogador.split()
print nomeSeparado[0], nomeSeparado[-1]
KeyboardInterrupt
>>> for i in range(len(quadradoMagico)):
print i, q[i]
0 Imperador Adriano
1 Principe Kaka
2 Ronaldinho Gacho
3 Ronaldo Bolao
4 Edson Arantes do Nascimento
5 Marco Andre Lopes Mendes
>>> jogador = q.pop()

10

>>> jogador
'Marco Andre Lopes Mendes'
>>> for i in range(len(quadradoMagico)):
print i, q[i]
0 Imperador Adriano
1 Principe Kaka
2 Ronaldinho Gacho
3 Ronaldo Bolao
4 Edson Arantes do Nascimento
>>> jogador = q.pop(3)
>>> jogador
'Ronaldo Bolao'
>>> for i in range(len(quadradoMagico)):
print i, q[i]
0 Imperador Adriano
1 Principe Kaka
2 Ronaldinho Gacho
3 Edson Arantes do Nascimento
>>> q.append("Diogo")
>>> q
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Edson Arantes do Nascimento', 'Diogo']
>>> q.insert(0,"Heleno")
>>> q
['Heleno', 'Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Edson Arantes do Nascimento', 'Diogo']
>>> fruta = ['banana','maca']
>>> fruta
['banana', 'maca']
>>> frutas = ['banana','maca']
>>> for i in range(len(frutas)):
frutas[i] += "s"
>>> frutas
['bananas', 'macas']
>>> for i in range(2):
frutas[i] += "s"
>>> for i in range(2):
print frutas[i]
bananass
macass
>>> frutas.append('kiwi')
>>> for i in range(2):
print frutas[i]
bananass
macass
>>> for i in range(3):
print frutas[i]
bananass
macass
kiwi
>>> fruta
['banana', 'maca']
>>> fruta = frutas[0]

11

>>> fruta
'bananass'
>>> fruta[:-1]
'bananas'
>>> fruta[:-2]
'banana'
>>> fruta[:]
'bananass'
>>> fruta
'bananass'
>>> fruta[0:-2]
'banana'
>>> fruta[0:2]
'ba'
>>> fruta[0:3]
'ban'
>>> fruta[0:-2]
'banana'
>>> q
['Heleno', 'Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Edson Arantes do Nascimento', 'Diogo']
>>> q.pop()
'Diogo'
>>> q
['Heleno', 'Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Edson Arantes do Nascimento']
>>> len(q)
5
>>> q.remove("Heleno")
>>> q
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Edson Arantes do Nascimento']
>>>
>>>
>>>
>>> min(q)
'Edson Arantes do Nascimento'
>>> notas = [9.6, 9.5, 6.1, 7.3]
>>> min(notas)
6.0999999999999996
>>> min(notas)
6.0999999999999996
>>> print min(notas)
6.1
>>> print max(notas)
9.6
>>> sum(notas)
32.5
>>> sum(notas)/len(notas)
8.125
>>> notas.append(9.5)
>>> notas
[9.5999999999999996, 9.5, 6.0999999999999996, 7.2999999999999998, 9.5]
>>> notas.count(9.5)
2
>>>
>>>
>>>
>>> notas.count(9.6)
1
>>> notas.count(9.4)
0
>>> q
['Imperador Adriano', 'Principe Kaka', 'Ronaldinho Ga\xfacho', 'Edson Arantes do Nascimento']
>>> notas
[9.5999999999999996, 9.5, 6.0999999999999996, 7.2999999999999998, 9.5]

12

>>> notas.pop()
9.5
>>> for i in range(len(quadradoMagico)):
print i, q[i], notas[i]
0 Imperador Adriano 9.6
1 Principe Kaka 9.5
2 Ronaldinho Gacho 6.1
3 Edson Arantes do Nascimento 7.3
>>> notas.pop()
7.2999999999999998
>>> for i in range(len(quadradoMagico)):
print i, q[i], notas[i]
0 Imperador Adriano 9.6
1 Principe Kaka 9.5
2 Ronaldinho Gacho 6.1
3 Edson Arantes do Nascimento
>>>

13

P3FuncoesResumo
MarcoAndreLopesMendes
Objetivos:
1.
2.

Escrever suas prprias funes;

Aceitar valores em sua funo atravs de parmetros;

3.
4.

Retornar informao de uma funo atravs de valores;

Trabalhar com variveis globais e constantes;

5.

Criar componentes que executem tarefas especficas.

Construir um programa grande a partir de pequenos componentes, cada um dos quais mais gerencivel que o programa original uma tcnica
chamada dividir e conquistar.
Componentes em Python so chamados funes, classes, mdulos e pacotes.
Programas Python tipicamente so escritos atravs da combinao de novas funes e classes que o programador escreve com funes de prempacotadas ou classes disponveis em numerosos mdulos de Python.
O programador pode escrever funes para definir tarefas especficas que podem ser usadas em muitos pontos num programa.
Uma funo invocada (i.e., feita executar sua tarefa designada) por uma chamada de funo.
A chamada de funo especifica o nome de funo e fornece informao (como uma lista separada por vrgulas de argumentos) que a funo
chamada necessita para fazer seu trabalho.
Todas as variveis criadas em definies de funo so variveis locaisso conhecidas s na funo em que elas so criadas.
A maioria das funes tm uma lista de parmetros que fornece o meio para comunicar informao entre funes. Um parmetro da uma funo
tambm uma varivel local.
A abordagem dividir-e-conquistar torna o desenvolvimento de programas mais gerencivel.
Outra motivao para usar a abordagem dividir-e-conquistar a reutilizao de software usando funes existentes como blocos de
construo para criar novos programas.
Uma terceira motivao para usar a abordagem dividir-e-conquistar evitar a repetio de cdigo num programa. Empacotar o cdigo como uma
funo permite que o cdigo seja executado de vrios locais num programa simplesmente chamando a funo.
As funes do mdulo math (matemtica) permitem ao programador executar certos clculos matemticos comuns.
Funes normalmente so chamadas escrevendo o nome da funo, seguido por um parntese esquerdo, seguido pelo argumento (ou uma lista
de argumentos separados por vrgula) da funo, seguido por um parntese direito.
Para usar uma funo que definida num mdulo, um programa tem que importar o mdulo, usando a palavra-chave import. Depois que o
mdulo foi importado, o programa pode acessar uma funo ou uma varivel no mdulo, usando o nome de mdulo, um ponto (.) e a funo ou
nome da varivel.
Funes so definidas com a palavra-chave def.
As instrues endentadas que seguem uma declarao def formam o corpo de funo. O corpo de funo tambm chamado de um bloco.
H trs meios de retornar controle ao ponto em que uma funo foi invocada. Se a funo no retorna um resultado, o controle retornado
simplesmente quando a ltima linha endentada alcanada, ou ao executar um return. Se a funo retorna um resultado, a declarao [return
expresso] retorna o valor de expresso ao chamador.
None um valor de Python que representa nulo indicando que nenhum valor foi declarado e isso avaliado como falso em expresses
condicionais.

14

O elemento de possibilidade pode ser introduzido em aplicaes de computador usando o mdulo random.
A funo randrange gera um nmero inteiro entre o primeiro argumento e o segundo, no incluindo, este ltimo. Se randrange verdadeiramente
produz nmeros inteiros aleatoriamente, cada nmero entre o primeiro argumento e o segundo argumento tem uma possibilidade igual (ou
probabilidade) de ser escolhido cada vez que a funo chamada.
Python tem regras estritas que descrevem como e quando um valor da varivel pode ser acessado. Estas regras so descritas em termos de
espao de nomes (namespaces) e escopos.
Espaos de nome armazenam informaes sobre um identificador e o valor ao qual ele est ligado.
Python define trs espaos de nome; quando um programa tenta acessar um valor de um identificador, Python procura nos espaos de nome
numa ordem especfica para ver se e onde o identificador existe.
O espao de nome local armazena ligaes criadas num bloco. Todos os parmetros de funo e qualquer identificador que a funo cria so
armazenados no espao de nome local da funo.
O espao de nome global (ou de mdulo) contm as ligaes para todos os identificadores, nomes de funo e nomes de classe definido num
arquivo ou mdulo.
Cada espao de nome global de um mdulo contm um identificador chamado name que fornece o nome desse mdulo. Quando uma sesso do
interpretador Python iniciada ou quando o interpretador Python invocado num programa armazenado num arquivo, o valor de name "main".
O espao de nomes built-in (padro) contm identificadores que correspondem a muitas funes e erros de Python. Python cria o espao de
nome padro quando o interpretador comea, e programas normalmente no modificam o espao de nome (p.e., por adicionar um identificador
ao espao de nome).
Um escopo de um identificador descreve a regio de um programa que pode acessar o valor do identificador.
Se um identificador definido no espao de nome local (p.e.,de uma funo), esse identificador tem escopo local. Uma vez que o bloco de cdigo
termina (p.e.,quando uma funo retorna), todos os identificadores nesse espao de nome local do bloco saem do escopo e no podem mais
ser acessados.
Se um identificador definido no espao de nome global, o identificador tem escopo global. Um identificador global conhecido por todo cdigo
que executa dentro desse mdulo, do ponto em que o identificador criado at o fim do arquivo.
Quando uma funo cria um identificador local com o mesmo nome que um identificador no espao de nome do mdulo ou padro, o
identificador local dito que sombreia (shadows) o identificador global ou padro. O programador pode introduzir um erro de lgica no programa
se ele referencia uma varivel local, mas pretende referenciar um identificador global ou padro.
Algumas chamadas de funo geralmente passam um valor particular de um argumento. O programador pode especificar que esse argumento
um argumento padro (default), e o programador podem fornecer um valor padro para esse argumento. Quando um argumento padro
omitido numa chamada de uma funo, o interpretador automaticamente insere o valor padro desse argumento e passa o argumento na
chamada.
Argumentos padro devem ser os argumentos mais a direita (finais) numa lista de parmetros de uma funo. Quando chamando uma funo
com dois ou mais argumentos padro, se um argumento omitido no o argumento mais a direita na lista de argumento, todos argumentos
direita desse argumento tambm devem ser omitidos.
O programador pode especificar que uma funo recebe um ou mais argumentos de palavra-chave. A definio de funo pode designar um
valor a um argumento de palavra-chave. Tanto uma funo pode associar um valor padro para um argumento de palavra-chave ou um chamado
de funo pode designar um novo valor ao argumento de palavra-chave, usando o formato [keyword = valor].
Referncias
1.

Deitel, H. M. et ali. Python How to Program. Prentice Hall,2002

P3ClassesResumo
MarcoAndreLopesMendes

15

Objetivos:
A programao orientada a objetos (POO) um meio diferente de pensar sobre programao. uma metodologia moderna que foi abraada
pela indstria de software e usada na criao da maioria dos software comerciais novos. O bloco bsico de construo em POO o objeto de
softwarefreqentemente chamados apenas de objeto. Agora, voc dar seus primeiros passos em direo compreenso da POO.
Especificamente, voc aprender a:
1.

Criar classes para definir objetos

2.
3.

Escrever mtodos e criar atributos para objetos

Instanciar objetos a partir de classes

4.

Restringir o acesso a atributos do objeto

A programao orientada a objetos (POO) encapsula (i.e., embrulha) dados (atributos) e funes (comportamentos) em componentes chamados
de classes. Os dados e funes de uma classe intimamente esto ligados.
Uma classe como um desenho tcnico. Usando um desenho tcnico, um construtor pode construir uma casa. Usando uma classe, um
programador podem criar um objeto (tambm chamado de uma instncia).
Classes tm uma propriedade chamada de ocultao da informao. Embora objetos possam saber como comunicar-se atravs de interfaces
bem-definidas, a um objeto normalmente no deve ser permitido saber como outro objeto implementado detalhes de implementao so
escondidos dentro dos objetos.
Em programao procedural, a unidade de programao a funo. Em programao orientada a objetos, a unidade de programao a classe
de quem objetos eventualmente so instanciados.
Programadores procedurais se concentram em escrever funes. Os verbos numa especificao de sistema ajudam o programador procedural a
determinar o conjunto de funes que trabalharo juntos para implementar o sistema.
Programadores de POO concentram-se em criar seus prprios tipos de dados definidos pelo usurio, chamados de classes. Os substantivos
numa especificao de sistema ajudam o programador de POO a determinar o conjunto de classes que ser usado para criar os objetos que
trabalharo juntos para implementar o sistema.
Classes simplificam a programao porque os clientes necessitam estar preocupados s com as operaes encapsuladas ou embutidas no
objeto a interface de objeto.
A palavra-chave class inicia uma definio de classe. A palavra-chave seguida pelo nome da classe, que seguido por um sinal de dois pontos
(:). A linha que contm a palavra-chave class e o nome de classe chamada de cabealho (header) da classe.
O corpo da classe um bloco de cdigo endentado que contm mtodos e atributos que pertencem classe.
Uma string de documentao opcional da classe descreve a classe. Se uma classe contm uma strings de documentao, a strings deve
aparecer na linha ou linhas seguindo o cabealho da classe.
O mtodo init o mtodo construtor de uma classe. Um construtor um mtodo especial que executa cada vez um objeto de uma classe
criado. O construtor inicia os atributos do objeto e retorna None.
Todos os mtodos, incluindo construtores, devem especificar ao menos um parmetro a referncia de objeto. Este parmetro representa o
objeto da classe para o qual o mtodo chamado. Os mtodos devem usar a referncia de objeto para acessar atributos e outros mtodos que
pertencem classe. Por conveno, o argumento de referncia de objeto chamado self. Cada objeto tem o prprio namespace que contm os
mtodos do objeto e atributos. O construtor da classe comea com um objeto vazio (self) e adiciona atributos ao namespace do objeto.
Uma vez que uma classe foi definida, programas podem criar objetos dessa classe. Os programadores podem criar objetos como necessrio. Isto
uma razo por que Python dita ser uma linguagem extensvel.
Um dos princpios fundamentais de um bom projeto de software que o cliente no deve necessitar saber como uma classe implementada
para usar essa classe. O uso de mdulos de Python facilita esta abstrao de dados um programa pode importar uma definio de classe e
usar a classe sem saber como a classe implementada.
Para criar um objeto de uma classe, simplesmente chama-se o nome da classe como se fosse uma funo. Este chamado invoca o construtor
da classe. Classes e objetos de classes ambos tm atributos especiais que podem ser manipulados. Estes atributos, que Python cria quando
uma classe definida ou quando um objeto de uma classe criado, fornecem informao sobre a classe ou objeto de uma classe a que eles
pertencem.

16

O acesso direto aos dados do objeto pode deixar os dados num estado inconsistente.
A maioria das linguagens de programao orientadas a objetos permitem que um objeto se previna de que seus clientes acessem os dados do
objeto diretamente. No entanto, em Python, o programador usa convenes de nomes de atributos para esconder os dados de clientes.
Embora um cliente possa acessar os dados do objeto diretamente (e talvez fazer com que os dados entrem em um estado inconsistente), um
programador pode projetar classes para encorajar o uso correto. Uma tcnica fornecer mtodos de acesso para a classe para que os dados da
classe podem ser lidos e escritos numa maneira cuidadosamente controlada.
Quando uma classe define mtodos de acesso, um cliente deve acessar atributos do objeto s por esses mtodos de acesso.
Classes freqentemente fornecem mtodos que permitem que os clientes coloquem ou recebam os valores dos atributos. Embora estes mtodos
no precisem ser chamados set e get, eles freqentemente so. Mtodos get tambm so chamados de mtodos de pergunta.
Um mtodo set pode controlar o formato dos dados. Um mtodo set pode e bem possivelmente devia verificar tentativas de modificar o
valor dos atributos. Isto assegura que o novo valor apropriado para aquele item de dados.
Um mtodo set pode especificar que uma mensagem de erro chamada uma exceo levantado ao cliente quando as tentativas de cliente
designar um valor invlido a um atributo.
Quando um autor de uma classe cria um atributo com um nico sublinhado principal, o autor no quer que os usurios da classe acessem o
atributo diretamente. Se um programa exige acesso aos atributos, o autor da classe fornece algum outro meio para fazer este acesso.
Em linguagens de programao tais como C + + e Java, uma classe pode declarar explicitamente que atributos ou mtodos podem ser
acessados por clientes da classe. Estes atributos ou mtodos so chamados de pblicos. Os atributos e mtodos que no podem ser acessados
por clientes da classe so chamados de privados.
Para prevenir o acesso indiscriminado a um atributo, coloque como prefixo ao nome do atributo dois ( caracteres de sublinhado).
Quando Python encontra um nome de atributo que comea com dois sublinhados, o interpretador previne o acesso indiscriminado aos dados. Ele
muda o nome de um atributo por incluir informao sobre a classe a que o atributo pertence.
Construtores podem definir argumentos padro que especificam valores iniciais para atributos do objeto, se o cliente no especifica um
argumento no momento da construo.
Construtores podem definir argumentos de palavra-chave que capacitam o cliente a especificar valores para determinados argumentos.
Construtores fornecidos pelo programador que possuem valores padro para todos os seus argumentos (ou que no exigem explicitamente
nenhum argumento) tambm so chamados de construtores padro.
Se nenhum construtor definido para uma classe, o interpretador cria um construtor padro. No entanto, o esse construtor que Python fornece
no executa nenhuma inicializao, ento, quando um objeto criado, no h garantia que o objeto esteja num estado coerente.
Um destruidor executado quando um objeto destrudo (p.e., depois que no existe mais nenhuma referncia ao objeto).
Uma classe pode definir um mtodo especial chamado del que executado quando a ltima referncia a um objeto removida ou sai do escopo.
Um destruidor normalmente no especifica nenhum parmetro alm de self e retorna None.
Um atributo de classe representa informao da amplitude da classe (i.e., uma propriedade da classe, no de um objeto especfico da classe).
Embora atributos de classe possam parecer como variveis globais, cada atributo de classe reside no espao de nome da classe em que
criado. Os atributos de classe devem ser iniciados uma vez (e s uma vez) na definio de classe.
Um atributo de classe pode ser acessado por qualquer objeto dessa classe. Os atributos de classe tambm existem mesmo quando nenhum
objeto dessa classe existe. Acessar um atributo de classe quando nenhum objeto da classe existe, coloque como prefixo o nome de classe,
seguido por um ponto, seguido pelo nome do atributo.
Programadores Python concentram-se em criar novas classes e em reutilizar classes da biblioteca padro. Este tipo de reusabilidade de software
agiliza o desenvolvimento de software poderoso e de alta-qualidade.
A biblioteca padro capacita os desenvolvedores de Python a construir aplicaes mais rpido atravs da reutilizao de classes previamente
existentes e extensamente testadas.

17

Referncias
1.

Deitel, H. M. et ali. Python How to Program. Prentice Hall,2002

P3StringsResumoAula
MarcoAndreLopesMendes

>>>s1="BSI320"
>>>s2="BSI320"
>>>
>>>len(s1)==len(s2)
True
>>>s1==s2
True
>>>len(s1)==len(s2);s1==s2
True
True
>>>s2="bsi320"
>>>len(s1)==len(s2);s1==s2
True
False
>>>s1="bsi320"
>>>len(s1)==len(s2);s1==s2
False
False
>>>s1;s2
'bsi320'
'bsi320'
>>>iflen(s1)==len(s2):
print"Mesmotamanho"
ifs1==s2:
print"iguais"
else:
print"diferentes"

>>>iflen(s1)==len(s2):
print"Mesmotamanho"
ifs1==s2:
print"iguais"
else:
print"diferentes"
else:
print"Tamanhodiferente"

Tamanhodiferente
>>>iflen(s1)==len(s2):
print"Mesmotamanho"
ifs1==s2:
print"iguais"
else:
print"diferentes"
else:
print"Tamanhodiferente"

Tamanhodiferente
>>>s1
'bsi320'

18

>>>s2
'bsi320'
>>>s1='bsi320'
>>>iflen(s1)==len(s2):
print"Mesmotamanho"
ifs1==s2:
print"iguais"
else:
print"diferentes"
else:
print"Tamanhodiferente"

Mesmotamanho
iguais
>>>s1='bsi310'
>>>iflen(s1)==len(s2):
print"Mesmotamanho"
ifs1==s2:
print"iguais"
else:
print"diferentes"
else:
print"Tamanhodiferente"

Mesmotamanho
diferentes
>>>iflen(s1)==len(s2):
print"Mesmotamanho"
ifs1==s2:
print"iguais"
else:
print"diferentes"
else:
print"Tamanhodiferente"

Mesmotamanho
diferentes
>>>s1="01"
>>>s2="1"
>>>iflen(s1)==len(s2):
print"Mesmotamanho"
ifs1==s2:
print"iguais"
else:
print"diferentes"
else:
print"Tamanhodiferente"

Tamanhodiferente
>>>s1>s2
False
>>>s1<s2
True
>>>int(s1)
1
>>>n="Ronaldinho"
>>>n
'Ronaldinho'
>>>forlinrange(len(n)1,1,1):printn[l],

19

ohnidlanoR
>>>forlinrange(len(n)1,1,1):printn[l].upper(),
OHNIDLANOR
>>>n[::1].upper()
'OHNIDLANOR'
>>>
>>>
>>>
>>>n="ovo"
>>>ni=n[::1]
>>>n==ni
True
>>>n='casa'
>>>n==ni
False
>>>ni=n[::1]
>>>n
'casa'
>>>ni
'asac'
>>>n='casa'
>>>ni=n[::1]
>>>n==ni
False
>>>n='natan'
>>>ni=n[::1]
>>>n==ni
True
>>>n="socorrammesubinoonibusemmarrocos"
>>>ni=n.replace("","")
>>>ni
'socorrammesubinoonibusemmarrocos'
>>>ni=ni[::1]
>>>n
'socorrammesubinoonibusemmarrocos'
>>>n="socorrammesubinoonibusemmarrocos"
>>>n=n.replace("","")
>>>ni=n[::1]
>>>n==ni
True
>>>n="Festanasexta!"
>>>n
'Festanasexta!'
>>>forlinrange(len(n)1,1,1):printn[l]
!
a
t
x
e
s

a
n

a
t
s
e
F

20

>>>forlinrange(len(n)):printn[l]
F
e
s
t
a

n
a

s
e
x
t
a
!
>>>foriinrange(len(n)):printn[:i+1]
F
Fe
Fes
Fest
Festa
Festa
Festan
Festana
Festana
Festanas
Festanase
Festanasex
Festanasext
Festanasexta
Festanasexta!
>>>foriinrange(len(n)):printn[0:i+1]
F
Fe
Fes
Fest
Festa
Festa
Festan
Festana
Festana
Festanas
Festanase
Festanasex
Festanasext
Festanasexta
Festanasexta!
>>>data="29/10/1973"
>>>data[0:2]
'29'
>>>data[3:5]
'10'
>>>data[6:]
'1973'
>>>foriinrange(len(n)1,1,1):printn[0:i+1]
Festanasexta!
Festanasexta
Festanasext

21

Festanasex
Festanase
Festanas
Festana
Festana
Festan
Festa
Festa
Fest
Fes
Fe
F
>>>
>>>mesesExt=['Jan','Fev','Mar']
>>>data="29/01/1973"
>>>mes=int(data[3:5])
>>>mes
1
>>>
>>>printmesesExt[mes1]
Jan
>>>n
'Festanasexta!'
>>>foriinrange(len(n)):
>>>c=0
>>>foriinrange(len(n)):
ifi
>>>forletrainn:
ifletra="":
>>>forletrainn:
ifletra=="":
c+=1

>>>c
2
>>>printmesesExt[mes1]
>>>n
'Festanasexta!'
>>>forletrainn:
ifletra=="":
c+=1
>>>c
4
>>>c=0
>>>
>>>
>>>
>>>
>>>v=0
>>>forletrainn:
ifletrain=="":v+=1

>>>v=0
>>>forletrainn:
ifletrain['a','e','i','o','u']:
v+=1
>>>v
5
>>>n
'Festanasexta!'
>>>n.upper()

22

'FESTANASEXTA!'
>>>n=n.lower()
>>>n
'festanasexta!'
>>>n.title()
'FestaNaSexta!'
>>>n.capitalize()
'Festanasexta!'
>>>n.title()
'FestaNaSexta!'
>>>'FestaNaSexta!'
'FestaNaSexta!'
>>>n
'festanasexta!'
>>>l=range(10)
>>>l
[0,1,2,3,4,5,6,7,8,9]
>>>l.reverse()
>>>l
[9,8,7,6,5,4,3,2,1,0]
>>>l
[9,8,7,6,5,4,3,2,1,0]
>>>l.sort()
>>>l
[0,1,2,3,4,5,6,7,8,9]
>>>importrandom
>>>random.shuffle(l)
>>>l
[6,9,4,0,1,3,7,5,8,2]
>>>data
'29/01/1973'
>>>data[3]
'0'
>>>data[2]
'/'
>>>a="marco"
>>>b=a
>>>b
'marco'
>>>b="andre"
>>>a
'marco'
>>>a
'marco'
>>>b
'andre'
>>>l
[6,9,4,0,1,3,7,5,8,2]
>>>l1=l
>>>l1
[6,9,4,0,1,3,7,5,8,2]
>>>l1.append(34566)
>>>l1
[6,9,4,0,1,3,7,5,8,2,34566]
>>>l
[6,9,4,0,1,3,7,5,8,2,34566]
>>>l1=l[:]
>>>l1
[6,9,4,0,1,3,7,5,8,2,34566]
>>>l
[6,9,4,0,1,3,7,5,8,2,34566]
>>>l.pop()
34566

23

>>>l
[6,9,4,0,1,3,7,5,8,2]
>>>l1
[6,9,4,0,1,3,7,5,8,2,34566]
>>>

24