Introdução ao Python

Prévia do material em texto

Python
Sofiane Labidi, PhD.
Roteiro
● Introdução ........................................................................ 04
● Python? ........................................................................... 08
● Instalação ......................................................................... 17
● IDLE Python ..................................................................... 28
● Expressões Python ............................................................ 42
● Tipagem ........................................................................... 56
● Strings ............................................................................. 76
● Atribuições ..................................................................... 113
● Saídas ............................................................................ 121
● Entradas ......................................................................... 151
2
Roteiro
● Controle Condicional ............................................................... 165
● Estruturas de Repetição ........................................................... 171
● Funções .................................................................................. 180
● Coleções ................................................................................. 192
● Arquivos ................................................................................. 303
● Matemática ............................................................................ 341
● Classes ................................................................................... 349
● Utilitários ............................................................................... 357
● Gráficos .................................................................................. 365
● Exceções ................................................................................ 368
● Packages & Módulos ............................................................... 377
● Anaconda .............................................................................. 389
● Conclusão ............................................................................... 400
3
Introdução
4
Linguagens de 
Programação
Linguagem de 
Programação
Permite às pessoas de expressarem o que eles desejam que 
o computador faz.
Transmite ao computador como fazer isto!
5
Paradigmas de 
Programação
● Programação Estruturada
C, Pascal, etc.
● Programação Orientada a Objeto
Java, C++, Python, C#, SmallTalk, Eiffel, etc.
● Programação Funcional
Lisp, Scheme ML, SML,etc.
● Programação Lógica
Prologo, etc.
● Programação Visual
Delphi, JBuilder, C++Builder, etc.
● Programação Concorrente / Distribuída / Paralela
OCCAM, C*, Ada, SR, Linda, Orca, etc.
6
Paradigmas de 
Programação ●Podemos ter uma Linguagem Multiparadigmas ?
●Qual é a melhor linguagem de Programação?
7
Python?
8
Linguagem
• Python é uma linguagem criada por Guido van Rossum no 
final de 1989, no Instituto Nacional de Matemática e Ciência da 
Computação da Holanda –CWI.
• Criada a partir da linguagem ABC.
• Foco inicial: auxiliar os profissionais da física e das 
engenharias.
• É uma linguagem de programação livre, com desenvolvimento 
comunitário.
• O nome é uma homenagem ao grupo humorístico britânico 
Monty Python, criador do programa Monty Python's Flying 
Circus.
Python
9
Linguagem
• Empresas que usam Python: Google (aplicações web), 
Yahoo (aplicações web), Microsoft (IronPython: Python 
para .NET), Disney (animações 3D), etc.
• Linguagem Python está na versão 3.6 (não compatível 
com as versões anteriores a 2.6, etc. (o objetivo era de 
corrigir falhas).
• Python usa simultaneamente um compilador e um 
interpretador.
Python
10
Linguagem
• Os arquivos fontes são armazenado com a extensão py.
• O Compilador transforma as instruções python em instruções 
de bytecode e salva em um arquivo (.pyc) .
• O arquivo .pyc é executado pelo interpretador apropriado.
• O Interpretador (Máquina Virtual Python - Python VM): 
responsável por converter bytecode em linguagem de 
máquina de baixo nível para execução direta no hardware.
• Bytecode Python é uma linguagem de máquina executada 
pela Máquina Virtual Python.
Python
11
Linguagem
• O Python pode ser executado diretamente no terminal:
python (executa o python no modo interativo)
python teste.py (executa o programa teste.py)Python
12
Linguagem
•Python é uma linguagem simples e amigável, com 
uma sintaxe clara, limpa e concisa.
• Não é necessário digitar ponto-e-vírgula no final de 
cada linha de instruções – caso seja preciso continuar 
na linha seguinte basta colocar uma barra invertida: \
• Não é necessário abrir e fechar blocos de código com 
chaves, como o C, Pascal, Java, etc.
 Os blocos são identificados pela indentação do código.
Python
13
Linguagem
• A identificação de blocos é feita por meio da 
indentação:
>>> i=0
>>> while i<8:
print(i)
i=i+3
 0
3
6
 >>>
Python
14
Linguagem
•Python é uma linguagem Orientada a Objeto,
Tudo é objeto em Python (inteiros, real, etc.). 
Até os tipos mais básicos possuem métodos 
específicos.
Python
15
Python
•Python oferece também ferramentas para:
• Programação funcional
• Processamento de imagens
• Interface gráfica
• Processamento distribuído
• Integração com C, C#, linguagem de script 
Blender, etc.
Multiparadigmas
16
Instalação
17
Interpretador 
Python
Interpretadores Online:
www.codeskulptor.org/ (da Rice university)
www.tutorialspoint.com/execute_python_online.php
http://mathcs.holycross.edu/~kwalsh/python/
Online
18
Interpretadore
s
Online
Outros Interpretadores Online (para várias linguagens)
 
Repl
https://repl.it/
Code, Compile & Run
https://www.codechef.com/ide
 
CodePad
http://codepad.org/
 Outras 6 Plataformas
https://elias.praciano.com/2016/12/6-compiladores-online-pa
ra-estudantes-de-programacao/ 
19
Instalando 
Python
●Python para Android (mobile):
●Pydroid 3
●QPython
QPython
20
Instalando 
Python
21
● IDLE Python (ou IDE) - Integrated Development 
Language Environment:
Ambiente de desenvolvimento integrado para Python.
Python.org
●Baixar:
● https://www.python.org/downloads/
 última versão 3.6.5 (2017)
● https://docs.python.org/3/tutorial/index.html
 Tutorial oficial Python.
Instalando 
Python
22
Instalando 
Python
●Automaticamente, o Python instala:
● IDLE Shell Python
● IDLE Editor.
23
Instalando 
Python
● IDLE / IDE (Integrated Development Environment) 
(Integrated Development and Learning Environment)
●É o Ambiente de Desenvolvimento Integrado, contendo:
● Pacote de desenvolvimento de softwares, contendo o editor de 
códigos.
● Ferramentas de Automação do processo de construção. 
● Depurador (Debugger),
● Plataforma Educacional.
IDE / IDLE
24
Instalando 
Python
● IDLEs Python:
● IDLE Python.org
●PyCharm 
●AnaConda
●Ninja
●Visual Studio Code
●Spyder, Atom, Sublime, etc. 
IDE / IDLE
25
https://rschalch.github.io/escolha-seu-editor.html
IDLE Python
26
IDLE ●IDLE Python
python.org Python
27
IDLE
● Iniciar uma cessão
●Reiniciar uma cessão 
Para remover quaisquer alterações feitas ou então, 
remover qualquer objeto criado em memória. 
Menu Shell -> Restart Shell ou CTRL + F6.
Python
28
Shell Python >>> # é o prompt de comandos Python
Prompt
29
Shell Python
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 16:07:46) [MSC v.1900 32 bit 
(Intel)] on win32
Type "copyright", "credits" or "license()" for moreinformation.
>>> 8*4
32
>>> print ('Olaa')
Olaa
>>> print("bom dia")
Bom dia # tanto faz aspas simples ou duplas
>>> print(5-2)
3
>>> 5-2
3
>>> 6
6
1os Comandos
30
Shell Python
●Navegando nos comandos (avançar e retroceder):
●Alt P Comando Anterior
●Alt N Próximo comando
●Observação:
●As teclas de atalho podem ser alteradas a vontade usando 
a opção de menu Option -> Configure IDLE -> Keys
Atalhos
31
32
Shell Python
●Atalhos dos comandos:
>>> 4+6
10
>>> _ * 5 # referencia o último valor retornado 
# pelo shell
50
>>>
Atalhos
33
Shell Python
Atalhos dos comandos:
● Alt + P -> retorna última instrução
● Alt + N -> avança para a próxima instrução
● Crl+D fecha a janela / ShellPython
● Ctrl + F6 -> Reinicia o IDLE
● Ctrl + N -> Abre o editor de Script´s de várias linhas
● Ctrl + Enter ->
● Ctrl + C -> interrompe a execução (Script em looping)
● Ctrl + Espaço -> abre o Code Complete
● Tab -> abre o Code Complete
● Ctrl + J -> adiciona linha e move o cursor para a mesma
Atalhos
34
Criando 
Arquivos 
Python
●Um arquivo Python é um arquivo texto composto por comandos 
python e cuja extensão é PY.
●É criado, no Idle, pela opção de meu: 
 File → New File - arquivo novo CTRL N
 File → Save / Save as... - salvar com a extensão py 
 Run → Run Module - executar o arquivo python 
