INTRODUÇÃO À

LINGUAGEM PYTHON

02/04/2019 Curso de Extensão

Este curso é dirigido aos alunos do IFG, tanto do ensino médio técnico
quanto do superior (Engenharias). Em nível introdutório, tem7se por
objetivo apresentar a Linguagem de Programação Python. Essa
linguagem tem como principal característica o ecletismo, permitindo
ao usuário o desenvolvimento de aplicativos de toda sorte, desde o
processamento de dados científicos até aplicações comerciais, para
rodar no , ou , envolvendo banco de dados,
servidores via Web ou não, manipulando grande massa de dados
( ).

Goiânia, Fev/2019
Cláudio A. Fleury
Introdução à Linguagem Python

O QUE É PYTHON?
É uma linguagem de programação de alto nível, interpretada, interativa, versátil, de código aberto e
legível aos seres humanos, orientada a objetos/imperativa/funcional/estruturada e de uso geral. Possui
um sistema de tipificação dinâmica de variáveis, gerenciamento automático de memória e uma biblioteca
padrão abrangente. Como outras linguagens dinâmicas, o Python é frequentemente usado como uma
linguagem de , mas também pode ser compilado em programas executáveis.
Nos exemplos a seguir, a entrada e a saída de comandos/respostas são diferenciadas pela presença ou
ausência de (>>> e ...): para reproduzir o exemplo, você deve digitar os comandos após o
>>>. As linhas que não começam com um são geradas pelo interpretador, são as respostas
aos comandos. Observe que um secundário sozinho em uma linha num exemplo significa que você
deve digitar uma linha em branco; isso é usado para encerrar um comando de várias linhas.
Muitos dos exemplos nesta apostila, mesmo aqueles inseridos no interativo, incluem comentários.
Comentários em Python começam com o caractere ‘#’, e se estendem até o final da linha física. Um
comentário pode aparecer no início de uma linha ou após um espaço em branco ou código, mas não
dentro de uma . Um caractere dentro de uma é apenas mais um caractere da . Como
os comentários são para esclarecer o código e não são interpretados pelo Python, eles podem ser
omitidos ao se digitar os exemplos.
>>> # Exemplo de script Python
>>> porta = 1 # porta aberta
>>> texto = "Deixe seu comentario em #comPythonehmaisfacil"

USANDO O PYTHON COMO UMA CALCULADORA:

O interpretador funciona como uma calculadora simples: você pode digitar uma expressão e aperta
[ ] para ter o valor calculado. A sintaxe da expressão é direta: os operadores +, 7, * e / funcionam
como na maioria das outras linguagens (Pascal, Java ou C). Os parênteses ‘( )’ podem ser usados para
alterar a hierarquia de resolução dos operadores. Por exemplo:
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6)/4
5
>>> 8/5 # divisão de operandos inteiros retorna resultado inteiro (Vs.2.7)
1
>>> 8./5 # divisão de operandos reais retorna resultado real (Vs.2.7)
1.6
>>> 5**2 # 5 ao quadrado
25

O sinal de igual (=) é usado para atribuir um valor a uma variável. Depois de uma atribuição nenhum
resultado é exibido antes do próximo :

Prof. Cláudio A. Fleury Página 1

 >>> largura = 10
>>> altura = 5 * 9
>>> largura * altura
450

Se uma variável não for "definida" (atribuída um valor), tentar usá7la causará um erro:
>>> n # tentativa de acessar uma variável não definida
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
>>>

HISTÓRICO
A linguagem Python começou a ser desenvolvida por ! ""
em 1989 (lançada oficialmente em 1999) na Centrum Wiskunde &
Informatica (CWI), Holanda, como sucessora da linguagem ABC (inspirada
na SETL1) que era capaz de lidar com exceções e interagir com o sistema
operacional que ele estava ajudando a desenvolver.
Guido era fã do grupo humorístico # , criador do programa
de comédia na televisão inglesa BBC (19697
1974). Ele quis homenagear o grupo dando o nome Python à linguagem.
Então, a denominação da linguagem não é devida à serpente Python,
embora o ícone utilizado para representação sejam duas cobras estilizadas.
Linha do tempo do lançamento das versões:

Fonte: http://www.trytoprogram.com/python7programming/history7of7python/

1Linguagem de programação de "altíssimo nível", baseada na teoria matemática de conjuntos. Foi originalmente
desenvolvida por Jacob Theodore Schwartz no na NYU no fim dos anos 1960.
Lambert Meertens passou um ano com o grupo SETL na NYU antes de finalizar o projeto da ling. ABC.

Prof. Cláudio A. Fleury Página 2

FILOSOFIA
A filosofia central da linguagem Python inclui os seguintes preceitos:
7 Bonito é melhor que feio.
7 Explícito é melhor que implícito.
7 Simples é melhor que complexo.
7 Complexo é melhor que complicado.
7 Legibilidade importa.

CARACTERÍSTICAS
Em vez de ter todas as suas funcionalidades incorporadas em seu núcleo, o Python foi projetado para ser
facilmente extensível. Essa modularidade compacta tornou7a popular, pois se pode adicionar interfaces
programáveis a aplicativos existentes. A intenção de era projetar uma linguagem com um pequeno
núcleo, uma grande biblioteca padrão e um interpretador facilmente extensível... Isso foi resultado de suas
frustrações com a ling. ABC, que adotava uma abordagem oposta.

PRINCIPAIS CARACTERÍSTICAS DA LINGUAGEM PYTHON:

1. $! % & : Python é uma linguagem muito legível e cada instrução é traduzida
individualmente e executada antes da instrução seguinte.
2. '() % & : Aprender Python é fácil por ela ser uma linguagem expressiva e de alto nível.
3. # % &% * : está disponível para execução em vários sistemas operacionais, tais como:
Mac7OS, MS7Windows, Linux, Unix, Oracle Solaris etc.
4. & ) : Python é uma linguagem de programação de código aberto.
5. + ,% ) : a ling. Python vem com uma grande biblioteca padrão com códigos e
funções úteis que podem ser usados enquanto se escreve código em Python.
6. : a ling. Python é gratuita para e uso.
7. # & % -) : Uma exceção é um evento que pode ocorrer durante a execução do
programa e que interrompe o fluxo normal do programa. A ling. Python permite o tratamento de
exceções, o que significa que podemos escrever códigos menos propenso a erros e testar vários
cenários que possam provocar uma exceção mais tarde.
8. ) " " .! ": geradores e abrangência de lista ( ). Veremos esses
recursos mais tarde.
9. ) . ( ) # / : a memória é limpa e liberada automaticamente. Você
não precisa se preocupar em liberar memória em seus códigos.

PALAVRAS7CHAVE 7 PYTHON 2.7

Fonte: https://www.programiz.com/python7programming/keyword7list

Prof. Cláudio A. Fleury Página 3

 >>> from keyword import kwlist
>>> print kwlist # Vs. 2.7.9
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for',
'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass',
'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

INSTALANDO O INTERPRETADOR PYTHON

Você pode instalar o interpretador Python OFICIAL em “qualquer” Sistema Operacional..., tais como
0 1", # ) , -/ -2 % " e outros. Para fazer a instalação do Python em seu Sistema
Operacional, acesse www.python.org/downloads/. Você terá a tela mostrada na figura seguinte.

Prof. Cláudio A. Fleury Página 4

 19,3 MB

Este é o site oficial da linguagem Python. A página detectará o sistema operacional instalado no seu
computador, e recomendará a versão adequada a ser baixada. Como estou usando o Windows764 no
meu , foram dadas as opções de para 34 e 35 para Windows.
Neste curso usaremos a versão 2.7 da ling. Python, portanto recomendo que você baixe a versão mais
recente do 34 (à época da escrita desse texto era a versão 467689 7 ver figura anterior).
As etapas de instalação são bem simples. Você só precisa escolher o diretório para instalação e clicar
para avançar nas próximas etapas: botão [! " #].

Prof. Cláudio A. Fleury Página 5

Após a instalação inicie uma janela de execução de comandos de linha ( %) e carregue o
interpretador Python instalado:

Para abandonar o interpretador Python, use o atalho de teclado [Ctrl7Z]+[ ] ou a função exit()
(finalize a entrada com a tecla [ ]).

Prof. Cláudio A. Fleury Página 6

TÓPICOS BÁSICOS
1. Variáveis e Operações
2. Tipos de Dados e Conversões
3.
4. Intervalo
5. Lista
6. Tupla
7. Conjunto
8. Dicionário
9. Entrada de Dados
10. Controle de Fluxo de Execução
11. Função Definida pelo Usuário
12. Funções Incorporadas
13. Arquivos de E/S
14. Exceções

PACOTES
15. Numpy
16. Scipy
17. Matplotlib
18. Pandas

1. Variáveis e Operações:

Um sinal de igual ‘=’ é usado para atribuir (armazenar) um valor a uma variável, como ocorre na
grande maioria das linguagens de programação de computadores.

Sempre que pressionarmos qualquer tecla numérica, letra ou instrução no console do Python
seguida da tecla [ ], a resposta do interpretador Python será mostrada na linha seguinte. Mas,
se atribuirmos um valor a uma variável, à esquerda do sinal de igual ‘=’, e pressionarmos [ ],
nenhuma informação será exibida na linha seguinte. Em vez disso, a informação digitada do lado
direito do sinal de igual será armazenada na variável.

Uma variável é como uma pequena caixa na memória do computador, na qual se armazena
qualquer informação. Quando declaramos uma variável, o computador aloca determinada
memória para armazenar essa variável. O endereço de memória de cada variável é único.

& . , (criação de variável)

No interpretador Python 2.7.15 digite:

>>> x = 'Python + Machine Learning = Sucesso'
>>> print x
Python + Machine Learning = Sucesso
>>>
>>> ML = 2019
>>> print ML
2019

Prof. Cláudio A. Fleury Página 7

 >>> xl = ML + 10
>>> print xl
2019
>>>

No exemplo anterior: a 'Python + Machine Learning = Sucesso' é armazenada numa

variável chamada . Na próxima figura, a instrução apresenta o valor armazenado na
variável . Depois foi atribuído o valor 2019 à variável ML, e então mostrado na tela. Na linha
seguinte foi feito uma operação aritmética de soma ML + 10 e o resultado atribuído à variável .

& ". : ) ": soma (+), subtração (7), multiplicação (*), divisão (/), resto da divisão
inteira (%), divisão inteira (//), potenciação (**). A prioridade de execução segue os padrões
matemáticos. Usando parênteses pode7se definir que parte da operação será feita antes da
operação.

Oper. Uso Descrição

+ a + b Soma os operandos em ambos lados do operador.
- a - b Subtrai o operando do lado direito do operando do lado esquerdo.
* a * b Multiplica os operandos em ambos lados do operador.
Divide o operando do lado esquerdo pelo operando do lado direito do operador (Python
/ a / b
2.7: retorna valor inteiro se operandos são inteiros).
Retorna o resto da divisão inteira do operando do lado esquerdo pelo operando do lado
% a % b
direito do operador.
Retorna a potenciação do operador do lado esquerdo elevado ao operador do lado direito
** a ** b
do operador.
Retorna o quociente da divisão dos operandos, onde o resultado é do tipo inteiro. Mas se
// a // b um dos operandos for negativo, o resultado é flutuante, isto é, arredondado para longe de
zero (em direção ao infinito negativo).

>>> 12-4*9
-24
>>> (12-4)*9
72
>>> 12-(4*9)
-24

Atenção: divisão com valores inteiros apresenta resultado também inteiro. Para obter resultado
fracionário um dos operandos deve ser do tipo real ( ).
>>> 8/6
1
>>> 8./6
1.3333333333333333
>>> 12.5/3
4.166666666666667
>>> 12.5//3
4.0
>>> 13 % 5
3
>>> 2 ** 10
1024
>>>

Prof. Cláudio A. Fleury Página 8

 & " % ) "

Oper. Uso Descrição

== a == b Retorna True se os operandos são iguais, e retorna False caso contrário
!= Retorna True se os operandos são diferentes, e retorna False caso contrário
a != b
<>
Retorna True se o operando do lado esquerdo do operador for maior que o operando do
> a > b
lado direito, e retorna False caso contrário
Retorna True se o operando do lado esquerdo do operador for menor que o operando do
< a < b
lado direito, e retorna False caso contrário
Retorna True se o operando do lado esquerdo do operador for maior ou igual ao operando
>= a >= b
do lado direito, e retorna False caso contrário
Retorna True se o operando do lado esquerdo do operador for menor ou igual ao operando
<= a <= b
do lado direito, e retorna False caso contrário

& " / ) "

Oper. Uso Descrição

and a and b Retorna True se os operandos são True, e retorna False caso contrário
or a or b Retorna True se um ou outro operando é True, e retorna False caso contrário
not not a Complementa o valor do operando booleano 'a'

& ", , ; atua nos operandos no nível de bits.

Oper. Uso Descrição

& a & b Operação E: copia um bit para o resultado se ele existe em ambos operandos.
Operação OU: copia um bit para o resultado se ele existe pelo menos em um dos
| a | b
operandos.
Operação XOU: copia um bit para o resultado se ele estiver ligado (1) em um dos
^ a ^ b
operandos, mas não em ambos.
~ ~a Operação Complemento 1: comuta os bits do operando.
Operação Desloc. à Esq.: desloca para esquerda os bits do operando à esquerda do
<< a << b
operador da quantidade de bits indicada pelo operador à direita.
Operação Desloc. à Dir.: desloca para direita os bits do operando à esquerda do operador
>> a >> b
da quantidade de bits indicada pelo operador à direita.

& " < ) : indica a existência/pertinência de um elemento num iterável.

Oper. Uso Descrição

Retorna True se o operando à esquerda do operador estiver presente na sequência à direita
in x in y
do operador.
Retorna True se o operando à esquerda do operador não estiver presente na sequência à
not in x not in y
direita do operador

& " : indica a existência/pertinência de um elemento num iterável.

Oper. Uso Descrição

is x is <tipo> Retorna True se se ambos os operandos se referirem ao mesmo tipo de objeto..
x is not Retorna False se as variáveis de cada lado do operador apontarem para o mesmo tipo de
is not
<tipo> objeto e True de outra forma.

Prof. Cláudio A. Fleury Página 9

 2. Tipos de Dado e Conversões ( , moldagem)

Dados em Python podem ser um dos cinco tipos a seguir: Números, None, Sequências (listas,
tuplas), Conjuntos ou Mapeamentos.

Conversão de Tipo significa converter variáveis de um tipo de dado em outro. O Python possui
algumas funções internas para conversão de tipos. Até agora vimos exemplos de variáveis de
tipos de dados inteiros, reais (ponto flutuante) e de (cadeias de caracteres). Para converter
estes tipos, as funções são, respectivamente 7 int(), float(), str().

! " & ": A função => é usada para converter ou em inteiros.

Observe que se a não resultar num valor inteiro então uma mensagem de erro de valor será
mostrado ao se solicitar a conversão de tipo para inteiro.

! " & : Use a função " => sem qualquer restrição para gerar uma cadeia de
caracteres.

Exercício: Qual é a explicação para a seguinte mensagem de erro?

Quando escrevemos múltiplas variáveis na instrução , conversões de devem ser usadas.

! " & ": A função => é usada para converter de ou inteiros em valores
reais.

Prof. Cláudio A. Fleury Página 10

 3. String

As são usadas para armazenar informações de texto, tais como nome, endereço,
mensagens etc. O Python monitora todos os elementos da como uma sequência de
caracteres. Por exemplo, o Python entende que a "IFG" é uma sequência de letras numa
ordem específica. Isso significa que poderemos usar a indexação para capturar letras específicas
(como a primeira ou a última letra).

índices positivos 0 1 2 3 4 5

índices negativos 76 75 74 73 72 71

Para criar uma em Python você precisa usar aspas simples ou aspas duplas.
Por exemplo (usando comentário na primeira linha):
>>> # palavra única
... 'IFG'
'IFG'
>>> # uma frase
... 'Bem-vindos ao Curso de Extensão do IFG 2019-1'
'Bem-vindos ao Curso de Extensão do IFG 2019-1'
>>> # erro de sintaxe
... 'Valor de 'x' no programa?'
File "<stdin>", line 2
'Valor de 'x' no programa?'
^
SyntaxError: invalid syntax
>>>

A causa do erro na acima é a aspa simples delimitando duas e o caractere ‘x’

ficou sem delimitação entre elas. Solução: use combinações de aspas duplas e simples para
obter a declaração correta.
>>> # erro de sintaxe
... "Valor de 'x' no programa?"

•
Usar a sequência de caracteres ( ) no (>>>) do interpretador mostrará
automaticamente seu valor, mas a maneira correta de exibir as na sua saída é usar a
instrução de impressão: .

• $ % & ' (
Na versão 2 a impressão é realizada por uma instrução (sentença, comando) enquanto que na
versão 3 é uma função que faz a impressão: .

Prof. Cláudio A. Fleury Página 11

 Na versão 3 você imprime da seguinte forma: & =? %( # @?>. Se você quer usar esta
funcionalidade no Python72, você pode importar o formulário do módulo futuro.
Atenção: depois de importar isso, você não poderá mais escolher o método de declaração de
impressão. Então, escolha o que você preferir, dependendo da sua instalação do Python e
continue com ele.

Uma instrução é uma diretiva para o compilador de que um módulo específico deve ser
compilado usando sintaxe ou semântica que estará disponível em uma versão futura do
Python. A declaração destina7se a facilitar a migração para versões futuras do Python
que introduzem alterações incompatíveis à linguagem. Ela permite o uso dos novos recursos por
módulo antes do lançamento no qual o recurso se torna padrão.

É como dizer "Como esse é o Python v2.7, use essa função diferente que também foi
adicionada ao Python v2.7, depois que ela foi adicionada no Python 3. Então, meu 'print' não
será mais uma instrução ( por exemplo ) mas uma função (por exemplo,
. Dessa forma, quando meu código é executado em Python 3, não irá
quebrar o programa (dar pau!).

Também podemos usar uma função chamada % => para verificar o tamanho de uma string.

• " %&

Sabemos que são sequências de caracteres, o que significa que o Python pode usar
índices para acessar partes da sequência.

Em Python, usamos colchetes [ ] depois de um objeto para trazer o conteúdo do índice.

Também devemos notar que, para o Python, a indexação começa em 0 (zero), ou seja, o

Prof. Cláudio A. Fleury Página 12

 primeiro caractere de uma é referenciado pelo índice 0. Vamos criar um novo objeto
chamado ‘s’ e realizar alguns exemplos de indexação.

Acessando um caractere da sequência de caracteres...

Acessando partes da sequência de caracteres usando fatiamento ( )

Observe o primeiro fatiamento acima: "AB;5C. Aqui estamos dizendo ao Python para acessar
os caracteres de ", do índice 0 até 3, não incluindo o índice 3 (quarta posição). Você notará
esse comportamento muitas vezes em Python, onde as declarações geralmente estão no
contexto "até, mas não incluindo".

Também podemos usar a notação de índice e fatia para capturar elementos de uma
sequência com um determinado incremento (o padrão é passo unitário). Por exemplo, podemos
usar dois dois7pontos em uma linha e, em seguida, um número especificando a frequência para
acessar os elementos. Por exemplo:

Acessando em ordem inversa:

Prof. Cláudio A. Fleury Página 13

 •

É importante notar que as têm uma propriedade conhecida como ,% . Isso

significa que, uma vez que uma é criada, os elementos dentro dela não podem ser
alterados ou substituídos. Por exemplo:

Observe como o erro nos diz diretamente o que não podemos fazer: não admite atribuição do
item!
Algo que podemos fazer é concatenar !

Podemos usar o símbolo de multiplicação para criar repetição de caracteres!

Ajuntando (concatenando) Strings:

>>> livre = ['Terça', 'Quinta', 'Sábado']

>>> todos = ' - '.join(livre)
>>> print todos
Terça - Quinta - Sábado
>>>

• ) ! *

Objetos em Python geralmente possuem métodos internos. Esses métodos são funções
associadas ao objeto (aprenderemos sobre isso com muito mais profundidade posteriormente)
que podem executar ações ou comandos no próprio objeto.
Nós acessamos os métodos de um objeto usando um ponto ‘.’ e depois o nome do método:
,D 6 : =& E ">, onde os parâmetros são argumentos extras que podemos passar
ao método. Não se preocupe com os detalhes se não fizeram sentido agora. Mais tarde

Prof. Cláudio A. Fleury Página 14

 criaremos nossos próprios objetos e métodos! Aqui estão exemplos de métodos internos dos
objetos :

Existem muitos mais métodos para objetos do que os abordados aqui.

• %& &

Python tem formatadores de impressionantes. Vamos mostrar os casos de uso mais

comuns cobertos pelas API’s de estilo de formatação de + antiga e nova.

À moda antiga: À moda nova:

nome = "Matheus"
prof = "Programador"

titulo = "%s, o %s" % (nome, prof) titulo = "{}, o {}".format(nome, prof)

print titulo
'Matheus, o Programador'

' ,(" ) : A formatação posicional simples é provavelmente o caso de uso mais

comum. Seu uso é mais indicado quando a ordem dos argumentos não precisa ser alterada e
você tiver poucos elementos que queira concatenar.

Como os elementos não são representados por algo tão descritivo quanto um nome, esse estilo
simples deve ser usado apenas para formatar uma quantidade relativamente pequena de
elementos.

À moda antiga: À moda nova:

print '%s, %s.' % ('Fleury', 'Cláudio') print '{}, {}.'.format('Fleury', 'Cláudio')
Fleury, Cláudio.
print '%s, %.1s.' % ('Fleury', 'Cláudio') print'{}, {:.1}.'.format('Fleury', 'Cláudio')
Fleury, C.

Com a nova formatação de estilo, é possível (e obrigatório no Python 2.6) dar aos espaços
reservados um índice posicional explícito. Isso permite reorganizar a ordem de exibição sem
alterar os argumentos. Esta operação não está disponível na formatação antiga.

>>> # à moda nova

... print {1}, {0}.'.format('Cláudio', 'Fleury')
Fleury, Cláudio.
>>>

Prof. Cláudio A. Fleury Página 15

 Formatação de números inteiros (%d) e reais (%f):

>>> # à moda antiga

... print '%d %f' % (54, 2.334343)
54 2.334343
>>> print '%4d %6.3f' % (54, 2.3349)
54 2.335
>>> # à moda nova
... print '{1:f} {0:d}'.format(54, 2.334343)
2.334343 54
>>> print '{:6.2f}'.format(2.334343)
2.33
>>>

Código comumente encontrado nas outras linguagens:

>>> usuario = 'Maria'
>>> if usuario == 'Maria':
... print '------------------------------'
... print usuario
... print '------------------------------'
...
------------------------------
Maria
------------------------------
>>>

Código pythônico:

>>> usuario = 'Maria'

>>> if usuario == 'Maria':
... print '{0}\n{1}\n{0}'.format('-'*30, usuario)
...
------------------------------
Maria
------------------------------
>>>

4. Intervalo
O tipo (intervalo de valores> representa uma sequência imutável de números e é comumente
usado para repetir um determinado número de vezes em laços de repetição .

Os intervalos podem ser construídos de duas formas:

• (final)
• (início, final[, passo])

Os argumentos para o construtor de devem ser inteiros (seja o nativo ou qualquer outro
objeto que implemente o método especial ). Se o argumento passo for omitido, o
padrão será 1 (um). Se o argumento início for omitido, o padrão será 0 (zeros). Se o passo for
zero, um erro será gerado.

Prof. Cláudio A. Fleury Página 16

 Para passo positivo, o conteúdo de um intervalo é determinado pela fórmula:
í ∗ , onde 0 e

Para passo negativo, o conteúdo de um intervalo é determinado pela fórmula:

í ∗ , onde 0 e

Um objeto estará vazio se 0 não atender à restrição de valor. Os intervalos suportam

índices negativos, mas estes são interpretados como indexação a partir do final da sequência
determinada pelos índices positivos.

Comparação de objetos do tipo para igualdade (==) ou diferença (!=) são realizados
como na comparação de sequências. Ou seja, dois objetos de intervalo são considerados iguais se
eles representam a mesma sequência de valores. Observe que dois objetos de intervalo que se
comparam como iguais podem ter diferentes atributos de início, final e passo, por exemplo:
range(0) == range(2,1,3) ou range(0,3,2) == range(0,4,2).

5. Lista:

As listas " ) % F " ,D " < ", os quais podem ser de qualquer tipo, inclusive
outras listas. As listas podem ser homogêneas (dados de um mesmo tipo) ou heterogêneas, o que
as tornam ferramentas muito poderosas no Python. Uma única lista pode conter dados de qualquer
tipo, tais como: números inteiros, números reais (ponto flutuante), , ou qualquer outro objeto.
As listas também são muito úteis na implementação de pilhas e filas. As listas são mutáveis e,
portanto, podem ser alteradas mesmo após sua criação.

No Python, é um & )& ( ) de estrutura de dados que é usado para

armazenar vários dados ao mesmo tempo. Ao contrário dos conjuntos ( ), a lista é ordenada e
tem uma contagem definida. Os elementos em uma lista são indexados de acordo com uma
sequência definida e a indexação de uma lista é feita com o índice 0 (zero) para o primeiro valor
armazenado. Cada elemento da lista tem seu lugar definido na lista, o que permite a existência
de elementos duplicados na lista, com cada elemento tendo seu próprio lugar na memória.

Prof. Cláudio A. Fleury Página 17

 A lista é uma ferramenta útil para preservar uma sequência de dados e para "iterar" sobre ela
(acesso a cada um de seus elementos).
>>> # exemplo de uma lista em Python
... placas = ['RPi', 'BeagleBone', 'Arduino']
>>> # mostrando o primeiro e terceiro elementos da lista
... print placas[0], placas[2]
Rpi Arduino
>>> print placas
['RPi', 'BeagleBone', 'Arduino']
>>>

• , - .
>>> lista_vazia = []
>>> print lista_vazia
[]
>>>

• , / 0 1
>>> mix = [3.141592653589, -5, 'Tudo certo?', True, '*']
>>> print mix
[3.141592653589, -5, 'Tudo certo?', True, '*']
>>>

• , '$
>>> lista2D = [['12',3, True],
[0.1, 'ok',22],
[-5, 'Tudo certo?', True]]
>>> print lista2D
[['12',3, True],[0.1, 'ok',22],[-5, 'Tudo certo?', True]]
>>> print lista2D[0][1]
3
>>> for linha in lista2D:
... for elem in linha:
... print elem,
... print
...
12 3 True
0.1 ok 22
-5 Tudo certo? True
>>>

• ,
>>> num = range(1,10)
>>> print num
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print num[0:3] # acessa do 1o. ao 3o. elementos
[1, 2, 3]
>>> print num[2:-2] # acessa do 3o. ao penúltimo elementos
[3, 4, 5, 6, 7]
>>>

• !2 , / 1

Prof. Cláudio A. Fleury Página 18

 >>> pesos = [56, 73, 92, 32, 45]
>>> soma = 0
>>> for peso in pesos:
... soma += peso
...
>>> print 'Soma dos Pesos: ', soma
Soma dos Pesos: 298

E se a lista contiver elementos não numéricos?

>>> pesos = [56, 73, 92, 'ok', 32, 45, True, "vida"]
>>> soma = 0
>>> for peso in pesos:
... soma += peso
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
TypeError: unsupported operand type(s) for +=: 'int' and 'str'
>>>

O interpretador Python indica erro para a tentativa de somar elemento do tipo ‘str’ com ‘int’.
Prevenindo7se do referido erro:
>>> pesos = [56, 73, 92, 'ok', 32, 45, True, "vida"]
>>> soma = 0
>>> for peso in pesos:
... if type(peso) == int: # verificação do conteúdo do elemento
... soma += peso
...
>>> print 'Soma dos Pesos: ', soma
Soma dos Pesos: 298

• %& , % %& / 1
>>> cores = ["azul","amarelo","vermelho","verde","roxo"]
>>> for cor in cores:
... print cor
... if cor == "amarelo":
... print "Amarelo é a minha cor favorita!"
...
azul
amarelo
Amarelo é minha cor favorita!
vermelho
verde
roxo
>>>

Exercícios:
1. Criar uma lista com os números inteiros positivos múltiplos de 7, de 7 a 70. Mostrar os
elementos da lista separados, um por linha.
2. Idem, porém mostrar apenas os elementos cuja soma de dígitos seja ímpar.
3. Idem, porém para múltiplos até 700, mostrados em sequência.
4. Idem, porém para múltiplos até N (entrada do usuário).

• %& ,
>>> pesos = [56, 73, 92, 'ok', 32, 45, True, "vida"]

Prof. Cláudio A. Fleury Página 19

 >>> pesos[0] = 100
>>> print pesos
[100, 73, 92, 'ok', 32, 45, True, "vida"]
>>>

• " ,
>>> pesos = [56, 73, 92, 'ok', 32, 45, True, "vida"]
>>> pesos.insert(2,"alegria")
>>> print pesos
[56, 73, 'alegria', 92, 'ok', 32, 45, True, "vida"]
>>> pesos.remove(45)
>>> pesos
[56, 73, 'alegria', 92, 'ok', 32, True, "vida"]
>>> del pesos[1]
>>> pesos
[56, 'alegria', 92, 'ok', 32, True, "vida"]
>>> ultimo = pesos.pop() # retorna último elemento, retirando-o da lista
>>> print pesos, '\n', ultimo
[56, 'alegria', 92, 'ok', 32, True]
"vida"
>>>

• $* & String , ("&% => é um método da classe String)

>>> sedans = 'focus/jetta/408/cruze/civic/corolla/mercedes c180/sentra/cerato'
>>> lista_carros = sedans.split("/") # sedans é uma variável string
>>> print lista_carros
['focus', 'jetta', '408', 'cruze', 'civic', 'corolla', 'mercedes c180', 'sentra',
'cerato']

• , (D => é um método da classe String)

>>> ' '.join(lista_carros)
'focus jetta 408 cruze civic corolla mercedes c180 sentra cerato'
>>> ', '.join(lista_carros)
'focus, jetta, 408, cruze, civic, corolla, mercedes c180, sentra, cerato'
>>> ' | '.join(lista_carros)
'focus | jetta | 408 | cruze | civic | corolla | mercedes c180 | sentra | cerato'
>>>

• 3 , /4 1 (% => é uma função incorporada)

>>> len(lista_carros)
9
>>>

• , 5 *

>>> lista_carros
['focus’, ‘jetta’, ‘408’, ‘cruze’, ‘civic’, ‘corolla’, ‘mercedes c180’, ‘sentra’,
‘cerato']
>>> lista_carros.reverse()
>>> lista_carros
['cerato', 'sentra', 'mercedes c180', 'corolla', 'civic', 'cruze', '408', 'jetta',
'focus']

Prof. Cláudio A. Fleury Página 20

 >>>

• , Sintaxe: A expressão * item lista C

Além das operações de sequência e os métodos da classe , o Python inclui uma operação mais
avançada chamada de abrangência de lista ( ). Trata7se de uma maneira rápida
de filtrar uma lista com base em um ou mais critérios estabelecidos pelo usuário.

, é uma construção oriunda da programação funcional, e equivale à seguinte

descrição matemática:
, ∀ ∈ ℕ, 0 ≤ ≤5
2

Leia7se: é o conjunto formado por todos os números do conjunto dos números naturais divididos
por 2, desde que o número seja maior ou igual a zero e menor ou igual a 5.
>>> r = [x/2 for x in range(6)]
>>> r
[0, 0, 1, 1, 2, 2]
>>>

, permite criar listas usando notação mais compacta do que seria possível usando
laços de repetição com o comando . Tenha cuidado, no entanto, pois nem
sempre é resposta para tudo. É fácil se deixar levar e escrever complexas e
difíceis de ler. Às vezes, escrever mais código é melhor, especialmente se isso ajudar na
legibilidade. Lembre7se: simples é melhor que complexo, e legibilidade importa!
>>> range(11)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> faixa = range(-10,11)
>>> faixa
[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> R = [x/2 for x in faixa if x >= 0 and x <= 5]
>>> R
[0, 0, 1, 1, 2, 2]
>>> R = [x/2. for x in faixa if x >= 0 and x <= 5]
>>> R
[0.0, 0.5, 1.0, 1.5, 2.0, 2.5]

Exemplo:
>>> letras = ['a', 'b', 'c', 'd']
>>> print letras
['a', 'b', 'c', 'd']
>>> letras_maiusc = []
>>> for letra in letras:
... letras_maiusc.append(letra.upper())
...
>>> print letras_maiusc
['A', 'B', 'C', 'D']
>>>

Prof. Cláudio A. Fleury Página 21

 Usando :

>>> letras = ['a', 'b', 'c', 'd']

>>> letras_maiusc = [letra.upper() for letra in letras]
>>> print letras_maiusc
['A', 'B', 'C', 'D']
>>>

Filtrando alguns valores, por exemplo: não incluir as letras maiúsculas 'A' e 'E'.
>>> letras = ['a', 'b', 'c', 'd']
>>> letras_maiusc = [x.upper() for x in letras if x not in ['a','e']]
>>> print letras_maiusc
['B', 'C', 'D']
>>>

Gerar uma lista de sedans com nome do modelo em maiúsculas e começando com 'c':

>>> [x.upper() for x in lista_carros if x[0]=='c']

['CRUZE', 'CIVIC', 'COROLLA', 'CERATO']

Idem, porém somente com a primeira letra do nome do modelo em maiúscula:

>>> [x[0].upper() + x[1:] for x in lista_carros if x[0]=='c']

['Cruze', 'Civic', 'Corolla', 'Cerato']

Agora usando o método capitalize() da classe String para colocar em maiúscula a primeira letra:
>>> [x.capitalize() for x in lista_carros if x[0]=='c']
['Cruze', 'Civic', 'Corolla', 'Cerato']
>>>

Métodos (funções) da classe :

append() acrescenta um único elemento ao final da lista
clear() elimina todos os elementos da lista
copy() retorna uma cópia superficial/rasa ( ) de uma lista
count() retorna a quantidade de ocorrências do elemento na lista
extend() acrescenta elementos de uma lista a outra lista
index() retorna o menor índice do elemento na lista
insert() insere elementos à lista
pop() remove o elemento da posição dada ou o último se não indicado a posição
remove() remove um elemento da lista
reverse() reverte a ordem dos elementos da lista
sort() classifica (ordena) os elementos de uma lista

Outras * F " ) & " e compatíveis com listas:

any() verifica se algum elemento de um iterável é

all() retorna quando todos os elementos de um iterável é
ascii() retorna uma contendo representação imprimível

Prof. Cláudio A. Fleury Página 22

 bool() converte um valor para + %
enumerate() retorna um do tipo
filter() constrói um a partir dos elementos que são
iter() retorna um para um objeto
list() cria uma lista
len() retorna o comprimento de um
max() retorna o maior elemento de um ,D )
min() retorna o menor elemento de um ,D )
map() aplica uma função a um iterável e retorna uma lista
reversed() retorna um de uma sequência revertida
slice() cria um objeto especificado por ()
sorted() retorna uma lista classificada a partir de um dado
sum() soma os itens de um
zip() retorna um de tuplas

Exemplo: Encontrar números comuns a duas listas, usando laço .

>>> lista_a = [0, 1, 2, 3, 4] # lista A

>>> lista_b = [2, 3, 4, 5] # lista B
>>> lista_c = [] # números em comum
>>> for elem_a in lista_a:
... for elem_b in lista_b:
... if elem_a == elem_b:
... lista_c.append(elem_a)
...
>>> print lista_c
[2, 3, 4]
>>>

Agora usando (abrangência de lista):

>>> lista_a = [0, 1, 2, 3, 4] # lista A

>>> lista_b = [2, 3, 4, 5] # lista B
>>> lista_d = [a for a in lista_a for b in lista_b if a == b]
>>> print lista_d
[2, 3, 4]
>>>

Operador :

Se você quiser apenas verificar se existe um valor dentro de um ,D (! % (lista, tupla ou

dicionário), a maneira mais rápida é fazer é usando o operador in:

Código não pythônico:

>>> cidade = 'Paris'
>>> achou = False
>>> if cidade == 'Nairobi' or cidade == 'Kampala' or cidade == 'Paris':
... achou = True
...

Prof. Cláudio A. Fleury Página 23

 >>> print achou
True
>>>

Código pythônico:
>>> cidade = 'Paris'
>>> achou = cidade in ['Nairobi', 'Kampala', 'Paris']
>>> print achou
True
>>>

Outro exemplo:

>>> dias_livres = ["Segunda", "Sexta"]

>>> desejado = "Sábado"
>>> if desejado in dias_livres:
... print("Eu estou disponível no(a)", desejado,"!")
... else:
... print("Desculpe, mas tenho compromisso no(a)", desejado,"!")
...
Desculpe, mas tenho compromisso no Sábado!
>>>

Exercício: Retornar os números não comuns das listas: lista_a = [0, 1, 2, 3, 4] e

lista_b = [2, 3, 4, 5], usando e depois .

6. Tupla:

Uma tupla é uma sequência imutável de objetos Python. Tuplas são sequências, assim como as
listas. As diferenças entre tuplas e listas são: as tuplas não podem ser alteradas diferentemente
das listas, e as tuplas usam parênteses como delimitadores enquanto as listas usam colchetes. Criar
uma tupla é tão simples quanto colocar diferentes valores separados por vírgulas e delimitados
por parênteses.

A construção de uma tupla usa ( ) com elementos separados por vírgulas. Por exemplo:

Assim como para as listas, a quantidade de elementos pode ser obtida com a função % =>:

Com objetos de tipos diversos:

Prof. Cláudio A. Fleury Página 24

 Todas as operações de acesso a elementos, usadas para listas também valem para tuplas:

• ) 67 3

Tuplas têm métodos embutidos, mas não tantos quanto aos métodos disponíveis para listas.

Só relembrando, as tuplas são imutáveis, não se pode modificar uma tupla depois que ela já
estiver definida...

• 8

Você pode estar se perguntando: "Por que se preocupar em usar tuplas quando elas têm menos
métodos disponíveis?" Para ser honesto, as tuplas não são usadas tão frequentemente quanto as
listas, mas são usadas quando a imutabilidade é necessária. Se no seu programa você está
passando um objeto e precisa ter certeza de que ele não será alterado, então a tupla será a
solução. Ela fornece uma forma conveniente de se obter integridade de dados.

7. Conjunto:

A estrutura ) D ( , em inglês) pode ser usada na execução de operações de conjuntos

matemáticos, tais como: união, interseção, diferença simétrica etc.

Prof. Cláudio A. Fleury Página 25

 Um ) D é uma ) % % " G ) " e que podem ser alterados,
acrescentados ou excluídos.

• 9

Podemos usar a função ou um par de chaves H I para criar um conjunto vazio, ou podemos
ainda criá7los com elementos a partir de outras estruturas iteráveis (lista, tupla, dicionário etc).

Exemplo: Criação e inserção de elementos num conjunto.

>>> A = set() # conjunto vazio, ou: A = { }

>>> A
set([])

• /1 9 :
>>> A.add('ok')
>>> A
set(['ok'])
>>>
>>> A.add(1)
>>> A.add(1)
>>> A
set([1, 'ok'])
>>>
>>> A.add(-8)
>>> A
set([-8, 1, 'ok'])
>>> A.add(5)
>>> A # coleção não ordenada
set([-8, 1, 'ok', 5])

Observe que os elementos não guardam qualquer ordem no conjunto e que elementos já existentes
não são repetidos ao serem adicionados mais de uma vez ao conjunto.

Exemplo: Supressão de elementos repetidos de uma lista ou tupla:

>>> lista = [22,22,23,25,25,25,26,26,27,28,28]

>>> print set(lista)
set([22, 23, 25, 26, 27, 28])
>>>
>>> tupla = tuple(lista)
>>> tupla
(22, 22, 23, 25, 25, 25, 26, 26, 27, 28, 28)
>>>
>>> B = set(tupla)
>>> print B
set([22, 23, 25, 26, 27, 28])

• * /1 9

Prof. Cláudio A. Fleury Página 26

 Um item específico pode ser removido do conjunto usando os métodos: ") => e ! =>. A
diferença entre esses métodos é que, ao usar o ") = > se o não existir no conjunto,
então ação ocorre, enquanto o método ! = > gerará um erro nessa situação.
>>> B.discard(23)
>>> B
set([22, 25, 26, 27, 28])
>>> B.discard(23)
>>> B.remove(23)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 23
>>>
• ; & 9

A união dos conjuntos . e + é um conjunto de todos os elementos de ambos os conjuntos. União é

realizada usando operador ‘|’ ou o método .

>>> A = {3,4,5}
>>> A
set([3, 4, 5])
>>> B = {4,5,6}
>>> print A | B # união dos conjuntos A e B
set([3, 4, 5, 6])
>>>
>>> print A.union(B) # união dos conjuntos A e B
set([3, 4, 5, 6])
>>>

• %& 9

A interseção entre . e + é um conjunto de elementos comuns a ambos os conjuntos. A interseção é

realizada usando o operador '&' ou o método .
>>> B.intersection(A)
set([4, 5])
>>> print B & A
set([4, 5])

• $ % 9

A diferença entre os conjuntos . e + é representada por . J +, e é um conjunto formado pelos

elementos que estão apenas em ., mas não em +. Da mesma forma, + J . é um conjunto formado
pelos elementos que estão em + e que não estão em .. A diferença é realizada em Python pelo
operador ‘7‘ ou pelo método .
>>> A – B # ou: A.difference(B)
set([3])
>>> print B - A # ou: B.difference(A)
set([6])
>>>
>>> homens = {"Pedro", "Matheus"}
>>> mulheres = {"Ana", "Camila"}

Prof. Cláudio A. Fleury Página 27

 >>> familia = homens | mulheres
>>> familia
set(['Matheus', 'Pedro', 'Camila', 'Ana'])
>>> empregado = {"Pedro"}
>>>
>>> desempregado = familia - empregado
>>> desempregado
set(['Matheus', 'Camila', 'Ana'])
>>> empregado - familia
set([])
>>>

• $ % ) 9

Diferença simétrica entre os conjuntos . e + é um conjunto de elementos em . e +, exceto aqueles

que são comuns a ambos. A diferença simétrica é realizada usando o operador ‘^’ou usando o
método " )K ** ) =>.

>>> A.symmetric_difference(B)
set([3, 6])
>>> print A ^ B, B ^ A
set([3, 6]) set([3, 6])
>>>
>>> familia ^ empregado
set(['Matheus', 'Camila', 'Ana'])
>>> familia - empregado
set(['Matheus', 'Camila', 'Ana'])
>>>

Exercício: Mostre os números incomuns das listas lista_a = [0, 1, 2, 3, 4] e

lista_b = [2, 3, 4, 5] usando .

• 9 :

Diferentemente das estruturas Lista e Tupla, os elementos do Conjunto não podem ser acessados
via indexação:
>>> B
set([4, 5, 6])
>>> B[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing
>>> for elem in B:
... print elem,
...
4, 5, 6
>>>

Funções incorporadas para conjuntos: all(), any(), enumerate(), len(), max(), min(), sorted() e sum().

• 9 7* :

Prof. Cláudio A. Fleury Página 28

 É uma estrutura que possui características de um conjunto, mas seus elementos não podem ser
alterados/acrescidos/removidos depois de atribuídos. Enquanto as tuplas são listas imutáveis, os
* L " " são conjuntos imutáveis.

Conjuntos não podem ser usados como chaves de dicionário, por serem mutáveis. Por outro lado, os
* L " " podem ser usados como chaves de um dicionário. Podem ser criados usando a função
* L " =>.
>>> A = frozenset([1, 2, 3, 4])
>>> B = frozenset([3, 4, 5, 6])
>>> A, B
(frozenset([1, 2, 3, 4]), frozenset([3, 4, 5, 6]))
>>> A ^ B, A | B
frozenset([1, 2, 5, 6]), frozenset([1, 2, 3, 4, 5, 6])
>>> A.add(5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
>>>

Exercício: Mostre a quantidade de vogais existente numa string, usando conjunto(s).

8. Dicionário:

São estruturas de dados que implementam mapeamentos. Um mapeamento é uma coleção de

associações entre pares de valores. De certa forma, um mapeamento é uma generalização do
acesso de dados por índices usados em vetores e matrizes, exceto que num mapeamento os índices
(ou chaves) podem ser de qualquer tipo de dado imutável, inclusive .

O dicionário é uma coleção não ordenada de itens. Enquanto outros tipos de dados compostos
(arranjos) têm apenas um valor para cada índice, um dicionário tem um par ) ! ;! % . Os
dicionários são otimizados para recuperar valores quando a ) ! for conhecida.

Se você estiver familiarizado com outras linguagens, pode pensar em dicionários como tabelas de
espalhamento ( ).

• Criando um Dicionário

Um dicionário em Python consiste de uma chave e um valor associado. Esse valor pode ser
praticamente qualquer objeto do Python.