F5
Editor
35
1º Arquivo 
Python
●Exemplo, arquivo "teste.py" 
a=2
b=3
print(a+b)
print(a-b) # um comando por linha
# Esse programa imprima a soma e a diferença
# de duas variáveis inteiras a e b na tela
5
-1
36
Arquivo 
Python
●O # é usado para os comentários em uma linha!
● ''' ... ''' comentário em várias linhas
●Temos um comando por linha.
●Não há uma cessão de declaração de variáveis.
●O tipo da variável é determinado pelo tipo do valor a 
ela atribuído.
Características
37
Arquivo 
Python
●Exemplo, arquivo "teste.py" 
a=2
b=3
print('A soma é: ',a+b)
print('A diferença é: ',a-b)
A soma é: 5
A diferença é: -1
print
38
Arquivo 
Python
●Limpar a tela:
>>> import os
os.system('cls' if os.name == 'nt' else 'clear')
>>> from os import system
>>> system('cls')
0
>>>
print
39
Expressões Python
40
Expressões / 
Operadores
•Expressões
• Lógicas
• AritméticasLógicos e Aritméticos
41
Operadores 
Aritméticos
42
>>> 8 -2*3
2
>>> (8 -2)*3
18
>>> 3**2
9 # potência
>>> pow(3,2)
9 # potência também
Operadores 
Aritméticos
>>> 8/2
4.0 # divisão real
>>> 9/2
4.5 # divisão real
>>> 9//2
4 # divisão inteira
>>> 9%2
1 # resto da divisão inteira
43
>>> -6/2
-3.0 # divisão real
>>> -9//2 
-3.0 # divisão real
>>> -6%-2
3 # divisão inteira
>>> 9%2/2
Operadores 
Aritméticos
print(9/2) # 4.5
print(-9/2) # -4.5
print(9/-2) # -4.5
print()
print(9//2) # 
print(-9//2) # 
print(9//-2) # 
print()
print(9%2) # 
print(-9%2) # 
print(9%-2) #
44
 
4.5
-4.5
-4.5
4
-5
-5
1
1
-1
 
Operadores 
Aritméticos
•+ -
•* / // %
•divmod() (x//y,x%y)
•** pow
abs valor absoluto
45
Operadores 
Aritméticos
>>> divmod(9,2)
(4, 1) 
>>> abs(-2)
2
>>> round(4.5) # arredonda uma float
4
>>> round(4.5)
5
46
Operadores 
Aritméticos
Prioridade Operador
1 ()
2 ** pow
3 * / // %
4 + -
Prioridades
47
Operadores 
Aritméticos
Expressão Avaliação
a-c**2 ?
pow(b,2)-4*a*c ?
a-b*c-d ?
a/b*c-d ?
Exercício
48
Variável Valor
a 12
b 4
c 2
d -3
8
-80
7
9.0
Operadores 
Aritméticos
Expressão Avaliação
a//c-3 ?
a-2*b%d ?
a/c%b ?
a**(a%d) ?
Exercício
49
Variável Valor
a 12
b 4
c 2
d -3
3
13
2.0
1
Operadores 
Aritméticos
Expressão Avaliação
a//c-3 ?
a-2*b%d ?
a/c//b ?
a**(c%d) ?
8*-b%a**(d-1) ?
Exercício
50
Variável Valor
a 6
b 4
c -2
d 3
-6
4
-1
6
4
Operadores 
Relacionais
> Maior que
>= Maior ou igual
< Menor que
<= Menor ou igual
== Igualdade
!= Diferente de
in pertence
Expressões Lógicas
51
Operadores 
Relacionais
>>> 4!=5
True
>>> 6==5
False
>>> 'Maria'=='maria'
False # Python é uma linguagem Case Sensitive
>>> resp='s'
>>> resp in ('s','S')
True # resp in ['s','S']
52
Bug
● Bug/Imprecisão
>>> ((1.5)-(1.0))
0.5
>>> ((1.3)-(1.0))
0.30000000000000004
>>> ((1.1)-(1.0))
0.10000000000000009
>>> ((1.2)-(1.0))
0.19999999999999996
>>> print 1.2-1.0
0.2
53
Bug
● Bug/Imprecisão
>>> y = 1.0/3.0
>>> y
0.33333333333333331
>>> print y
0.333333333333
>>>
>>> y2 = round(y, 4)
>>> y2
0.33329999999999999
>>> print y2
0.3333
54
Variáveis e Tipagem
55
Variáveis •Variáveis não precisam ser declaradas.
56
Variáveis • Faz o algoritmo de troca de duas variáveis
Swap
57
● # swap a=8 b=4 print(a,b) print('\n1a Solução NAO 
FUNCIONA')a=bb=aprint(a,b)
● print('\n2a Solução')a=8b=4print(a,b)x=aa=bb=xprint(a,b)
● print('\n3a Solução')a=8b=4print(a,b)a=a+bb=a-ba=a-bprint(a,b)
● print('\n4a Solução')a=8b=4print(a,b)a,b=b,aprint(a,b)
58
Tipagem
•Python é uma linguagem com tipagem:
• Forte, e
• Dinâmica.
59
Tipos
• inteiro (int):
>>> a=10
 # normalmente representados com 32 bits 
 # 
 
• ponto flutuante (float):
>>> a=2.453 (ou 24.53e-1)
• complexo (complex):
>>> a=3-2j
Tipos Numéricos
60
Tipos
• Tipo lógico (bool):
>>> a=False
>>> type(a)
<type 'bool'> 
>>> bool('')
False
>>> 2 < 4 
True 
>>> 5 > 7 
False 
>>> 6 < 8 < 10 
True 
>>> 2 < 5 < 4 
False
Tipo bool (lógico)
61
•Tipo lógico 
(bool):
>>> a=4
>>> a=a==4
Tipos
>>> a=-2+3j
>>> b= 5-1j
>>> a+b
3+2j
>>> complex(2,-1)
(2-1j)
>>> c=2-1j
>>> c.conjugate()
(2+1j) # inverte o sinal da parte imaginária (j)
Tipo Complexo
62
Tipos
>>> (-2+3j)/(-2+3j)
(1+0j)
>>> a=1j
>>> a**2
(-1+0j)
>>> a**3
(-0-1j)
Tipo Complexo
63
>>> (2-3j)*(1+j)
(5-1j)
>>> (3-1j)-(2+4j)
(1+3j)
>>> 3-1j/2+4j
(3+3.5j)
>>> (3-1j)/(2+4j)
(-0.1-0.7j)
Tipos
•A função type retorna o tipo de uma variável ou expressão.
print type(1)
<class 'int'>
type(2.0)
<class 'float'>
Type("Alô")
<class 'str'>
 type('Maria‘)
 <class ‘str'>
 
Extração do Tipo 
64
type(a==2)
 <class 'bool'>
type(4/2)
 <class 'float'>
type(5//2) #ou %
 <class ‘int'>
type(2-4j)
 <class ‘complex'>
Tipos
• Tipo lógico (booleano): bool
• As expressões booleanas ou lógicas são expressões criadas a 
partir do uso de:
• operadores lógicos (and, or, not) 
• operadores relacionais (>,>=,<,<=,==,!=)
 e cujo o resultado é:
● verdadeiro (True) ou 
● falso (False). 
Tipo bool
65
Tipo
Operador Lógico Descrição
AND Conjunção
OR Disjunção
NOT Negação
Tipo bool
66
>>> a=2
>>> b=6
>>> (a>=b)
False
>>> (a!=b) or (b==2)
True
>>> not (a==a) or (b>=a+1) and (a<0)
False
Tipos
• Notação científica:
 >>> 2e1 # 2*10**1
20.0
>>> 2e3
2000.0
>>> 2e-1
0.2
>>> 5e-3
0.005 
Notação Científica
67
Tipos
a = 1 # tipo inteiro
a = 'Maria' ou a="Maria" # string
a = 1.0 # float
Conversão de Tipos
68
Tipos
>>> a=28
>>> str(a)
'28'
>>> float(a)
28.0
>>> int(3.14)
3
>>> int(3.9)
3
Conversão de Tipos
69
str(a) #converte para string
float(a) #converte para float
int (a) #converte para inteiro
Tipos
>>> a=2.0
>>> a+1 # ouprint(a+1)
3.0
>>> a='São Paulo'
# As variáveis podem mudar de tipo: a tipagem é dinâmica
# aqui a variável a mudou do tipo inteiro para string
Tipagem Dinâmica
70
Tipos
>>> bin(5)
'0b101'
>>> bin(10)
'0b1010'
>>> bin(200)
'0b11001000'Conversão de bases
71
>>> hex(15)
'0xf'
>>> hex(255)
'0xff'
>>> hex(100)
'0x64'
bin converter decimal p binário
hex converter um decimal p hexa
>>> oct(5)
'0o5'
>>> oct(10)
'0o1012'
>>> oct(8)
'0o10'
Tipos
● Dir mostra a lista das operações que pode ser aplicadas em 
cima de uma variável, de acordo com seu tipo.
>>> a=8.5 
>>> print(dir(a))
['__abs__', '__add__', '__bool__', '__class__', '__delattr__', '__dir__', 
'__divmod__', '__doc__', '__eq__', '__float__', '__floordiv__', 
'__format__', '__ge__', '__getattribute__', '__getformat__', 
'__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', 
'__int__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', 
'__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', 
'__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', 
'__rmul__', '__round__', '__rpow__', '__rsub__', '__rtruediv__', 
'__setattr__', '__setformat__', '__sizeof__', '__str__', '__sub__', 
'__subclasshook__', '__truediv__', '__trunc__', 'as_integer_ratio', 
'conjugate', 'fromhex', 'hex', 'imag', 'is_integer', 'real']
72
Tipos
>>> 0b111
7
>>> 0b10
2
>>> 0b1010
10
>>> 
Conversão de bases
73
>>> 0xA
10
>>> 0xFFF
4095
>>> 0xA2
162
>>> 
0b converter binário p decimal
0x converter um hexa p decimal
Tipos
>>> print int('01010101111',2)
687
>>> int('1010', 2)
10
>>>
>>> int('ff', 16)
255
>>> int('b', 16)
11
>>>
Conversão de bases
74
Converter de qualquer base p decimal
Tipos
2 8 10 16 b
2
-
0b
>>> 0b11
3
8 - 0o
>>> 0o10
8
10 bin
>>> bin(101)
'0b1100101')
oct
>>> oct(9)
'0o11'
-
hex
>>> 
hex(15)
'0xf'
16 0x
>>> 0x1F
31
-
b int
>>> int('40',5)
20
Operadores de Conversão 
de bases
75
Tipos
● Python suporta o famoso calculo bits a bits.
● É a possibilidade de armazenar uma série de valores booleanos em bytes, mas 
que precisam de operadores (bit a bit).
● Exemplo:
● Suponhamos que temos 8 informações booleanas representando o estado de 8 
lâmpadas. Ao invés de armazenar cada informação em sua variável booleana, é 
mais econômico usar 1 byte, que tem 8 bits, e armazenar os estados das 
lâmpadas nesses bits.
● Se as lâmpadas 1, 3 e 4 estejam acesas, podemos armazenar o seu estado nos 
bits 1, 3 e 4 do byte (10110000 em binário). Isso corresponde ao número 
decimal 176 que passa a indicar o estado dessas luzes:
● luzes = 176 # 10110000
Operadores Bit a Bit
76
Tipos
Operador Bit a Bit Descrição
>> Deslocamento de bits para direita
<< Deslocamento de bits para esquerda
& E bit a bit
| OU bit a bit
^ OU exclusivo bit a bit
~ Complemento
Operadores Bits a Bits
77
Tipos
Operadores Bits a Bits
Exemplo de aplicação
78
>>> bitsA = int('1010', 2) 
10
>>> bitsB = int('1011', 2) 
11
bitsResultado = bitsA & bitsB 
print(f'BitsA e bitsB = {bitsResultado:b}) 
bitsResultado = bitsA | bitsB 
print(“bitsA ou bitsB = %s" % "{0:b}".format(bitsResultado)) 
bitsResultado = ~bitsA 
print("Inversão dos bitsA = %s" % "{0:b}".format(bitsResultado))
bitsA 1 0 1 0
bitsB 1 0 1 1
^ 1 0 1 0
| 1 0 1 1
~ -1 0 1 1
Exemplo Cálculo Bit a Bit
Strings
79
Strings
●Concatenação de strings usando o +:
>>> a,b='São','Luís' # a='São' e b='Luís'
>>> a+b+'Cidade do Amor'
'SãoLuísCidade do Amor' # sem espaços entre as palavras.
>>> a+' '+b+' '+'Cidade do Amor'
'São Luís Cidade do Amor'
>>> print(a+' '+b+'\t'+'Cidade do Amor.')
São Luís Cidade do Amor.
Manipulação de Strings,
Concatenação usando o +
80
>>> a+='\t\t‘ 
# equivalente a a=a+'\t\t'
>>> a
'São \t\t'
>>> print(a,'Luís')
São Luís
Strings
● Concatenação de strings usando o operador join:
>>> s1='Bom'
>>> s2='dia'
>>> ' '.join((s1,s2)) # as strings a concatenar são colocadas
'Bom dia' # em uma tupla: (str1,str2,str3,...)
>>> ''.join((s1,s2)) # pois o join aceita apenas 1 parâmetro
'Bomdia' 
>>> ','.join((s1,s2))
'Bom,dia'
>>> ' '.join((s1,s2,'.'))
'Bom dia .'
>>> ' '.join((s1,s2,'Maria.'))
'Bom dia Maria.'
Manipulação de Strings,
Concatenação usando o join
81
# ''.join(('Ana','tem','um','filho.'))
# 'Anatemumfilhoo.'
# aqui o separador especificado é o vazio
>>> ','.join((s1,s2))
'Ana tem um filho.‘
# aqui o separador especificado é o espaço
Strings
●Conversão Lista -> String usando join()
>>> ','.join(['a','b','c','d','e','f','gg','h'])
'a,b,c,d,e,f,gg,h' # converte uma lista em um string
>>> ','.join(['a','b','c']) # ou seja, concatenando os elementos
'a,b,c‘ # de uma lista.
>>> ''.join(['a','b','c'])
'abc'
>>> ' '.join(['a','b','c'])
'a b c'
>>> ' '.join(['a','b','c'])
'a b c'
Operadores de 
Manipulação,
Conversão de uma lista 
para uma string usando o 
join
Ou seja, concatenando os 
elementos de uma lista
82
Strings
●Conversão String <–> Lista 
>>> l=['João','gosta','de','Música']
>>> s=' '.join(l) # criando um string tendo o espaço como 
 # separador
>>> s
'João gosta de Música'
>>> l=s.split() # divide o string em elementos, a cada espaço, 
 # formando uma lista 
>>> l
['João', 'gosta', 'de', 'Música']
Operadores de 
Manipulação
83
Strings
●Conversão String -> Lista usando o Split()
>>> s='São Luís' # A string s é convertida em uma lista l
>>> l=s.split() # pro default, a divisão é feita a cada espaço.
>>> l
['São', 'Luís']
>>> s.split()[0] # Como o split retorna uma lista, então podemos
'São' # é l[0] # acessar seus elementos usando o índice.
>>> 'a,b,c'.split(',') # É possível fazer o split cortando em outros
['a', 'b', 'c'] # caracteres, por exemplo na virgule, basta 
# especificá-lo como parâmetro do split.
>>> 'a*b*cde*f**g'.split('*')
['a', 'b', 'cde', 'f', '', 'g']
Operadores de 
Manipulação: split
84
Strings
●Conversão String <–> Lista 
 >>> s='João gosta de Música'
 >>> s.split() # retorna ['João', 'gosta', 'de', 'Música']
 >>> ' '.join(s.split()) 
 'João gosta de Música'
 
 >>> s.split('de') # retorna ['João gosta ', ' Música']
 >>> 'de'.join(s.split('de'))
 'João gosta de Música'
 # O join pode anular o split e o split pode anular o join,
 # pois os dois realizam operações inversas.
Operadores de 
Manipulação
85
Strings
●Concatenação de strings usando o operador __add__ :
>>> s1='Boa'
>>> s2='Tarde.'
>>> s1.__add__(s2)
'BoaTarde.' # colocados juntos sem espaço no meio.
>>> (s1.__add__(' ')).__add__(s2)
'Boa Tarde.' # aqui um espaço é concatenado no meio
>>> s1.__add__('Tarde!')
'Boa Tarde!'
Manipulação de Strings
86
Strings
●Multiplicação de strings *:
 >>> a*4
 'São São São São'
 >>> 'Aa'*3
 AaAaAa
Manipulação de Strings
87
Strings
●Multiplicação de strings *:
 >>> print(((('Maria'+'\t')*2)+'\n')*5)
Maria Maria
Maria Maria
Maria Maria
Maria Maria
Maria Maria
Manipulação de Strings
88
Strings
>>> len("abcdefg") # tamanho
7
>>> “Sami".startswith("S") # inicia por
True
>>> “Sami".startswith("s")
True
>>> "Sami".endswith("d") # termina por
True
>>> "am" in "Sami“ # substring ?
True
>>> “im" in "Sami"
False
Manipulação de Strings
89
Strings
>>> 'Sofiane'.find('mar') # procura por uma substring dentro de uma string
-1 # retorna a sua posição (posição da 1ª ocorrência)
>>> 'Sofiane'.find('s') # ou -1 se não estiver
-1
>>> 'Sofiane'.find('So')# o parametro do find deve ser uma string
0
>>> 'Sofiane'.find('ane')
4
>>> 'ebgfecdefg'.find('e')
0
>>> 'ebgfecdefg'.find('e',1) # podemos especificar o início da pesq.
4
>>> 'ebgfecdefg'.find('e',1,5) # podemos especificar o interval da pesq.
4 
Manipulação de Strings
90
Strings
>>> s='José Carlos'
>>> s.find('o',s.find('o'))
1
>>> s.find('o',s.find('o')+1)
9
Manipulação de Strings
91
Strings
>>> "abcdefg".index("c")# é a mesma coisa que o find
2 # apenas retorna erro qdo o substring não existe 
>>> "abcdefg".index("x")
...
ValueError: substring not found
Manipulação de Strings
92
Strings
● Os strings são indexados a partir do 0 e podem ser fatiados:
>>> nome='Carla Bruni'
>>> nome[0] # 1° elemento do string
'C'
>>> nome[1] # 2° elemento do string
'a'
>>> nome[2] # 3° elemento do string
'r'
>>> 'Carla Bruni'[-1] # último elemento do string
'i'
>>> 'Carla Bruni'[-2] # penultimo elemento do string
'n'
Slicing/Fatiamento de 
Strings
93
Strings
●Fatiando strings:
>>> nome='Carla Bruni'
>>> nome[2:4] # do 2° índice até o 4° índice (4° não incluso)
'rl'
>>> nome[2:] # do 2° até o fim (último)
'rla Bruni'
>>> nome[:2] # do início até o 2° elemento (2° não incluso)
'Ca‘
>>> 'Carla Bruni'[::] # imprime tudo
'Carla Bruni'
Slicing/Fatiamento de 
Strings
94
Strings
●Fatiando strings:
>>> 'Carla Bruni'[-2:] # do penúltimo até o fim 
'ni'
>>> 'Carla Bruni'[:-2] # do início até o penultimo (este não incluso)
'Carla Bru'
Slicing/Fatiamento de 
Strings
95
Strings
● Fatiando strings:
>>> 'Carla Bruni'[::] # imprime tudo o string
'Carla Bruni'
>>> 'Carla Bruni'[::2] # imprime tudo o string com passo 2
'CraBui'
>>> 'Carla Bruni'[::3] # imprime tudo o string com passo 3
'ClBn'
>>> 'Carla Bruni'[::-1] # imprime tudo o string de tras pra frente
'inurB alraC‘ # reverte o string (a ordem das letras)
>>> 'Carla Bruni'[::-2] # imprime tudo o string com passo -2
'iuBarC‘
>>> 'Carla Bruni'[::-5] # retorna a lista de elementos de tras pra frente com passo 
'i C‘ # retorna a lista de elementos com passe -5
>>> 'Carla Bruni'[1:8:-5] # não funciona
'‘
>>> 'Carla Bruni'[8:1:-5] # o 5° e o 3° elemento
'ul'
Slicing/Fatiamento de 
Strings
96
Strings
● Inversão de strings:
>>> s
'Carla Bruni'
>>> s=s[::-1] # equiv. a s.reverse()
>>> s
'inurB alraC'
Operadores de 
Manipulação
97
Strings
●Outras operações de strings:
>>> 'ABCD'.lower() # converte tudo para minúsculos
abcd
>>> 'abcd'.upper() # converte tudo para maiúsculos 
ABCD
>>> 'AbcD'.swapcase()# altera maiúsculos/minúsculos
aBCd
Operadores de 
Manipulação
98
Strings
● Checar se uma palavra/texto é em maiúsculo ou minúsculo:
>>> 'SOFIANE'.isupper() 
True 
>>> 'Sofiane'.isupper() 
False
>>> 'Brasil'.islower()
False
>>> 'brasil'.islower()
True
>>> s.upper().isupper()
True
>>> 'São Luís, Ilha Do Amor!'.istitle() # veridical se é um title
True
Operadores de 
Manipulação
99
Strings
●Checar o conteúdo de uma palavra/texto é alfanumérica:
>>> 'a5 abc 3'.isalnum() # não deve conter um caractere especial
# nem o espaço.
>>> 'a5abc3'.isalnum()
True
>>> '245'.isdigit() # verifica se a string contém apenas números
True
>>> '24.5'.isdigit()
False
>>> 'abc21'.isalpha()# verifica se a string é composta por apenas letras
False
>>> 'abc'.isalpha()
True
Operadores de 
Manipulação
100
Strings
●Checar se só há espaços na string:
>>> ‘>>>>> ''.isspace()
False
>>> ' '.isspace()
True
>>> ' '.isspace()
True
>>> ' e '.isspace()
False
Operadores de 
Manipulação
101
Strings
●Adicionando espaços na string:
>>> ‘>>>>> 'Karen'.ljust(10) # alinhamento à esquerda
'Karen '
>>> 'Karen'.rjust(10) # alinhamento à direita
' Karen'
>>> 'Karen'.center(10) # centraliza o texto 
' Karen '
Operadores de 
Manipulação
102
Strings
●Os espaços de alinhamento podem ser espalhados a direita e 
esquerda da string:
>>> ‘>>
 >>> 'Karen.'.rjust(15).strip()
 'String.'
 >>> 'Karen.'.ljust(15).rstrip()
 'String.'
Operadores de 
Manipulação
103
Strings
●Outras operações de strings: Eliminando caracteres brancos
>>> ' abcd e fgh '.lstrip() # Elimina os caracteres em branco 
'abcd e fgh ' # do lado esquerdo
>>> ' abcd e fgh '.rstrip() # Elimina os caracteres em branco
' abcd e fgh‘ # do lado direito
>>> ' abcd e fgh '.strip() # Elimina os caracteres em branco
'abcd e fgh‘ # dos lados direitro e esquerdo
Operadores de 
Manipulação
104
Strings
●Outras operações de strings:
>>> s='PARIS cApital da frança'
 
>>> s.lower()
'paris capital da frança'
>>> s
'PARIS cApital da frança'
>>> s.lower().capitalize() # coloca a 1ª letra em maiúsculo
'Paris capital da frança‘
>>> s.title() # transforma a 1ª letra de cada
'Paris Capital Da França' # palavra em maiúsciulo
Operadores de 
Manipulação
105
Strings
●Outras operações de strings:
>>> 'Carla Bruni'.replace(' ',' - ')
'Carla - Bruni'
>>> s='Olá Carla!'
>>> s.replace('Carla','Lucas')
'Olá Lucas!'
Operadores de 
Manipulação
106
Strings
●Strings são imutáveis:
>>> nome='Caren'
Imagina que digitamos o nome de Caren com C e que precisamos 
corrigir para Karen (trocando C por K).
Intuitivamente, íamos executar o seguinte comando:
>>> nome[0]='K'
 isto gera erro, pôs as strings no python são imutáveis.
A solução é de criar uma nova string:
>>> novonome='K'+nome[1:]
>>> novonome
'Karen'
Operadores de 
Manipulação
107
Strings
●Strings são imutáveis:
>>> a = '20' # o string é um conjunto imutável
>>> id(a) # ao mudar o seu conteúdo, o identificador
103936544 # muda também.
>>> a= 'Olá'
>>> id(a)
1868623968
>>> a='Maria'
>>> id(a)
103937920
Operadores de 
Manipulação
108
Strings
●Comparando Strings
>>> 'Fortaleza'<'Salvador'
True
>>> 'Bahia'!='Pernambuco'
True
>>> 'Maranhão'>='Maranhão'
True
if Cidade_Nascimento'== 'São Luís' :
print(' Você é Ludovicense')
Operadores de 
Manipulação
109
Strings
● Iterando/Percorrendo um String
>>> for letra in 'Lucas':
print(letra)
L
u
c
a
s
>>>
Operadores de 
Manipulação
110
Strings
● Iterando/Percorrendo um String
>>> s='Fruta'
>>> i=0
>>> while i<len(s):
c=s[i]
print(c)
i+=1
F
r
u
t
a
Operadores de 
Manipulação
111
Strings
● O comando chr imprime o caractere correspondente ao código 
ascii passado como parâmetro:
>>> chr(42)
'*' 
>>> chr(97)
 'a'
>>> chr(123)
 'z'
>>> chr(65)
 'A‘
>>> chr(91)
 ' Z'
chr
112
Strings
● Imprime as letras do alfabeto:
>>> for i in range(97,123): # 97=a 123=z
print(chr(i),end=' ')
a b c d e f g h i j k l m n o p q r s t u v w x y z
>>> for i in range(65,91): # 65=A 91=Z
print(chr(i),end=' ')
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 
chr
113
Strings
● Imprime as letras do alfabeto (outro método):
>>> [chr(x) for x in range(97,123)]
['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
 'r','s','t','u','v','w','x','y','z']
# gerar uma lista
>>> {chr(x) for x in range(97,123)}
{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
 'r','s','t','u','v','w','x','y','z‘}
# gerar um set (conjunto)
chr
114
Strings
● Imprime as letras do alfabeto (mais um método):
 >>> l=map(chr,list(range(65,91)))
>>> for i in l:
print(i,end=' ')
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 
chr
115
Tipos
● Tipos simples - constituídos por simples blocos, como int() e float().
● Tiposde contêiner - objetos capazes de conter outros objetos.
● Tipos de código - objetos encapsuladores de elementos dos 
programas.
● Tipos internos - tipos que serão utilizados durante a execução dos 
programas.
Classificação
116
Tipos
● Outros tipos:
lista - para agrupar um conjunto de elementos, mas que tem 
 ordem.
tupla - semelhante ao tipo list, porém, imutável.
dic - para agrupar elementos que serão recuperados usando
 uma chave. 
set - conjunto de valores.
conjuntos
117
Atribuições
118
Atribuições
>>> a=3.0 # A atribuição é feita usando o símbolo =
>>> a
3.0
 
>>> b=a-1 
>>> b
2.0
Variáveis
119
Atribuições
>>> nome="Lucas" # os strings devem ser colocados 
>>> nome # entre aspas simples ou duplas
'Lucas'
>>> bairro='Calhau'
>>> bairro
'Calhau' 
Strings
120
Atribuições
>>> a,b,c=3,2,4 # A atribuição pode ser feita em série
 # I.e. Atribuição de valores a várias 
 # variáveis de uma vez só 
 # isto é feito de forma sequencial
>>> a 
3
>>> b
2
>>> c
4
>>> a,b,c
(3,2,4)
Atribuição em série
121
Atribuições
Uma Reflexão:
>>> a=2
>>> a,b=4,a+1
# Qual será o valor de a (2 ou 4) e de b (3 ou 5) ?
>>> a
?
>>> b
?
Variáveis
122
Atribuições
● Exercício
Faça o programa swap de troca entre duas variáveis.
>>> a,b=4,6
>>> a,b
(4,6)
>>> a,b=b,a
>>> a,b
(6,4)
Exercício de Swap
123
Atribuições
a=a+b 
 a+=b
a*=6
a=a*6
Essas duas expressões são equivalentes!
Abreviações
124
Atribuições
None é o equivalente ao valor nulo (null)
Uma variável pode ser iniciada com um valor nulo
>>> nome=None (N deve ser escrito em maiúsculo e sem aspas)
>>> nome
>>>
None
125
Saídas
126
Saídas
Comando print
127
a=2
b=3
print('A soma de ',a,' com ',b,' é: ',a+b)
A soma de 2 com 3 é: 5
Saídas
print
128
a=2
b=3
print(a,b)
# é possível ter duas ou mais saídas no mesmo print
2 3
Saídas
a=8
b=6
print('A soma é: \n',a+b)
Print(‘\n\n') # pula duas linhas
print('A diferença é: ',a-b)
A soma é: 
14
A diferença é: 2
\n
129
Saídas
>>> idade=28
>>> nome="Lucas"
>>> print("Seu nome é %s e sua idade é %d"%(nome,idade))
Seu nome é Lucas e você tem 28 anos.
%s é uma lacuna que é preenchida por cada variável da lista na 
ordem que elas nela se apresentam.
O % é usado para separar a mensagem com a máscara dos valores 
que são colocados entre parênteses.
Formatação com o %
130
Saídas
● Impressão por formatação:
>>> nome='João'
>>> sobrenome= 'Alberto'
>>> print("%s %s"%(nome,sobrenome))
João Alberto
Formatação com o %
131
Saídas
● Impressão por formatação:
Formatação com o %
132
Expressão Significado
%s String
%c Caractere
%d Inteiro
%f Real (float)
%e Notação Científica (e)
%% um %
Saídas
● Formatação de número (%d %f %e):
>>> '%6d'%25
' 25'
>>> '%-6d'%25 # com um número negativo, os caracteres brancos
'25 ' # são adicionados do lado direito.
>>> '%13f'%25
' 25.000000'
>>> '%10.2f'%25
' 25.00'
>>> '%-10.2f'%25
'25.00 '
>>> '%-10.2e'%25
'2.50e+01 '
>>> '%10.2e'%25
' 2.50e+01‘/
Formatação com o %
133
>>> '%5.2f'%20
 
'20.00'
>>> '%10.2f'%20
' 20.00'
>>> '%-10.2f'%20
'20.00 '
>>> '%-10.2e'%20
'2.00e+01 '
Saídas
● Impressão por formatação:
>>> pi=3.141592653589793
>>> print("%f"%pi) # os () são opcionais no caso 
 >>> print("%f"%(pi)) # onde há apenas uma variável
3.141593
>>> print("%6.3f"%pi)
3.142
>>> print("%6.2f"%pi)
3.14
Formatação com o %
Uso das ()
134
Saídas
● Formatação usando a notação científica:
 >>> x = 300000
 >>> y = 0.00003
 print('Número grande %.2e\nNumero pequeno %.2e'%(x, y))
 
 # Numero grande 3.00e+05
 # Numero pequeno 3.00e-05
Formatação com o %
%e
135
Saídas
● Formatação usando a notação científica:
>>> print("%e"%10000)
1.000000e+04
>>> print("%e"%(10000))
1.000000e+04
>>> print("%2e"%(10000))
1.000000e+04
>>> print("%.2e"%(10000))
1.00e+04
>>> print("%.0e"%(10000))
1e+04
Formatação com o %
%e
136
Saídas
● Caracteres não imprimíveis:
 
\
137
Simbolo Efeito 
\n New line
\t Tab
\\ \
\x41 'A' (caractere com código hexadecimal é 41)
\’ ’ 
\” “
Saídas
● Caracteres não imprimíveis:
 
print('Sofiane\tLabidi\nCarla\tBrune')
print('Cesar\tMaia')
Print('\\')
Sofiane Labidi
Carla Brune
Cesar Maia
\
\
138
Saídas
● Caracteres não imprimíveis:
 
>>> print('\x27')
'
>>> print('\x28')
(
>>> print('\x29')
)
>>> print('\x30')
0
>>> 
\x
139
Saídas
● É possível desabilitar os efeitos da \ colocando na frente da 
expressão a letra r:
 
>>> print(r'Sofiane\nLabidi')
Sofiane\nLabidi
>>> 
r
140
Saídas
● É possível escrever um texto comprido em várias linhas desde que 
se coloque uma barra invertida no final de cada linha:
 
>>> print('São Luis\tCaxias\n\
 Imperatriz\n\
 Balsas')
São Luís Caxias
Imperatriz
Balsas
>>> 
\
141
Saídas
● É possível fazer a mesma coisa delimitando o texto em três aspas (simples ou 
duplas)
● A saída imprime tudo igual!
 print("""
 Maria
 Joao
 Carlos
 Roberta\n""")
print('''
 Maria
 Joao
 Carlos
 Roberta\n''')
’’’ ’’’ 
3 aspas (duplas ou 
simples) 
142
Maria
Joao
 Carlos # afastado
 Roberta
 Maria
 Joao
 Carlos # afastado
 Roberta
>>> 
Saídas
● Usamos as aspas triplas também para poder imprimir aspas:
 >>> print(''' ' ''')
 ' 
 
 >>> print('''a ' b''')
 a ' b
 >>> 
 
’’’ ’’’ 
3 aspas (duplas ou 
simples) 
143
Saídas
● Testando se uma string é vazia ou preenchida?
 Se a string é vazia o operador bool retorna falso.
 
 >>> bool('aabb')
 True
 
 >>> bool('a')
 True
 >>> bool('')
 False
 
 >>> bool("")
 False 
Vazia ou Preenchida? 
144
 s='aaabbb'
 If s:
 print(‘String preenchido')
If not s:
 print(‘String vazio!')
Saídas
● .format()
● Formatação moderna, usada a partir da versão Python 2.6
● O uso do operador % para formatação de saídas deve deixar de existir nas 
próximas versões do Python.
● O % é substituído por {}
 >>> a,b=4,5
 >>> a,b
 (4, 5)
 
 >>> print('O valor de a é {} e o valor de b é {}'.format(a,b))
 O valor de a é 4 e o valor de b é 5 
 
Formatação Moderna: 
.format
145
Saídas
● format()
 A lista das variáveis no .format é indexada, a partir do zero. Portanto, 
 podemos usar os índices para indicar as variáveis nas lacunas (as {})
 
 >>> print('{0} gosta de {1}.'.format('Maria','Lucas'))
 Maria gosta de Lucas. # usando índices 
 # Maria tem índice 0 e Lucas tem índice 1
 
 >>> print('{1} gosta de {0}.'.format('Maria','Lucas'))
 Lucas gosta de Maria. # observe que aqui a ordem foi alterada
.format (usando os 
índices)
146
Saídas
● .format()
É possível usar referentes (apelidos) dentro da formatação e 
usá-los em lugar dos índices. 
 
 >>> print('Este {objeto} é {adjetivo}.'.format(objeto='Relógio',adjetivo='muito caro') 
 Este Relógio é muito caro. # usando referentes (apelidos)
 .format usando referentes 
ou apelidos
147
Saídas
● .format()
 >>> a,b=2,4
 >>> print('A soma de {0} com {1} é {2}'.format(a,b,a+b))
 A soma de 2 com 4 é 6 # usando a posição na sequencia 
 >>> print('A soma de {a} com {b} é {sm}'.format(a=a,b=b,sm=a+b))
 A soma de 2 com 4 é 6 # usando os apelidos
 >>> print('A soma de {a} com {b} é {sm}'.format(a=a,b=b,sm=a+b))
 A soma de 2 com 4 é 6 # podemos trocar a posição dos apelidos no 
.format
 
 >>> print('A soma de {e} com {f} é {sm}'.format(e=a,f=b,sm=a+b))
 A soma de 2 com 4 é 6 # usando nomes de apelidos diferentes
 # dos nomes das variáveis 
 .format usando referentes 
ou apelidos
148
Saídas
● A formatação pode ser separada (colocada em uma variável de tipo 
string)
 >>> s= 'O filme {0} do autor {1} merece {2} estrelas' 
 >>> s.format('O Fugitivo','Harrsisson Ford', 4) 
 'O filme O Fugitivo do autor Harrisson Ford merece 4 estrelas' 
.format
149
Saídas
>>> import math
>>> math.pi
3.141592653589793
>>> print('O valor de PI é aproximadamente {0:.3f}.'.format(math.pi))
O valor de PI é aproximadamente 3.142. # indica 3 dígitos após a 
vírgula
>>> print(f'O valor de PI é aproximadamente {math.pi:.3f}.')
Os f-strings
150
Saídas
>>> idade=28
>>> nome="Carla"
>>> print("{0:10} - {1:5}".format(nome,idade))
Carla - 28
# 10 caracteres p Carla e 5 dígitos p 28
>>> >>> print("{0:10} - {1:5.2f}".format(nome,idade))
# f para saída flutuante, e para saída em notação científica 
(2.8e+01), e d para decimal (inteiro: sem vírgula) 
.format
151
Saídas
● Outro recurso para Formatação
● f
>>> a=10
>>> f 'O dobro de {a} é {2*a}' # aspa simples ou dupla
O dobro de 5 é 10 # pode usar o print
f-strings
152
Saídas
Interpolação de strings
nome='João'
peso=48.5 # escreve na tela: João você pesa 48.50 kilos.
print(nome,'você pesa',peso,'kilos.') #1º formato de saída
print('%s você pesa %f kilos.'%(nome,peso)) #2º formato de saída: %
print('%s você pesa %.2f kilos.'%(nome,peso))
print('{} você pesa {} kilos.'.format(nome,peso)) #3º formato de saída: .format
print('{0} você pesa {1} kilos.'.format(nome,peso))
print('{0} você pesa {1:.2f} kilos.'.format(nome,peso))
#print('{1} você pesa {0} kilos.'.format(nome,peso))
print(f'{nome} você tem {peso:.2f} kilo.') #4º formato de saída: f
print(f'{nome:20} você tem {peso:.2f} kilo.')
exemplo
153
Saídas
sep O valor padrão de sep é um espaço em branco, quando dois ou mais 
argumentos são passados para a função print sep coloca entre eles um 
espaço em branco ou um outro valor que podemos passar para sep.
end O valor padrão de end é uma nova linha “\n” e por isso que sempre a função 
print adiciona uma nova linha depois de imprimir tudo que lhe foi passado, 
mas, podemos definir outro valor com uma tabulação “\t” por exemplo.
file Este é o padrão que define onde será impresso os argumentos passados para 
print. Seu valor padrão é definido por sys.stdout, o fluxo de saída padrão que 
normalmente é o terminal. Podemos alterar esse valor para especificar um 
arquivo por exemplo.Configurações end sep e 
file
154
# o print tem 3 parâmetros: 
# sep (o separador, por default é o espaço), 
# end (o fim da linha, por default é o \n) e
# file (o arquivo de saída, por default é o stdout).
# mas isto pode ser alterado a critério!
Saídas
>>> a,b,c=10,20,30
>>> print(a,b,c,sep='***',end='...\n')
10***20***30...
>>> 
Configurações end sep e 
file
155
Entradas
156
Entradas
input
● Para leitura de dados a partir do teclado, usaremos a função input.
>>> nome= input("Digite seu nome: ")
Digite seu nome: Sofiane
>>> nome
'Sofiane'
>>> 
157
Entradas
• A função input retorna um string.
• Para leitura de uma inteiro ou real, é preciso fazer uma conversão 
usando o int ou o flaot.
>>> idade= int(input("Digite sua idade: "))
Digite sua idade: 28
>>> idade
28
input
158
Entradas
• A função eval permite de avaliar uma expressão dada como 
entrada.
>>> eval(input("Digite uma expressão: "))
 
Digite uma expressão: 8+3
11
>>>
Muito cuidado com o uso do comando eval!
eval
159
Entradas
• Observação:
Na versão 2, o Python usa a função raw_input para entrada de dados. 
Na sua versão 3 o Python usa o input.
Há uma forma de detectar a versão do python que está sendo usada:
>>> import sys
>>> sys.version_info.major
3
version_info.major
160
Entradas
• Observação:
import sys
if sys.version_info.major == 2:
 usuario = raw_input('Insira seu login: ')
elif sys.version_info.major == 3:
 usuario = input('Insira seu login: ')
Input / raw_input ?
161
Entradas
● É possível ler várias variáveis na mesma linha, graças ao 
comando split: input().split()
 >>> e,f=input("Entra com dois números: ").split()
 Entra com dois números: 25 10
 >>> e
 '25'
 >>> f
 '10'
 >>> e,f
 ('25','10 ')
split
162
Entradas
● Por default, o separador é o espaço, mas isto pode ser alterado 
(especificado):
 >>> a,b,c=input("Entra com três nomes: ").split('--')
 Entra com três nomes: Carlos--Maria--Lucas
 >>> a
 'Carlos'
 >>> b,c
 ('Maria', 'Lucas')
split
163
Entradas
● # Quando a entrada não é de tipo string, é preciso fazer a 
conversão!
 >>> idade=int(input("Qual é sua idade: "))
 >>> peso=float(input("Qual é seu peso: "))split
164
Entradas
• Exercício 1:
Faça o programa Python que leia a temperatura ambiente em 
graus Celsius e a converte em graus Fahrenheit, e 
vice versa.
Exercício
165
Entradas
Celsius Fahrenheit
0 32
15 59
-8.89 16
Exercício
166
Usa a calculadora do Windows para verificar as conversões de temperaturas
Ou este site:
https://www.metric-conversions.org/pt-br/temperatura/celsius-em-fahrenheit.htm
C/5 = (F-32)/9
Entradas
# C/5 = (F-32)/9
# Celsius para Fahrenheit
C=float(input("Qual é a temperatura (em graus Celsius): "))
F=9/5*C+32
print(F)
print() # pula uma linha
# Fahrenheit para Celsius
F=float(input("Qual é a temperatura (em graus Fahrenheit): "))
C=5/9*(F-32)
print(C)
Print(f)
print('A temperatura %5.2f em graus Celsius é equivalente a %5.2f em graus 
Fahrenheit'%(C,F))
167
Controle Condicional
168
Controle 
Condicional
• A construção if de controle condicional:
if <condição>:
<expressão 1>
elif <condição 2>:
<expressão 2>
else:
<expressão 3>
if
169
if
# idade=18
idade=int(input('Informa sua idade: '))
if idade<20:
 print("Você é jovem! ")
170
If-else
idade=int(input('Informa sua idade: '))
if idade>=18:
 print("Você é Maior de Idade! ")
else:
 print("Você é Menor de Idade! ")
171
If-elif-else
hora=int(input('Informa a hora: '))
if hora<11:
 print('Bom dia! ')
elif hora<17:
 print('Boa tarde')
else:
 print('Boa noite! ')
172
If-elif-else
idade=int(input("Informa sua idade pfvr: "))
if idade<12:
 print("Criaca!")
elif idade<15:
 print("Pre Adolescente")
elif idade<17:
 print("Adolescente")
elif idade<25:
 print("Jovem")
elif idade<60:
 print("Adulto")
else:
 print("Idoso")
173
Entradas
h,m=input('Informa a hora: ').split(':')
h=int(h)
m=int(m)if h<6:
 print('Boa madrugada')
elif h<12:
 print('Bom dia!')
elif h<17:
 print('Boa tarde')
else:
 print('Boa noite!')
Exercício
174
Entradas
• Exercício 2:
Faça o programa Python que resolve uma equação de 1º grau.
ax+b=0
Exercício
175
ax+b=0
Entradas
a=float(input('Digita o valor de a: '))
b=float(input('Digita o valor de b: '))
if (a==0):
 if (b==0):
 print('IR')
 else:
 print('Impossível!')
else:
 x = -b/a
 print('A solução é:',x)
 print('A solução é: %.2f'%x)
 print('A solução é: {:.2f}'.format(x))
 print(f'A solução é: {x:.2f}')
split
176
Entradas
#a,b=input().split()
a,b=input('Entra com dois número: ').split() # na mesma linha, separados 
# por um espaço
a=float(a)
b=float(b)
print('Raiz da equação {0:.2f}x+{1:.2f}=0 é {2:.2f}'.format(a,b,-b/a))
print(f'Raiz da equação {a:.2f}x+{b:.2f}=0 é {-b/a:.2e}')
# de dois formatos f e .format()
Entra com dois número: 2 -1
Raiz da equação 2.00x+-1.00=0 é 0.50
Raiz da equação 2.0x+-1.0=0 é 5.00e-01 # e para notação científica
split
177
Estruturas de Repetição
178
Repetição
• A expressão for é utilizada para percorrer listas, 
sequencias e realizar processos iterativos:
for <referência> in <sequencia>:
<bolco de expressões>
continue
break
else:
<bolco de expressões>
for
179
Repetição
for <thing> in <list of things>:
 #
for i in range(3):
print(i)
0
1
2
3
for
180
Repetição
• Exp:
>>> lista=[1,2,3] 
>>> for i in lista: 
 Print(i)
 
1 
2 
3 
>
for
181
Repetição
• A função range(m, n, p) define uma sequencia de inteiros 
iniciada em m, menor do que n (ou maior, depende da 
direção da sequencia), a um passo p (podendo ser 
negativo):
>>> for i in range(1,10,2): 
... print i 
... 
1 
3 
5 
7 
9
range
182
Repetição
• While
while<condição>:
<bloco de expressões>
continue
break
else:
<bloco de expressões>
while
183
Repetição
• Exemplo:
>>> a=0 
>>> while a<5: 
... print(a) 
... a+=2 
... 
0 
2 
4
while
184
Repetição
• Exercício:
• Imprima a série de fibionacci até 50.
 
Fib(0)=1
Fib(1)=1
Fib(n)=fib(n-1)+fib(n-2)
 1 1 2 3 5 8 13 21 34 55 88 143 231 … 
 
Exercício
185
Repetição
• Fibionacci
>>> a,b = 0,1
>>> while b < 50:
print(b,end=' - ')
a, b = b, a+b
1 - 1 - 2 - 3 - 5 - 8 - 13 - 21 - 34 - 
Exercício
186
Repetição
• Se tiver 2 for aninhados, o break só termina o laço onde ocorre, o laço externo a 
ele continua normalmente:
x = [1,3,5,7]
for i in x:
 k = i+1
 
 for n in range(10):
 if n > i:
 print(n,"é maior que",i)
 break
 
print(k)
break
187
2 é maior que 1
4 é maior que 3
6 é maior que 5
8 é maior que 7
8
>>>
Repetição
x = [1,3,5,7]
for i in x:
if i > 3:
 print(i+1)
 break
else:
 print('acabou')
Saída:
6
break
188
Repetição
x = [1,3,5,7]
for i in x:
if i > 3:
 print(i+1)
else:
 print('acabou')
break
189
Saída:
6
8
acabou
Funções
190
Funções
import math
def areacirculo(raio):
return math.pi*raio**2
>>> areacirculo(10)
314
191
Funções
import math
def areac(r):
 return math.pi*r**2
raio=int(input('Qual é o raio do círculo: '))
print(f'Área do círculo de raio {raio} é {areac(raio):.2f}')
Qual é o raio do círculo: 10
Área do círculo de raio 10 é 314.16
192
Funções
●Sempre que o compilador encontra uma atribuição a um 
nome/variável dentro de uma função, ele assume que tal 
nome/variável é local em toda a função, não importando onde 
a atribuição ocorre.
Variáveis locais vs globais
193
Funções
Variáveis locais vs globais
194
def f1():
 print(x) # ok(global) 10
def f2():
 print(x) # erro (local)
 x=1 
# essa atribuição a torna local
 
def f3():
 x=1
 print(x) # ok (local) 1
def f4():
 global x
 print(x) # ok 10
def f5():
 global x
 x=1
 print(x) # ok 1
x=10
f1() # 10
#f2() # erro
f3() # 1 
print(x) # 10 (não foi alterado)
f4() # 10
print(x) # 10 global
f5() # 1
print(x) # 1
# saídas: 10 1 10 10 10 1 
1
Funções
● Variáveis globais não são aconselhados no Python, pois tornam o 
código mais difícil de ler e modificar podendo levar a bugs difíceis 
de serem encontrados.
● É por isso que o Python força o programador a explicitar suas 
variáveis globais quando quiser alterá-la fora do escopo global. .
Variáveis locais vs globais
195
Funções
●Função que procura um caractere em uma string:
def achar(c,s):
 i = 0
 while i < len(s):
 if s[i] == c:
 return i
 i+=1
 return -1
Exercícios
196
>>> achar('a','Sofiane')
True
>>> achar('b','Sofiane')
False
Funções
●Função que procura um caractere em uma string:
def achar (c,s):
 i=0 # p é a posição da 1ª ocorrência do caractere c na string s
 p=-1 # retorna -1 e falso se não existe.
 achei=False
 while (i<len(s)) and (not achei):
 if s[i]==c:
 achei=True
 p=i
 
 i+=1
 return(achei,p)
Exercícios
197
>>> achar('a','Sofiane')
(True,4)
>>> achar('b','Sofiane')
(False,-1)
Funções
●Função que retorna o número de ocorrências de um caractere 
em uma string:
def contar(c,s):
 contador = 0
 for letra in s:
 if letra == c:
 contador +=1
 
 return(contador)
Exercícios
198
>>> fruta = 'banana'
>>> contar('n',fruta)
2
Funções
●Procedimento que retorna número de letras e de palavras em uma 
frase de tipo string:
def frase(f):
 cc,cp=0,0
 for palavra in f.split():
 cp+=1
 for letra in palavra:
 cc+=1
 print(f'Palavras: {cp} Caracteres: {cc}')
# return(cp,cc) # a,b=frase('Boa noite') # (2,8)
Exercícios
199
>>> frase('Maria Adora Cinema e 
Futebol.')
Palavras: 5 Caracteres: 25
Funções
●Função que verifica se um caractere é minúsculo ou não:
●Há várias formas de fazer:
def eMinusculo(ch):
 return 'a' <= ch <= 'z'
Exercícios
200
>>> eMinusculo('B')
False
>>> eMinusculo('a')
True
Funções
●As rotinas Python podem ou não retornar um valor. É o 
que faz a diferença entre procedimento e funções.
●Diferentemente de várias linguagens, as funções Python 
podem retornar vários valores.
Procedimento
201
Coleções de Dados
Coleções Sequenciais de Objetos
202
Strings, Listas, 
tuplas, Sets e 
Dicionários
● Listas. Os elementos de uma lista são colocados em sequência e para cada um 
deles é determinado um índice numérico.
a = [] b=[5,3,6,1] # estrutura homogênea
● Tuplas. Funciona da mesma forma que listas, mas os elementos são imutáveis 
(seus elementos não podem ser alterados).
a = (1,2,3) # estrutura heterogênea
● Dicionários. Os índices dos dicionários não precisam ser numéricos.
a {‘teste’ : ‘teste_cont’}
● Listas e Tuplas são estruturas indexadas.
● Dicionários e Sets são estruturas não indexadas.
203
Coleções de 
Dados
● Coleções são estruturas de dados sequenciais de objeto:
● No Python destacamos os:
● Strings. Compostas por caracteres, e
s=‘Maria de FAtima’
● Listas formados por elementos de qualquer tipo.
lst=[2,'b',4,56,'cde']
● A diferença é que as listas são mutáveis (seus elementos podem ser 
alterados)e os strings são imutáveis (os caracteres de uma string não 
podem ser alterados).
Strings, Listas, Tuplas, 
Sets e Dicionários
204
Listas
 # É um conjunto de elementos heterogêneos e ordenados.
>>> lista1=[] # lista vazia
>>> lista1
[]
>>> lista2=[6,8,'Carla',10.5,False] # estrutura heterogênea
>>> lista2
[6,8,'Carla',10.5,False]
>>> lista=list(range(5))
[0,1,2,3,4]
>>> lista = [x*2 for x in range(8)]
[0,2,4,6,8,10,12,14]
Construção
205
Strings ● [x for x in range(100) ]
● [x for x in range(100) if x % 4 == 0]generators
206
Listas
●O comando list cria uma lista a partir de uma série de 
argumentos:
 >>> lista1=list(range(5)) # 5 elementos (de 0 a 4)
 [0,1,2,3,4]
 
 >>> lista2=list(range(1,10,2)) # de 1 a 10 com passo 2
 [1,3,5,7,9]
Construção: operador list
207
Listas
●O comando list cria uma lista a partir de uma série de 
argumentos:
 >>> lista1=list(range(5)) # 5 elementos (de 0 a 4)
 [0,1,2,3,4]
 
 >>> lista2=list(range(1,10,2)) # de 1 a 10 com passo 2
 [1,3,5,7,9]
Construção: operador list
208
Listas
● Listas aninhadas:
>>> lista=[6,'d',[10,8],5]
>>> lista=[[5,4,8],[1,6,10,2,5,5,7]]
Listas aninhadas
209
Listas
 # Acessando os elementos de uma lista usando o índice:
>>> lista=[25, 10, 2, 34] 
>>> lista
[25, 10, 2, 34]
>>> lista[0] # 1º elemento da lista.
25
>>> lista[1] # 2º elemento da lista.
[10]
>>> lista[2]*4
8
>>> lista[-1] # último elemento da lista 
[10]
Acessando pelo índice
210
Listas
● Inicialização de Listas
>>> tamanho = 10 
>>> lista = [0] * tamanho 
>>> lista 
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
211
Listas
● Multiplicação de Listas
lista * n equivale a lista + lista + ... + lista (n vezes) 
>>> lista = [1,2,3] 
>>> lista * 3 
[1,2,3,1,2,3,1,2,3]
212
● Ler notas de alunos
213
Listas
● Criação de Listas
>>> n=7
>>> lista = [] 
for i in range(2,n+1,2): 
 lista = [i] + lista 
>>> print(lista)
[2,4,6]
214
Listas
●Podemos gerar cópias (clones) de uma lista de várias formas. O 
comando is verifica se duas listas são equivalentes (mesma 
referência e portanto o mesmo conteúdo) i.e. com o mesmo id:
Cópia de Lista: clone
Operador is
215
>>> l1=[1,2,3,4,5,6]
>>> l2 = l1
>>> l2
[1, 2, 3, 4, 5, 6]
>>> l2 is l1
True
>>> l1 is l2
True
# listas equivalentes
>>> l1=[1,2,3,4,5,6]
>>> l3 = l1[:] # cria um clone l3 de l1
>>> l3 is l1
False
>>> l1 is l3
False
# listas com mesmo conteúdo, porém 
# com referências diferentes
Listas
●Podemos também gerar clones de uma lista copiando uma fatia 
da lista original:
 >>> a=[20,21,22,23,24]
 >>> b=a[:] # cria um clone (b) da lista toda.
 >>> b
 [20,21,22,23,24]
 >>> a==b # b e a são iguais (de conteúdo).
 True
 >>> a is b # mas não são idênticos (de endereço/referência).
 False # elas têm um id diferente.
Cópia de Lista: clone
Operador is
216
Listas
 >>> a=[20, 21, 22, 23, 24]
 >>> b=a[:]
 [20, 21, 22, 23, 24]
 >>> a[1]=31 # a alteração de um elemento na lista
 >>> a # original não se repercute na lista clone.
 [20, 31, 22, 23, 24] # as duas listas têm ids diferentes.
 >>> b
 [20, 21, 22, 23, 24]
 >>> a==b
 False
 >>> a is b
 False
Cópia de Lista: clone
Operador is
217
Listas
>>> nome='arara'
>>> nome2=nome[::-1]
>>> nome1
'arara'
>>> nome2
'arara'
>>> nome1==nome2
True
>>> nome2 is nome1
False
>>> [1,2,3,4,5,6,7,8][2:5]
[3,4,5]
Cópia de Lista: clone
Operador is
218
Listas
●Mas:
 >>> a=[20, 21, 22, 23, 24]
 >>> b=a # e não b=a[:]
 [20, 21, 22, 23, 24]
 >>> a[1]=31 # a alteração na lista original se repercute 
 >>> a # na nova lista.
 [20, 31, 22, 23, 24] # as duas listas têm ids iguais.
 >>> b
 [20, 31, 22, 23, 24]
 >>> a==b
 True
 >>> a is b
 True
Cópia de Lista: clone
Operador is
219
Listas
>>> a=[1,2,3,4]
>>> b=['a','b']
>>> a[2]=b
>>> a
[1, 2, ['a', 'b'], 4]
Cópia de Lista: clone
Operador is
220
Listas
>>> a=[1,2,3,4]
>>> b=['a','b']
>>> a[2:2]=b
>>> a
[1, 2, 'a', 'b', 3, 4]
>>> a=[1,2,3,4]
>>> a[2:3]=b
>>> a
[1, 2, 'a', 'b', 4]
>>> a=[1,2,3,4]
>>> a[2:4]=b
>>> a
[1, 2, 'a', 'b']
Cópia de Lista: clone
Operador is
221
>>> a=[1,2,3,4]
>>> a[2:5]=b
>>> a
[1, 2, 'a', 'b']
>>> a=[1,2,3,4]
>>> a[2:6]=b
>>> a
[1, 2, 'a', 'b']
>>> a=[1,2,3,4]
>>> a[2:]=b
>>> a
[1, 2, 'a', 'b']
Listas
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> x[:0] = y # inserção/concatenação a esquerda
>>> x
[4, 5, 6, 1, 2, 3]
>>> x=[1,2,3]
>>> x[0:]=y
>>> x
[4, 5, 6]
Cópia de Lista: clone
Operador is
222
Listas >>> x[:] = []
# apaga o conteúdo de uma listaCópia de Lista: clone
Operador is
223
Listas
>>> x=[1,2,3]
>>> id(x)
103175032
>>> y=x # clone
>>> id(y)
103175032
>>> z=x[:] # clone
>>> z
[1, 2, 3]
Cópia de Lista: clone
Operador is
224
>>> id(z)
103318112
>>> z is x
False
>>> y is x
True
# y é uma copia idêntica
# z não é (apenas de conteúdo)
Listas
>>> x = [1, 2, 3]
>>> y=x
>>> id(x)
101864432
>>> x[:]=[]
>>> x
[]
>>> y
[]
>>> id(x)
101864432
Cópia de Lista: clone
Operador is
225
>>> x is y
True
>>> y is x
True
Listas
>>> a=list(range(10,14))
>>> a
[10, 11, 12, 13]
>>> a[2:]=['a','b','c']
>>> a
[10, 11, 'a', 'b', 'c']
Cópia de Lista: clone
Operador is
226
>>> a=list(range(10,14))
>>> a
[10, 11, 12, 13]
>>> a.insert(2,['a','b','c'])
>>> a
[10, 11, ['a', 'b', 'c'], 12, 13]
 
 posição 2
Listas
>>> a=list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b=2*['bola']
>>> b
['bola', 'bola']
>>> a[::3]=b # em toda lista do início até o fim com 
>>> a # passo 3
['bola', 1, 2, 'bola', 4, 5, 'bola', 7, 8, 'bola']
# irá dar erro se o tamanho da sequencia (aqui 4) for diferente
# do tamanho do fatiamento (4)
Cópia de Lista: clone
227
Listas
>>> a=[45,76,34,55]# lista original
>>> b=3*a # lista nova (* é o operador de repetição)
>>> b
[45,76,34,55,45,76,34,55,45,76,34,55]
# Na realidade, a nova lista (b) é uma lista que contém 3 referências à lista original a.
Operador de repetição *
228
a
b
Listas
●O que acontece se modificamos o valor de um elemento da lista 
original a:?
 
Operador de repetição *
229
 >>> a=[45,76,34,55]
 >>> b=3*[a]
 >>> a
 [45, 76, 34, 55] 
 >>> b
 [45, 76, 34, 55, 45, 76, 34, 55, 45, 76, 34, 55]
>>> a[1]=200
>>> a
[45, 200, 34, 55]
>>> b
[45, 200, 34, 55, 45, 200, 34, 55, 45, 
200, 34, 55]
Listas
●O comando copy e deepcopy cria uma nova lista (cópia) a partir 
de uma lista original:
Cópia de Lista: copy e 
deepcopy
230
>>> l1=[1,[2,3],4,5,[6],7]
>>> l5=copy.deepcopy(l1)
>>> l5
[1, [2, 3], 4, 5, [6], 7]
>>> l5 is l1
False
>>> l1 is l5
False
# com a cópia profunda, as 
sublistas são copiadas e não 
referenciadas
import copy
>>> l1=[1,2,3,4,5,6]
>>> l4 = copy.copy(l1)
>>> l4
[1, 2, 3, 4, 5, 6]
>>> l4 is l1
False
>>> l1 is l4
False
Listas
●O comando shuffle permite de embaralhar uma lista (altera 
a ordem dos elementos):
Embaralhar uma lista: 
shuffle
231
import random
>>> l1=[1,2,3,4,5,6]
>>> random.shuffle(l1)
>>> l1
[5, 3, 1, 4,2, 6]
>>> random.shuffle(l1)
>>> l1
[5, 4, 3, 2, 6, 1]
Listas
●O comando sample permite de gerar uma amostra aleatória 
de n elementos a parti de uma dada lista:
Gerar amostra a partir de 
uma lista: sample
232
import random
>>> l1=[1,2,3,4,5,6]
>>> l6=random.sample(l1,3) # gera uma sublista de 3 elemtnos de l1 
[2, 1, 4]
>>> l6=random.sample(l1,3)
[1, 4, 6]
>>> l6=random.sample(l1,5) # gera uma sublista de 5 elemtnos de l1 
[1, 6, 4, 3, 5]
>>> l6=random.sample(l1,5)
[1, 6, 4, 5, 3]
Listas
Gerar amostra a partir de 
uma lista: sample
233
import random
>>> l1=[1,2,3,4,5,6]
>>> l7=random.sample(range(0,100,2),4)
>>> l7
[66, 30, 46, 60]
>>> l7=random.sample(range(0,100,2),4)
>>> l7
[64, 42, 56, 44]
>>> l7=random.sample(range(1,100,2),10)
>>> l7 # gera uma lista aleatória de 10 números impares entre 1 e 100
[83, 77, 73, 47, 43, 99, 3, 71, 91, 51]
>>> l7=random.sample(range(80),10)
>>> l7
[33, 58, 63, 2, 20, 4, 23, 5, 57, 1]
Listas
●O comando choice retorna um elemento aleatório a parti de 
uma dada lista:
 Gerar amostra: choise
234
import random
>>> l1=[1,2,3,4,5,6]
>>> random.choice(l1)
3
>>> random.choice(l1)
2
>>> random.choice(l1)
2
Listas
●O comando zip permite de juntar duas listas, formando pares 
de elementos: :
Gerar amostra a partir de 
uma lista: zip
235
import random
>>> l8=zip(range(0,3),range(5,10))
>>> for e in l8:
e
(0, 5)
(1, 6)
(2, 7)
Listas
●Criar uma lista intercalada a partir de outras:
Gerar listas intercaladas
236
import random
>>> l1=[1,2,3,4,5,6]
>>> l2=list(range(10,20))
>>> l2
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> l10=l1[::2],l2[3:],l1[1::2]
>>> l10
([5, 3, 6], [13, 14, 15, 16, 17, 18, 19], [4, 2, 1]) # contém 3 sublistas
>>> l10=l1[::2],l2[3:]
>>> l10
([1, 3, 5], [13, 14, 15, 16, 17, 18, 19]) # contém 2 sublitas
Listas
● O comando map permite de aplicar uma função (anônima ou não) 
a todos os elementos de uma lista:
map: aplica uma função 
anônima ou não em cima 
de cada elemento da lista
237
import random
>>> l1=[1,2,3,4,5,6]
>>> l11=map(lambda x: x*-1,l1)
>>> l11
Listas
● Tornar todos elementos de uma lista positivos:
map: aplica uma função 
anônima ou não em cima 
de cada elemento da lista
238
def positiva(lst):
 return (map(lambda x: abs(x), lst))
l1=[-3,-2,-1,0,1,2,3]
l2=positiva(l1)
for e in l2: 
print(e,end=' ')
Listas
● O comando filter permite de filtrar os elementos de uma lista 
baseando-se em um critério:
Filtrando elementos de 
uma lista: filter
239
import random
>>> l1=[1,2,3,4,5,6]
>>> def criterio(x): return x>=0
>>> criterio(-2)
False
>>> criterio(5)
True
>>> filter(criterio,l1)
>>> filter(criterio,range(-6,6))
>>> filter(None,range(-3,3)) % [-3,-2,-1,0,1,2]
# retira da lista os elementos que não vereficamo critério
# no caso a1uiu, os elemtndso negativos.
Listas
 # O slicing (fatiamento) é o acesso a sublistas usando o operador :
>>> uma_lista = ['a', 'b', 'c', 'd', 'e','f']
>>> uma_lista[1:3] # (índice_início:índice_fim) não incluso (aqui o 3)
['b', 'c']
>>> uma_lista[:4] # até a posição 4 (não inclusa)
['a', 'b', 'c', 'd']
>>> uma_lista[3:] # da posição 3 até o final
['d', 'e', 'f']
>>> uma_lista[:] # todos os elementos
['a', 'b', 'c', 'd', 'e', 'f']
>>> uma_lista[-1] # último elemento, -2 é o penúltimo
'f'
>>> >>> l[-len(uma_lista)] # retorna o 1º elemento da lista
'a'
>>> 
Acessando: slicing
240
Listas
 # O slicing (fatiamento):
>>> ll=list(range(10))
>>> ll
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> ll[0]
0
>>> ll[1::2] # inicia no 1 (2º) vai até o fim com passo 2
[1, 3, 5, 7, 9] # índices impares
>>> >>> ll[0::2] # inicia no 0 (1º) vai até o fim com passo 2
[0, 2, 4, 6, 8] # índices pares
>>> ll[2:8:3] # inicia no 2 (3º) vai até o 8 (9º) com passo 3
[2, 5]
>>> ll[::4] # inicia no 1º vai até o fim com passo 4
[0, 4, 8]
Acessando: slicing :
241
Listas
 # O slicing (fatiamento):
>>> a=list(range(3))
>>> a
[0, 1, 2]
>>> a[0]=9
>>> a
[9, 1, 2]
>>> a[1:3]
[1, 2]
>>> a[1:3]=[4,5,6]
>>> a
[9, 4, 5, 6]
>>> 
Acessando: slicing :
242
Listas
 # 
>>> lista=list(range(2))
>>> print(lista)
[0, 1]
>>> lista = [x*2 for x in list(range(5))]
>>> lista
[0, 2, 4, 6, 8]
>>>
Criação de Listas
243
Listas
 # 
>>> range(10)
range(0, 10)
>>> lista=list(range(10))
>>> lista
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> 
Criação de Listas
244
Listas 
 # Percorrendo uma lista usando o for
>>> lista=[0,6,1,2,4,3]
>>> for x in lista:
 print(x) # faça algo com a lista
 
0
6
1
2
4
3
Percorrendo uma Lista
245
Listas 
 # Percorrendo uma lista usando o for
>>> lista=[0,6,1,2,4,3]
>>> s=0
>>> ‘ in lista:
 s+=x # s=s+x # faça algo com a lista
 
>>> print(s)
16
# isto é equivalente a:
>>> sum(lista)
16
Percorrendo uma Lista
246
Listas
# Criando uma lista de números em sequencia
>>> lista=[1, 2, 3, 4]
>>> for indice,valor in enumerate(lista):
 print(f'lista[{indice}] = {valor}')
# print("lista[%d] = %d" % (indice, valor))
Lista[0] = 1
Lista[1] = 2
Lista[2] = 3
Lista[3] = 4
>>> l=2,4,5]
>>> for x,v in enumerate(l):
l[x]=l[x]*2
[4, 8, 16]
Percorrendo uma Lista: 
enumerate
247
Listas
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[3:6]: # o incremento é 1 por defaut
print(x)
3
4
5
>>>
Percorrendo uma Lista
248
Listas
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[7:4:-1]:
print(x)
7
6
5 
>>>
Percorrendo uma Lista
249
Listas
# Percorrendo uma lista usando o for:
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[7:4:-2]:
print(x)
7
5
>>>
Percorrendo uma Lista
250
Listas
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[::-1]:
print(x)
9
8
7
6
5
4
3
2
1
>>>
Percorrendo uma Lista
251
Listas
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[::-1]:
print(x)
9
8
7
6
5
4
3
2
1
>>>
Percorrendo uma Lista
252
Listas
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[::-1]: # equivalente a for x in reversed (lista)
print(x)
>>> for x in reversed(lista):
print(x)
9
8
7
...
1
>>>
Percorrendo uma Lista
253
Listas
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in sorted(lista):
print(x)
9
8
7
...
1
>>>
Percorrendo uma Lista
254
Listas
import random
>>> lista=list(range(10))
>>> random.choice(lista)
7
>>> random.choice(lista)
2
Acesso aleatório
255
Listas
>>> lista= ['b',8,45,'k',3]
>>> lista
['b',8,45,'k',3]
>>> nova_lista=['Maria',lista,28,'bbb']
>>> nova_lista # ['Maria',['b',8,45,'k',3],28,'bbb']
>>> nova_lista[0] # 'Maria'
>>> nova_lista[1] # ['b',8,45,'k',3]
>>> nova_lista[2] # 28
>>> nova_lista[3] # 'bbb' 
>>> nova_lista[1][0] # 'b' (1º elemento da sublista)
Listas Compostas
256
Listas
# Tamanho de uma lista
>>> lista=[25,8,-3,12]
>>> lista
[25, 8, -3, 12]
>>> len(lista)
4
len
257
Listas
>>> lista=['a','b','c']
>>> lista[0]= 'A'
>>> lista
['A','b','c']
>>>lista[2]=30
[’A','b',30]
Alterando elementos da 
Lista
258
Listas
>>> l1=['a','b','c']
>>> l2=[1,2,3,4]
>>> print(l1+l2)
['a', 'b', 'c', 1, 2, 3, 4]
>>> print(l2*3) # concatena 3 vezes a mesma lista
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
Concatenação
259
Listas
# verificar se um elemento/símbolo pertence a uma lista
Lista=[45,23,12,8,22,0,15]
>>> 8 in lista
True
>>> 'gato' in lista
False
in
260
Listas
# Operadores
l2=[1,2,3,4]
>>> print(min(l2))
1
>>> print(max(l2))
4
>>> print(sum(l2))
10
sum min max
261
Listas
# Operadores
>>> livros = ['Java','C','Python']
>>> livros.append('C++') # o append é o operador de 
# concatenação das listas,
# e o + é operador de concatenação
# das strings
>>> livros
 ['Java','C','Python','C++']
Concatenação: append
262
Listas
Concatenação
263
EM STRINGS
>>> s = 'Bom '
>>> s += 'dia'
>>> s
' Bom dia '
# strings não 
# suportam o append
EM LISTAS
>>> l=[]
>>> l.append('Bom ')
>>> l
['Bom ']
>>> l.append('dia')
>>> l
['Bom ', 'dia']
# observação
>>> l=[]
>>> l+='Bom'
>>> l
['B', 'o', 'm']
Listas
>>> lst=[]
>>> for i in range(10):
lst.append('a')
>>> lst
['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']
>>> lst=''.join(lst)
>>> lst
'aaaaaaaaaa'
Convertindo lista para 
String
264
Listas
# Operadores
>>> livros = ['Java','C','Python']
>>> livros.insert(0,'Arduino') # insere um elemento na posição zero
>>> livros
 ['Arduino','Java','C','Python']
insert
265
Listas
 # retirar elementos
>>> livros = ['Java','C','Python,'C++']
>>> livros.pop() # retira o último elemento
'C++'
>>> livros
 ['Java','C','Python']
>>> livros.pop(1) # retira o 2º elemento (índice 1)
'C'
>>> livros
 ['Java','Python']
pop
266
Listas
 # retirar elementos da lista:
>>> livros = ['Java','C','Python,'C++']
= ['Java','C','Python
>>> livros.remove('C++') # retira apenas a 1ª ocorrência
>>> livros # do elemento
 ['Java','C','Python']
 # outra forma de deletar elementos em uma lista:
 >>> livros[3:4]=[] # ou livros[3:]=[] 
 >>> livros
 ['Java', 'C', 'Python']
remove
267
Listas
 # reverter
>>> livros = ['Java','C','Python,'C++']
>>> livros.reverse() # muda a lista original
>>> livros
 ['C++','Python','C','Java']
reverse
268
Listas
 # ordenar
>>> livros = ['Java','C','Python,'C++']
>>> livros.sort() # muda a lista original
>>> livros
 ['C','C++','Java','Python']
sort
269
Listas
 # contar ocorrência
>>> l2=[3,4,5,3,2,8,10,6]
>>> l2.count(3)
2
count
270
Listas
 # retornar o índice da 1ª ocorrência de um elemento na lista:
>>> l2=[3,4,5,3,2,8,10,6]
>>> print(l2.index(2) # gera erro s o elemento não existe 
4
>>> l2.index(3)
0
index
271
Listas
● Representação de matrizes, sob forma de lista composta:
>>> matriz=[[1,2,3],[4,5,6],[7,8,9]]
>>> matriz[1]
[4,5,6]
>> matriz[1][2]
6
Matrizes
272
Listas
# Criar matriz:
def criarMatriz(l,c):
 matriz=[]
 for i in range(l):
 linha=[]
 for j in range(c):
 ms='Matriz[{}][{}]: '.format(i,j)
 a=int(input(ms))
 linha.append(a)
 matriz.append(linha)
 print('\nMatriz M[{}x{}] criada!\n'.format(l,c))
 return(matriz)
Matrizes
273
Listas
# Mostrar matriz:
def mostrarMatriz(m):
 for a in m:
 print(a)
 print()
m=criarMatriz(3,3)
mostrarMatriz(m)
Matrizes
274
Listas: 
Métodos 
list.append → adiciona ao final.
list.count → conta a quantidade de determinado elemento em uma lista
list.index → mostra a posição de um determinado elemento na lista
list.insert → enquanto append adiciona ao final, aqui especificamos a posição 
list.pop → retira e exibe algum elemento, por padrão o último
list.remove → similar ao pop, mas sem exibir a posição do elemento a retirar
del lista[1] → lextrai um elemento ou um sublista
a.clear() → apagar o conteúdo de uma lista
list.reverse → inverte a ordem dos itens
list.sort → ordena os elementos, o método de ordenamento usado é o 
 TimSort: https://pt.wikipedia.org/wiki/Timsort
275
Listas
1. Leia um vetor de 10 posições e ordene o vetor, usando 3 
métodos de ordenação diferentes (crie um programa para cada 
um) a. Insertion Sort b. Selection Sort c. Bubble Sort
2. Um dado é lançado 50 vezes, e o valor correspondente é 
armazenado em um vetor. Faça um programa que determine o 
percentual de ocorrências de face 6 do dado dentre esses 50 
lançamentos.
3. Faça um programa que leia um vetor vet de 20 posições. O 
programa deve gerar, a partir do vetor lido, um outro vetor pos 
que contenha apenas os valores inteiros positivos de vet. A partir 
do vetor pos, deve ser gerado um outro vetor semdup que 
contenha apenas uma ocorrência de cada valor de pos.
Exercícios
276
Exercício
● turma=[]
● aluno=[]
●
n=int(input('Qual o tamanho da Turma: '))
● print()
●
for i in range(n):
● aluno=[]
● aluno.append(input('Nome do '+str(i+1)+'º Aluno: '))
● aluno.append(float(input('Nota P1 de '+aluno[0]+': ')))
● aluno.append(float(input('Nota P2 de '+aluno[0]+': ')))
● media=(aluno[1]+aluno[2])/2
● aluno.append(media)
● if aluno[3]>=7:
● aluno.append(True)
● else:
● aluno.append(False)
● aluno.append(0)
● turma.append(aluno)
● print()
277
Exercício
● print(turma)
● print()
●
for e in turma:
● print('{}\t{}'.format(e[0],e[3]))
●
for i in range(n-1):
● for j in range(i+1,n):
● if turma[i][3]<turma[j][3]:
● x=turma[i]
● turma[i]=turma[j]
● turma[j]=x
●
i=0
● for e in turma:
● turma[i][5]=i+1
● print('{}.\t{}\t{}'.format(e[5],e[0],e[3]))
● i+=1
●
print(turma)
278
Tuplas
●Python tem duas outras estruturas de dados muito importantes: as tuplas 
e os Dicionários.
●Tuplas:
É um sequência de itens de qualquer tipo e que são imutáveis.
Tais itens são separadas por uma vírgula e normalmente colocados 
entre parênteses.
Tuplas são semelhantes aos records de outras linguagens.
c=('Caneta',2.50,'Escolar',300)
As tuplas permitem, portanto, de agrupar várias informações heterogêneas 
em um único objeto.
As tuplas permitem os mesmos operadores que as listas e strings 
 têm.
Tuplas
279
Tuplas
●Tupla simples:
>>> t=(2,)
>>> type(t)
<class 'tuple'>
>>> t[0]
2
Tupla é uma estrutura imutavel
Tuplas
280
Tuplas
●Tupla simples:
>>> t=(2,3,4,5,6)
>>> type(t)
<class 'tuple'>
>>> len(t)
5
Tuplas
281
Tuplas
●Tupla composta: Lista dentro de uma tuple.
>>> t=(2,3,[4,5,6])
>>> type(t)
<class 'tuple'>
>>> len(t)
3
Tuplas compostas
282
Tuplas
●Tupla composta: lista dentro de uma tupla:
>>> t=(2,3,[4,5,6])
t[2]=10
TypeError: 'tuple' object does not support item assignment
>>> t[-1][1]
5
>>> t[-1][1]=88
>>> t
(2, 3, [4, 88, 6])
# É possivel alterar uma lista dentro de uma tupla mas nunca
# se consegue alterar uma tupla diretamente.
Tuplas compostas
283
Tuplas
●Tupla composta: Tupla dentro de uma tupla:
>>> t2=(2,3,(4,5))
>>> t2
(2, 3, (4, 5))
>>> type(t2)
<class 'tuple'>
>>> t2[-1]
(4, 5)
>>> t2[-1][0]=10
TypeError: 'tuple' object does not support item assignment
Tuplas compostas
284
Tuplas
●Para alterar uma tupla, pode-se criar um clone dela (cópia) i.e. 
criar uma varável que referência uma nova tupla com os 
elementos desejados, usando as técnicas de fatiamento 
(slicing) e de concatenação.