Criar um dicionário é tão simples quanto colocar itens separados por vírgula entre chaves { }.
Um item tem uma ) ! e um ! % correspondente, e é expresso como um par ) ! ; ! % .
Embora os valores possam ser de qualquer tipo de dado e possam se repetir, as chaves devem ser
do tipo imutável ( , número ou tupla) e devem ser exclusivas.

>>> # criando um dicionário vazio

... dici = { }
>>> # dicionário com chaves do tipo numérico 'inteiro'

Prof. Cláudio A. Fleury Página 29

 ... z = { 1 : 'manga', 2 : 'bola', 3 : 1220 }
>>> z[1]
'manga'
>>> z[1] = 'banana'
'banana'
>>> z
{ 1 : 'banana', 2 : 'bola', 3 : 1220 }
>>> z[3]
1220

>>> # criando dicionário com chaves mistas (vários tipos de dados)

... y = { 'nome': 'Maria', 'notas': [6,7,4], 5: 'ok' }
>>> y[5]
'ok'
>>> y['nome']
'Maria'
>>> y['notas']
[6, 7, 4]
>>> y['notas'][0]
[6]

Também podemos criar um dicionário usando a * ) & que requer como

parâmetro uma lista de tuplas, cada uma com um par ) ! ;! % , ou uma sequência de itens no
formato ) ! M! % .
>>> # criando dicionário com a função dict()
... w = dict([('nome','Maria'), ('notas',[6,7,4]), (5,'ok')])
>>> w
{5: 'ok', 'notas': [6, 7, 4], 'nome': 'Maria'}
>>>
>>> a = dict(x=1,y=2)
>>> a
{'y': 2, 'x': 1}
>>> a['x']
1
>>>

Nós também podemos criar chaves via operador de atribuição. Por exemplo, se começássemos
com um dicionário vazio, poderíamos adicionar elementos continuamente:
>>> d = { } # dicionário vazio
>>> d['animal'] = 'gato' # acrescenta o elemento 'animal':'gato'
>>> d['idade'] = 6 # acrescenta o elemento 'idade':6
>>> d
{'idade': 6, 'animal': 'gato'}
>>>

• $ 7

Dicionário são estruturas mutáveis. Podemos adicionar novos itens ou alterar o valor dos itens
existentes usando o operador de atribuição. Se a chave já estiver presente, o valor será
atualizado, caso contrário, um novo par ) ! ;! % será adicionado ao dicionário.

Prof. Cláudio A. Fleury Página 30

 >>> d
{'idade': 6, 'animal': 'gato'}
>>> d['idade'] = 5
>>> d['cor'] = 'branco'
>>> d['nome'] = 'Teo'
>>> d
{'idade': 5, 'cor': 'branco', 'animal': 'gato', 'nome': 'Teo'}
>>>

• " $ 7

Podemos remover um item específico em um dicionário usando o método . Este método

remove o item com a chave fornecida e retorna o valor.

O método pode ser usado para remover e retornar um item arbitrário (chave, valor) do
dicionário. Todos os itens podem ser removidos de uma vez usando o método . Também
podemos usar a função incorporada => para remover itens individuais ou o dicionário inteiro.
>>> y
{5: 'ok', 'notas': [6, 7, 4], 'nome': 'Maria'}
>>> y.pop(5)
'ok'
>>> y
{'notas': [6, 7, 4], 'nome': 'Maria'}
>>> del y['notas']
>>> y
{'nome': 'Maria'}
>>>

>>> d
{'idade': 5, 'cor': 'branco', 'animal': 'gato', 'nome': 'Teo'}
>>> del d
>>> d
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'd' is not defined
>>>

Outros tantos métodos estão disponíveis para uso com dicionários: clear(), copy(),
fromkeys(seq[, v]), get(key[,d]), items(), keys(), pop(key[,d]), popitem(),update([other]), values().
>>> notas = {}.fromkeys(['matematica','espanhol','portugues'],0)
>>> notas
{'portugues': 0, 'espanhol': 0, 'matematica': 0}
>>> for disciplina in notas.items():
... print disciplina
...
('portugues', 0)
('espanhol', 0)
('matematica', 0)
>>> list(sorted(notas.keys()))
['espanhol', 'matematica', 'portugues']
>>>

Prof. Cláudio A. Fleury Página 31

 • $ 7

O Python é poderoso com sua flexibilidade de aninhar objetos e na chamada de métodos. Vamos
ver um dicionário aninhado dentro de outro dicionário:
>>> d = {'chave1':{'ch_aninh':{'ch_sub_aninh':1000}}}
>>> d
{'chave1': {'ch_aninh': {'ch_sub_aninh': 1000}}}
>>>
>>> d['chave1']['ch_aninh']['ch_sub_aninh']
1000
>>>

>>> pessoas = {1: {'nome':'Maria', 'idade':25, 'sexo':'Fem.',

'cor':'branca'}, 2: {'nome':'Luiz', 'idade':35, 'sexo':'Masc.'} }
>>>
>>> print pessoas
{1: {'idade': 25, 'sexo': 'Fem.', 'cor': 'branca', 'nome': 'Maria'}, 2:
{'idade': 35, 'sexo': 'Masc.', 'nome': 'Luiz'}}
>>>
>>> print pessoas[1]['nome'] + ', ', pessoas[2]['nome']
Maria, Luiz
>>>
>>> pessoas[3] = {'nome':'Ana','idade':19,'sexo':'Fem.','casada':False}
>>> print pessoas
{1: {'idade': 25, 'sexo': 'Fem.', 'cor': 'branca', 'nome': 'Maria'}, 2:
{'idade': 35, 'sexo': 'Masc.', 'nome': 'Luiz'}, 3: {'idade': 19,
'sexo': 'Fem.', 'casada': False, 'nome': 'Ana'}}
>>>
>>> for id, info in pessoas.items():
... print u"\nIdentificação:", id
... for caracteristica in info:
... print caracteristica, ': ', info[caracteristica]
...

Identificação: 1
idade : 25
sexo : Fem.
nome : Maria
Identificação: 2
idade : 35
sexo : Masc.
nome : Luiz
Identificação: 3
idade : 19
sexo : Fem.
casada : False
nome : Ana

• 0 $ 7

A abrangência do dicionário é uma maneira elegante e concisa de criar um novo dicionário a

partir de um objeto iterável em Python. A abrangência do dicionário consiste num par ) ! ;! %

Prof. Cláudio A. Fleury Página 32

 seguido por uma instrução dentro de chaves { }. Aqui está um exemplo para fazer um dicionário
em que cada item é um par formado por um número e seu cubo.
>>> cubos = {x : x**3 for x in range(6)}
>>> print cubos
{0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125}

Código equivalente usando a sentença :

>>> cubos = {}
>>> for x in range(6):
... cubos[x] = x*x*x
...
>>> print cubos

Uma abrangência de dicionário pode, opcionalmente, conter mais instruções ou . Uma

instrução pode filtrar itens para formar o novo dicionário. Veja um exemplo para criar um
dicionário com apenas itens ímpares.
>>> quadrados_impares = {x: x*x for x in range(11) if x%2 == 1}
>>> print quadrados_impares
{1: 1, 3: 9, 9: 81, 5: 25, 7: 49} >>> for x in range(11):
>>> ... if x%2:
... quadrado_impares[x]
• 3 %& $ 7

Podemos testar se uma chave está num dicionário ou não usando a palavra7chave . Observe que
o teste de associação é válido somente para chaves, não para valores.
>>> print quadrados_impares
{1: 1, 3: 9, 9: 81, 5: 25, 7: 49}
>>>
>>> print 1 in quadrados_impares
True
>>> print 2 in quadrados_impares
False
>>> print 25 in quadrados_impares
False
>>>

• $ 7

Usando um laço , podemos iterar por cada chave do dicionário.

>>> print quadrados_impares
{1: 1, 3: 9, 9: 81, 5: 25, 7: 49}
>>>
>>> for i in quadrados_impares:
... print i,":",quadrados_impares[i],
...
1 : 1 3 : 9 9 : 81 5 : 25 7 : 49
>>>

• %< ) $ 7

Funções incorporadas, tais como, %%(), (), % (), ) &(), " () etc, são comumente usadas com
o dicionário para realizar diferentes tarefas.

Prof. Cláudio A. Fleury Página 33

 Função Descrição
%%=> Retorna se todas as chaves do dicionário são verdadeiras (ou se o
dicionário está vazio)
=> Retorna se qualquer chave do dicionário é verdadeira. Se o dicionário
está vazio, retorna
% => Retorna o comprimento (a quantidade de itens) do dicionário
) &=> Compara os itens de dois dicionários
" => Retorna uma nova lista ordenada de chaves/valores do dicionário

Método Descrição
) & => Retorna uma cópia profunda do dicionário, um novo objeto é criado na
memória contendo todos os pares do dicionário fonte da cópia
* N "=> Retorna um novo dicionário cujas chaves são os elementos de lista (prim.
Parâmetro) e cujos valores são todos iguais a valor (seg. parâmetro)
& => Atualiza um dicionário com os elementos de outro. Os itens do outro dic são
adicionados um a um ao dicionário original

Exemplos:

>>> print quadrados_impares

{1: 1, 3: 9, 9: 81, 5: 25, 7: 49}
>>> print len(quadrados_impares)
5
>>> print sorted(quadrados_impares) # somente as chaves
[1, 3, 5, 7, 9]
>>> print sorted(quadrados_impares.values()) # somente os valores
[1, 9, 25, 49, 81]

>>> antonimos = {'sobe':'desce', 'certo':'errado', 'verdadeiro':'falso'}

>>> antônimos
{'sobe':'desce', 'certo':'errado', 'verdadeiro':'falso'}
>>> opostos = antônimos
>>> opostos
{'sobe':'desce', 'certo':'errado', 'verdadeiro':'falso'}
>>> opostos['certo'] = 'incerto'
>>> antonimos
{'certo': 'incerto', 'sobe': 'desce', 'verdadeiro': 'falso'}
>>> copia = antonimos.copy() # cópia profunda
>>> copia
{'certo': 'incerto', 'sobe': 'desce', 'verdadeiro': 'falso'}
>>> copia['certo'] = 'duvidoso'
>>> antonimos
{'certo': 'incerto', 'sobe': 'desce', 'verdadeiro': 'falso'}
>>> copia
{'certo': 'duvidoso', 'sobe': 'desce', 'verdadeiro': 'falso'}
>>> opostos
{'certo': 'incerto', 'sobe': 'desce', 'verdadeiro': 'falso'}
>>> id(antonimos), id(opostos), id(copia)
(111542608, 111542608, 111542320)
>>>

Prof. Cláudio A. Fleury Página 34

 >>> x = {"Carla":[1,2], "Maria":[3,4]}
>>> y = x.copy() # cópia profunda
>>> id(x), id(y)
(111524720, 111528960)
>>> y['Carla'] = [0]
>>> print x, '\n', y
{'Carla': [1, 2], 'Maria': [3, 4]}
{'Carla': [0], 'Maria': [3, 4]}
>>>

>>> y["Mariana"] = [5,6]

>>> y
{'Carla': [0], 'Mariana': [5, 6], 'Maria': [3, 4]}
>>> x["Carla"] = x["Carla"] + [3] # ou x["Carla"] += [3]
>>> x
{'Carla': [1, 2, 3], 'Maria': [3, 4]}
>>> y
{'Carla': [0], 'Mariana': [5, 6], 'Maria': [3, 4]}
>>> id(x), id(y)
(111524720, 111528960)

>>> z = {"a":1, "b":2, "c":3}

>>> q = {"z":9, "b":7}
>>> z.update(q)
>>> z
{'a': 1, 'c': 3, 'b': 7, 'z': 9}
>>> q
{'z': 9, 'b': 7}
>>>

• . $ 7

Considere a seguinte matriz esparsa:

Uma representação dessa matriz usando uma lista terá muitos zeros:

>>> matriz = [ [0, 0, 0, 1, 0],

[0, 0, 0, 0, 0],
[0, 2, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 3, 0] ]

Uma alternativa para economizar memória é usarmos um dicionário. Para as chaves, nós podemos
usar tuplas que contêm os índices da linha e da coluna:
>>> esparsa = {(0,3): 1, (2, 1): 2, (4, 3): 3}

Nós precisamos apenas de três pares ) ! ;! % , para armazenar os valores diferente de zero
da matriz. Cada chave é uma tupla, e cada valor é um número inteiro.

Prof. Cláudio A. Fleury Página 35

 Para acessarmos um elemento da matriz armazenada na lista utilizamos o operador de indexação
[]:
>>> matriz[0][3]
1

Note que a sintaxe da representação de um dicionário não é a mesma usada na representação

das listas. Em vez de usarmos dois índices inteiros, nós usamos apenas um índice, que nesse caso, é
uma tupla de dois valores inteiros.

Mas temos um problema com essa alternativa... Se tentarmos buscar um elemento zero, obteremos
um erro, pois não existe uma entrada no dicionário para a chave especificada, 0 (zero):

>>> matriz[1][3]
0
>>> esparsa[0,3]
1
>>> esparsa[1,3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: (1,3)
>>>

O método => resolve esse problema:

>>> esparsa.get((0,3), 0)
1

O primeiro parâmetro do => é a chave buscada, e o segundo parâmetro é o valor que =>
retornará caso a chave não exista no dicionário. Exemplo:
>>> esparsa.get((1,3),0) for i in range(5):
... for j in range(5):
0
... print esparsa.get((i,j), 0),
>>> ... print= x**2

- )$) ";
1. Dada uma palavra, só com letras minúsculas, digitada pelo usuário, mostre a quantidade de
letras na palavra.
2. Dada uma palavra, só com letras minúsculas, digitada pelo usuário, mostre a ocorrência de
cada letra da palavra (histograma = contagem de frequência), usando % " .
3. Dada uma palavra, só com letras minúsculas, digitada pelo usuário, mostre a ocorrência de
cada letra da palavra (histograma = contagem de frequência), usando ) ( .

9. Entrada de Dados

Python fornece funções nativas que pegam entradas realizadas via teclado. A mais simples é
chamada 1K & =>. Ao executar esta função, o programa para e espera o usuário digitar
alguma coisa. Quando o usuário finaliza a entrada de dados ao pressionar a tecla [ ], o
programa prossegue e a função 1K & => retorna a digitação do usuário sempre como :

Prof. Cláudio A. Fleury Página 36

 >>> entrada = raw_input()
Curso de Introdução ao Python
>>> print entrada
Curso de Introdução ao Python

Antes de usar 1K & => é bom exibir uma mensagem para o usuário dizendo o que ele deve
digitar. Esta mensagem é como se fosse uma pergunta ( ):
>>> nome = raw_input("Qual é o seu nome? ")
Qual é o seu nome? Arthur, Rei dos Bretões!
>>> print nome
Arthur, Rei dos Bretões!

Se a entrada esperada for um valor numérico inteiro, então podemos usar a função =>.

A função do Python também lê dados informados pelo usuário via teclado. Se a informação
a ser entrada pelo usuário for uma então a informação deve ser digitada com os
delimitadores de (par de aspas ou apostrofes), mas se a informação for numérica então
nenhum delimitador será necessário.
>>> nome = input('Digite o seu sobrenome: ')
Digite o seu sobrenome: 'Fleury'
>>> idade = input('Digite a sua idade: ')
Digite a sua idade: 19
>>> print nome, 'tem', idade, 'anos.'
Fleury tem 19 anos.
>>>

Atente7se para o fato de que devem ser delimitadas por aspas (") ou apóstrofos (') na
entrada de dados com a função & =>.

>>> pergunta = "Velocidade de percurso (km/h): "

>>> velocidade = input(pergunta)
Velocidade de percurso (km/h): 80
>>>

Se o usuário digitar uma de números, ela será convertida num inteiro e atribuída à variável
! % ) . Infelizmente, se o usuário digitar um caractere que não seja um dígito numérico, o
programa trava:
>>> velocidade = input(pergunta)
Qual... é a velocidade de vôo de uma andorinha?
De qual você fala, uma andorinha Africana ou uma Europeia?
SyntaxError: invalid syntax

Para evitar esse tipo de erro, geralmente é bom usar 1K & => para pegar uma e,
então, usar funções de conversão para outros tipos de dados: int(), float(), long().

Prof. Cláudio A. Fleury Página 37

 10. Controle de Fluxo de Execução

) %

Para poder escrever programas úteis, quase sempre precisamos da habilidade de checar
condições e mudar o comportamento do programa de acordo com elas. As instruções condicionais
oferecem essa habilidade. A forma mais simples é a instrução (se):
if x > 0:
print x, "é positivo"

A expressão booleana depois da instrução é chamada de condição. Se ela é verdadeira (3 ),

então a instrução indentada2 é executada. Se não, nada acontece, e segue7se com a execução do
comando seguinte ao *.

As instruções compostas em Python são constituídas de um cabeçalho e de um bloco de comandos

separados por um caractere ':' como mostrado a seguir:
INSTRUÇÃO-COMPOSTA:
PRIMEIRO COMANDO
...
ULTIMO COMANDO

A primeira instrução não endentada marca o final do bloco.

Não existe limite para a quantidade de instruções que podem aparecer aninhadas numa instrução
. Ocasionalmente, é útil ter um corpo sem nenhuma instrução (usualmente, como um delimitador de
espaço para código que você ainda escreverá!). Nesse caso, você pode usar o comando , que
indica ao Python: “passe por aqui sem fazer nada” ou "siga em frente...".

if a < b:
pass
print a, b
...

" " .% ! "

Simples:

if condição:
comando(s) # executados se condição é True

Composta:

if condição:
comando(s) # executados se condição é True
else:
comando(s) # executados se condição é False

2 Recuar o texto em relação à margem esquerda da folha; inserir espaços entre a margem e o começo da linha de um parágrafo.

Prof. Cláudio A. Fleury Página 38

 Encadeada:
if condição1:
comando(s) # executados se condição1 é True
elif condição2:
comando(s) # executados se condição2 é True
...
elif condiçãoN:
comando(s) # executados se condiçãoN é False
else:
comando(s) # executados se todas as condição são False

Exemplo:

if a < b:
print a, "é menor que", b
elif a > b:
print a, "é maior que", b
else:
print a, "e", b, "são iguais"

A expressão é uma abreviação de “ ” (“senão se”). No Python não existe uma instrução
do tipo ") % O) " ( = = , na ling. C/C++), mas pode7se usar:

if escolha == 'A':
funcao_A()
elif escolha == 'B':
funcao_B()
elif escolha == 'C':
funcao_C()
else:
print "Escolha não disponível."

" " &

Em geral, as instruções são executadas sequencialmente: a primeira instrução em uma função é

executada primeiro, seguida pela segunda e assim por diante. Pode haver situações em que você
precise executar um bloco de comandos várias vezes. As linguagens de programação fornecem
várias estruturas de controle que permitem caminhos de execução mais complexos.

Uma delas apresenta um teste da condição de manutenção do laco de repetição no início da

estrutura: 1 % (enquanto).

Nesse caso o(s) comando(s) a serem repetidos são colocados de forma indentada após o
caractere ':', e podem ser executados nenhuma ou várias vezes, enquanto a condição for
verdadeira ( ).

Inicialização
while condição:
comando(s)

Uma instrução 1 % na linguagem de programação Python executa repetidamente um ou mais

comandos endentados, enquanto a ) for verdadeira. A ) pode ser qualquer

Prof. Cláudio A. Fleury Página 39

 expressão e é qualquer valor diferente de zero. O loop itera enquanto a condição for
verdadeira.

No Python, todas as instruções recuadas pela mesma quantidade de caracteres espaços após uma
construção de programação ':' são consideradas parte de um único bloco de código. Python usa
recuo (endentação) como método de agrupar instruções.

Exemplo:

>>> curso = 'Python'

>>> indice = 0
>>> while indice < len(curso):
... letra = curso[indice]
... print letra,
... indice = indice + 1
...
P y t h o n

Usar um índice para percorrer um conjunto de valores é uma tarefa comum em programação, de
modo que o Python oferece uma sintaxe alternativa simplificada 7 o laço de repetição * :
>>> curso = 'Python'
>>> for letra in curso:
... print letra,' ',
...
P y t h o n
>>>

11. Função Definida pelo Usuário

Função é um grupo de instruções relacionadas que executam uma tarefa específica. As funções
ajudam a dividir os programas em partes menores e modulares. À medida que o programa se
torna maior, as funções o tornam mais organizado e gerenciável, além de evitar a repetição de
comandos e gerar códigos reutilizáveis.
def nome_funcao(parametros):
""" string documental para descrever o que faz a funcao """
comando(s) indentado(s)

A primeira após o cabeçalho da função é chamada de )" . Ela é usada para resumir
o que faz a função. Embora opcional, a documentação é uma boa prática de programação.
Geralmente, usamos aspas triplas para que a possa se estender por várias linhas. Esta
estará disponível para nós como atributo KK )KK da função.

A instrução é usada para encerrar a função e voltar para o local de onde foi chamada.

Exemplo:
import math
def polar(x, y):
""" converte a coordenada retangular (x,y) em polar (mod,fase) """
mod = math.sqrt(x*x + y*y)

Prof. Cláudio A. Fleury Página 40

 fase = math.atan2(y,x)*180./math.pi # ângulo em graus
return mod,fase

z,teta = polar(4, 4)
print "4 + j4 = %.2f|_%.1f (grau)" % (z, teta)

>>> runfile('E:/python/apostila2.py', wdir=r'E:/python')

4 + j4 = 5.66|_45.0 (grau)
>>> print polar.__doc__
Converte a coordenada retangular (x,y) em polar (mod,fase)
>>> help(polar)
Help on function polar in module __main__:
polar(x, y)
converte a coordenada retangular (x,y) em polar (mod,fase)

Funções que definimos para executar determinada tarefa específica são referidas como * F "
* " & % " ( . A maneira como definimos e chamamos funções em Python já é discutida.

Funções que vêm prontas com o Python são chamadas de * F " " (ou incorporadas).

Funções escritas por outras pessoas na forma de biblioteca

são denominadas funções de biblioteca.

' ) "' F "

Depois de definida pelo usuário (comando *) a função

poderá ser chamada no sempre que for necessário.

") & P (! " "" E "

O ") & de uma variável se refere ao local num programa em

que a variável é reconhecida. Parâmetros e variáveis definidos
dentro de uma função não são visíveis de fora dessa função. Por
isso, diz7se que variáveis desse tipo têm ") & % ) %. O Tempo
de vida de uma variável é o período em que ela existe até ser
apagada da memória. O tempo de vida de variáveis dentro de
uma função é o mesmo para a função ser executada. Elas são
destruídas quando a função é encerrada. Assim, uma função não
se lembra do valor de suas variáveis em chamadas anteriores.

def minha_funcao():
x = 10
print "Valor de 'x' dentro da funcao:", x

x = 20
minha_funcao()
print "Valor de 'x' fora da funcao:", x

>>> runfile('E:/python/apostila2.py', wdir=r'E:/python')

Valor de 'x' dentro da funcao: 10
Valor de 'x' fora da funcao: 20
>>>

Prof. Cláudio A. Fleury Página 41

 P " "' F " * "& % " (

• As funções definidas pelo usuário ajudam a decompor um programa grande em pequenos

trechos, o que torna o programa mais fácil para se entender, manter e depurar.
• Se ocorrer código repetido em um programa. A função pode ser usada para incluir esses
códigos e executar quando necessário, chamando a função definida pelo usuário.
• Programadores de grandes projetos dividem a carga de trabalho criando diferentes
funções.

def comum(lista1, lista2):

'''Retorna uma lista com os elementos em comum.'''
A = set(lista1)
B = set(lista2)
return list(A & B)

x = [1,2,3,4,5]
y = [3,4,5,6,7,9]
z = range(0,50,5)
print "Comum entre x e y:", comum(x,y)
print "Comum entre x, y e z:", comum(comum(x,y),z)
>>> runfile('E:/python/apostila2.py', wdir=r'E:/python')
Comum entre x e y: [3, 4, 5]
Comum entre x, y e z: [5]

Exercícios:
1. Calcule e mostre o mínimo múltiplo comum (mmc) de dois números (menor inteiro positivo que é
perfeitamente divisível pelos dois números dados).
2. Calcule e mostre o máximo divisor comum (mdc) de dois números (maior inteiro positivo que é
perfeitamente divisível pelos dois números dados)

12. Funções Incorporadas

O interpretador Python possui várias * F " ) & " que estão sempre disponíveis – não
dependem de importações (carga prévia). Elas estão listadas em ordem alfabética a seguir:

Funções Incorporadas
abs() divmod() input() open() staticmethod()
all() enumerate() int() ord() str()
any() eval() isinstance() pow() sum()
basestring() execfile() issubclass() print() super()
bin() file() iter() property() tuple()
bool() filter() len() range() type()
bytearray() float() list() raw_input() unichr()
callable() format() locals() reduce() unicode()
chr() frozenset() long() reload() vars()
classmethod() getattr() map() repr() xrange()
cmp() globals() max() reversed() zip()

Prof. Cláudio A. Fleury Página 42

 compile() hasattr() memoryview() round() __import__()
complex() hash() min() set()
delattr() help() next() setattr()
dict() hex() object() slice()
dir() id() oct() sorted()
%< : matemática, repres. numérica, string, estr. de dados, , outras.

Fonte: docs.python.org/2/library/functions.html#

- )$) ";

1. Dada uma lista de chamada dos alunos (máx. 99 alunos) de uma turma, pede7se mostrar a
lista com a seguinte aparência:
01 7 JOAO
02 7 ANA
03 7 RUBENS
04 7 OTACILIO
05 7 ...

2. Considere a lista do exercício 1 contendo também a idade de cada aluno:

["Joao",22,"Ana",19,...]. Mostre a lista com a mesma aparência, porém listando apenas os
alunos com mais de 20 anos.

3. Considere uma lista de preços de frutas e verduras em reais, de uma feira de rua:
["Pepino",5.5,"Tomate",8.3,"Banana",4.5,"Laranja",3.0,"Café Jacú",990.5,...]. Mostre a lista
com preços convertidos para dólar americano (use câmbio R$ 3,80/US$) com a seguinte
aparência:
01 Pepino 1.33
02 Tomate 2.43
03 Banana 1.21
04 Laranja 0.91
05 Café Jacú 20.23

enumerate(iterable, start=0)

Retorna um objeto enumerado. O parâmetro ,% pode ser uma sequência, um iterador ou

3
algum outro objeto que suporte iteração . O método - => do iterador retornado por
=> retorna uma tupla contendo uma contagem (do início, parâmetro " , cujo padrão é
0) e os valores obtidos da iteração pela sequência:

>>> estacoes = ['Primavera', 'Verao', 'Outono', 'Inverno']

>>> list(enumerate(estacoes))
[(0, 'Primavera'), (1, 'Verao'), (2, 'Outono'), (3, 'Inverno')]
>>> list(enumerate(estacoes,start=1))
[(1, 'Primavera'), (2, 'Verao'), (3, 'Outono'), (4, 'Inverno')]

3 : substantivo feminino. 1. ato de iterar; repetição. 2. ÁLGEBRA: processo de resolução de uma equação mediante
operações em que sucessivamente o objeto de cada uma é o resultado da que a precede. 3. COMPUT.: é o processo de
repetição de uma ou mais ações; cada iteração se refere a apenas uma instância da ação.

Prof. Cláudio A. Fleury Página 43

 Equivalente a:

def enumerate(sequence, start=0):

n = start
for elem in sequence:
yield n, elem
n += 1

Outro exemplo:
>>> frutas = ('manga', 'banana', 'laranja')
>>> for cont, fruta in enumerate(frutas,10):
... print "Fruta %d: %s" % (cont,fruta)
...
Fruta 10: manga
Fruta 11: banana
Fruta 12: laranja
>>>

Outro exemplo:
>>> diasSemana = ["Segunda", "Terça", "Quarta", "Quinta", "Sexta"]
>>> for i, dia in enumerate(diasSemana,1):
... print("{}-feira é o {}o. dia útil da semana".format(dia, i))
...
Segunda-feira é o 1o. dia útil da semana
Terça-feira é o 2o. dia útil da semana
Quarta-feira é o 3o. dia útil da semana
Quinta-feira é o 4o. dia útil da semana
Sexta-feira é o 5o. dia útil da semana
>>>

filter(funcao, iteravel)

A função * % => cria uma lista a partir dos elementos da estrutura de dados ! %, para os
quais a aplicação da * ) retorna . O parâmetro iterável pode ser uma sequência, um
contêiner que suporta iteração ou um iterador. Se ! % for uma ou uma tupla, o resultado
também será desse mesmo tipo; caso contrário, será uma lista. Se o parâmetro * ) não for
especificado ou for ! , a função => é assumida, ou seja, todos os elementos iteráveis que
forem ' %" não serão considerados.

Obs.: A função * % () é equivalente à seguinte :

• Com parâmetro * ) especificado: [item item ! % funcao(item)]
• Com parâmetro * ) não especificado: [item item ! % item]

>>> lista = [8, 9, -1, -3, 3, -5, -4, 5, -4, 2, 5, 91, -11, 5, 10, 93, -75]
>>> positivos = []
>>> for item in lista:
... if item > 0:
... positivos.append(item)
...
>>> print positivos

Prof. Cláudio A. Fleury Página 44

 [8, 9, 3, 5, 2, 5, 91, 5, 10, 93]
>>> negativos = [x for x in lista if item < 0]
>>> print negativos
[-1, -3, -5, -4, -4, -11, -75]

Agora vamos mostrar o ‘jeito Python’ de fazer a mesma coisa, mas de uma forma pouco mais
compacta, usando uma função definida pelo usuário e denominada & " =>:

>>> lista = [8, 9, -1, -3, 3, -5, -4, 5, -4, 2, 5, 91, -11, 5, 10, 93, -75]
>>> def positivo(x): # função retorna True para x positivo
... return x > 0
...
>>> positivos = filter(positivo, lista)
>>> positivos
[8, 9, 3, 5, 2, 5, 91, 5, 10, 93]
>>>

Agora sem usar uma função específica em * % :

>>> lista = [1, 'a', 0, False, True, '0']

>>> result = filter(None, lista)
>>> print 'Elementos mantidos:', result
Elementos filtrados: [1, 'a', True, '0']
>>>

map(funcao, iteravel, ...)

Aplica * ) a cada item ! % e retorna uma lista com os resultados.

O mapeamento consiste em aplicar uma função a todos os itens de uma sequência, gerando outra
lista contendo os resultados e com o mesmo tamanho da lista inicial. Se argumentos iteráveis
adicionais forem passados, a função deve tomar tantos quantos argumentos que serão aplicados
aos itens de todos os iteráveis em paralelo. Se um iterável for menor que outro, então ele será
estendido com itens ! . Se a função não for especificada (! ), a função identidade é
assumida; se houver vários argumentos, &=> retorna uma lista que consiste em tuplas contendo os
itens correspondentes de todos os iteráveis (um tipo de operação de transposição). Os argumentos
iteráveis podem ser sequência ou qualquer objeto iterável; o resultado é sempre uma lista.

>>> import math

>>> quadrados = [1, 4, 9, 16, 25]
>>> resultado = map(math.sqrt, quadrados)
>>> print resultado
[1.0, 2.0, 3.0, 4.0, 5.0]
>>>

Ao chamar a função &= 6"Q 2 % " 8>, estamos solicitando ao interpretador para que
execute a função 6"Q ( 4 + do inglês: raiz quadrada) usando como entrada cada um
dos elementos da lista Q , e inserindo o resultado na lista retornada como resultado da função
map(), a lista " % .

Prof. Cláudio A. Fleury Página 45

 Podemos facilmente substituir uma chamada a &=> com . O código anterior
poderia ser substituído por:

>>> result = [math.sqrt(x) for x in quad]

>>> print result
[1.0, 2.0, 3.0, 4.0, 5.0]
>>>

Expressões lambda

" é uma função anônima composta apenas de expressões. As funções são expressas
apenas numa linha, e podem ter o resultado atribuído a uma variável. Funções são muito
usadas em programação funcional.

No exemplo da função * % =>, tivemos que definir uma nova função (& " ! ) para ser usada só
dentro da função * % =>, sendo chamada uma vez para cada elemento filtrado. Ao invés de
definir uma nova função de usuário com a instrução *, podemos definir uma função válida
somente enquanto durar a execução do * % =>. Não é necessário nem nomear tal função, sendo,
portanto chamada de função anônima ou função .

Considere o exemplo seguinte:

>>> valores = [10, 4, -1, 3, 5, -9, -11]

>>> print filter(lambda x: x > 0, valores)
[10, 4, 3, 5]
>>>

Definimos uma função anônima que recebe um parâmetro de entrada (a variável -) e retorna o
resultado da operação relacional - R B: ou ' %" .

Podemos também usar uma função no exemplo mostrado para a função ) =>;

>>> cinco = [1, 2, 3, 4, 5]

>>> soma = reduce(lambda x, y: x + y, cinco)
>>> print soma
15
>>>

No código acima, definimos uma função anônima que recebe dois parâmetros de entrada e
retorna a soma deles.

reduce(funcao, iteravel[, inicializador])

Aplica a * ) de dois parâmetros, aos dois primeiros elementos do ! %, depois aplica

novamente * ) usando como parâmetros de entrada o resultado do primeiro par e o terceiro
elemento de ! %, seguindo assim até o final da sequência. O resultado final da redução é
apenas um elemento.

Prof. Cláudio A. Fleury Página 46

 " :

reduce(lambda x, y: x + y, [1,2,3,4,5]) faz o seguinte cálculo ((((1+2)+3)+4)+5).

O argumento da esquerda, x, é o valor acumulado e o argumento da direita, y, é o valor de

atualização do ! %. Se ) % L opcional estiver presente, ele será colocado antes dos
itens do ! % no cálculo e servirá como padrão quando o ! % estiver vazio. Se o
) %L não for fornecido e ! % contiver apenas um item, o primeiro item será retornado.
Aproximadamente se equivale a:

def reduce(funcao, iteravel, inicializador=None):

it = iter(iteravel)
if inicializador is None:
try:
inicializador = next(it) # primeiro valor do iterable
except StopIteration:
raise TypeError('reduce() de sequência vazia e sem valor inicial')
acumulador = inicializador
for x in it:
acumulador = funcao(acumulador, x)
return acumulador

Para somar os valores de uma determinada lista:

>>> import operator # necessário para obter a operação de soma

>>> cinco = [1, 2, 3, 4, 5]
>>> dez = range(11)
>>> print reduce(operator.add, cinco)
>>> print reduce(operator.add, dez)
15
55
>>>

É claro que, para realizar a soma de todos os elementos de uma sequência, é muito mais simples
utilizarmos a função " =>:

>>> print sum(cinco) , '\n', sum(dez)

15
55
>>>

A função ) => pode ser usada para calcular o fatorial de um valor :

# Calcula o fatorial de n
>>> def fatorial(n):
... return reduce(lambda x,y: x*y, range(1,n+1))
...
>>> print fatorial(6)
720
>>>

Prof. Cláudio A. Fleury Página 47

zip(iteraveis)

Função que retorna um iterador de tuplas. Iteraveis podem ser listas, strings, dicionários e
definições do usuário (objetos com o método __iter__).

Exemplo:

>>> # argumentos de mesmos comprimentos

>>> for i in zip([1,2,3],['a','b','c']): # 3 elementos em cada lista
... print i,
...
(1, ‘a’) (2, ‘b’) (3, ‘c’)
>>>
>>> for i in zip([1,2,3],['a','b','c'],['#','*','$']): # idem
... print i,
...
(1, 'a', '#') (2, 'b', '*') (3, 'c', '$')
>>> # somente um argumento
>>> for i in zip([1,2,3]):
... print i,
...
(1,) (2,) (3,)
>>> # argumentos de comprimentos diferentes (menor qtde é determinante)
>>> for i in zip([1,2,3],['a','b','c','d','e'],['#','*','$',400]):
... print i,
...
(1, 'a', '#') (2, 'b', '*') (3, 'c', '$')
>>>

Desembrulhando as tuplas: vimos como compactar valores, agora vamos descompactá7los, usando
o caractere * com a função L &=>.

>>> z = zip([1,2,3],['a','b','c'],['#','*','$'])
>>> a,b,c = zip(*z)
>>> a,b,c
((1, 2, 3), (‘a’, ‘b’, ‘c’), (‘#’, ‘*’, ‘$’))
>>>

Exercício:

1. Defina uma função Python * , )) = > para calcular e mostrar a série de Fibonacii com
termos até n, não usando/usando expressões % , .

Prof. Cláudio A. Fleury Página 48

 * " " P "F " 4 5 ;

Retornam iteradores

&

&

&

13. Arquivos de E/S

$ " em Dispositivo Padrão

A maneira mais simples de produzir uma saída na tela é usando a instrução & , na qual se pode
passar zero ou mais expressões separadas por vírgulas. Essa função converte as expressões numa
e grava o resultado na saída padrão, da seguinte forma:

>>> print "Python é uma grande linguagem de programação, ", "não é mesmo?"

Isso produz o seguinte resultado em seu dispositivo padrão de saída de dados (tela):

Python é uma grande linguagem de programação, não é mesmo?

" em Dispositivo Padrão

O Python também fornece duas funções internas para ler uma linha de texto da entrada de dados
padrão (teclado). Essas funções são: 1K & => e & => (vistas anteriormente).

• 1K & =[msg]>: lê uma linha da entrada padrão e a retorna como uma

(removendo o último caractere de linha nova, > ).
• & =[msg]>: é equivalente a 1K & =>, exceto pelo fato de assumir que a entrada é
uma expressão válida do Python e retorna o resultado avaliado para você, ou seja, você
pode usar ctes ou variáveis com informações numéricas ou .

Prof. Cláudio A. Fleury Página 49

 O " .Q ! "

Até agora fizemos leituras e escritas em entrada e saída padrões. Agora, vamos usar arquivos de
dados reais. O Python fornece funções básicas e métodos necessários para manipular arquivos.
Podemos fazer a maior parte da manipulação de arquivos usando um objeto de arquivo (* % ).

4 * : Antes de ler ou escrever um arquivo, é preciso abri7lo usando a função =>

do Python. Essa função cria um objeto de arquivo que será utilizado na chamada de outros
métodos de suporte associados a ele.
objeto_arq = open(nome_arq [, modo_accesso][, buffer])

? 4 com o nome do arquivo a ser acessado.

? determina o modo no qual o arquivo será aberto: leitura/escrita/anexação
etc. Este parâmetro é opcional e o modo de acesso padrão é leitura ( ).
Se o valor do buffer for 0, não existirá nenhum buffer. Se o valor do buffer
for 1, o buffer de linha é criado ao acessar um arquivo. Se o valor do
buffer for um inteiro maior que 1, a ação do buffer será executada com o
tamanho do buffer indicado. Se for negativo, o tamanho do buffer é o
padrão do sistema ( ).

, % # " .) "" Q ! ";

Abre um arquivo apenas para leitura. O ponteiro do arquivo é colocado no início do
arquivo. Este é o modo padrão.
, Abre um arquivo para leitura somente em formato binário. O ponteiro do arquivo é
colocado no início do arquivo. Este é o modo padrão.
S Abre um arquivo para leitura e gravação. O ponteiro do arquivo colocado no início do
arquivo.
,S Abre um arquivo para leitura e gravação em formato binário. O ponteiro do arquivo
colocado no início do arquivo.
1 Abre um arquivo apenas para gravação. Sobrescreve o arquivo se o arquivo existir. Se
o arquivo não existir, cria um novo arquivo para gravação.
1, Abre um arquivo para gravação somente em formato binário. Sobrescreve o arquivo
se o arquivo existir. Se o arquivo não existir, cria um novo arquivo para gravação.
1S Abre um arquivo para escrita e leitura. Sobrescreve o arquivo existente se o arquivo
existir. Se o arquivo não existir, cria um novo arquivo para leitura e gravação.
1,S Abre um arquivo para escrita e leitura em formato binário. Sobrescreve o arquivo
existente se o arquivo existir. Se o arquivo não existir, cria um novo arquivo para leitura e
gravação.
Abre um arquivo para anexar. O ponteiro do arquivo está no final do arquivo, se o
arquivo existir. Ou seja, o arquivo está no modo de acréscimo. Se o arquivo não existir, ele
criará um novo arquivo para gravação.
, Abre um arquivo para anexar em formato binário. O ponteiro do arquivo está no final
do arquivo, se o arquivo existir. Ou seja, o arquivo está no modo de acréscimo. Se o arquivo
não existir, ele criará um novo arquivo para gravação.
S Abre um arquivo para anexar e ler. O ponteiro do arquivo está no final do arquivo, se
o arquivo existir. O arquivo é aberto no modo de acréscimo. Se o arquivo não existir, ele cria
um novo arquivo para leitura e gravação.
,S Abre um arquivo para anexar e ler em formato binário. O ponteiro do arquivo está no

Prof. Cláudio A. Fleury Página 50

 final do arquivo, se o arquivo existir. O arquivo é aberto no modo de acréscimo. Se o arquivo
não existir, ele cria um novo arquivo para leitura e gravação.

Atributos do objeto * % : Depois que um arquivo é aberto tem7se um objeto * % , pelo qual se pode
obter várias informações relacionadas ao arquivo aberto.

9? @ Retorna se o arquivo for fechado, caso contrário, ' %" .

9? @ Retorna o modo de acesso com o qual o arquivo foi aberto.
9? @ Retorna o nome do arquivo.
9? @ Retorna ' %" se o espaço for explicitamente requerido com & ,
caso contrário.

Métodos do objeto * % :

O método )% " => libera qualquer informação não escrita e fecha o objeto * % , após o qual
nenhuma escrita mais pode ser feita. O Python fecha automaticamente um arquivo quando o
objeto de referência de um arquivo é reatribuído a outro arquivo. É uma boa prática usar o
método )% " => para fechar um arquivo.

objeto_arq.close()

Exemplo:

# abertura/fechamento de um arquivo de dados

fo = open("qq.txt", "wb")
print "Nome do arquivo : ", fo.name
print "Fechado ou não : ", fo.closed
print "Modo de abertura : ", fo.mode
print "Flag de Softspace: ", fo.softspace
fo.close()

Resultado:

Nome do arquivo : qq.txt

Fechado ou não : False
Modo de abertura : wb
Flag de Softspace: 0
>>>

O método 1 => grava qualquer num arquivo aberto. É importante observar que as
Python podem ter dados binários e não apenas texto. O método 1 => não adiciona um
caractere de nova linha ('\n') ao final da .
objeto_arq.write(string)

Exemplo:
# abre um arquivo
fo = open("qq.txt", "wb")
fo.write("Python é uma grande linguagem.\nNão é mesmo?\n")
# fecha o arquivo aberto
fo.close()

Prof. Cláudio A. Fleury Página 51

 Vamos visualizar na tela o conteúdo do arquivo recém7criado usando um comando do S.O.:
Para S.O. Windows: >>> !type qq.txt
Para S.O. Linux: >>> !cat qq.txt
Resultado: Python é uma grande linguagem.
Não é mesmo?

O método => lê uma de um arquivo aberto. É importante observar que as Python

podem ter dados binários, além dos dados de texto.

O método % => lê a primeira linha de um arquivo (isto é, até encontrar um caracter linha7
nova ( ) ou um caracter EOF ( >5 > ) no caso do arquivo ter apenas uma linha, e
retorna uma .

varstr = objeto_arq.read(quantidade_bytes)
varstr = objeto_arq.readline([quantidade_bytes])

Exemplo:
fo = open("qq.txt", "r+") # abre o arquivo "qq.txt" p/ leitura e
gravação
msg = fo.read(25)
print "String lida: ", msg
fo.close() # fecha arquivo aberto
String lida: Python é uma grande ling

O método %%=> informa a posição atual dentro do arquivo. Em outras palavras, a próxima leitura
ou gravação ocorrerá naquela quantidade de bytes a partir do início do arquivo.

O método " N= **" [, * ]> altera a posição atual do arquivo. O parâmetro **" indica o
número de bytes a serem movidos. O parâmetro * especifica a posição de referência de onde
os bytes devem ser movidos: B (padrão) significa usar o início do arquivo como posição de
referência; 8 significa usar a posição atual como a posição de referência e; 4, significa que a
referência será o final do arquivo.
objeto_arq.tell()
objeto_arq.seek(100)

Exemplo:
fo = open("qq.txt", "r+")
msg = fo.read(10) # lê apenas 10 bytes
print "String lida: ", msg
posicao = fo.tell() # verifica a posição corrente
print "Posição corrente no arquivo: ", posicao
# Reposiciona o ponteiro no início do arquivo novamente
posicao = fo.seek(0)
msg = fo.read(50)
print "Denovo, a String lida: ", msg
# Close opend file
fo.close() # fecha arquivo aberto

Prof. Cláudio A. Fleury Página 52

 Resultado:

String lida: Python é

Posição corrente no arquivo: 8
Denovo, a String lida: Python é uma grande linguagem.
Não é mesmo?
>>>

Exercícios:

1. Fazer um programa para criar uma agenda de compromissos: evento, dia, horário, local, obs
devem ser cadastrados para cada compromisso. Usuário deve conseguir inserir, alterar, excluir
e visualizar compromisso(s) do dia, da semana e do mês.
2. Fazer um programa para cadastrar ofertas de produtos de supermercados, armazenando:
supermercado, produto (categoria, descrição, quantidade, unidade de medida, preço), data.
Usuário deve inserir, alterar, excluir e visualizar oferta(s) do dia, classificadas por categoria.

14. Exceções
Existem pelo menos dois tipos distintos de erros: erros de
sintaxe e exceções.
Erros de sintaxe (ou erros de análise de comandos) são
talvez o tipo mais comum de queixa que você recebe
enquanto ainda está aprendendo Python...

Exemplo:
>>> while True print 'Hello world'
File "<stdin>", line 1
while True print 'Hello world'
^
SyntaxError: invalid syntax

No exemplo anterior, o erro é detectado na palavra7chave print, já que estão faltando dois
pontos (':') depois da constante True.

Mesmo se uma instrução ou expressão estiver sintaticamente correta, ela poderá causar um erro
quando for executada. " ) " - ) são chamados de -) F " e não
são incondicionalmente fatais. A maioria das exceções não é tratada pelos programas, e
resultam em mensagens de erro:
>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects

Prof. Cláudio A. Fleury Página 53

 O Python fornece dois recursos importantes para lidar com " F " (s) nos seus
programas e para incluir ) " & neles.
• Manipulação de Exceção ( " )
• Afirmações ( )

-)

É um evento que ocorre durante a execução de um programa e que interrompe o fluxo normal de
execução das instruções do programa. Em geral, quando o interpretador Python encontra uma
situação com a qual ele não pode lidar, ele gera uma exceção. Uma exceção é um objeto Python
que representa um erro. Quando um Python provoca uma exceção, ele deve manipular a
exceção imediatamente, pois caso contrário, ele será encerrado.

-)

Se seu tiver algum código suspeito que possa provocar uma -) , então você pode
defender seu programa colocando o código suspeito em um bloco ;. Depois desse bloco inclua
uma instrução -) & ;, seguida por um bloco de código que manipula o problema da maneira
mais elegante possível.
try:
operação suspeita de provocar erro(s) do seu script
....
except Exception1:
se existir Exception1, então execute este bloco.
except Exception2:
se existir Exception2, então execute este bloco.
....
else:
se não for nenhuma das exceções anteriores, então execute este bloco.
....

A instrução funciona da seguinte maneira:

1. A cláusula (as sentenças entre as palavras7chave e -) & ) é executada.
2. Se nenhuma exceção ocorrer, a cláusula -) & será ignorada e a execução da instrução
será concluída.
3. Se ocorrer uma exceção durante a execução da cláusula , o resto da cláusula será
ignorada. Então, se o tipo da exceção corresponder à exceção nomeada após a palavra7
chave -) & , a cláusula -) & será executada e depois a execução continuará após a
instrução .
4. Se ocorrer uma exceção que não corresponda à exceção nomeada na cláusula -) & , ela
será passada para as instruções externas; se nenhum manipulador for encontrado, será
uma exceção não tratada e a execução será interrompida com uma mensagem.

- &% :

while True:
try:
x = int(raw_input("Entre um valor numérico inteiro: "))
break
except ValueError:
print "Oops! Isso não é um número inteiro. Tente novamente..."

Prof. Cláudio A. Fleury Página 54

 - &% : Abre um arquivo, grava conteúdo nesse arquivo e sai corretamente, porque não há
problema algum.
try:
arq = open("arqteste.txt", "w")
arq.write("Arquivo teste para tratamento de exceção!!")
except IOError:
print "Erro: não pode encontrar arquivo, ou os dados de leitura."
else:
print "Conteúdo escrito no arquivo com sucesso."
arq.close()

Conteúdo escrito no arquivo com sucesso.

>>>

- &% : Tentativa de abrir um arquivo inexistente para leitura, para gerar uma exceção.
try:
arq = open("arqfantasma.txt", "r")
arq.read(10)
except IOError:
print "Erro: não pode encontrar arquivo, ou os dados de leitura."
else:
print "Conteúdo lido do arquivo com sucesso."
arq.close()

Erro: não pode encontrar arquivo, ou os dados de leitura.

>>>

Pode7se também usar a instrução -) & sem exceções definidas:

try:
operação suspeita do seu script
....
except:
se existir alguma exceção, então execute este bloco.
....
else:
se não existir exceção então execute este bloco.
....

Esse tipo de instrução 3 -) & captura todas as exceções que ocorrem. A utilização desse tipo
de instrução 3 -) & não é considerada uma boa prática de programação, justamente por ela
capturar todas as exceções, e não ajudar o programador a identificar a causa do problema que
está ocorrendo...

Prof. Cláudio A. Fleury Página 55

 Outra possibilidade para a instrução -) & é usar várias exceções numa única cláusula:
try:
operação suspeita do seu script
....
except (Excecao1[, Excecao2[, ... ExcecaoN]]]):
se for uma das exceções da lista, então execute este bloco.
....
else:
se não existir exceção então execute este bloco.
....

Você pode usar um bloco * %% : junto com um bloco ;. O bloco * %% é o lugar para se
colocar qualquer código que deve ser executado de qualquer forma, quer o bloco de teste ( )
tenha gerado uma exceção ou não.

try:
arq = open("arqteste.txt", "w")
arq.write("Teste de gravação em arquivo p/ tratamento de exceção!!")
finally:
print "Erro: arquivo ou dados não localizados!!"

Quando uma exceção é lançada por uma instrução dentro do bloco , a execução passa
imediatamente para o bloco * %% e depois a exceção é levantada novamente e é tratada nas
instruções -) & se presentes na próxima camada superior da instrução 3 -) & .
try:
arq = open("arqteste.txt", "w")
try:
arq.write("Teste de grav. em arquivo p/ tratamento de exceção!!")
finally:
print "Indo fechar o arquivo..."
arq.close()
except IOError:
print "Erro: não pode encontrar arquivo, ou os dados de leitura."

Você pode gerar exceções arbitrariamente, ou seja, quando você precisar, e de várias maneiras
usando a instrução " .
raise [exc [, args [, traceback]]]

Exc é o tipo de exceção (por exemplo, ! ) e args são os possíveis argumentos da exceção
(opcionais 7 se não for fornecido, o argumento da exceção será ! ). O argumento final,
traceback, também é opcional (e raramente usado na prática) e, se presente, é o objeto #
usado na exceção.

- &% : Uma exceção pode ser uma , uma classe ou um objeto. A maioria das exceções
que o núcleo do Python gera são classes, com um argumento que é uma instância da classe. Definir
novas exceções é muito fácil e pode ser feito da seguinte maneira:
def nomeFuncao(nivel):
if nivel < 1:
raise Exception("Nível não permitido!")
# O código abaixo disto não será executado se a exceção for gerada

Prof. Cláudio A. Fleury Página 56

 5 : Para capturar uma exceção, uma cláusula -) & deve referir7se à mesma exceção lançada
como objeto de classe ou . Por exemplo, para capturar a exceção definida acima, devemos
escrever a cláusula -) & da seguinte forma:
try:
comandos suspeitos
....
except Exception("Nível não permitido!"):
tratamento da exceção aqui...
else:
resto do código aqui...

-) F " & L " ;

6 -) # ! ) < )
1 -) & Classe base para todas as exceções
2 StopIteration O método - => de um iterador não aponta para nenhum objeto.
3 SystemExit Função " "6 - =>.
4 Classe base para todas as exceções internas, exceto & e
" - .
5 . ) Classe base para todos os erros que ocorrem no cálculo numérico.
6 OverflowError Um cálculo excede o limite máximo de um tipo numérico.
7 FloatingPointError Um cálculo de ponto flutuante falha.
8 ZeroDivisionError Uma divisão ou módulo por zero (para todos os tipos numéricos).
9 AssertionError Em caso de falha da declaração do ."" .
10 AttributeError Em caso de falha de referência a atributo.
11 EOFError Não há entrada para função 1K & => ou & => e o final do arquivo
é atingido.
12 ImportError Uma declaração de importação falha.
13 KeyboardInterrupt O usuário interrompe a execução do programa: [Ctrl]+[C].
14 N & Classe base para todos os erros de pesquisa.
15 IndexError Um índice não é encontrado em uma sequência.
16 KeyError A chave especificada não é encontrada no dicionário.
17 NameError Um identificador não é encontrado no espaço de nomes local/global.
18 UnboundLocalError Ao tentar acessar uma variável local em uma função ou método, mas
nenhum valor foi atribuído a ela.
19 ! Classe base p/ todas exceções que ocorrem fora do ambiente Python.
20 IOError Uma operação de entrada/saída falha, como a instrução & ou a
função & => ao tentar abrir um arquivo que não existe.
21 IOError Por erros relacionados ao sistema operacional.
22 SyntaxError Há um erro na sintaxe do Python.
23 IndentationError O recuo não é especificado corretamente.
24 SystemError O interpretador encontra um problema interno, mas quando esse erro é
encontrado, o interpretador Python não sai.
25 SystemExit O interpretador Python é encerrado usando a função " "6 - =>. Se não
for tratado no código, faz com que o intérprete saia.
26 TypeError Uma operação/função tentada é inválida para o tipo de dado indicado
27 ValueError A função interna de um tipo de dado possui o tipo válido de
argumentos, mas os argumentos têm valores inválidos especificados.
28 RuntimeError Um erro gerado não se enquadra em nenhuma categoria.
29 NotImplementedError Um método abstrato de uma classe herdada não foi implementado.

Prof. Cláudio A. Fleury Página 57

 .* F "

Uma afirmação é uma verificação de sanidade que você

ativa durante o desenvolvimento do programa e desativa
quando terminar de testar o programa. A maneira mais fácil
de pensar numa afirmação é compará7la a uma declaração
" 3 * (gera7se) ou, para ser mais preciso, a uma
declaração " 3 *3 (gera7se7não). Uma expressão é
testada e, se o resultado for * %" , uma exceção é gerada
( , levantada).

As afirmações são executadas pela instrução "" , a mais nova palavra7chave para o Python,
introduzida na versão 1.5. Os programadores costumam colocar afirmações no início de uma
função para verificar se há uma entrada válida e depois de uma chamada de função para
verificar se a saída é válida.

assert expressao[, argumentos]

Quando uma declaração de afirmação ( "" expressão) é encontrada, o Python avalia sua
expressão (espera7se que o resultado dessa avaliação seja ! para que o fluxo de
execução siga normalmente). Se a expressão for * %" , o Python gerará a exceção $ .

As exceções $ podem ser capturadas e tratadas como qualquer outra exceção usando
a instrução 3 -) & , mas se não forem tratadas, elas encerrarão o programa e produzirão um
#.

- &% : Dado uma função que converte temperatura de graus Kelvin para graus Fahrenheit.
Como zero grau Kelvin é definido como a temperatura mais baixa, a função não deve aceitar
uma temperatura negativa.

def Kelvin2Fahrenheit(Temperature):
assert (Temperature >= 0),"Mais frio que o zero absoluto?!"
return ((Temperature-273)*1.8)+32

print Kelvin2Fahrenheit(273)
print int(Kelvin2Fahrenheit(505.78))
print Kelvin2Fahrenheit(-5)

>>> print Kelvin2Fahrenheit(273)

32.0
>>> print int(Kelvin2Fahrenheit(505.78))
451
>>> print Kelvin2Fahrenheit(-5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in Kelvin2Fahrenheit
AssertionError: Mais frio que o zero absoluto?!
>>>

Aplicação do "" em Python:

• Na verificação de tipos e de entrada válida.

Prof. Cláudio A. Fleury Página 58

 • Na verificação de valores de argumentos.
• Verificação de saídas de funções.
• Como um depurador para interromper o programa onde ocorre um erro.
• No teste do código.

- &% :
def div(p,q):
assert q!=0
return p/q
>>> div(2,3)
0.6666666666666666
>>> div(2,0)
Traceback (most recent call last):
File “<pyshell#7>”, line 1, in <module>
div(2,0)
File “<pyshell#5>”, line 2, in div
assert q!=0
AssertionError
>>>

- )$) ":

1. Crie uma função que converta temperaturas em Kelvin para Celsius, tal como no exemplo
anterior.

2. Crie uma função que calcule a velocidade média de um automóvel, dados a distância (m) e o
tempo (s) gasto para percorrê7la. Use afirmação.

Prof. Cláudio A. Fleury Página 59

PACOTES 7 MÓDULOS
Um pacote no Python é uma " (Q ) / Q ! " que define um único ambiente
de aplicativo Python que consiste em módulos e subpacotes e "subsubpacotes" e assim por diante.
% &'
Até agora, falamos sobre tipos e funções incorporados à linguagem. Mas uma das melhores coisas sobre o
Python é o grande número de , ,% ) " personalizadas de alta qualidade que estão disponíveis para
ele. Algumas dessas bibliotecas fazem parteda "biblioteca padrão", o que significa que você pode
encontrá7las em qualquer lugar que execute o Python. As outras bibliotecas (não fazem parte da
“biblioteca padrão”) também podem ser facilmente acrescentadas.

O acesso a esses códigos (módulos/pacotes/bibliotecas) se faz em Python através das importações

(comando & ). Começaremos nosso exemplo importando o pacote/módulo da biblioteca
padrão. Um módulo é apenas uma coleção de variáveis ( ) definidas por outra pessoa. Podemos
ver todos os nomes definidos no módulo usando a função =>.

>>> import math

>>> print 'Tipo da biblioteca "math": {}'.format(type(math))
Tipo da biblioteca "math": <type 'module'>
>>> dir(math)
>>> dir(math)
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh',
'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e',
'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp',
'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log',
'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt',
'tan', 'tanh', 'trunc']
>>>

Podemos acessar esses elementos usando a sintaxe do ponto “.” para separar os nomes do módulos de
seus componentes. Alguns desses elementos referem7se a simples valores (constantes), tal como 6& ,
6 , enquanto outros elementos referem7se a funções, tal como 6% =>2 6"Q =>2 666:

>>> print "O número pi com 4 dígitos significativos = {:.4}".format(math.pi)

O número pi com 4 dígitos significativos = 3.142
>>> math.log(32,2) # logaritmo de 32 na base 2
5.0
>>>

Se você não souber o que faz uma determinada função, então peça ajuda ao interpretador, usando a
função %&=>:

>>> help(math.log)
Help on built-in function log in module math:
log(...)
log(x[, base])

Return the logarithm of x to the given base.

If the base not specified, returns the natural logarithm (base e) of x.

Prof. Cláudio A. Fleury Página 60

 >>>

% &(
Se soubermos os nomes das funções em que serão usadas com frequência, podemos importá7las com
um (apelido) mais curto para economizar digitação (embora nesse caso o módulo " " já seja uma
palavra bem curta).

>>> import math as mt

>>> mt.pi
3.141592653589793
>>>

Não seria ótimo se pudéssemos nos referir a todas as variáveis do módulo usando apenas os nomes
delas? Ou seja, se pudéssemos nos referir ao número pi apenas citando & em vez de 6& ou 6& ?
Boas notícias: podemos fazer isso. Veja um exemplo disso a seguir:

>>> from math import *

>>> print pi, log(32, 2)
3.141592653589793 5.0
>>>

O comando & T torna todas as variáveis do módulo acessíveis diretamente (sem qualquer prefixo
com ponto). Más notícias: alguns puristas podem reclamar de você por fazer isso.

Esse tipo de "importação com estrela (asterisco)" pode ocasionalmente levar a situações estranhas e
difíceis de depurar (corrigir).

>>> from math import *

>>> from numpy import *
>>> print pi, log(32, 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: return arrays must be of ArrayType
>>>

O problema neste caso específico é que os módulos e & têm funções de logaritmo com o
mesmo nome: % , porém com semânticas diferentes. Porque nós importamos & por último, sua função
% sobrescreveu a função % importada do módulo .

Um boa prática de programação, adotada pelos profissionais da área, é importar apenas as variáveis
(constantes e funções) específicas de cada módulo que serão necessárias no seu código ( ):

>>> from math import log, pi

>>> from numpy import asarray
>>> print pi, log(32, 2)
3.14159265359 5.0
>>>

Prof. Cláudio A. Fleury Página 61

 )
Vimos que os módulos contêm variáveis que podem se referir a funções ou constantes. Lembre7se de que
os módulos também podem ter variáveis que se referem a outros módulos (submódulos).

>>> print "numpy.random é um", type(numpy.random)

numpy.random é um <type 'module'>
>>> print "Ele contém nomes tais como...",dir(numpy.random)[-15:]
Ele contém nomes tais como... ['set_state', 'shuffle', 'standard_cauchy',
'standard_exponential', 'standard_gamma', 'standard_normal', 'standard_t',
'test', 'triangular', 'uniform', 'vonmises', 'wald', 'warnings', 'weibull',
'zipf']
>>>

Então, se nós importamos & como acima, então para chamar uma função no "submódulo"
será preciso o uso de dois pontos:

>>> # Lançamento do dado 10 vezes

... lancamentos = numpy.random.randint(1, 7, 10)
>>> lancamentos
array([2, 4, 3, 1, 5, 2, 1, 5, 2, 4])
>>>

*
No item anterior vimos que ao chamar uma função & sempre teremos um arranjo ( ) como
retorno. Nós nunca vimos algo assim antes (não neste curso de qualquer forma). Mas não entre em pânico:
temos três funções incorporadas para nos ajudar nessa questão.

1. & => (o que é isso?)

>>> type(lancamentos)
<type 'numpy.ndarray'>
>>>

2. => (o que posso fazer com isso?)

>>> print dir(lancamentos)[-20:]

['round', 'searchsorted', 'setfield', 'setflags', 'shape', 'size', 'sort',
'squeeze', 'std', 'strides', 'sum', 'swapaxes', 'take', 'tofile', 'tolist',
'tostring', 'trace', 'transpose', 'var', 'view']
>>>
>>> # O que quero fazer com os resultados dos lancamentos do dado?
... # Talvez eu queira o valor médio...
... lancamentos.mean()
2.8999999999999999
>>>

3. %&=> (conte7me mais sobre...)

>>> # o atributo "ravel" soa interessante. Eu sempre fui fã de música clássica...

Prof. Cláudio A. Fleury Página 62

 >>> help(lancamentos.ravel)
Help on built-in function ravel:

ravel(...)
a.ravel([order]) --> Return a flattened array.
Refer to 'numpy.ravel' for full documentation.

See Also
--------
numpy.ravel : equivalent function
ndarray.flat : a flat iterator on the array.
>>>
>>> # Ok, o que há para saber sobre numpy.ndarray
>>> help(lançamentos)
Help on ndarray object:

class ndarray(builtins.object)
| ndarray(shape, dtype=float, buffer=None, offset=0,
| strides=None, order=None)
|
| An array object represents a multidimensional, homogeneous array
| of fixed-size items. An associated data-type object describes the
...
>>>

#/ % " "U ";

• Científico: & + # &% % , + ) &

• Banco de Dados: "
• Interface Gráfica V2 N 2W
• Desenvolvimento p/ Web '% "N2 D
• Manipulação de Imagens %% 1 = ( , ) amigável, & P
• Rastreador Web ) &

Prof. Cláudio A. Fleury Página 63

 15. Numpy

O é um pacote fundamental para computação científica com o Python. Ele contém, entre
outras coisas:
• Um poderoso objeto de D 3 " %
• Funções sofisticadas ( )
• Ferramentas para )/ " O SS '
• Pacotes de funções para X% , , "* ' e geração de G "
% / ".

Além do óbvio uso científico, o também pode ser usado como um contêiner
multidimensional eficiente para dados genéricos. Tipos de dados arbitrários podem ser definidos.
Isso permite ao fácil e rápida integração a uma ampla variedade de bancos de dados. A
seguir veremos como usar o pacote & para manipulação básica de arranjos ( ).

Primeiro, precisamos importar & , para só então poder usar suas classes, funções e demais
recursos.
>>> import numpy as np
>>>

Criando um arranjo (vetor) numpy:

>>> np.array([4,5,6]) # converte uma lista num vetor (array)
array([4, 5, 6])

Criando outro arranjo (matriz ou vetor) & :

>>> np.array([[4,5,6],[7,8,9],[10,11,12]])
array([[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])

Verificando a forma do arranjo (quantidade de linhas e de colunas da matriz):

>>> mat = np.array([[4,5,6],[7,8,9],[10,11,12]])
>>> mat.shape
(3, 3)

Criando uma matriz com valores de 1 a 59, uniformemente espaçados de 2 em 2:

>>> faixa = np.arange(1,60,2)
>>> faixa
array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33,
35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59])
>>> faixa.reshape(3,10)
array([[ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19],
[21, 23, 25, 27, 29, 31, 33, 35, 37, 39],
[41, 43, 45, 47, 49, 51, 53, 55, 57, 59]])
>>>

Gerando um vetor com 15 valores uniformemente espaçados de 1 a 8:

Prof. Cláudio A. Fleury Página 64

 >>> x = np.linspace(1,8,15)
>>> x
array([ 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. ,
6.5, 7. , 7.5, 8. ])
>>>

Agora, vamos alterar a forma do vetor na memória (a função " . " altera a forma da matriz na
memória, ao contrário de " " que só muda a forma na apresentação da informação).

>>> x.resize(5,3)
>>> x
array([[ 1. , 1.5, 2. ],
[ 2.5, 3. , 3.5],
[ 4. , 4.5, 5. ],
[ 5.5, 6. , 6.5],
[ 7. , 7.5, 8. ]])
>>>

Criando um arranjo com todos os elementos iguais a um e outro com zeros:

>>> y = np.ones((4,4))
>>> y
array([[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.]])
>>> z = np.zeros((3,2))
>>> z
array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]])
>>>

Criando uma matriz diagonal unitária:

>>> diag = np.eye(5)

>>> diag
array([[ 1., 0., 0., 0., 0.],
[ 0., 1., 0., 0., 0.],
[ 0., 0., 1., 0., 0.],
[ 0., 0., 0., 1., 0.],
[ 0., 0., 0., 0., 1.]])
>>> print diag
[[ 1. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 1. 0.]
[ 0. 0. 0. 0. 1.]]
>>>

Criando um + via repetição de lista e outro usando função & => (de repetição):

>>> r1 = np.array([1,2,3]*6)

Prof. Cláudio A. Fleury Página 65

 >>> r1
array([1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3])
>>> r2 = np.repeat([1,2,3],6)
>>> r2
array([1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3])
>>>

Gerando dois + de dimensão 2x3, preenchidos com valores aleatórios entre 0 e 1:

>>> a = np.random.rand(2,3)
>>> a
array([[ 0.15472392, 0.11692319, 0.35272142],
[ 0.84370634, 0.43836276, 0.5290161 ]])
>>> b = np.random.rand(2,3)
>>> b
array([[ 0.88079953, 0.85233273, 0.9430226 ],
[ 0.34204979, 0.30754441, 0.98637748]])
>>>

Empilhando verticalmente as duas matrizes criadas anteriormente, e :

>>> vert = np.vstack([a,b])

>>> vert
array([[ 0.15472392, 0.11692319, 0.35272142],
[ 0.84370634, 0.43836276, 0.5290161 ],
[ 0.88079953, 0.85233273, 0.9430226 ],
[ 0.34204979, 0.30754441, 0.98637748]])
>>>

Agora, horizontalmente:

>>> hor = np.hstack((a,b))

>>> hor
array([[ 0.15472392, 0.11692319, 0.35272142, 0.88079953, 0.85233273,
0.9430226 ],
[ 0.84370634, 0.43836276, 0.5290161 , 0.34204979, 0.30754441,
0.98637748]])
>>>

Vamos fazer algumas operações elemento a elemento em arranjos de mesmas dimensões:

>>> a
array([[1, 2],
[3, 4]])
>>> b = -a
>>> b
array([[-1, -2],
[-3, -4]])
>>> a + b
array([[0, 0],
[0, 0]])
>>> a * b
array([[ -1, -4],

Prof. Cláudio A. Fleury Página 66

 [ -9, -16]])
>>> a**3
array([[ 1, 8],
[27, 64]])
>>>

Multiplicação matricial:

>>> a.dot(b)
array([[ -7, -10],
[-15, -22]])
>>>

Transposição matricial:

>>> a.T
array([[1, 3],
[2, 4]])
>>>

Agora, vamos verificar o tipo de dados dos elementos na matriz:

>>> a.dtype
dtype('int32')
>>> b.dtype
dtype('int32')
>>>

Mudando o tipo de dados da matriz, de inteiro para ponto flutuante ( ):

>>> c = a.astype('f')
>>> c
array([[ 1., 2.],
[ 3., 4.]], dtype=float32)
>>> print c
[[ 1. 2.]
[ 3. 4.]]
>>>

Agora, vamos ver algumas funções matemáticas aplicadas aos elementos de uma matriz,
começando pela soma, depois valores máximo e mínimo, e por fim a média:

>>> a.sum()
10
>>> a.max()
4
>>> a.min()
1
>>> a.mean()
2.5
>>>

Tabuada de 5, indexação e fatiamento:

Prof. Cláudio A. Fleury Página 67

 >>> tab5 = np.arange(0,11)*5 # ou: np.arange(0,51,5)
>>> tab5
array([ 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50])
>>> tab5[1:5]
array([ 5, 10, 15, 20])
>>> tab5[-1]
50
>>> tab5[::-1]
array([50, 45, 40, 35, 30, 25, 20, 15, 10, 5, 0])

Criando um arranjo bidimensional a partir de um vetor:

>>> d = np.arange(25)
>>> d
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24])
>>> d.reshape(5,5)
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]])
>>> d.shape
(25,)
>>>

Mudando a forma do arranjo na memória:

>>> d = np.arange(25)
>>> d
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24])
>>> d.resize(5,5)
>>> d
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]])
>>> d.shape
(5,5)
>>>

Acessando a quarta e quinta colunas da quarta linha da matriz . Observe que a numeração das
linhas e colunas começam em 0 (zero):

>>> d[3,3:5]
array([18, 19])
>>>

Selecionando os valores maiores que 15 da matriz , e atribuindo valor zero:

Prof. Cláudio A. Fleury Página 68

 >>> d[d>15]
array([16, 17, 18, 19, 20, 21, 22, 23, 24])
>>> d[d>15] = 0
>>> d
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 0, 0, 0, 0],
[ 0, 0, 0, 0, 0]])
>>>

Criando uma matriz 3x3 preenchida com números inteiros aleatórios entre 5 e 20:

>>> e = np.random.randint(5,20,(3,3))
>>> e
array([[14, 5, 18],
[19, 18, 10],
[18, 5, 19]])
>>>

Muito bem, até agora vimos como criar, como acessar e como manipular arranjos numéricos
(vetores e matrizes) em & . Na próxima seção, veremos os pacotes SCIPY, MATPLOTLIB e
PANDAS, todos construídos a partir do pacote & .

O pacote ) possui funções úteis à manipulação de sinais na análise de sistemas de Engenharia,

em geral.

O pacote # &% % , é um pacote que permite a apresentação de dados na forma gráfica. Possui
uma extensa gama de tipos de gráficos, muito útil também na exibição de sinais contínuos e
discretos.

O pacote " facilita muito a manipulação e análise de dados em Python, além de oferecer
estruturas de dados e operações para tabelas numéricas e séries temporais.

1 1 2
- )$) : Dada a seguinte matriz A, gere sub_A e a inversa de A (A71): = 3 5 8
13 21 34
Sub_A

"' F "U "

Para processar a fase use a função % e 1 &. Além disso, as funções % "& ) e % "& )
retornam amostras igualmente espaçadas em uma escala linear ou logarítmica.

Por fim, é útil estar ciente dos recursos de indexação do & . Deve7se mencionar a função
" % ) que estende a funcionalidade do 1 para incluir várias condições e várias opções.
>>> select(listacond, listaescolha, default = 0).

" % ) é uma forma vetorizada da declaração * múltipla. Permite a construção rápida de uma
função que retorna uma matriz de resultados com base em uma lista de condições. Cada elemento

Prof. Cláudio A. Fleury Página 69

 da matriz de retorno é retirado da matriz numa lista de opções correspondente à primeira
condição na listacond que é verdadeira. Por exemplo:
>>> x = np.r_[-2:3]
>>> x
array([-2, -1, 0, 1, 2])
>>> np.select([x > 3, x >= 0], [0, x+2])
array([0, 0, 2, 3, 4])

>>> y = np.r_[-2:5]
>>> x
array([-2, -1, 0, 1, 2, 3, 4])
>>> np.select([y > 3, y >= 0], [-3, y+2])
array([ 0, 0, 2, 3, 4, 5, -3])
>>>

Algumas outras funções úteis também podem ser encontradas no módulo ") & 6 "). Por exemplo:
* ) % e ) , que calculam o fatorial %! e a quantidade de combinações (sem considerar a
%!
ordem dos elementos) '(,) = * , =
+
2 usando aritmética inteira exata (graças ao objeto
-!.%/-0!
inteiro , ) ou usando a precisão de ponto flutuante e a função Gama.
Simples
Permutação
Com
Todos
repetição
Organizar
elementos Arranjo A.B.C≠A.B.C≠
diferentes (com ordem) B.C.A≠C.B.A...
Alguns
Combinação A.B.C=A.B.C=
(sem ordem) B.C.A=C.B.A...

- &% 38: Seja o conjunto Z = {A, B, C, D}. Quantos grupos podem ser formados agrupandos os
elementos de Z, de 2 em 2, sem levar em consideração a ordem dos elementos (os grupos não
podem ter os mesmos elementos, ainda em que em posições distintas).

4 4! 4.3.2! 12
'1,2 = * , = = = = 6 grupos
2 2! .4 3 20! 2! 2! 2
>>> import scipy.misc as sm
>>> print sm.comb(4,2)
6.0
>>>

- &% 34: Quantas apostas de seis números da MegaSena são necessárias para garantir a
premiação (acerto das seis dezenas)?

60! 60.59.58.57.56.55.54!
'=>,= = * ,
60
50.063.860 apostas
6 6! .60 3 60! 6! 54!

Prof. Cláudio A. Fleury Página 70

 >>> import scipy.misc as sm
>>> print sm.comb(60,6)
50063860.0
>>>

" (& . D "

Existem algumas instâncias de classe que fazem uso especial da funcionalidade do fatiamento
( ) para fornecer meios eficientes na construção de arranjos (vetores, matrizes). Vamos ver a
operação das funções &6 , &6 , &6 K e &6)K na construção rápida de arranjos.

Por exemplo, em vez de escrever:

>>> a = np.concatenate(([3], [0]*5, np.arange(-1, 1.002, 2/9.0)))
>>> a
array([ 3. , 0. , 0. , 0. , 0. ,
0. , -1. , -0.77777778, -0.55555556, -0.33333333,
-0.11111111, 0.11111111, 0.33333333, 0.55555556, 0.77777778, 1. ])
>>>

Com o comando K escreva apenas:

>>> a = np.r_[3,[0]*5,-1:1:10j] # o resultado é o mesmo!

Essa forma facilita a digitação e torna o código mais legível. Observe como os objetos são
concatenados e a sintaxe de fatiamento é usada para construir intervalos. Outro termo que
merece explicação é o número complexo 8BD usado como o tamanho do passo na sintaxe do
fatiamento. Esse uso não padrão permite que o número seja interpretado como o G
& " a serem produzidos no intervalo, ao invés de um & "" . Esse uso não padrão
pode ser desagradável para alguns, mas dá ao usuário a capacidade de construir rapidamente
vetores complicados de uma forma muito legível. Quando o número de pontos é especificado
dessa maneira, o ponto final é inclusivo.

A letra " " significa ) ) % ( ,), porque se os objetos entre vírgulas forem
matrizes bidimensionais, eles serão empilhados por linhas (e, portanto, devem ter colunas
proporcionais). Existe um comando equivalente )K que empilha arrays bidimensionais por colunas
() ) ) % ( )), mas funciona de forma idêntica ao K para arranjos
unidimensionais.

# % "= ">

Uma instância da classe nd_grid, A C2 no seu caso mais simples, é usada para construir
intervalos de faixas unidimensionais como substituta conveniente à função . Também usa
números complexos na indicação do tamanho do passo para indicar o número de pontos a serem
colocados entre os pontos inicial e final (inclusivos). O propósito real dessa função, entretanto, é o
de produzir grades !7dimensionais que forneçam matrizes de coordenadas para um volume !7
dimensional. A maneira mais fácil de entender isso é com um exemplo de uso da função:
>>> np.mgrid[0:5,0:5]
array([[[0, 0, 0, 0, 0],
[1, 1, 1, 1, 1],
[2, 2, 2, 2, 2],
[3, 3, 3, 3, 3],
[4, 4, 4, 4, 4]],

Prof. Cláudio A. Fleury Página 71

 [[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]]])
>>> np.mgrid[0:5:4j,0:5:4j]
array([[[ 0. , 0. , 0. , 0. ],
[ 1.66666667, 1.66666667, 1.66666667, 1.66666667],
[ 3.33333333, 3.33333333, 3.33333333, 3.33333333],
[ 5. , 5. , 5. , 5. ]],

[[ 0. , 1.66666667, 3.33333333, 5. ],
[ 0. , 1.66666667, 3.33333333, 5. ],
[ 0. , 1.66666667, 3.33333333, 5. ],
[ 0. , 1.66666667, 3.33333333, 5. ]]])
>>>

Ter matrizes de malha como esta é, por vezes, muito útil. No entanto, nem sempre é necessário
avaliar algumas funções !7dimensionais numa grade, devido às regras de transmissão de arranjos
do & e do ) . Se este for o único propósito da geração de uma grade de malha, então
você deve usar a outra instância da classe nd_grid, A C que gera uma grade “aberta”
(esparsa) usando 1 - " para criar ! matrizes !7dimensionais, onde somente uma dimensão em
cada arranjo tem comprimento maior que 1. Isso economiza memória e produz o mesmo resultado
se a única finalidade da grade de malha for gerar pontos de amostra para avaliação de uma
função !7dimensional.

% Y "

Existem duas maneiras (intercambiáveis) de lidar com polinômios unidimensionais no Python. A

primeira é usar a classe & % 8 do & (forma mais antiga). A classe & % 8 aceita
coeficientes ou raízes polinomiais para inicializar um polinômio. O objeto polinomial pode então
ser manipulado em expressões algébricas, integrado, diferenciado, avaliado e até mostrado como
um polinômio:
>>> from numpy import poly1d
>>> p = poly1d([3,4,5])
>>> print p, p.roots, p.order, p(0)
2
3 x + 4 x + 5 [-0.66666667+1.1055416j -0.66666667-1.1055416j] 2 12
>>> print p*p
4 3 2
9 x + 24 x + 46 x + 40 x + 25
>>> print p.integ(k=6)
3 2
1 x + 2 x + 5 x + 6
>>> print p.deriv()
6 x + 4
>>> p([4, 5]) # avaliação do polinômio em x = 4 e x = 5
array([ 69, 100])

A outra maneira de lidar com polinômios é como vetor de coeficientes, com o primeiro elemento da
matriz fornecendo o coeficiente de maior potência, usando o submódulo % % do &
(forma mais recente). Existem funções explícitas para adicionar, subtrair, multiplicar, dividir,
integrar, diferenciar e avaliar polinômios representados como sequências de coeficientes.

Prof. Cláudio A. Fleury Página 72

 ' F " P L

O fornece uma classe vetorizada para converter uma função Python comum, que aceita
escalares e retorna escalares, em uma “* ! L ” com as mesmas regras de transmissão
que outras funções & (ou seja, as funções Universais ou * )"). Por exemplo, suponha que
você tenha uma função Python chamada " " , definida como:
>>> def somasubtrai(a,b):
... if a > b:
... return a - b
... else:
... return a + b
>>>

que define uma função que atua em duas variáveis escalares e retorna um resultado escalar. A
classe ! ) L pode ser usada para “vetorizar” esta função:
>>> vec_somasubtrai = np.vectorize(somasubtrai)

Retorna uma função que recebe argumentos matriciais e retorna um resultado matricial:
>>> vec_somasubtrai([0,3,6,9],[1,3,5,7])
array([1, 6, 1, 2])
>>>

Esta particular função poderia ter sido escrita em forma vetorial sem o uso de ! ) L . No
entanto, funções que empregam rotinas de otimização ou integração provavelmente só podem ser
vetorizadas usando ! ) L .

# & % & "

Observe a diferença entre &6 ") &% -/ &6 " % e &6 ") &% - ,D/ &6 " % ,D. As funções
&6 ") &% -/ &6 " % são baseadas em matrizes e retornam matrizes de uns e zeros fornecendo
o resultado do teste elementar. As funções &6 ") &% - ,D/ &6 " % ,D são baseadas em
objetos e retornam um escalar descrevendo o resultado do teste em todo o objeto.

Frequentemente, é necessário obter apenas a parte real ou a imaginária de um número complexo.

Enquanto números complexos e matrizes têm atributos que retornam esses valores, se não tiver
certeza se o objeto será ou não de valor complexo, é melhor usar as funções &6 % e &6 .
Essas funções são funcionam para qualquer coisa que possa ser transformada em um arranjo
& . Considere também a função &6 %K *K)% " que transforma um número de valor
complexo com pequena parte imaginária em um número real.

Para verificar se um número é ou não escalar ((% ) , *% ,) &% - ou matriz de rank470) use
a função &6 "") % que retorna 1 ou 0.

Para garantir que objetos sejam do tipo & existe um dicionário de funções no )
específicas para isto: &6) " . As chaves do dicionário são os tipos de dados para os quais se
deseja a conversão e os valores do dicionário armazenam funções para executar as conversões.
>>> np.pi

4 Posto ou Característica de uma matriz 7 número de linhas ou colunas linearmente independentes da matriz.

Prof. Cláudio A. Fleury Página 73

 3.141592653589793
>>> type(np.pi)
<type 'float'>
>>> np.cast['f'](np.pi)
array(3.1415927410125732, dtype=float32)
>>> np.cast['i'](np.pi)
array(3)
>>> np.cast['l'](np.pi)
array(3)
>>> sorted(np.cast.items())
[(<type 'numpy.bool_'>, <function <lambda> at 0x02A2FF30>),
(<type 'numpy.object_'>, <function <lambda> at 0x02A380F0>),
(<type 'numpy.string_'>, <function <lambda> at 0x02A38170>),
(<type 'numpy.unicode_'>, <function <lambda> at 0x02A381F0>),
(<type 'numpy.void'>, <function <lambda> at 0x02A382B0>),
(<type 'numpy.int8'>, <function <lambda> at 0x02A2FCF0>),
(<type 'numpy.int16'>, <function <lambda> at 0x02A2FD70>),
(<type 'numpy.int32'>, <function <lambda> at 0x02A2FDF0>),
(<type 'numpy.int32'>, <function <lambda> at 0x02A2FEB0>),
(<type 'numpy.int64'>, <function <lambda> at 0x02A2FF70>),
(<type 'numpy.uint8'>, <function <lambda> at 0x02A38070>),
(<type 'numpy.uint16'>, <function <lambda> at 0x02A38130>),
(<type 'numpy.uint32'>, <function <lambda> at 0x02A381B0>),
(<type 'numpy.uint32'>, <function <lambda> at 0x02A38270>),
(<type 'numpy.uint64'>, <function <lambda> at 0x02A382F0>),
(<type 'numpy.float16'>, <function <lambda> at 0x02A2FD30>),
(<type 'numpy.float32'>, <function <lambda> at 0x02A2FDB0>),
(<type 'numpy.float64'>, <function <lambda> at 0x02A2FE70>),
(<type 'numpy.float64'>, <function <lambda> at 0x02A2FEF0>),
(<type 'numpy.datetime64'>, <function <lambda> at 0x02A38030>),
(<type 'numpy.timedelta64'>, <function <lambda> at 0x02A380B0>),
(<type 'numpy.complex64'>, <function <lambda> at 0x02A2FFB0>),
(<type 'numpy.complex128'>, <function <lambda> at 0x02A38230>),
(<type 'numpy.complex128'>, <function <lambda> at 0x02A2FE30>)]
>>>

- )$) : Criar uma matriz 4x4 e rotacioná7la para direita e para baixo.
from numpy import arange, roll, copy
# Solução Perigosa: desenvolver código para a tarefa
def rotacDir(A):
ult = A.shape[1]-1 # qtde de colunas
vc = copy(A[:,ult]) # preserva a última coluna
for i in range(ult,0,-1):
A[:,i] = A[:,i-1] # coluna à direita recebe coluna à esquerda
A[:,0] = vc # primeira coluna recebe últ. coluna preservada
return A

def rotacAbaixo(A):
ult = A.shape[0]-1 # qtde de linhas
vl = copy(A[ult,:]) # preserva a última linha
for i in range(ult,0,-1):
A[i,:] = A[i-1,:] # linha debaixo recebe linha acima
A[0,:] = copy(vl) # primeira linha recebe última linha preservada
return A

Prof. Cláudio A. Fleury Página 74

 A = arange(1,17).reshape(4,4)
print "Matriz Original:\n", A
print "Matriz A Rotacionada uma linha para baixo:\n", rotacionaAbaixo(A)
print "Matriz A Rotacionada mais uma linha para baixo:\n", rotacionaAbaixo(A)
A = arange(1,17).reshape(4,4)
print "Matriz Original:\n", A
print "Matriz A Rotacionada uma linha para baixo:\n", rotacionaDir(A)
print "Matriz A Rotacionada mais uma linha para baixo:\n", rotacionaDir(A)
print '-*'*35

# Solução Indicada: reusar código existente

A = arange(1,17).reshape(4,4)
print "Matriz Original:\n", A
print "Matriz A Rotacionada uma linha para baixo:\n", roll(A,1,0)
print "Matriz A Rotacionada mais uma linha para baixo:\n", roll(A,2,0)
print "Matriz Original:\n", A
print "Matriz A Rotacionada uma coluna para direita:\n", roll(A,1,1)
print "Matriz A Rotacionada mais uma coluna para direita:\n", roll(A,2,1)

% " , ":

Funções:
- array()
- arange(), linspace()
- zeros(), ones(), eye()
- repeat()
- vstack(), hstack()
- roll()
- poly1d()

Atributos:
- shape
- dtype
- T

Métodos:
- reshape()
- resize()
- dot()
- astype()
- sum(), min(), max(), mean()
- transpose()

Subpacote:
Funções:
- random.rand()
- random.randint()

Prof. Cláudio A. Fleury Página 75

 8Z6 ) & (documentação oficial: docs.scipy.org)

) é uma coleção de algoritmos matemáticos e funções de conveniência construídos sobre o

pacote & do Python. Ele acrescenta poder significativo à sessão interativa do Python,
fornecendo ao usuário comandos e classes de alto nível para manipular e visualizar dados. Com o
SciPy, uma sessão Python interativa torna7se um ambiente de processamento de dados e
prototipagem do sistema que rivaliza com sistemas como MATLAB, IDL, Octave, R7Lab e SciLab.

As aplicações científicas que usam o ) se beneficiam do desenvolvimento de módulos

adicionais em inúmeros nichos do cenário de por desenvolvedores em todo o mundo. Tudo,
de programação paralela até sub7rotinas e classes de base de dados e da Web, foi
disponibilizado para o programador Python. Todo esse poder está disponível além das bibliotecas
matemáticas do ) .

Por questões de conveniência e brevidade, assumimos que os pacotes científicos principais,

& , ) & e # &% % ,2 foram importados como:

>>> import numpy as np

>>> import matplotlib as plt
>>> import scipy as sc

L )&

,& ) ")
)% " Algoritmos de agrupamento
) " " Constantes físicas e matemáticas
** & )N Rotinas de transformada rápida de Fourier
Integração e solucionadores de equação diferencial ordinária
& % Interpolação e suavização Splines
Entrada e saída
% % Álgebra Linear
") Funções diversas: factorial, comb, lena, ...
Processamento de imagem N7dimensional
Regressão de distância ortogonal
& L Rotinas de optimização e localização de raízes
" % Processamento de sinais
"& " Rotinas de matrizes esparsas e associadas
"& % Algoritmos de estruturas de dados espaciais
"& ) % Funções especiais
" " Funções e distribuições estatísticas

Os subpacotes do ) & precisam ser importados separadamente, por exemplo:

>>> from scipy import linalg, optimize

Para usar funções de módulos do ) & , use:

>>> from scipy import algum_modulo
>>> algum_modulo.alguma_funcao()

Prof. Cláudio A. Fleury Página 76

 Exemplo: Matriz de Pascal:
>>> from scipy import linalg
>>> linalg.pascal(4)
array([[ 1, 1, 1, 1],
[ 1, 2, 3, 4],
[ 1, 3, 6, 10],
[ 1, 4, 10, 20]], dtype=uint64)
>>>

O ) & também contém funções do pacote & e do submódulo & 6% ,6") . No

entanto, é melhor usá7las diretamente do módulo & .

O submódulo ") tem funções diversas, inclusive uma função que retorna uma imagem comum
usada no processamento de imagens: % .

>>> import scipy.misc as sm

>>> import pylab as pl
>>> pl.gray()
>>> pl.imshow(sm.lena())
<matplotlib.image.AxesImage object at 0x0C068290>
>>> pl.show()
>>>

"* ' (submódulo ** & )N)

A análise de Fourier é um método usado para expressar um sinal como uma soma de componentes
periódicas e para recuperar o sinal desses componentes. Quando o sinal e sua transformada de
Fourier são substituídos por contrapartes discretizadas, ela é chamada de "* ")
' (DFT).

A DFT se tornou um dos pilares da computação numérica, em parte devido a um algoritmo muito
rápido de calculo, chamado ' " ' "* (FFT)5, que já era conhecido por Gauss (1805)
e foi trazido à luz, em sua forma atual, por Cooley e Tukey (1965).

A FFT C + de comprimento D, da sequência de comprimento7! é definida como:

I/J
).(
C+ =E . F /G2H I
(K>
E a FFT inversa é definida como:
I/J
).(
= E C + . F G2H I
)K>
Essas transformações podem ser calculadas por meio das funções ** => e ** =>, respectivamente.
>>> from scipy.fftpack import fft, ifft
>>> x = np.array([1.0, 2.0, 1.0, -1.0, 1.5])
>>> X = fft(x)
>>> X
array([ 4.5 +0.j , 2.08155948-1.65109876j,

5 Usuários para quem a velocidade das rotinas FFT é crítica devem considerar a instalação do pacote PyFFTW.

Prof. Cláudio A. Fleury Página 77

 -1.83155948+1.60822041j, -1.83155948-1.60822041j,
2.08155948+1.65109876j])
>>> Xinv = ifft(X)
>>> Xinv
array([ 1.0+0.j, 2.0+0.j, 1.0+0.j, -1.0+0.j, 1.5+0.j])

O exemplo representa a FFT da soma de dois senos nas frequências de 50 e 80 Hz:

) "" " (submódulo " %)

A caixa de ferramentas de processamento de sinais contém

atualmente algumas funções de filtragem, um conjunto
limitado de ferramentas de projeto de filtros e alguns
algoritmos de interpolação B7spline para dados
unidimensionais e bidimensionais. Embora os algoritmos B7
spline possam tecnicamente ser colocados sob a categoria
do subpacote & % , eles são incluídos aqui porque
eles só trabalham com dados igualmente espaçados e
fazem uso intenso da teoria de filtragem e do formalismo
da função de transferência para fornecer uma
transformação B7spline rápida. Para entender esta seção,
você precisará entender que um sinal no SciPy é uma matriz
de números reais ou complexos.

Filtragem

Filtragem é um nome genérico dado à operação realizada por qualquer sistema que modifica um
sinal de entrada de alguma forma. No ) & um sinal pode ser visto como um arranjo ( )
& (vetor ou matriz).

Existem diferentes tipos de filtros para diferentes tipos de operações e, em geral, eles estão
divididos em duas grandes categorias de operação de filtragem: linear e não linear. ' % "
% " podem sempre ser reduzidos a uma multiplicação de matrizes & achatadas (todos
os elementos da matriz são colocados numa única linha) por uma matriz resultante apropriada em
outra matriz & achatada.

# Retorna uma cópia do array colapsado em (reduzido a) uma dimensão.

Prof. Cláudio A. Fleury Página 78

 numpy.ndarray.flatten(order='C')

>>> a = np.array([[1,2], [3,4]])

>>> a.flatten()
array([1, 2, 3, 4]) # construído por linha
>>> a.flatten('F')
array([1, 3, 2, 4]) # construído por coluna

É claro que isto não é usualmente a melhor forma para calcular o filtro, pois as matrizes e vetores
envolvidos podem ser enormes. Por exemplo, a filtragem de uma imagem 512x512 com este
método precisaria da multiplicação de uma matriz 5122x5122 por um vetor de 5122 elementos.
Apenas o armazenamento dessa matriz Numpy padrão, seriam necessários 68.719.476.736
elementos (68 bilhões). Usando armazenamento de 4 bytes por elemento (valor de precisão
simples) seriam necessários mais de 256 GB de memória. Na maioria das aplicações os elementos
dessa matriz são nulos e um método diferente para cálculo da saída deve ser empregado.

Convolução/Correlação

Muitos filtros lineares também possuem a propriedade de ! E ) "% ) . Isto

significa que a operação de filtragem é a mesma em locais diferentes do sinal e implica que a
matriz de filtragem pode ser construída a partir do conhecimento de uma linha (ou coluna) da
matriz sozinha. Neste caso, a multiplicação da matriz pode ser realizada usando transformadas
de Fourier.

Seja um sinal unidimensional indexado pelo inteiro . Convolução de dois sinais

unidimensionais pode ser expressa por:
N

L = E + . ℎ[ − +]
)K/N

Esta equação só pode ser implementada diretamente se limitarmos as sequências a sequências de

durações finitas para que possam ser armazenadas num computador. Vamos escolher = 0 para
ser o ponto inicial de ambas as sequências, e seja O + 1 o valor para o qual [ ] = 0 para todo
≥ O + 1 e Q + 1 seja o valor para o qual ℎ[ ] = 0 para todo ≥ Q + 1, então a expressão
de ) ! % ") será:
RST((,U)

L[ ] = E [+]. ℎ[ − +]
)KRVW((/X,>)

A convolução discreta de duas sequências finitas de comprimentos O + 1 e Q + 1,

respectivamente, resulta numa sequência finita de comprimento
O + Q + 1 = (O + 1) + (Q + 1) − 1.

A convolução unidimensional é implementada no ) com a função ) ! %! . Esta função tem

como entradas os sinais , ℎ, e dois opcionais e e retorna o sinal L.

O flag permite especificar qual parte do sinal de saída será retornada. O valor padrão
* %% retorna o resultado cheio, ou seja, todos os valores calculados na convolução (inclusive nulos).
Se o for " , somente os O valores centrais serão retornados, começando em

Prof. Cláudio A. Fleury Página 79

 L[⌊(Q − 1)/2⌋], de modo que a saída tenha o mesmo comprimento do primeiro sinal das
entradas. Se o for ! % então somente os O − Q + 1 valores de saída são retornados.

O segundo flag "método", opcional, determina como a convolução é computada, seja através da
abordagem da transformada de Fourier com ** ) ! %! ou através do método direto.
Normalmente é selecionado o método esperado mais rápido. O método da transformada de
Fourier tem ordem \(D. ] D) enquanto o método direto tem ordem \(D 2 ). Dependendo da
constante \ e do valor de D, um desses métodos pode ser mais rápido. O valor padrão "auto"
executa um cálculo aproximado e escolhe o método esperado mais rápido, enquanto os valores
"direto" e "fft" forçam a computação com os outros dois métodos. O código abaixo mostra um
exemplo simples de convolução de 2 sequências:
>>> x = np.array([1.0, 2.0, 3.0])
>>> h = np.array([0.0, 1.0, 0.0, 0.0, 0.0])
>>> signal.convolve(x, h)
array([ 0., 1., 2., 3., 0., 0., 0.])
>>> signal.convolve(x, h, 'same')
array([ 2., 3., 0.])

Cálculo da Convolução pelo Método da Tabela (manual):

0.0
| 1.0 2.0 3.0 1.0+0.0 = 1.0
----+-------------- 0.0+2.0+0.0 = 2.0
0.0 | 0.0 0.0 0.0 0.0+0.0+3.0 = 3.0
0.0+0.0+0.0 = 0.0
1.0 | 1.0 2.0 3.0 0., 1., 2., 3., 0., 0., 0.
0.0+0.0 = 0.0
0.0 | 0.0 0.0 0.0
0.0 = 0.0
0.0 | 0.0 0.0 0.0
0.0 | 0.0 0.0 0.0

Essa mesma função ) ! %! pode, na verdade, usar matrizes !7dimensionais como entradas e
retornar a convolução !7dimensional das duas matrizes, conforme mostrado no exemplo seguinte.
Os mesmos de entrada também estão disponíveis para esse caso.
>>> x = np.array([[1.,1.,0.,0.],[1.,1.,0.,0.],[0.,0.,0.,0.],[0.,0.,0.,0.]])
>>> h = np.array([[1.,0.,0.,0.],[0.,0.,0.,0.],[0.,0.,1.,0.],[0.,0.,0.,0.]])
>>> signal.convolve(x, h)
array([[ 1., 1., 0., 0., 0., 0., 0.],
[ 1., 1., 0., 0., 0., 0., 0.],
[ 0., 0., 1., 1., 0., 0., 0.],
[ 0., 0., 1., 1., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0., 0.]])

A correlação é muito semelhante à convolução, troca7se apenas o sinal de menos por um mais.
Portanto, a correlação cruzada dos sinais e L, é dada por:
N

^[ ] = E L[+]. [ + +]
)K/N
Para sinais de comprimento finito com L[ ] = 0 fora do intervalo [0, O] e [ ] = 0 fora do
intervalo [0, Q], o somatório seria:

Prof. Cláudio A. Fleury Página 80

 RST((,U)

^[ ] = E L[+]. [ + +]
)KRVW((/X,>)

A função ") & 6) % => implementa a correlação. equivalentes aos da função ) ! %! =>
estão disponíveis para esta operação para retornar a sequência completa de comprimento
O + Q + 1 (* %%) ou uma sequência com o mesmo tamanho da maior sequência iniciando em
^[−O + ⌊Q − 1⌋⁄2] (" ) ou uma sequência onde os valores dependem de todos os valores da
menor sequência (! % ). Esta opção final retorna os K − M + 1 valores da sequência ^[Q − O]
até ^[0], inclusive.

Quando D = 2, correlacionar e/ou convoluir pode ser usado para construir filtros de imagem
arbitrários para executar ações como desfoque, melhoramento e detecção de borda para uma
imagem.

import numpy as np
from scipy import signal, misc
import matplotlib.pyplot as plt

guaxinim = misc.face(gray=True)
filtro = np.zeros((50, 50))
filtro[0][0] = 1.0
filtro[49][25] = 1.0
guaxfilt = signal.fftconvolve(guaxinim, filtro)

plt.figure(); plt.imshow(guaxinim); plt.gray()

plt.title('Imagem Original - Guaxinim')

plt.figure(); plt.imshow(guaxfilt); plt.gray()

plt.title('Imagem Filtrada'); plt.show()

O cálculo da convolução no domínio do tempo, como acima, é usado principalmente para filtrar
quando um dos sinais é muito menor do que o outro (O ≫ Q), caso contrário, a filtragem linear é
calculada com mais eficiência no domínio de frequência, usando a função ** ) ! %! =>. Por
padrão, ) ! %! => estima o método mais rápido usando ) " K) !K ().

Se a matriz filtro[n,m] puder ser fatorada de acordo com: M , a = MJ M2 a , a

convolução pode ser calculada por meio da função " &* 4 = >.

Prof. Cláudio A. Fleury Página 81

 &% : Seja um filtro gaussiano M , a ∝ F c = F c . F e , o qual é frequentemente usado
d /ed d d
-
para borrar imagens.

import numpy as np
from scipy import signal, misc
import matplotlib.pyplot as plt

imagem = misc.ascent()
filtro = signal.gaussian(10, 10.0)
imgnova = signal.sepfir2d(imagem, filtro, filtro)
plt.figure(); plt.imshow(imagem); plt.gray(); plt.title('Imagem Original')
plt.figure(); plt.imshow(imgnova); plt.gray(); plt.title('Imagem Filtrada')
plt.show()

Prof. Cláudio A. Fleury Página 82

 17. Matplotlib
• Introdução
• Gráficos Simples
• Figuras, Subgráficos, Eixos e Marcas de Eixo ( )
• Outros tipos de Gráficos: exemplos e exercícios
• Depois dessa Introdução
• Referências Rápidas

Trata7se de uma excelente biblioteca para traçado de gráficos de dados científicos em 2D e 3D.
Algumas vantagens desta biblioteca:
• Facilidade de uso e apresentação de dados em forma gráfica;
• Tem suporte a etiquetas e textos formatados em LaTeX;
• Pode7se controlar todos os elementos da figura, incluindo tamanho e DPI6;
• Saída de alta qualidade em vários formatos, incluindo PNG, PDF, SVG, EPS;
• GUI para explorar figuras de modo interativo, e suporte à geração de arquivos de
figuras sem cabeçalhos (útil para trabalhos com de lotes de comandos 7 ).

Uma das principais características do &% % , é que todos os aspectos da figura podem ser
controlados via programação (ou seja, sem precisar usar a GUI). Isso é importante para a
reprodutibilidade, e conveniente quando é necessário regerar a figura com dados atualizados ou
alterar sua aparência.

Visite matplotlib.org/gallery.html para ver diversos gráficos gerados por essa biblioteca.

O # &% % , é incluído automaticamente como parte do espaço de nomes do & % , interativo,

mas se você precisar importá7lo em seu próprio (por exemplo, em um ou módulo
não interativo), assim como usamos a abreviação & para e & para ", usaremos a
abreviação costumeira, &% , para a importação da biblioteca # &% % ,:

: ', ))
Modela a criação de coelhos a partir de um casal desses animais.

import matplotlib.pyplot as plt

import numpy as np

def fibonacci(n):
seq = zeros(n)
seq[1] = 1
for i in range(2,n):
seq[i] = seq[i-1] + seq[i-2]
return seq

plt.plot(fibonacci(10))
plt.bar(range(10),fibonacci(10))
plt.show()

6 $ 7 pontos por polegada

Prof. Cláudio A. Fleury Página 83

 & % " % Y
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 1, 20)
y = np.cos(x) + 0.3*np.random.rand(20)
p = np.poly1d(np.polyfit(x, y, 3))
print p
t = np.linspace(0, 1, 200)
plt.plot(x, y, 'o', t, p(t), '-')
plt.show()
>>>
3 2
0.847 x - 1.371 x + 0.08229 x + 1.211

, / % & &%
Ele fornece uma interface de procedimentos e rotinas para a biblioteca de plotagem orientada a
objetos, &% % ,. Ele é modelado para imitar os comandos gráficos do Matlab™. A maioria dos
comandos em pyplot possui argumentos semelhantes e análogos aos do Matlab™.

(* ) " &% "

Vamos plotar as funções seno e cosseno num mesmo gráfico (plano cartesiano). A partir das
configurações padrão, iremos enriquecer o gráfico, passo a passo, para torná7lo mais
apresentável. O primeiro passo é a obtenção das coordenadas dos pontos (dados):

import numpy as np

x = np.linspace(-np.pi, np.pi, 256) # abscissas

s, c = np.sin(x), np.cos(x) # ordenadas

O Matplotlib vem com um conjunto de configurações que permitem personalizar várias

características do gráfico: tamanho/dpi da figura, largura/cor/estilo da linha, propriedades de
eixo/grade, propriedades de texto/fonte etc.
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-np.pi, np.pi, 256)

s, c = np.sin(x), np.cos(x)

plt.plot(x, s)
plt.plot(x, c)

plt.show()

# ) " % "% "

Vamos traçar a curva do cosseno em azul e do seno em vermelho, e ambas com linhas ligeiramente
mais grossas. Nós também vamos alterar um pouco o tamanho da figura para torná7la mais
horizontal.
plt.figure(figsize=(10, 6), dpi=80)
plt.plot(x, s, color="red", linewidth=2.5, linestyle="-")
plt.plot(x, c, color="blue", linewidth=2.5, linestyle="-")

Prof. Cláudio A. Fleury Página 84

 .D " % " " - "
Os limites atuais do gráfico estão um pouco
apertados e queremos criar algum espaço para ver
claramente os pontos de dados.
plt.xlim(x.min()*1.1, x.max()*1.1)
plt.ylim(s.min()*1.1, s.max()*1.1)

# " ) " " - "= #>

Os padrões não são ideais porque eles não
mostram valores interessantes, tais como ±π, ±π/2,
para as funções seno e cosseno. Vamos mudá7los de
modo a mostrar apenas esses valores.

pi = np.pi
plt.xticks([-pi, -pi/2, 0, pi/2, pi])
plt.yticks([-1, 0, +1])

# " / % "= > " ) "

Os padrões não são ideais porque eles não
mostram valores interessantes, tais como ±π, ±π/2,
para as funções seno e cosseno. Vamos mudá7los de
modo a mostrar apenas esses valores.
pi = np.pi
r = [r'$-\pi$', r'$-\pi/2$', r'$0$',
r'$+\pi/2$', r'$+\pi$'] # rótulos
plt.xticks([-pi, -pi/2, 0, pi/2, pi], r)
plt.yticks([-1, 0, +1])

" - " L % ! ) %( )
Os eixos são linhas que conectam as marcas dos eixos até os limites da área de dados. Eles
podem ser colocados em posições arbitrárias e até agora, eles estavam nas fronteiras da figura.
Vamos colocá7los no meio do gráfico. Como há quatro deles (superior/inferior/esquerda/direita),
descartamos a parte superior e a direita, definindo a cor deles como ? ? (nenhuma). Movemos
a parte inferior e a esquerda para a origem nas coordenadas do espaço de dados.
ax = plt.gca()
# gca é abreviação para 'get current axis'
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom');
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))

.) ") %
Vamos inserir uma legenda no canto superior esquerdo, bastando colocar um argumento de
palavra7chave % , % (que será usado na caixa de legendas) aos comandos de plotagem.

Prof. Cláudio A. Fleury Página 85

 plt.plot(x, s, color="red", linewidth=2.5,
linestyle="-", label="seno")
plt.plot(x, c, color="blue", linewidth=2.5,
linestyle="-", label="cosseno")

plt.legend(loc='upper left')

% "& " (* )
Vamos anotar alguns pontos interessantes usando o
comando . Escolhemos o valor 2π/3 para comentar, tanto na função seno como na
cosseno. Primeiro, desenhamos um marcador na curva e depois uma linha pontilhada. Em seguida,
usamos o comando de anotação para exibir algum texto com uma seta.
t = 2*np.pi/3
plt.plot([t,t], [0,np.cos(t)], color='blue', linewidth=2.5, linestyle="--")
plt.scatter([t,], [np.cos(t),], 50, color='blue')

plt.annotate(r'$sin(\frac{2\pi}{3})=\frac{\sqrt{3}}{2}$',
xy=(t, np.sin(t)), xycoords='data',
xytext=(+10, +30), textcoords='offset points', fontsize=16,
arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))

plt.plot([t, t],[0, np.sin(t)], color='red', linewidth=2.5, linestyle="--")

plt.scatter([t, ],[np.sin(t), ], 50, color='red')

plt.annotate(r'$cos(\frac{2\pi}{3})=-\frac{1}{2}$',
xy=(t, np.cos(t)), xycoords='data',
xytext=(-90, -50), textcoords='offset points', fontsize=16,
arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"))

. " % "
Os rótulos das marcas ficaram pouco visíveis por causa das linhas azul e vermelha. Podemos
aumentá7las e também podemos ajustar suas propriedades de modo que elas sejam renderizadas
em um plano de fundo branco semitransparente. Isso nos permitirá ver os dados e os rótulos.
for rotulo in ax.get_xticklabels() + ax.get_yticklabels():
rotulo.set_fontsize(16)
rotulo.set_bbox(dict(facecolor='white', edgecolor='None', alpha=0.65))

Prof. Cláudio A. Fleury Página 86

 ' "2 , (* ) "2 - " # ) " - = #>
Uma “figura” no &% % , significa toda a janela apresentada na interface com o usuário.
Dentro dessa figura pode haver "" ,&% "". Até agora usamos figura e criação de eixos implícitas
ao comando &% . Isso é útil nas plotagens rápidas.

Podemos ter mais controle sobre a exibição usando o comando * , " ,&% e - "
explicitamente. Enquanto o " ,&% posiciona os gráficos numa grade regular, o comando - "
permite a colocação livre do gráfico dentro da figura.

Já trabalhamos com figuras e suplots, sem chamá7los explicitamente. Quando usamos &% , o
&% % , chama ) () para obter os eixos atuais, e o comando ) , por sua vez, chama )*()
( ) para obter a figura atual. Se não existir nenhuma figura, ela chama * ()
para criar uma, especificamente falando, para fazer um " ,&% =888>.

' "
Uma figura é a janela na GUI que tem como título “Figure #”. As figuras são numeradas a partir
de 1, em oposição ao modo normal do Python, a partir de 0. Isso mostra claramente o estilo
MATLAB. Existem vários parâmetros que determinam o aspecto da figura:

Parâmetro Default Descrição

num 1 Número da figura
figsize figure.figsize Tamanho da figura em polegadas: (largura, altura)
dpi figure.dpi Resolução em pontos por polegada (dpi)
facecolor figure.facecolor Cor do fundo do desenho
edgecolor figure.edgecolor Cor da borda em volta do fundo do desenho
frameon True Desenha o quadro da figura ou não

Assim como acontece com outros objetos, pode7se definir propriedades de figura usando " & ou
com os métodos " K % & & . Quando você trabalha com a GUI, você pode fechar
uma figura clicando no [x], no canto superior direito da janela. Mas você pode fechar uma figura
programaticamente chamando o método )% " . Dependendo do argumento, ele fecha:
(1) a figura atual (sem argumento),
(2) uma figura específica (número da figura como argumento) ou
(3) todas as figuras (" %%" como argumento).
plt.close(1) # fecha a figura 1

Prof. Cláudio A. Fleury Página 87

 ,&% "
Com o " ,&% pode7se organizar os gráficos em uma matriz regular de gráficos. Você especifica
o número de linhas e colunas de gráficos e a posição do próximo gráfico a ser plotado. Note que
o comando "& ) é uma alternativa mais poderosa.

- "
Os eixos são semelhantes aos , mas permitem a colocação de gráficos em qualquer local
na figura. Então, se quisermos colocar um gráfico menor dentro de um maior, fazemos isso com os
eixos.

# ) " " - "= #>

Marcas bem formatadas são importantes nas figuras prontas para publicação. O # &% % ,
fornece um sistema totalmente configurável para marcas. Existem localizadores de marcas para
especificar onde as marcas devem aparecer e formatadores de marcas para se conseguir a
aparência desejada. Marcas maiores e menores podem ser locadas e formatadas
independentemente uma da outra. Por padrão, os ticks secundários não são mostrados, ou seja, há
apenas uma lista vazia para eles: %% ) .

Os localizadores de ticks controlam as posições dos ticks e estão definidos da seguinte maneira:
ax = plt.gca()
ax.xaxis.set_major_locator(eval(locator))

Prof. Cláudio A. Fleury Página 88

 Todos esses localizadores derivam da classe mãe &% % ,6 )N 6 ) . Você pode fazer seu
próprio localizador derivando dessale. Lidar com datas como marcas pode ser especialmente
complicado e por isso, o &% % , fornece localizadores especiais em &% % ,6 ".

" & " (* ) "; - &% " - )$) "

X & ) : a partir do código abaixo, tente
reproduzir o gráfico à direita, com áreas preenchidas.
$ : Use o comando * %%K, 1 .
n = 256
X = np.linspace(-np.pi, np.pi, n, endpoint=True)
Y = np.sin(2 * X)
plt.plot(X, Y + 1, color='blue', alpha=1.00)
plt.plot(X, Y - 1, color='blue', alpha=1.00)

(* ) " "& " : a partir do código abaixo, tente

reproduzir o gráfico à direita, com áreas preenchidas.
$ : A cor é dada pelo ângulo de (X, Y).
n = 1024
X = np.random.normal(0,1,n)
Y = np.random.normal(0,1,n)

plt.scatter(X,Y)

(* ) " , ": Começando pelo código abaixo,

tente reproduzir o gráfico à direita adicionando rótulos
às barras vermelhas.
n = 12; X = np.arange(n)
Y1 = (1-X/float(n))*np.random.uniform(0.5,1.0,n)
Y2 = (1-X/float(n))*np.random.uniform(0.5,1.0,n)

plt.bar(X, Y1, facecolor='#9999ff',

edgecolor='white')
plt.bar(X,-Y2, facecolor='#ff9999',
edgecolor='white')

Prof. Cláudio A. Fleury Página 89

 for x, y in zip(X, Y1):
plt.text(x+0.4, y+0.05, '%.2f' % y, ha='center', va='bottom')
plt.ylim(-1.25, +1.25)

(* ) ": A partir do código abaixo, tente

reproduzir o gráfico à direita, cuidando do mapa de cores
(Colormaps). $ : Você precisa usar o comando )% , %.
def f(x, y):
return (1-x/2+x**5+y**3) * np.exp(-x**2-y**2)

n = 256
x = np.linspace(-3, 3, n)
y = np.linspace(-3, 3, n)
X, Y = np.meshgrid(x, y)

plt.contourf(X, Y, f(X, Y), 8, alpha=.75, cmap='jet')

C = plt.contour(X, Y, f(X, Y), 8, colors='black', linewidth=.5)
plt.show()

: A partir do código abaixo, tente reproduzir o

gráfico à direita, cuidando do mapa de cores, da
interpolação de imagens e da origem. $ : Você precisa
cuidar da da imagem no comando " 1 e usar
uma barra de cores.
def f(x, y):
return (1-x/2+x**5+y**3) * np.exp(-x**2-y**2)

n = 10
x = np.linspace(-3, 3, 4 * n)
y = np.linspace(-3, 3, 3 * n)
X, Y = np.meshgrid(x, y)
plt.imshow(f(X, Y))

(* ) ": A partir do código abaixo, tente

reproduzir o gráfico à direita, cuidando do tamanho das
cores e fatias. $ : Você precisa modificar Z.
Z = np.random.uniform(0, 1, 20)
plt.pie(Z)

(* ) ": A partir do código abaixo, tente

reproduzir o gráfico à direita, cuidando das cores e
orientações.
$ : Você precisa desenhar as flechas duas vezes.
n = 8
X, Y = np.mgrid[0:n, 0:n]
plt.quiver(X, Y)

Prof. Cláudio A. Fleury Página 90

 ": A partir do código abaixo, tente
reproduzir o gráfico à direita, cuidando dos estilos
de linha.
axes = plt.gca()
axes.set_xlim(0, 4)
axes.set_ylim(0, 3)
axes.set_xticklabels([])
axes.set_yticklabels([])

# % (* ) ": A partir do código abaixo, tente

reproduzir o gráfico à direita.
$ : Vc pode usar vários subplots com diferentes
partições.
plt.subplot(2, 2, 1)
plt.subplot(2, 2, 3)
plt.subplot(2, 2, 4)

- % : Começando pelo código abaixo, tente

reproduzir o gráfico à direita.
$ : Você só precisa modificar a linha com o
comando - ".
plt.axes([0, 0, 1, 1])
N = 20
ang = np.arange(0., 2*np.pi, 2*np.pi/N)
raio = 10*np.random.rand(N)
larg = np.pi/4*np.random.rand(N)
barras = plt.bar(ang, raio, width=larg,
bottom=0.0)

for r, barra in zip(raio, barras):

barra.set_facecolor(plt.cm.jet(r/10.))
barra.set_alpha(0.5)

(* ) " 5 : Começando pelo código abaixo, tente

reproduzir o gráfico à direita.
$ : Você precisa usar o comando ) *.
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure()
ax = Axes3D(fig)
X = np.arange(-4, 4, 0.25)
Y = np.arange(-4, 4, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='hot')

Prof. Cláudio A. Fleury Página 91

 - : Tente fazer o mesmo a partir do código
abaixo.
$ : Dê uma olhada no logotipo do &% % ,.
eq = (r"$\int_{-\infty}^\infty e^{-x^2}dx =
\sqrt{\pi}$")
x,y = np.random.uniform(0, 1, 2)

plt.text(x, y, eq, ha='center', va='center',

color="#11557c", alpha=0.35,
transform=plt.gca().transAxes, fontsize=18,
clip_on=True)
plt.xticks(()); plt.yticks(())
plt.show()

& " "" 666

Tutorial do &% 7 http://matplotlib.org/users/pyplot_tutorial.html
• Introdução • Trabalhando c/ várias figuras/eixos
• Controlando as propriedades da • Trabalhando com texto
linha
Tutorial de imagem 7 http://matplotlib.org/users/image_tutorial.html
• Comandos de inicialização
• Importando dados de imagem para matrizes &
• Plotando matrizes & como imagens
Tutorial de - (texto) 7 http://matplotlib.org/users/index_text.html
• Introdução ao - • Escrevendo expr.s matemáticas
• Comandos - básicos • Renderização de texto em LaTeX
• Propriedades de texto e layout • Anotando texto
Tutorial de " (artista) 7 http://matplotlib.org/users/artists.html
• Introdução • Recipiente - "
• Customizando seus objetos • Contêineres - "
• Recipientes de objetos • Contêineres )N
• Contêiner *
Tutorial de & (caminho) 7 http://matplotlib.org/users/path_tutorial.html
• Introdução
• Exemplo Bézier
• Caminhos compostos
Tutorial de transformações 7 http://matplotlib.org/users/transforms_tutorial.html
• Introdução • Usando transformações de
• Coordenadas de dados deslocamento ( ) para criar efeito
• Coordenadas dos eixos sombra
• Transformações homogêneas • A transformação tubo ( )
( )

) # &% % ,: Guia do Usuário 7 http://matplotlib.org/users/index.html

Prof. Cláudio A. Fleury Página 92

 ) )/ : O código está bem documentado e você pode acessar rapidamente
um comando específico a partir de uma sessão do Python:

>>> import matplotlib.pyplot as plt

>>> help(plt.plot)
Help on function plot in module matplotlib.pyplot:

plot(*args, **kwargs)
Plot lines and/or markers to the
:class:`~matplotlib.axes.Axes`. *args* is a variable length
argument, allowing for multiple *x*, *y* pairs with an
optional format string. For example, each of the following is
legal::

plot(x, y) # plot x and y using default line style and color

plot(x, y, 'bo') # plot x and y using blue circle markers
plot(y) # plot y using x as index array 0..N-1
plot(y, 'r+') # ditto, but with red plusses

If *x* and/or *y* is 2-dimensional, then the corresponding columns

will be plotted.
...

* < ) " (& "

Propriedades de Linha

Prof. Cláudio A. Fleury Página 1

 Estilos de Linha Marcadores

Mapas de Cores

Prof. Cláudio A. Fleury Página 2

 18. Pandas

O- é uma API7 de análise de dados, orientada a colunas. É uma ótima ferramenta para
manipular e analisar dados de entrada, e é usada por muitos ML8 para tratamento de
dados. Embora uma introdução abrangente à API - certamente teria muitas páginas, os
principais conceitos são bem diretos. Para uma referência mais completa, o site - contém
extensa documentação e muitos tutoriais.

Nossos objetivos principais em relação ao pacote - são:

• Apresentar as estruturas de dados * e .
• Acessar e manipular dados num * e .
• Importar dados CSV9 para um * .
• Reindexar um * para misturar dados.

) " +(" ) "

A linha a seguir importa a API Pandas e mostra a versão da API instalada no seu sistema:

>>> from __future__ import print_function

>>> import pandas as pd
>>> pd.__version__

'0.15.2'
>>>

Sobre a primeira linha do acima: considerando a versão 2.6+ do Python, você pode
importar a função de impressão do Python73 usando: * KK* KK & & K* ) , com
o objetivo de compatibilizar seu com as futuras versões do Python6

No Python 3, a " de impressão foi alterada para uma * , ou seja, você deve usar:

>>> print('Olá mundão!')

Olá mundão!
>>>

Isso também funciona no Python 2, desde que você tenha colocado a instrução
* KK* KK & & K* ) no seu script. Lembre7se de que depois dessa instrução a
versão 2.6+ do comando & já não poderá ser mais usada:

>>> from __future__ import print_function

>>> print 'Olá mundão!'
File "<stdin>", line 1
print 'Olá mundão!'
^
SyntaxError: invalid syntax
>>>

7 , do inglês: Interface de Programação de Aplicativos

8 , , do inglês: Aprendizado de Máquina
9 - , do inglês: Valores Separados por Vírgula

Prof. Cláudio A. Fleury Página 3

 As estruturas de dados primárias em Pandas são implementadas como duas classes:
• * , que você pode imaginar como uma tabela de dados relacionais, com linhas e
colunas nomeadas.
• , que é uma única coluna. Um * contém uma ou mais e um nome para
cada .

O quadro de dados é uma abstração comumente usada na manipulação de dados.

Implementações semelhantes existem em e .

Uma maneira de criar uma " é construir um objeto da classe . Por exemplo:

pd.Series(['Sao Francisco', 'Sao Jose', 'Sacramento'])

0 Sao Francisco
1 Sao Jose
2 Sacramento
dtype: object
>>>

Objetos * podem ser criados passando7se os nomes das colunas numa string de
mapeamento do tipo dicionário ( ) para suas respectivas . Se a série não corresponder em
comprimento, os valores omissos serão preenchidos com valores especiais NA/NaN. Exemplo:

>>> nomes_cid = pd.Series(['Sao Francisco', 'Sao Jose', 'Sacramento'])

>>> populacao = pd.Series([852469, 1015785, 485199])
>>> pd.DataFrame({ 'Nome da Cidade': nomes_cid, 'Populacao': populacao })
Nome da Cidade Populacao
0 Sao Francisco 852469
1 Sao Jose 1015785
2 Sacramento 485199
>>>

Mas na maioria das vezes, você carrega um arquivo inteiro num * . O exemplo a seguir
carrega um arquivo com dados de habitação da Califórnia. Execute a seguinte célula para
carregar os dados e criar definições de recursos:

>>> hab_calif_df = pd.read_csv("https://download.mlcc.google.com/mledu-

datasets/california_housing_train.csv", sep=",")
>>> hab_calif_df.describe()
>>> longitude latitude housing_median_age total_rooms \
count 17000.000000 17000.000000 17000.000000 17000.000000
mean -119.562108 35.625225 28.589353 2643.664412
std 2.005166 2.137340 12.586937 2179.947071
min -124.350000 32.540000 1.000000 2.000000
25% -121.790000 33.930000 18.000000 1462.000000
50% -118.490000 34.250000 29.000000 2127.000000
75% -118.000000 37.720000 37.000000 3151.250000
max -114.310000 41.950000 52.000000 37937.000000

total_bedrooms population households median_income \

count 17000.000000 17000.000000 17000.000000 17000.000000
mean 539.410824 1429.573941 501.221941 3.883578
std 421.499452 1147.852959 384.520841 1.908157

Prof. Cláudio A. Fleury Página 4

 min 1.000000 3.000000 1.000000 0.499900
25% 297.000000 790.000000 282.000000 2.566375
50% 434.000000 1167.000000 409.000000 3.544600
75% 648.250000 1721.000000 605.250000 4.767000
max 6445.000000 35682.000000 6082.000000 15.000100

median_house_value
count 17000.000000
mean 207300.912353
std 115983.764387
min 14999.000000
25% 119400.000000
50% 180400.000000
75% 265000.000000
max 500001.000000
>>>

O exemplo acima usou ' . ") , => para mostrar estatísticas interessantes sobre um
* . Outra função útil é o ' 6 =>, que exibe os primeiros registros de um
* :
>>> hab_calif_df.head()
longitude latitude housing_median_age total_rooms total_bedrooms \
0 -114.31 34.19 15 5612 1283
1 -114.47 34.40 19 7650 1901
2 -114.56 33.69 17 720 174
3 -114.57 33.64 14 1501 337
4 -114.57 33.57 20 1454 326

population households median_income median_house_value

0 1015 472 1.4936 66900
1 1129 463 1.8200 80100
2 333 117 1.6509 85700
3 515 226 3.1917 73400
4 624 262 1.9250 65500
>>>

Lembrete:
# : substantivo feminino
1. GEOMETRIA: segmento de reta que liga o vértice de um
triângulo retângulo ao meio do lado oposto.
2. ESTATÍSTICA: valor que divide um conjunto de valores
ordenados em partes iguais (o valor do meio de um
conjunto de dados).

Outra característica poderosa do pacote - é a representação gráfica. Por exemplo,

' 6 " => permite estudar rapidamente a distribuição de valores numa coluna:

>>> hab_calif_df.hist('housing_median_age')
array([[<matplotlib.axes._subplots.AxesSubplot object
at 0x0988C4D0>]], dtype=object)
>>>

Prof. Cláudio A. Fleury Página 5

 .) "" "

Você pode acessar dados do * usando operações conhecidas de dicionários/listas do

Python:

>>> cidades = pd.DataFrame({ 'Nome Cidade': nomes_cid, 'Populacao': populacao })

>>> print(type(cidades['Nome Cidade']))
<class 'pandas.core.series.Series'>
>>> cidades['Nome Cidade']
0 Sao Francisco
1 Sao Jose
2 Sacramento
Name: Nome Cidade, dtype: object
>>> cidades
Nome Cidade Populacao
0 Sao Francisco 852469
1 Sao Jose 1015785
2 Sacramento 485199
>>> cidades['Nome Cidade'][2]
'Sacramento'
>>> print(type(cidades['Nome Cidade'][2]))
<type 'str'>
>>> cidades[0:2]
Nome Cidade Populacao
0 Sao Francisco 852469
1 Sao Jose 1015785
>>>

Além disso, o - oferece uma API extremamente rica para seleção e indexação avançada
que é muito extensa para ser abordada aqui.

# & % "

Você pode aplicar as operações aritméticas básicas do Python a uma . Por exemplo:

>>> populacao
0 852469
1 1015785
2 485199
dtype: int64
>>> populacao/1000.
0 852.469
1 1015.785
2 485.199
dtype: float64
>>>

Uma " pode ser usada como argumento para a maioria das funções do :

>>> import numpy as np

>>> np.log(populacao)
0 13.655892

Prof. Cláudio A. Fleury Página 6

 1 13.831172
2 13.092314
dtype: float64
>>>

Para transformações mais complexas em coluna única, você pode usar o método "6 &&% .
Assim como a função & do Python, o método "6 &&% aceita como argumento uma função
, que é aplicada a cada valor. O exemplo abaixo cria uma nova que indica se a
população da cidade é superior a um milhão:

>>> populacao.apply(lambda val: val > 1000000)

0 False
1 True
2 False
dtype: bool
>>>

Modificar um * também é simples. Por exemplo, o código a seguir adiciona duas

a um * existente:

>>> cidades['Area (milhas2)'] = pd.Series([46.87, 176.53, 97.92])

>>> cidades['Densidade Populacional'] = cidades['Populacao'] / cidades['Area
(milhas2)']
>>> cidades
Nome Cidade Populacao Densidade Populacional Area (milhas2)
0 Sao Francisco 852469 18187.945381 46.87
1 Sao Jose 1015785 5754.177760 176.53
2 Sacramento 485199 4955.055147 97.92
>>>

- )$) ;

Modifique a tabela de cidades adicionando uma nova coluna booleana que seja verdade (3 )
se, e somente se, as duas opções forem verdadeiras:
A cidade recebeu o nome de um santo.
A cidade tem uma área maior que 50 milhas quadradas.
: As séries booleanas são combinadas usando os operadores bit a bit, em vez dos tradicionais
booleanos. Por exemplo, ao executar a lógica ‘ [ use \ em vez de .

Solução:

>>> cidades['Grande e Nome Santo'] = (cidades['Area (milhas2)'] > 50) &

cidades['Nome Cidade'].apply(lambda nome: nome.startswith('Sao'))
>>> cidades
Nome Cidade Populacao Densidade Populacional Area (milhas2) \
0 Sao Francisco 852469 18187.945381 46.87
1 Sao Jose 1015785 5754.177760 176.53
2 Sacramento 485199 4955.055147 97.92

Grande e Nome Santo

0 False
1 True

Prof. Cláudio A. Fleury Página 7

 2 False
>>>

] ) "

Os objetos e* também definem uma propriedade que designa um valor de

identificador para cada item da ou linha do * . Por padrão, na construção, o pacote
- atribui valores de índice que refletem a ordenação dos dados de origem. Uma vez criados,
os valores do índice são estáveis; isto é, eles não mudam quando os dados são reordenados.

>>> cidades.index
Int64Index([0, 1, 2], dtype='int64')
>>>

Chame a função ' 6 -=> para reorganizar manualmente as linhas. Por exemplo, o
seguinte comando tem o mesmo efeito da classificação por nome da cidade:

>>> cidades
Nome Cidade Populacao Densidade Populacional Area (milhas2) \
0 Sao Francisco 852469 18187.945381 46.87
1 Sao Jose 1015785 5754.177760 176.53
2 Sacramento 485199 4955.055147 97.92

Grande e Nome Santo

0 False
1 True
2 False
>>> cidades.reindex([2, 0, 1])
Nome Cidade Populacao Densidade Populacional Area (milhas2) \
2 Sacramento 485199 4955.055147 97.92
0 Sao Francisco 852469 18187.945381 46.87
1 Sao Jose 1015785 5754.177760 176.53

Grande e Nome Santo

2 False
0 False
1 True
>>>

Reindexar é uma ótima maneira de embaralhar (randomizar) um * . No exemplo

seguinte, pegamos o índice, que é semelhante a um vetor, e o passamos para a função
6& do , que embaralha seus valores no lugar. Chamar a reindexação
com esse vetor embaralhado faz com que as linhas do ' sejam embaralhadas da mesma
maneira. Execute o comando seguinte várias vezes!

>>> cidades.reindex(np.random.permutation(cidades.index))
Nome Cidade Populacao Densidade Populacional Area (milhas2) \
1 Sao Jose 1015785 5754.177760 176.53
2 Sacramento 485199 4955.055147 97.92
0 Sao Francisco 852469 18187.945381 46.87

Grande e Nome Santo

1 True

Prof. Cláudio A. Fleury Página 8

 2 False
0 False
>>> cidades.reindex(np.random.permutation(cidades.index))
Nome Cidade Populacao Densidade Populacional Area (milhas2) \
1 Sao Jose 1015785 5754.177760 176.53
0 Sao Francisco 852469 18187.945381 46.87
2 Sacramento 485199 4955.055147 97.92

Grande e Nome Santo

1 True
0 False
2 False
>>>

- )$) ;

1. O método de reindexação permite valores de índice que não estão nos valores de índice do
' original. Experimente e veja o que acontece se você usar esses valores! Por que
você acha que isso é permitido?

Solução:

Se o vetor de entrada de reindexação incluir valores que não estão nos valores originais do índice
* , a função - incluirá novas linhas para esses índices "ausentes" e preencherá
todas as colunas correspondentes com valores NaN:

>>> cidades.reindex([0, 4, 5, 2])

Nome Cidade Populacao Densidade Populacional Area (milhas2) \
0 Sao Francisco 852469 18187.945381 46.87
4 NaN NaN NaN NaN
5 NaN NaN NaN NaN
2 Sacramento 485199 4955.055147 97.92

Grande e Nome Santo

0 False
4 NaN
5 NaN
2 False
>>>

Esse comportamento é desejável porque os índices são geralmente cadeias de caracteres

extraídos dos dados reais (consulte a documentação sobre - do - para obter um
exemplo em que os valores de índice são nomes de navegadores).

Nesse caso, permitir índices "ausentes" facilita a reindexação usando uma lista externa, já que não
se precisa preocupar7se com a limpeza da entrada.

Prof. Cláudio A. Fleury Página 9

 :

:== @ =
:== @ = > > > > > >AB ' BCBDEA
:== @ @ = "= @
:== @ = @ = =
:== @ .@ = > = F
:== @ .@ = > = " =
:== @ @ @ = = = ? ? @ F 3 G D H3I-JK
:== @ @ = = > > >A
:== @ @ = = > > " >
:== @ @ = = ? ? @
:== @ @ = = ? " @
:== @ @ = = > > >
:== @ @ = > @
:== @ @ = > > =
:== > @ = = > =
:==9 * @ @ = ? =
:== > @ = = = @ F >
:== > > > @ @ = = = ?LI@ F * > >
> >

M" : -+ $. &

7 POO (classes/objetos)
7 Programação CGI (Web)
7 Acesso a BD
7 Redes
7 Envio de E7mail
7
7 Processamento XML
7 Programação GUI
7 Extensões adicionais ( , C++, Java etc)

Prof. Cláudio A. Fleury Página 10

 " N

Item 8:
1.
# Contando letras de uma palavra
p1 = 'anticonstitucionalissimamente'
p2 = 'pneumoultramicroscopicossilicovulcanoconiótico'
print "Qtde. de letras: p1 = %d, p2 = %d" % (len(p1), len(p2))

2.
# Ocorrências de letras de uma palavra - sol. com lista
ocor = [0]*26
orig = ord('a')
for letra in p1:
ocor[ord(letra) - orig] += 1
for asc,freq in enumerate(ocor):
print "Letra %s = %d" % (chr(asc+ord('a')), freq)

3.

# Ocorrências de letras de uma palavra - sol. com dicionário

ocor = {}
for letra in p1:
ocor[letra] = ocor.get(letra,0) + 1
print ocor # ordem alfabética: print sorted(ocor.items())

Prof. Cláudio A. Fleury Página 11