Algorimos Python 28 08 2023

Algoritmos
Sofiane Labidi, PhD.

Plataformas
Sofiane Labidi, PhD.

sofiane.labidi@ufma.br
Wa. 098 9.8860-6410
@slabidi
Roteiro
▰ Introdução ....................................................................................................... 04
▰ Python? ........................................................................................................... 23
▰ Instalação ....................................................................................................... 37
▰ IDLE Python ..................................................................................................... 46
▰ Variáveis / Tipos ............................................................................................. 63
▰ Expressões Python ........................................................................................ 116
▰ Saídas ........................................................................................................... 133
▰ Entradas ................................................................................................................. 167
▰ Controle Condicional ..................................................................................... 181
▰ Estruturas de Repetição ................................................................................ 194
▰ Funções ........................................................................................................ 223
▰ Coleções ....................................................................................................... 261
▻ Strings ................................................................................................ 265
3
Roteiro
▻ Listas ........................................................................................................... 304

▻ Tuplas .......................................................................................................... 386
▻ Sets ............................................................................................................. 401
▻ Dict .............................................................................................................. 429
▻ Arrays .......................................................................................................... 455
▰ Arquivos (Texto e Dados) ........................................................................ 465
▰ Matemática ............................................................................................ 545
▰ Classes ................................................................................................... 553
▰ Packages & Módulos ............................................................................. 626
▰ Exceções ................................................................................................ 664
▰ Utilitários ................................................................................................ 673
▰ Interface Gráfica ..................................................................................... 682
▰ Anaconda .............................................................................................. 688
▰ Conclusão .............................................................................................. 699 4
Introdução
5
LINGUAGENS DE PROGRAMAÇÃO
1. Escreva um programa que troca o conteúdo de duas variáveis.
2. Escreva um programa para verificar se um número é par ou ímpar.
3. Crie um programa para encontrar o maior número em uma lista de três números.
4. Escreva um programa para encontrar o fatorial de um número inteiro.
6
Linguagem de
Programação
Linguagens de
Programação Permite às pessoas de expressarem o que eles desejam que o
computador faz.
Transmite ao computador como fazer isto!
7
LINGUAGENS DE PROGRAMAÇÃO: EVOLVUÇÃO
LM LAN
(1940) (1950/60)
Assembly
(1950)
8
LINGUAGENS DE ALTO NÍVEL: EVOLUÇÃO
3rdGL 5thGL
4thGL
9
LINGUAGENS DE ALTO NÍVEL
 3rd Generation Language

JAVA, C, C++, C#, etc.
 4th Generation Language

SQL, FOCUS, NOMAD, PostScript, etc.
 5th Generation Language

Linguagens de Inteligência Artificial (PROLOG, etc.).
10
LINGUAGENS DE ALTO NÍVEL
https://whimsical.com/mind-maps
11
PARADIGMAS DE PROGRAMAÇÃO
Programação Estruturada
Programação Lógica
C, Pascal, etc.
Prologo, etc.
Programação Orientada a Objeto

Programação Visual
Java, C++, Python, C#, SmallTalk, Eiffel, etc.
Delphi, JBuilder, C++Builder, etc.
Programação Funcional
Programação Concorrente / Distribuída / Paralela
Lisp, Scheme ML, SML, Haskell, Erlang,
etc. OCCAM, C*, Ada, SR, Linda, Orca, etc.
12
PARADIGMA IMPERATIVO/PROCEDIMENTAL
 Instrução = Ordem
nos dois sentidos: ordem para a máquina, e

ordem nos enunciados.
 Especificação da solução em termos de comportamento da máquina.
13
PARADIGMA ORIENTADO A OBJETO
 Instrução básica = Envio de mensagem

 Especificação da solução em termos de interações entre objetos
instâncias de uma hierarquia de classes (categorias de objetos).
14
PARADIGMA LÓGICO
 Instrução = Relação
 Especificação da solução em termos de relações entre entidades.
 Linguagens que utilizam o paradigma lógico são classificadas também como Declarativas.
 Descrevem o problema e não a solução.
 Descrevem “O Que?” deve ser feito e não “Como?” deve ser feito.
15
PARADIGMA FUNCIONAL
 Instrução = Função
que calcula e retorna um valor: a solução.
 Especificação da solução em termos de valores calculados.
16
OUTROS PARADIGMAS
 Visual
 Concorrente, Paralela, Distribuída, etc.
17
PROGRAMAÇÃO MULTIPARADIGMAS
 Cada paradigma tem suas vantagens e inconvenientes.
 É possível combinar os paradigmas?
 É interessante desenvolver linguagens que suportem diferentes paradigmas: uma
linguagem multiparadigmas?
 Há tentativas de combinar a orientação a objeto com outras categorias de
linguagens: ObjLog, CLOS, etc.
18
PROGRAMAÇÃO MULTIPARADIGMAS: REFLEXÃO
Qual é a melhor Linguagem de Programação?
Ela existe ?
Podemos ter uma Linguagem Multiparadigmas ?
Analogia com os Idiomas: o Esperanto (1887 / 1905 / 1984 – 120 países / 2 milhões)!
19
TOP PROGRAMMING LANGUAGE RANK
 GIT HUB
https://madnight.github.io/githut/#/pushes/2019/4
 IEEE SPECTRUM
https://spectrum.ieee.org/static/interactive-the-top-programming-languages-2019
20
14/11/2023 21
GIT HUB
14/11/2023 22
23
Python
24
• 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, C, Java e Perl.

Linguagem • Foco inicial: auxiliar os profissionais da física e das engenharias.
Python
• É 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 da TV Británica.
25
• Características
Linguagem • Facilidade, Flexibilidade e Versatilidade
Python • Muito poderosa
Vantagens • Largo Ecossistema
26
Exemplo de saída de dados em Java e em Python:
Código Java:
public class Exemplo {

public static void main(String[] args) {
String nome = "Alice";
int idade = 25;
System.out.println("Olá, meu nome é " + nome + " e tenho " + idade + " anos.");
Linguagem
}
}
Python Código Python:
Vantagens nome = "Alice"

idade = 25
print("Olá, meu nome é", nome, "e tenho", idade, "anos.")
Saía (em Python e Java)
Olá, meu nome é Alice e tenho 25 anos.
27
• Python
• Aplicações Web
• Aplicações Desktop
• Desenvolvimento de Jogos
Linguagem • Ciência de Dados

Python • Aprendizagem de Máquina
Aplicações • Sistemas de IA.

• Web Development
• Mobile Development
• Desktop Development
28
• Empresas que usam Python:
• Google (aplicações web), Yahoo (aplicações web), Microsoft
(IronPython: Python para .NET), Disney (animações 3D), etc.
Linguagem
• Linguagem Python está na versão 3.12.
Python
• Python usa simultaneamente um compilador e um interpretador.
29
• 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).
Linguagem
• O arquivo .pyc é executado pelo interpretador apropriado.
Python
• 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.
30
Python Virtual
Machine -PVM
Execução
Tradução pela
(compilador
Linguagem Source Code
)
ByteCode
Python .py .pyc
Compilação &
Execução arquivos-
fonte
Arquivos de byte code
31
(Login/Create New / Boards / Add Mind-Map / *)
32
• 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
Linguagem >>> print(5- \
colocar uma barra invertida: \ 6)
Python -1
>>>
• 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.
33
• O Python pode ser executado diretamente no terminal:
python (executa o python no modo interativo)

Linguagem
python teste.py (executa o programa teste.py)
Python
34
• A identificação de blocos é feita por meio da indentação
>>> i=0
>>> while i<8:
Linguagem print(i)
Python i=i+3
0
3
6
>>>
35
• Python é uma linguagem Orientada a Objeto,
Tudo é objeto em Python (inteiros, real, etc.).
Linguagem Até os tipos mais básicos possuem métodos específicos.
Python
36
• Python oferece também ferramentas para:
• Programação funcional
• Processamento de imagens
• Interface gráfica
Python
• Processamento distribuído
Multiparadigmas
• Integração com C, C#, linguagem de script Blender, etc.
37
Instalação
38
Interpretadores Online:
www.codeskulptor.org/ (da Rice university)
Interpretador www.tutorialspoint.com/execute_python_online.php
Python
Online
PythonAnywhere Sign-up (www.pythonanywhere.com)
Python – Replit
Anaconda Nucleus
The Collaborative Data Notebook For EDA & ETL – Noteable
39
Outros Interpretadores Online (para várias linguagens)
Repl
https://repl.it/
Interpretadores Code, Compile & Run

Online https://www.codechef.com/ide
CodePad
http://codepad.org/
Outras 3 Plataformas [Ideone, OnlineCompiler, RemoteInterview]
https://elias.praciano.com/2016/12/6-compiladores-online-para-estudantes-de-programacao/
40
Instalando  Python para Android (mobile):
Python  Pydroid 3
QPython
 QPython
41
 IDLE Python (ou IDE) - Integrated Development Language
Environment:
Ambiente de desenvolvimento integrado para o Python.
Instalando Python.org
Python
 Baixar:
 https://www.python.org/downloads/
Python 3.11.3 Abril 15, 2023

 https://docs.python.org/3/tutorial/index.html
Tutorial oficial Python.
42
pyhton.org
Instalando
Python
43
 Checar se o python está instalado:
 Wind + cmd
 Python
 exit()
Instalando  Checar a versão do Python

Python  python --version
44
 Automaticamente, o Python instala:
Instalando  IDLE Shell Python
Python
 IDLE Editor.
45
 IDLE / IDE (Integrated Development Environment) (Integrated Development
and Learning Environment)
 É o Ambiente de Desenvolvimento Integrado, contendo:
Instalando  Pacote de desenvolvimento de softwares, contendo o editor de códigos.
Python  Ferramentas de Automação do processo de construção.
IDE / IDLE  Depurador (Debugger),
 Plataforma Educacional.
46
IDLE Python
47
 IDLEs Python:
 IDLE Python.org
 Ninja IDE
IDLEs Python  PyCharm
Instalação  Outros.
48
 Ninja
IDLE
http://ninja-ide.org/downloads/
Ninja
49
 PyCharm
da JetBrains
https://www.jetbrains.com/pycharm/download/#section=windows
IDLE https://www.jetbrains.com/help/pycharm/installation-guide.html#standalone
PyCharm
Guia de Instalação
https://www.jetbrains.com/help/pycharm/installation-guide.html
50
 IDLE Python
IDLE python.org
Python
51
 Iniciar uma cessão
 Reiniciar uma cessão

Para remover quaisquer alterações feitas ou então, remover
IDLE qualquer objeto criado em memória.
Python
Menu: Shell / Restart Shell ou CTRL + F6.
52
Shell Python >>> # é o prompt de comandos Python
Prompt
53
"""
>>> ... comentário em várias linhas
"""
ou
Shell Python '''
Comentários >>> ... comentário em várias linhas
'''
54
Python 3.11.3 (tags/v3.11.3:f3909b8, Apr 4 2023, 23:49:59) [MSC v.1934 64 bit
(AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> 8*4
32
>>> print ('Olaa')
Olaa
Shell Python >>> print("bom dia")
Comandos
Bom dia # tanto faz, aspas simples ou duplas
>>> print(5-2)
3
>>> 5-2
3
>>> 6
6
55
 Navegando no histórico de comandos (avançar e retroceder):
 Alt P Comando Anterior (previous)
 Alt N Próximo comando (next)
 Observação:
Shell Python
 As teclas de atalho podem ser alteradas usando a opção de menu
Atalhos
Option -> Configure IDLE -> Keys
56
Opções / Configure IDLE / Fonts
Opções / Configure IDLE / Keys, etc.
57
Opções / Configure IDLE / Fonts
Opções / Configure IDLE / Keys, etc.
58
 Atalhos dos comandos:
>>> 4+6
10
Shell Python >>> _ * 5 # referência o último valor retornado

# pelo shell
Atalhos
50
>>>
59
Atalhos dos comandos:
 Alt + P -> retorna última instrução
 Alt + N -> avança para a próxima instrução
 Crl+D fecha a janela / Shell Python
 Ctrl + F6 -> Reinicia o IDLE, equivalente de exit()

Shell Python  Ctrl + N -> Abre o editor de Scripts de várias linhas (File / New File)
Atalhos
 Ctrl + Enter -> Executa o código que está sendo inserido
 Ctrl + C -> interrompe a execução (Script em looping)
 Ctrl + Espaço -> abre o “Code Complete” (complementação da digitação)
 Ctrl-Tab -> abre o “Code Complete” mais específico
 Ctrl + J -> adiciona linha e move o cursor para a mesma
60
 Um arquivo Python é um arquivo de texto composto por
Criando comandos python e cuja extensão é PY.
Arquivos  É criado, no Idle, pela opção de meu:
Python
Editor File → New File - arquivo novo CTRL N
File → Save / Save as... - salvar com a extensão py CTRL S
Run → Run Module - executar o arquivo python F5
61
O# é usado para os comentários em uma linha!
 ''' ... ''' comentário em várias linhas (ou """ ... """)
 Temos um comando por linha.

Arquivo Python
Características  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.
62
 Exemplo, arquivo "teste.py"
a=2
b=3
Arquivo Python print('A soma é: ',a+b)
print print('A diferença é: ',a-b)
A soma é: 5
A diferença é: -1
63
Variáveis, Tipos &
Atribuição de Valores
64
IPO Chart
• Dividir para Conquistar! / Administrar a complexidade!
INPUT PROCESSING OUTPUT
• Recuperar os • Processamento • Mostrar o

Dados do (Solucionar o Resultado
Problema problema)
65
 Tanto os programas executados pelo computador, como
A 20
os seus dados, todos, devem ser carregados na sua
Memória Central para execução. B 14
Variáveis  Os dados são armazenados na memórias do computador

C 5
em variáveis.
66
 Uma variável é caracterizada pelo:
 Nome A 20 @1
 Endereço
B 14.5 @2
Variáveis:  Tipo
Características  Conteúdo (que pode variar, mas sem mudar de tipo)

C Carlos @3
67
• No Python, as variáveis não são declaradas.
• Python é uma linguagem com tipagem:

Variáveis • Forte, e
Tipagem • Dinâmica.
68
 O símbolo de atribuição é o =
a=8
a 8
b=a
Variáveis: b=b+1 b 89
Atribuições de Valores
69
>>> a=3.0 # A atribuição é feita usando o símbolo =
>>> a
3.0
>>> b=a-1
Atribuições >>> b
Variáveis
2.0
>>> a='Boa tarde!'
>>> a
'Boa tarde!'
70
>>> nome="Lucas" # os strings devem ser colocados
>>> nome # entre aspas simples ou duplas
'Lucas'
Atribuições
Strings >>> bairro='Calhau'
>>> bairro
'Calhau'
71
>>> a,b,c=3,2,4 # A atribuição pode ser feita em série
# isto é feito de forma paralela
>>> a
>>> b
Atribuições >>> c
(a,b,c ) = 3,2,4
Atribuição em série 4
# Podemos colocar parênteses:
>>> a,b,c
(3,2,4)
>>> b,a
(2,3)
72
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) ?
Atribuições >>> a
Variáveis
?
>>> b
# A atribuição em série se faz em paralelo
# então a = 4 e b = 3 (2+1)
73
O Python, a partir da versão 3 do Python (2008), permitiu a utilização de caracteres
acentuados e outros caracteres Unicod na definição dos nomes das variáveis.
Anteriormente, na versão 2 do Python, os nomes das variáveis eram limitados
apenas a caracteres ASCII.
Na realidade, a maioria das linguagens usam o código ascii.
Atribuições
Nomes das Variáveis Linguagens Nomes das Variáveis
C, C++, Java, JavaScript caracteres ASCII (7 bits, 128 caracteres).
Python, Ruby, Perl, R e Swift caracteres acentuados e outros caracteres

Unicode (16 bits, 143 mil caracteres).
74
chr()
65
'A '
Códigos Ascii Caracteres chr()
(inteiros, 7 bits) correspondentes
[0, 127] aos códigos ascii chr()
Ascii Unicode CHR

ascii()
65 65 'A'
Atribuições chr() x 233 'é'
Nomes das Variáveis 169 x

Unicode 8364
Ascii '€'
Códigos Unicode '© ' Caracteres correspondentes
x 4 '@'
(inteiros, 16 bits) aos códigos unicode
[0, 1.114.111] x 169 '©'
x 167 '§'
ord()
ascii()
>>> ascii('Olá Sofiane.') ord()

"'Ol\\xe1 Sofiane.'"
75
O nome de uma variável em Python deve:
• começar com uma letra (maiúscula ou
minúscula) ou com um sublinhado (_).
• seguido por letras, dígitos ou sublinhados. Exemplos:
• Podem ser usados caracteres acentuados (é, à, endereço
ã, etc.). café
• Mas, não são permitidos caracteres especiais,

Atribuições espaços ou símbolos de pontuação.
usuário
_b
Nomes das Variáveis é_grande
nome_funcionário
Caracteres Acentuados:
á, à, â, ã, é, è, ê, í, ì, î, ó, ò, ô, õ, ú, ù, û, ü, ç, Á, À, Â, Ã, É, È, Ê, Í, Ì, Î, Ó, Ò, Ô, Õ, Ú, Ù, Û, Ü, Ç
Caracteres Especiais:
@, #, $, %, &, *, +, -, /, , |, ~, ^, <, >, =, ?, !, [, ], {, }, (, ), ", ', :, ;, ., ,, _
Caracteres de Pontuação:
., ,, :, ;, !, ?, -, _, ', ", (, ), [, ], {, }
76
É recomendado sempre seguir as convenções de boas práticas da linguagem. No
Python, é aconselhado de seguir o estilo snake_case que é considerado mais claro e
mais legível do que outros estilos, como o camelCase, etc.
snake_Case é uma convenção que recomenda de utilizar nomes descritivos que
reflitam o propósito ou conteúdo da variável, evitando nomes ambíguos ou
excessivamente longos, além da utilização de letras minúsculas e de separar palavras
Atribuições compostas por sublinhados.
Estilo snake_case Estilo camelCase
Nomes das Variáveis
nome_completo nomeCompleto
idade_pessoa idadePessoa
total_produtos totalProdutos
valor_total_pedido valorTotalPedido
lista_de_nomes listaDeNomes
saldo_conta saldoConta
numero_telefone numeroTelefone
quantidade_itens quantidadeItens
77
# swap: trocar o conteúdo de duas variáveis a e b:
# 1ª solução, não Funciona!

a=6
b=8
1º Exercício print(a,b) # 6 8
Swap a=b # aqui perdemos
o valor de a
b=a
print(a,b) # 8 8
78
x
7 # 2ª solução
a=6
1º Exercício x  a b=8
print(a,b) # 6 8
Swap a b a x=a
a=b
8
7 b=x
b x print(a,b) # 8 6
7
8
b
79
# Sem uso de uma variável auxiliar
# 3a Solução
a=6
1º Exercício
b=8
print(a,b) # 6 8
Swap a=a+b
b=a-b
a=a-b
print(a,b) # 8 6
Apenas numéricos
80
Qual é a melhor solução ?
# 2ª solução # 3a Solução
a=6 a=6
b=8 b=8
print(a,b) # 6 8 print(a,b) # 6 8
x=a a=a+b
a=b b=a-b
b=x a=a-b
print(a,b) # 8 6 print(a,b) # 8 6
1º Exercício consome mais

memória
consome mais
processamento
Swap
Memória Processamento
(Espaço) (Tempo)
Computação é um compromisso Tempo / Espaço
81
x
7
x  a
Algoritmo a b a
8
7
SWAP b x
7
8
b
82
Torre de Hanoi
83
 1. Move o disco 1 para a haste C
 2. Move o disco 2 para a haste B
 3. Move o disco 1 para a haste B

Torre de Hanoi  5. Move o disco 1 para a haste A
84
 Swap, usando a solução de atribuição em série!
# 4ª solução
>>> a,b=4,6
a=6
>>> a,b b=8
Atribuições
print(a,b) # 6 8
(4,6) a,b=b,a
Exercício de Swap print(a,b) # 8 6
Apenas no Python
>>> a,b=b,a
>>> a,b
(6,4) # assim, conseguimos fazer a troca (swap)
85
 Essas duas expressões são equivalentes!
a=a+b
a+=b
Atribuições
Abreviações a=a*6
a*=6
86
x = y = z = 10
Senso das atribuições
 Atribuições em cadeia
x = y = z = 10
print(x, y, z) # 10 10 10
a=b=5
b=b+1
print(a, b) # 5 6
Atribuições
Atribuições em cadeia lista1 = lista2 = [1, 2, 3]
lista2.append(4)
print(lista1, lista2) # [1, 2, 3, 4] [1, 2, 3, 4]
msg1 = msg2 = "Olá"

msg2 = msg2 + ", mundo!"
print(msg1, msg2) # Olá Olá, mundo!
87
 Operador warlus := (a partir da versão 3.8 do Python)
O := permite de atribuir um valor a uma variável e ao mesmo tempo de
utilizar esse valor dentro de uma expressão.
while (linha := input()) != "sair":

print("Você digitou:", linha)
Atribuições
Operador warlus := linha = input()
while linha != "sair":
print("Você digitou:", linha)
linha = input()
Código equivalente
a:=8 (a:=8)==8
SyntaxError: invalid syntax True
88
None é o equivalente ao valor nulo (null)
Uma variável pode ser iniciada com um valor nulo
Atribuições >>> nome = None
None # o N do None deve ser escrito em maiúsculo e sem aspas
>>> nome
>>>
89
 Tipos simples - constituídos por simples blocos: int(), float(), str() e
complex().
 Tipos de contêiner - objetos capazes de conter outros objetos: list(),

tuple(), set(), e dict().
Tipos
Classificação
 Tipos de código - objetos encapsuladores de elementos dos
programas: function.
 Tipos internos - tipos que serão utilizados durante a execução dos

programas.
90
Tipos
Tipos Tipos
Simples Contêiner
de Código Interno
Int() list() function modulo
float() tuple() class type
str() set()
bool() dict()
complex() 91
Esses tipos de dados são formados por blocos básicos e diretos.
 int(): Representa números inteiros. 8 0

-2
 float(): Representa números de ponto flutuante. 0.6 3.14 -2.0

Tipos Simples
 bool(): Representa valores booleanos.
(básicos) True False
 str(): Representa sequências de caracteres. 'Olá, Mundo!'
 complex(): Representa números complexos. 24-3j
92
• São objetos que podem conter/armazenar outros objeto (objetos
complexos/compostos).
 list(): uma sequência ordenada e mutável de elementos. a=[2,1,3]
 tuple(): uma sequência ordenada e imutável de elementos. a=(3,1,2)
 set(): uma coleção não ordenada e não duplicada de elementos.

Tipos Contêiner a={1,2,3}
 dict(): uma coleção de pares chave-valor, onde cada valor é acessado por de
a={1:'um',2:'dois',3:'três'}
sua chave única.
registro = { "nome" : "Maria",

"idade" : 28,
"cidade" : "São
Luís" }
>>> registro["idade"]
28 (Dicionário, simulando o
struct do C)
93
Esses tipos de dados são objetos que encapsulam elementos dos
programas.
 function: Representa uma função definida pelo usuário.

 class: Representa uma classe definida pelo usuário.
class Registro:
def __init__ (self, nome, idade, cidade):
Tipos de Código self.nome = nome
self.idade = idade
self.cidade = cidade
# Criar um objeto instância da classe Registro:

registro = Registro("Maria", 28, "São Luís")
# Para acessar um atributo (nome, idade, cidade) usamos

classe a notação de ponto:
registro.nome.
94
Esses tipos de dados são usados durante a execução dos
programas, mas não são diretamente acessíveis ou utilizados pelo
usuário.
 module: Representa um módulo, que é um arquivo contendo um

Tipos internos conjunto de definições e declarações Python.
 type: Representa o tipo de um objeto em tempo de execução.
95
• inteiro (int):
>>> a=10
# a representação varia de
# -231-1 a 232-1, para sistemas de 32 bits, e
# de -263-1 a 263-1, para sistemas de 64 bits
Tipos # não existe o tipo long
Tipos Numéricos
• ponto flutuante (float):
>>> a=2.453 (ou 24.53e-1)
• complexo (complex):
>>> a=3-2j
96
• type
A função type retorna o tipo de uma variável ou expressão:
>>> a=2 >>> a='Maria' >>> a=False

>>> type(a) >>> type(a) >>> type(a)
Tipos <class 'int'> <class 'str'> <class 'bool'>
type
>>> a=3.5 >>> a=3-1j >>> a=5!=6

>>> type(a) >>> type(a) >>> type(a)
<class 'float'> <class 'complex'> <class 'bool'>
Os 4 Tipos Básicos: int, float, str, e bool além do tipo complex
97
print(type(1))
type(a==2)
<class 'int'>
<class 'bool'>
type(2.0) type(4/2)
<class 'float'> <class 'float'>
type("Alô") type(5//2)
Tipos <class 'str'> <class 'int'>
Extração do Tipo type(2-4j)

type('Maria')
<class 'complex'>
<class 'str'>
a=1 # tipo inteiro
a = 'Maria' ou a="Maria" # string
a = 1.0 # float
98
• 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) ou
Tipos • operadores relacionais (>,>=,<,<=,==,!=)
Tipo lógico: bool
e cujo o resultado é:
 verdadeiro (True) ou
 falso (False).
99
> Maior que
>= Maior ou igual
< Menor que
<= Menor ou igual
Operadores ==
!=
Igualdade
Diferente de (<>)
Relacionais in pertence
Expressões Lógicas
Operador Lógico Descrição

AND Conjunção
OR Disjunção
NOT Negação
100
• Tipo lógico (bool):
>>> a=2
>>> b=6
>>> (a>=b)
False
Tipo >>> (a!=b) or (b==2)
Tipo bool True
>>> not (a=!b) or (b>=a+1) and (a<0)

False
101
• Tipo lógico (bool):
>>> bool('') >>> a=4

>>> a=False
False
>>> type(a) >>> a=a==4
<type 'bool'> >>> 2 < 4
True
Tipos True
>>> 5 > 7 >>> 2 < 5 < 4

Tipo booleano (lógico)
False False
>>> bool('False')
>>> 6 < 8 < 10
True True
>>> bool('True')
True
102
>>> a=-2+3j
>>> b= 5-1j
>>> a+b
3+2j
Tipos >>> complex(2,-1) # construtor de números complexos
(2-1j)
Tipo Complex
>>> c=2-1j
>>> c.conjugate()
(2+1j) # inverte o sinal da parte imaginária (j)
103
>>> (-2+3j)/(-2+3j)
>>> (2-3j)*(1+1j)
(1+0j) (5-1j)
>>> (3-1j)-(2+4j)
>>> a=1j
(1-5j)
>>> a**2
>>> 3-1j/2+4j
Tipos (-1+0j)
(3+3.5j)
Tipo Complex
>>> a**3 >>> (3-1j)/(2+4j)
(-0.1-0.7j)
(-0-1j)
• Para dividir 2 números complexos, multiplicamos tanto o numerador como o denominador

da divisão pelo conjugado do denominador.
• O conjugado de um número complexo é obtido trocando o sinal da parte imaginária.
104
• Notação científica:
>>> 2e1 # 2*10**1
20.0
Tipos >>> 2e3
Notação Científica 2000.0
>>> 2e-1
0.2
>>> 5e-3
0.005
105
>>> a=28 Casting
>>> str(a)
'28'
str(a) # converte a
para string
>>> float(a) float(a) # converte a
para float
Tipos 28.0 int (a)
para inteiro
# converte a
Casting
(conversão de tipos) >>> int(3.14)
a = 1 # tipo inteiro
3
a = 'Maria' ou a="Maria" # string
a = 1.0 # float
>>> int(3.9)
106
>>> a=2.0
>>> a+1 # ou print(a+1)
3.0
Tipos
Tipagem Dinâmica >>> 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
107
bin converte um decimal p binário
oct converte um decimal p octal
hex converte um decimal p hexadecimal
>>> bin(5) >>> oct(5) >>> hex(15) >>> format(7,'b')

'111'
'0b101' '0o5' '0xf'
Tipos
>>> format(12,'o')
>>> bin(10) >>> oct(10) >>> hex(255)
'14’
'0o12' '0xff'
'0b1010'
>>> format(15,'x')
Conversão de bases >>> oct(8) >>> hex(100) 'f'
>>> bin(200)
(do decimal para '0o10' '0x64' Outra solução
'0b11001000'
binário, octal e hexadecimal)
• O format só funciona para conversão da base decimal (10) para as bases

convencionais (2, 8 e 16).
• Para as outras bases é preciso implementar uma função específica.
108
Zero (e sem espaços no meio) pode ser em maiúsculo ou em minúsculo
>>> 0b111 >>> 0o25 >>> 0xA

7 21 10
>>> 0b10 zero b >>> 0o17 >>> 0xFFF
2
15 4095
Tipos >>> 0b1010

>>> 0o77
63
>>> 0xA2
162
Conversão de bases 10
>>> >>>
Ao contrário, do binário, >>>
octal e hexadecimal para o

decimal
0b converte binário p decimal
0o converte octal p decimal
0x converte hexa p decimal
109
O número a ser convertido deve ser no formato string
>>> print int('01010101111',2)
687
>>> int('1010', 2)
Base do número a converter para decimal
10
Tipos >>>
int('28',7)
Conversão de bases >>> int('ff', 16) # dar erro pq n existe o dígito 8 na base 7
De qualquer base para 255

decimal
>>> int('b', 16)
11
Converte de qualquer base para decimal
110
2 8 10 16 b
binário octal decimal hexadecimal Qqr outra base
2 0b
- >>> 0b11
binário 3
8 - 0o
>>> 0o10
octal 8
Tipos 10
decimal
bin
>>> bin(101)
'0b1100101')
oct
>>> oct(9)
'0o11'
-
hex
>>> hex(15)
'0xf'
d2b
Operadores de Conversão
de bases
16 0x -
>>> 0x1F
hexadecimal 31
b int
>>> int('40',5)
Qqr b2b
20
outra base
111
def d2b(decimal,b):
if decimal==0:
return 0
else:
digitos='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
numb=''
num=decimal
while (num>0):
Sistemas de
num,rest=num//b,num%b
numb+=digitos[rest]
Numeração return numb[::-1]
Conversão de Bases >>> d2b(31,16)

'1F'
>>> d2b(13,2) def b2b(numero,b1,b2):
'1101' decimal=int(str(numero),b1)
numb2=d2b(decimal,b2)
return numb2
>>> b2b('F02',16,8)
'7402'
>>> b2b('450',6,4)
2232
112
 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

Tipos lâmpadas. Ao invés de armazenar cada informação em sua variável booleana, é mais
Operadores Bit a Bit
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, int('10110000',2) =176:
 luzes = 176 # 10110000 indica as lâmpadas acesas
113
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
Tipos ~ Complemento
Operadores Bits a Bits
114
bitsA 1 0 1 0
bitsB 1 0 1 1
^ 1 0 1 0
>>> bitsA = int('1010', 2) | 1 0 1 1
10
~ -1 0 1 1
>>> bitsB = int('1011', 2)
Tipos 11
Exemplo de Cálculo Bit a Bit
Operadores Bits a Bits bitsResultado = bitsA & bitsB

print(f'BitsA e bitsB = {bitsResultado:b})
Exemplo de aplicação
bitsResultado = bitsA | bitsB
print("bitsA ou bitsB = %s" % "{0:b}".format(bitsResultado))
bitsResultado = ~bitsA
print("Inversão dos bitsA = %s" % "{0:b}".format(bitsResultado))
115
 Outros tipos:
lista - para agrupar um conjunto de elementos, mas que tem

ordem.
Tipos tupla - semelhante ao tipo list, porém, imutável.
conjuntos dic - para agrupar elementos que serão recuperados usando

uma chave.
set - conjunto de valores.
116
Limpar a tela:
>>> import os
os.system('cls' if os.name == 'nt' else 'clear')
>>> from os import system

Limpar Tela >>> system('cls')
0
system('cls'))
>>>
def limpatela():
os.system('clear')
print("\x1b[2J")
117
import os
def limpar_janela():
from idlelib import idle
def limpar_janela():
Limpar Tela idle.clear_shell()
>>> import os
system('cls'))
limpar_janela() os.system('cls' if os.name == 'nt' else 'clear')

>>> from os import system
>>> system('cls')
0
>>>
118
Expressões Python
119
• Expressões
• Aritméticas
Expressões /
• Lógicas
Operadores
Lógicos e Aritméticos
120
>>> 8 -2*3
2
>>> (8 -2)*3
Operadores 18
Aritméticos
>>> 3**2
9 # potência
>>> pow(3,2) >>> pow(3,4)

9 # potência também 81
121
>>> 8/2
>>> 9//2
4.0 # divisão real 4 # divisão inteira
>>> -9//2
Operadores >>> 9/2
-5.0 # divisão inteira
Aritméticos
4.5 # divisão real >>> 9%2
1 # resto da divisão inteira
>>> -6/2
-3.0 # divisão real
122
Import math
>>> round(4.526,2)
4.53
-5 -4 -3 -2 -1 0 1 2 3 4 5 >>> round(-4.526,2)
-4.53
floor ceil floor ceil >>> round(-4.526,0)

-5.0
Operadores >>> int(4.7) >>> math.floor(4.5) >>> math.ceil(4.5) >>> round(4.5)
Aritméticos 4 4 5 4
>>> int(-4.7) >>> math.floor(-4.1) >>> math.ceil(-4.5) >>> round(4.8)

-4 -5 -4 5
>>> int(4.2) >>> math.floor(2.81) >>> math.ceil(2.81) >>> round(-4.5)

4 2 3 -4
>>> int(-4.2) >>> math.floor(-2.81) >>> math.ceil(-2.81) >>> round(-4.8)

-4 -3 -2 -5
Import math
int retorna a parte inteira, removendo a decimal. floor arredonda para o número para baixo
round arredonda para o inteiro mais próximo ceil arredonda para o número para cima
123
>>> 7%2
1 # o resto da divisão inteira de 7 por 2
# [7/2=3.5] [floor(3.5)=3] [3*2=6] [7-6=1]
Divisão real Divisão inteira multiplicação REST
O
>>> -7%2
Operadores 1 # o resto da divisão inteira de -7 por 2
Aritméticos # [-7/2=-3.5] [floor(-3.5)=-4] [-4*2=-8] [-7--8=-7+8=1]
O
>>> 7%-2
-1 # o resto da divisão inteira de 7 por -2
# [7/-2=-3.5] [floor(-3.5)=-4] [-4*-2=8] [7-8=-1]
O
>>> -7%-2
-1 # o resto da divisão inteira de -7 por -2
# [-7/-2=3.5] [floor(3.5)=3] [3*-2=-6] [-7--6=-7+6=-1]
O
124
>>> 8%3
2 # o resto da divisão inteira de 8 por 3
# [8/3=2.666] [floor(2.666)=2] [2*3=6] [8-6=2]
Divisão real Divisão inteira Multiplicação RESTO
>>> -8%3
1 # o resto da divisão inteira de -8 por 3
Operadores # [-8/3=-2.666] [floor(-2.666)=-3] [-3*3=-9] [-8--9=-8+9=1]
Aritméticos Divisão real Divisão inteira Multiplicação RESTO
>>> 8%-3
-1 # o resto da divisão inteira de 8 por -3
# [8/-3=-2.666] [floor(-2.666)=-3] [-3*-3=9] [8-9=-1]
>>> -8%-3
-2 # o resto da divisão inteira de -8 por -3
# [-8/-3=2.666] [floor(2.666)=2] [2*-3=-6] [-8--6=-8+6=-2]
125
>>> 9%2/2
0.5
Operadores
# o % tem a mesma prioridade que a /
Aritméticos # a prioridade é para o operador que vem
# em primeiro (i.e. que está do lado esquerdo)
# portanto aqui é o %
# 9%2/2 = (9%2)/2 = 1 /2 = 0.5
126
• Funções Aritméticas:
divmod(a,b) # (a//b, a%b)
Operadores
Aritméticos >>> a,b=7,3
>>> divmod(a,b)
(2, 1)
>>> divmod(a,b)[0]
2
>>> divmod(a,b)[1]
1
127
Prioridade Operador
1 ()
2 ** pow
3 * / // %
Operadores 4 + -
Aritméticos
Prioridades
128
1/3
Expressão Avaliação
a-c**2 ?
pow(b,2)-4*a*c ?
a-b*c-d ?
Operadores a/b*c-d ?
Aritméticos
Exercício 1
Variável Valor
a 12 8
b 4 -80
c 2 7
d -3 9.0
129
2/3
a//c-3 ?
a-2*b%d ?
a/c%b ?
Operadores a**(a%d) ?
Aritméticos
Exercício 2
Variável Valor
a 12 3
b 4 13
c 2 2.0
d -3 1
(2) 8%-3 # [8/-3=-2.666] [floor(-2.666)=-3] [-3*-3=9] [8-9=-1]

Divisão real Divisão inteira multiplicação RESTO
130
3/3
a//c-3 ?
a-2*b%d ?
a/c//b ?
Operadores a**(c%d) ?
Aritméticos 8*-b%a**(d-1) ?
Exercício
Variável Valor
a 6 -6
b 4 4
-1
c -2
6
d 3
4
131
> Maior que
>= Maior ou igual
< Menor que

Operadores
Relacionais <= Menor ou igual
Expressões Lógicas
== Igualdade
!= Diferente de (<>)
in pertence
132
>>> 4!=5
True
>>> 6==5
False
Operadores
Relacionais >>> 'Maria'=='maria'
False # Python é Case Sensitive
>>> resp='s'
>>> resp in ('s','S')
True # resp in ['s','S']
133
 Bug / Imprecisão
>>> ((1.5)-(1.0))
0.5
Bug >>> ((1.3)-(1.0))
0.30000000000000004 17º dígito
>>> ((1.1)-(1.0))
0.10000000000000009
>>> ((1.2)-(1.0))
0.19999999999999996
134
 Bug/Imprecisão
>>> y = 1.0/3.0
>>> y
0.33333333333333331
Bug >>> print y
0.333333333333
>>> y2 = round(y, 4)
>>> y2
0.33329999999999999
>>> print y2
0.3333
135
Saídas
136
a=2
b=3
print('A soma de ',a,' com ',b,' é: ',a+b)
print('A soma de '+str(a)+' com '+str(b) +' é:
Saídas '+str(a+b))
Comando print
A soma de 2 com 3 é: 5
137
a=2
b=3
print(a,b)
# é possível ter duas ou mais saídas no mesmo print
Saídas
print
2 3
138
a=8
b=6
print('A soma é: \n',a+b)
Print('\n\n') # pula duas linhas

Saídas print('A diferença é: ',a-b)
\n
A soma é:
14
A diferença é: 2
139
>>> idade=28
>>> nome="Lucas"
>>> print("Seu nome é %s e sua idade é %d"%(nome,idade))
Saídas
Formatação com o % Seu nome é Lucas e você tem 28 anos.
%s é uma lacuna que é preenchida por cada variável da lista na ordem que
elas se apresentam.
O % é usado para separar a mensagem com a máscara dos valores que são
colocados entre parênteses.
140
 Impressão por formatação:
>>> nome='João'
>>> sobrenome= 'Alberto'

Saídas
Formatação com o % >>> print("%s %s"%(nome,sobrenome))
João Alberto
141
Expressão Significado
%s String
Saídas %c Caractere
Formatação com o % %d Inteiro

%f Real (float)
%e Notação Científica (e)
%% um %
142
 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

# (número alinhado para a esquerda).
Saídas
>>> '%13f'%25
>>> '%5.2f'%20
' 25.000000' # 4 espaços '20.00'
Formatação com o % >>> '%10.2f'%25
' 25.00’ # 5 espaços >>> '%10.2f'%20

' 20.00'
>>> '%-10.2f'%25
'25.00 '
>>> '%-10.2f'%20
>>> '%-10.2e'%25 '20.00 '
'2.50e+01 '
>>> '%10.2e'%25
>>> '%-10.2e'%20
'2.00e+01 '
' 2.50e+01 '
143
>>> 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)
Saídas 3.142
Formatação com o % >>> print("%6.2f"%pi)
Uso das () 3.14
>>> import math
>>> '%6.2f'%math.pi
' 3.14'
print('%5.2f'%math.pi)
3.14
144
 Formatação usando a notação científica:
>>> x = 300000 = 3x105 = 300x102
>>> y = 0.00003 = 3x10-5
Saídas print('x=%.2e\ny= %.2e'%(x, y))
Formatação com o % # x=3.00e+05

%e
# y=3.00e-05
145
 Formatação usando a notação científica:
>>> print("%e"%10000)
1.000000e+04
>>> print("%e"%(10000))
Saídas 1.000000e+04
Formatação com o % >>> print("%2e"%(10000))
%e 1.000000e+04
>>> print("%.2e"%(10000))
1.00e+04
>>> print("%.0e"%(10000))
1e+04
146
Caracteres não imprimíveis:
Símbolo Efeito
\n New line
Saídas \t Tab
\ \\ \
\x41 'A' (caractere com código hexadecimal é 41)
\' '
\" "
147
 Caracteres não imprimíveis:
print('Sofiane\tLabidi\nCarla\tBrune')
print('Cesar\tMaia')
Print('\\')
Saídas
\
Sofiane Labidi
Carla Brune
Cesar Maia
148
 Caracteres não imprimíveis:
>>> print('\x27') # usando a representação em

# código hexa dos caracteres
'
>>> print('\x28')
Saídas (
\x >>> print('\x29')
>>> print('\x30')
>>> '\x29'
')'
149
 É possível desabilitar os efeitos da \ colocando na frente da
expressão a letra r:
Saídas >>> print(r'Sofiane\nLabidi')

r
Sofiane\nLabidi
>>>
150
 É 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\
Saídas Balsas')
\
São Luís Caxias
Imperatriz
Balsas
>>>
151
 É possível fazer a mesma coisa delimitando o texto em três aspas (simples ou duplas)!
# 3 aspas duplas
print("""
Maria
Joao
Maria
Saídas Carlos Joao
Carlos # afastado
’’’ ’’’ Roberta\n""")
Roberta
3 aspas (duplas ou # 3 aspas simples

Maria
simples) print(''' Joao
Carlos # afastado
Maria
Roberta
Joao >>>
Carlos
Roberta\n''')
152
 Usamos as aspas triplas também para poder imprimir aspas:
>>> print(''' ' ''')
'
Saídas
’’’ ’’’
>>> print('''a ' b''')
3 aspas (duplas ou
simples) a ' b
>>>
153
 Testando se uma string é vazia ou preenchida?
Se a string é vazia o operador bool retorna falso.
>>> bool('aabb')
True
Saídas >>> bool('a') s='aaabbb'

Vazia ou Preenchida? True If s: # bool(s)
print('String preenchido')
>>> bool('')
If not s:
False print('String vazio!')
>>> bool("")
False
154
>>> nm='João'
>>> nm
'João'
Saída
print >>> print(nm)
João
155
 .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
Saídas >>> a,b
Formatação
Moderna: .format (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
156
 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'))

Saídas
.format (usando os Maria gosta de Lucas. # usando índices
í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
157
 .format()
É possível usar referentes (apelidos) dentro da formatação e

usá-los em lugar dos índices.
Saídas >>> print('Este {objeto} é {adjetivo}.'.format(objeto='Relógio',

.format usando
referentes ou apelidos adjetivo='muito caro')
Este Relógio é muito caro.
# usando referentes (apelidos)
158
 .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
Saídas >>> print('A soma de {a} com {b} é {sm}'.format(a=a,b=b,sm=a+b))
.format usando A soma de 2 com 4 é 6 # usando os apelidos

referentes ou apelidos
>>> print('A soma de {b} com {a} é {sm}'.format(a=a,b=b,sm=a+b))
A soma de 4 com 2 é 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
159
 A formatação pode ser separada (colocada em uma variável de tipo string)
>>> s= 'O filme {0} do autor {1} merece {2} estrelas'

Saídas
.format >>> s.format('O Fugitivo','Harrsisson Ford', 4)
'O filme O Fugitivo do autor Harrisson Ford merece 4 estrelas'
160
>>> import math
>>> math.pi
3.141592653589793
Saídas >>> print('O valor de PI é aproximadamente {0:.3f}.'.format(math.pi))

Os f-strings
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}.')
161
>>> idade=28
>>> nome="Carla"
>>> print("{0:10} - {1:5}".format(nome,idade))
Carla - 28
Saídas # 10 caracteres p Carla e 5 dígitos p 28
.format
>>> >>> 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)
162
 Outro recurso para Formatação
f
>>> a=5
Saídas
f-strings >>> f 'O dobro de {a} é {2*a}' # aspa simples ou dupla
O dobro de 5 é 10 # pode usar o print
163
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(str(nome)+', você pesa'+str( peso)+'kilos. ') #2º formato de saída
Saídas print('%s, você pesa %5.2f kilos.'%(nome,peso))
print('%s você pesa %.2f kilos.'%(nome,peso))

#3º formato de saída: %
exemplo
print('{}, você pesa {} kilos.'.format(nome,peso)) #4º formato de saída:
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} kilos.') #5º formato de saída: f'
print(f'{nome:20}, você tem {peso:.2f} kilos.')
164
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.
Saídas
Configurações end sep e
file
# 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, no print: end='', sep='', file=''
165
 Redirecionado a saída para escrever em um arquivo de texto:
# Abrir o arquivo saída.txt no modo de escrita
arquivo = open("saida.txt", "w")

# Se o arquivo não existe ainda, ele é automaticamente criado
Saída # Redirecionar a saída para o arquivo
File (stdout)
print("Texto de exemplo", file=arquivo)
# Fechar o arquivo
arquivo.close()
166
 Para imprimir o conteúdo do arquivo de texto (saída.txt):
# Abrir o arquivo no modo de leitura

arquivo = open("saida.txt", "r")
Saída # Ler o conteúdo do arquivo
File (stdout) conteudo = arquivo.read()
# Imprimir o conteúdo
print(conteúdo)
# Fechar o arquivo arquivo.close()
167
>>> a,b,c=10,20,30
>>> print(a,b,c,sep='***',end='...\n')
10***20***30...
Saídas
Configurações end sep e
file
>>>
168
Esses dois comandos têm o mesmo efeito de pular uma linha em
branco:
print()
Saídas print('\n')
New Line
169
Entradas
170
 Para leitura de dados a partir do teclado, usaremos a função input.
>>> nome= input("Digite seu nome: ")

Digite seu nome: Sofiane
Entradas >>> nome

input 'Sofiane'
>>>
171
• A função input retorna um string.
• Para leitura de um inteiro ou real, é preciso fazer uma conversão

usando o int ou o flaot.
>>> idade= int(input("Digite sua idade: "))

Entradas
input Digite sua idade: 28
>>> idade
28
172
• 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

Entradas
eval 11
>>> eval("6*2")
12
Muito cuidado com o uso do comando eval!
173
• 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:
Entradas >>> import sys
version_info.major >>> sys.version
'3.11.3 (tags/v3.11.3:f3909b8, Apr 4 2023, 23:49:59) [MSC v.1934 64 bit

(AMD64)] '
>>> import sys
>>> sys.version_info.major
3 # retorna apenas o número da versão principal do Python
174
• Observação:
import sys
if sys.version_info.major == 2:
Entradas
Input / raw_input ? usuario = raw_input('Insira seu nome: ‘)
version_info.major
else sys.version_info.major == 3:
usuario = input('Insira seu nome: ')
175
 É 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
# o separador por default é o espaço
>>> e
Entradas '25'
split >>> f
'10'
>>> e,f
('25','10’)
# podemos ler várias variáveis, usando o split
176
 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
Entradas
split >>> a
'Carlos'
>>> b,c
('Maria', 'Lucas')
177
# Convertendo múltiplas entradas!
a,b=input().split()
67
a,b
('6', '7')
(a,b)[0] # (a,b)[1] dar
'7'
'6'
Map aplica uma função sobre todos os elementos da sequencia
Entradas (a,b)=map(int,(a,b))
Split e Map # é uma tupla
a,b
(6, 7)
a,b=map(int,input().split()) #é
uma tupla
43
>>> a,b
(4, 3)
O map só se aplica sobre listas, tuplas e strings mas não se aplica sobre os
dicionários.
178
>>> h,m = input("Que horas são: ").split(':') # : é o separador
Que horas são: 15:42
>>> h,m # strings
('15', '40') # h,m=map(int,(h,m))

Entradas
Split
# Conversão direta em inteiros
Conversão direta em
inteiros >>> h,m=map(int,input('Que horas são: ').split(':'))
Que horas são: 09:45
>>> h,m
(9, 45)
179
 # Quando a entrada não é de tipo string, é preciso fazer a conversão!
>>> nome=(input("Qual é seu nome: "))
Entradas
>>> idade=int(input("Qual é sua idade: "))
Conversão de tipos
>>> peso=float(input("Qual é seu peso: "))
180
• 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.
Entradas
Exercício
C / 5 = (F-32) / 9
181
Celsius Fahrenheit
0 32
15 59
-8.89 16
Entradas
C/5 = (F-32)/9
Exercício
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
182
# C/5 = (F-32)/9
# Celsius para Fahrenheit
C=float(input("Qual é a temperatura (em graus Celsius): "))
F=9/5*C+32
print(F)
Entradas 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))
183
Controle Condicional
184
Estruturas de Controle de Fluxo em Python
Declaração Loop While
Usada para executar um bloco de código enquanto uma

condição for verdadeira.
1 2 3
Declaração if Declaração Loop For
Usada para executar um bloco de código, se uma condição for Usada para iterar sobre um objeto e executar um bloco de
verdadeira. código.
• A construção if de controle condicional:
if <condição>:
Controle <expressão 1>

Condicional [else:
if
<expressão 3>]
186
# idade=18
idade=int(input('Informa sua idade: '))
if
if idade<20:
print("Você é jovem! ")
187
idade=int(input('Informa sua idade: '))
if idade>=18:
If-else print("Você é Maior de Idade! ")
else:
print("Você é Menor de Idade! ")
188
• A construção if de controle condicional:
if <condição>:
<expressão 1>
Controle [elif <condição 2>:
Condicional <expressão 2>]
if [else:
<expressão 3>]
189
hora=int(input('Informa a hora: ‘))
if hora<11:
print('Bom dia! ')
If-elif-else elif hora<17:
print('Boa tarde')
else:
print('Boa noite! ')
190
idade=int(input("Informa sua idade pfvr: "))
if idade<12:
print("Criaça!")
elif idade<15:
print("Pre Adolescente")
If-elif-else elif idade<17:
print("Adolescente")
elif idade<25:
print("Jovem")
elif idade<60:
print("Adulto")
else:
print("Idoso")
191
h,m=input('Informa a hora: ').split(':’)
h=int(h)
m=int(m)
if h<6:
If-else print('Boa madrugada')
Exercício elif h<12:
print('Bom dia!')
elif h<17:
print('Boa tarde')
else:
print('Boa noite!')
192
• Exercício 2:
Faça o programa Python que resolve uma equação de 1º

grau. ax+b=0
if
Exercício
ax+b=0
193
a=float(input('Digita o valor de a: '))
b=float(input('Digita o valor de b: ‘))
if (a==0):
if (b==0):
print('IR')
if else:
print('Impossível!')
split
else:
x = -b/a
print('A solução é: ',x) # 1º formato
print('A solução é: %.2f'%x) # 2º formato
print('A solução é: {:.2f}'.format(x)) # 3º formato
print(f'A solução é: {x:.2f}') # 4º formato
194
# 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)
if print('Raiz da equação {0:.2f}x+{1:.2f}=0 é {2:.2f}'.format(a,b,-b/a))

split
print(f'Raiz da equação {a:.2f}x+{b:.2f}=0 é {-b/a:.2e}')
# de duas maneiras, usando o .format() e o f' :
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
195
opção=input("Digita sua opção: ")
match opcao:
case "A":
print("Opção A selecionada")
If-elif-else case "B":
match print("Opção B selecionada")
case "C":
print("Opção C selecionada")
case _: # outro caso
print("Opção inválida")
196
numero = int(input("Entra com uma dizena: "))
match numeror:
case 10:
print("O número é DEZ.")
case 20:
If-elif-else print("O número é VINTE.")
case 30:
match
print("O número é TRINTA.")
case _:
print("O número é DEZ NÃO É 10, 20, ou 30.")
197
Estruturas de Repetição
198
• A expressão for é utilizada para percorrer listas, sequencias e realizar
processos iterativos:
for <referência> in <sequencia>:
<bolco de expressões>
Repetição continue
for
break
else:
<bloco de expressões>
199
• Exp:
>>> lista=[1,2,3]
>>> for i in lista:
Print(i)
Repetição 1
for 2
>>>
>>> for i in [1,2,3]: # range(1,4)
print(i)
200
for <objeto> in <lista de objetos>:
for i in range(3):
Repetição print(i,end=' ')

for
0 1 2
201
• A função range(m, n, p) define uma sequência de inteiros iniciada em m, menor do que n
(ou maior, depende da direção da sequência), a um passo p (podendo ser negativo):
>>> for i in range(1,10,2):
# range(inicio, fim, passo)
... print i
Repetição ...
range
1
202
• Faça o algoritmo que imprima na tela Boa tarde!
print('Boa tarde!')
• Faça o algoritmo que imprima na tela três vezes Boa tarde!
print('Boa tarde!')
print('Boa tarde!')
print('Boa tarde!')
Repetição print('Boa tarde!'*3) # print('Boa tarde!\n'*3)
Exercício
• Faça o algoritmo que imprima na tela 30 vezes Boa tarde!
for i in range(30):
print('Boa tarde!') # print('Boa tarde!',end='\n')
for i in range(30):
print(i+1,'. Boa tarde!')
203
• Não existe o comando downto no Python, mas é simulado usando o
range com passo negativo!
for i in range(5, -1, -1):

print(i)
Repetição 5
“Downto” 4
3
2
1
0
204
import time
for i in range(10, 0, -1):

print(i,end=' - ')
time.sleep(1) # espera um segundo antes de continuar
Repetição print("\nContagem regressiva concluída!")
“Downto”
10 - 9 - 8 - 7 - 6 - 5 - 4 - 3 - 2 - 1 -
Contagem regressiva concluída!
205
Terminar com ponto.
import time
for i in range(10, 0, -1):

if i==1:
c= '.\n'
else:
Repetição c=' - '
print(i,end=c)
“Downto” time.sleep(1) # espera um segundo antes de continuar
print("Contagem regressiva concluída!")
10 - 9 - 8 - 7 - 6 - 5 - 4 - 3 - 2 – 1.
Contagem regressiva concluída!
206
for i in range(30,0,-1):
print('{:02d}. Boa tarde!'.format(i))
30. Boa tarde!
Repetição
29. Boa tarde!
28. Boa tarde!
...
“Downto” 06. Boa tarde!
05. Boa tarde!
04. Boa tarde!
03. Boa tarde!
02. Boa tarde!
01. Boa tarde!
207
• While
while <condição>:
continue
Repetição
while break
else:
208
• Exemplo:
>>> a=0
>>> while a<5:
print(a)
Repetição a+=2 # step 2

while
209
• Fatorial de n (5)
fat(n) = 1*2*3* ... *n fat(0)=1
>>> n = 5 >>> n=5

>>> f = 1 >>> f=1
Repetição >>> i = 1
>>> while i<=n: >>> for i in range(1,6):
Exercício
fat=fat*i # fat*=i f*=i
i+=1 #
>>> f
i=i+1
120
>>> fat
120
210
i=0
while i < 5:
i += 1
if i == 3:
continue
print(i)
Repetição print("Fim do programa")

continue
1
2
4
5
Fim do programa
O continue faz com que o programa pule para a

próxima iteração do laço.
211
i=0
while i < 5:
i += 1
if i == 3:
break
print(i)
Repetição print("Fim do programa")
break
1
2
Fim do programa
Com o break, o programa sai imediatamente do

laço, ignorando o restante das iterações, e pular
para o 1º comando após o laço.
212
x = [1,3,5,7]
for i in x:
if i > 3:
print(i+1)
break
Repetição else:
break
print('Terminou')
Terminou
Terminou
6
213
nomes = ["João", "Maria", "Pedro", "Ana"]
for nome in nomes:
if nome == "Pedro":
print("Encontrado o nome Pedro!")
break
else:
print("Nome Pedro não encontrado na lista.")
print("Fim do programa")
Repetição
else Encontrado o nome Pedro!
Fim do programa
Nome Carla não encontrado na lista.

Fim do programa
O else em um laço (for ou while) é opcional. Ele é utilizado quando

desejamos executar algum código após o término normal do laço, sem
a necessidade de uma condição adicional.
214
numeros = [1, 2, 3, 4, 5]
for numero in numeros:

print(numero)
else:
print("Laço concluído sem interrupções")
Repetição 1
else 2
3
4
5
Laço concluído sem interrupções
215
contador = 0
while contador < 5:
print(contador)
contador += 1
else:
print("Laço concluído sem interrupções")
Repetição
else (while) 0
1
2
3
4
Laço concluído sem interrupções
216
O continue, break e o else funcionam tanto no for como no while.
O continue é usado para pular a iteração atual do laço e passar para a próxima
iteração, ignorando o restante do código dentro do bloco do laço.
Repetição O break é usado para interromper completamente o laço e sair do bloco de

repetição.
continue break else
O else é usado para especificar um bloco de código a ser executado quando a
condição do laço se tornar falsa, ou seja, quando o laço for concluído sem a
ocorrência de um break.
217
Criação de um Loop infinito
while True:
numero = int(input("Digite um número (ou 0 para sair): "))
if numero == 0:
Repetição print("Loop encerrado.")
Loop “Infinito” break
else:
print("O número digitado é:", numero)
Dentro do loop while True, é necessário ter uma lógica para interromper o loop
como uma declaração break ou uma condição if.
218
• Exercício:
• Imprima a série de fibionacci até 100.
Fib(0)=1
Repetição Fib(1)=1
Exercício Fib(n)=fib(n-1)+fib(n-2)
[0 1 1 2 3 5 8 13 21 34 55 89 144 233 … ]
219
• Fibionacci
>>> a,b = 0,1

>>> while b < 100:
print(b,end=' - ')
Repetição a, b = b, a+b
Exercício
# 1 1 2 3 5 8 13 21 34 55 89
220
• Se tiver 2 for aninhados, o break só termina o laço onde ocorre, e o laço externo
continua normalmente:
x = [1,3,5,7]
for i in x:
Repetição k = i+1
2 é maior que 1
break for n in range(10):
4 é maior que 3
if n > i:
6 é maior que 5
print(n,"é maior que",i) 8 é maior que 7
break 8
print(k) >>>
221
Um laço dentro de um outro laço.
for i in range(3):
for j in range(3):
print(i, j)
Repetição 00
01
Laços aninhados 02
10
11
12
20
21
22
222
Cria a Tábua de Multiplicação de um número n!
n=int(input('Número: ‘))
for i in range(1,10):
print(f'{n:2d}*{i}={n*i:02d}')
Número: 3
Repetição 3*1=03
3*2=06
Exercícios 3*3=09
3*4=12
3*5=15
3*6=18
3*7=21
3*8=24
3*9=27
223
Cria a Tábua de Multiplicação completa (n<=9).
for j in range(1,10):
Repetição print(f'{i:2d}*{j}={i*j:02d}')
Exercícios
print()
224
Imprimir um padrão de asteriscos nos seguintes formatos (A,B, C, D, e E):
(C)+
(D2)
**
** **
*** ***
Repetição (5x5) (5x5) (10x5) (3x5)
**** ****
* * ** *** **********
Exercícios ** ** ** ** *** **
*** *** *** *** **
**** **** **** **** *** **
***** ***** ********** *** **
(A) (B) (C) ***
(D) (E)
225
car='*'
# (D)
# (A) for i in range(5):
for i in range(6): for j in range (3):
print(car*i) print(car,end='')
print()
Repetição # (B)
for i in range(6): # (E)
Exercícios print(' '*(5-i)+car*i) for i in range(1,6):
print(' '*(5-i)+car*2*i)
for i in range(5):
# (C) for j in range (4):
print(' ',end='')
print(' '*(5-i)+car*2*i) print(car*2)
226
Funções
227
nome da função Parâmetros de entrada da função
def media (a,b):

return (a+b)/2
Valor de saída da função
Funções
Definição / Criação
print(media(7,9)) # chamada da função
8.0 #
resultado da chamada
print(media(7.5,6)) # chamada da função

6.75 # resultado da
chamada
228
Parâmetros de entrada da função
nome da função
def maior (a,b):

if a>b:
Valor de saída da função
return a
Funções else:
return b
Definição / Criação
print(maior(-2,3),end=' - ') # chamada
print(maior(5,1))
3–5 #
resultado da chamada
229
def abs (a): # função valor
absoluto
if a>0:
return a
else:
Funções return -a
Definição / Criação print(abs(-2)) # chamadas
print(abs(6))
2 #
resultados
6
230
def eh_par(num):
if num%2==0:
return True
else:
return False
Funções
Definição / Criação a=int(input('Digita um número: '))
print(eh_par(a))
Digita um número: 8
True
231
import math
def area_circulo(raio):
return math.pi*raio**2
Funções
Definição / Criação raio=int(input('Digita o raio do Círculo: '))
print(f'A áre ado círculo é {area_circulo(raio):.2f}')
Digita o raio do Círculo: 10

A área do círculo 314.16
232
 Cria as funções:
 diametro_circulo
 area_circulo
 Perimetro_circulo
Funções
Exercício
233
import math
def area_circulo(raio):
return math.pi*raio**2
def diametro_circulo(raio):
return raio*2
Funções def perimetro_circulo(raio):

return diametro*math.pi
Exercício
raio=int(input('Digita o raio do Círculo: '))
print(f'{diametro_circulo(raio):.2f}')
print(f'{area_circulo(raio):.2f}')
Digita o raio do Círculo: 5

6.28
78.54
234
def f():
pass
Funções # cria uma função sem código (sem ação!)

Função Vazia # a ser definido depois!
235
def funcao_sem_retorno():
print("Esta função não retorna nenhum valor.")
return None
def funcao_sem_retorno():
print("Esta função não retorna nenhum valor.")
Funções return
Retorno Vazio
O return com o None é equivalente ao return sem nada
236
São funções anônimas (sem nome, cujo o nome padrão é lambda)
>>> lista = [1, 2, 3, 4, 5]

# lista
>>> dobro = list(map(lambda x: x * 2, lista))
>>> dobro
[2, 4, 6, 8, 10]
Funções >>> tupla = (2, 1, 4,6)
# tupla
Lambda Funções
>>> triplo = tuple(map(lambda x: x * 3, tupla))
>>> triplo
(6, 3, =12,
frase 18)Mundo'
'Olá
# string
maiusculas = ''.join(map(lambda x: x.upper(), frase))
>>> maiúsculas
"OLÁ MUNDO"
map se aplica sobre as listas, tuplas e strings mas não se aplica sobre os dicionários.
237
Não é possível aplicar o map diretamente nos dicionários, mas podemos aplicas nos
valores do dicionário.
dic1 = {'a': 1, 'b': 2, 'c': 3}

# Aplicando o map() aos valores do dicionário
novos_valores = dict(map(lambda item: (item[0], item[1] * 2), dicionario.items()))
Funções print(novos_valores)
# Saída: {'a': 2, 'b': 4, 'c': 6}
Lambda Funções
dicionario = {"a": 1, "b": 2, "c": 3}
# Usando uma compreensão de dicionário para aplicar o map() aos valores do dicionário
novos_valores = {chave: valor * 2 for chave, valor in dicionario.items()}
>>> print(novos_valores)
{'a': 2, 'b': 4, 'c': 6}
238
• Uma função pode retornar vários valores?
• Sim, e de várias formas!
def retorna_valores():
a,b = 10, 20
return a, b
Funções # Chamada da função

Multivalores >>> res1, res2 = retorna_valores()
>>> print(res1)
10
>>> print(res2)
20
239
def retornar_valores():
valor1 = 10
valor2 = "Olá"
valor3 = [1, 2, 3]
return valor1, valor2, valor3
Funções # Chamando a função e recebendo os valores retornados

Multivalores res1, res2, res3 = retornar_valores()
print(res1) # 10
print(res2) # "Olá"
print(res3) # [1, 2, 3]
240
def f():
a,b,c,d,e,f,g=1,2,3,4,5,6,7
return a,b,c,d,e,f,g
>>> x,y,z,t,u,v,w=f()
Funções
Multivalores >>> print(x,y,z,t,u,v,w)
1234567
Não há um limite específico em relação à quantidade de valores que

uma função pode retornar.
241
• 2ª Solução: sob forma de uma lista !
# Podemos juntar todos os valores para retornar em uma Lista

def retorna_valores():
lista_valores = [10, 20]
return lista_valores
Funções
# Chamada da função e acesso aos valores retornados
Multivalores (listas)
resultado = retorna_valores()
>>> print(resultado[0])
10
>>> print(resultado[1])
20
Podemos juntar todos os valores em uma Lista e retornar esta lista.
242
 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.
 Todas as variáveis definidas fora de uma função / bloco é considerada

Funções
como variável global.
Variáveis locais vs globais
243
As variáveis globais têm visibilidade em
Variáveis Globais
todos os lugares dentro do programa
(inclusivo, dentro das funções e dos blocos de Função 1
código). Variáveis Locais 1
Porém, se, dentro de uma função, existe uma
variável (local) com o mesmo nome que uma
variável global, o que vale é a variável local e, Função 2
Funções portanto, as mudanças no conteúdo dessas Variáveis Locais 2
Escopo variáveis locais não se reflitam nas variáveis

(Portabilidade/Visibilidade) globais (variáveis com o mesmo nome) fora da
das Variáveis Locais e Globais
função.
Contudo, se desejamos que essas mudanças se
repercutem fora da função, é preciso declarar
tais variáveis como globais (dentro da função
Escopo das Variáveis Globais e Locais
ou bloco [global x].
244
Exemplo de Variável Global
x = 10 # Variável global
def minha_funcao():
print(x) # Acessando a variável global dentro da função
minha_funcao() # 10
Funções
Variáveis locais vs globais Exemplo de Variável Local
def minha_funcao():
y=5 # Variável local
print(y) # Acessando a variável local dentro da função
minha_funcao() # 5
245
Modificação de Variável Global dentro de uma Função
def minha_funcao():
global x # Declarando a variável global dentro da função
x = 20 # Modificando o valor da variável global
minha_funcao()
print(x) # 20
Funções
Variáveis locais vs globais Variável Local com o mesmo Nome da Variável Global
def minha_funcao():
x=5 # Variável local com o mesmo nome da variável global
print(x) # Acessando a variável local dentro da função
minha_funcao() # 5
print(x) # 10 (a variável global não é afetada)
246
def f1(): def f4():
print(x) # global global x
print(x)
x=10
f1() # 10 (x é X=3
global) f4() # 3
print(x) # 3 x é global
def f2(): def f5():

print(x) x=2
x=1 # essa atribuição a torna local global x
Funções x=6 print(x)
f2() # erro x é local, sem valor f5()
Variáveis locais vs globais
print(x) # erro x atribuída um
# valor (vira local) antes de
def f3(): # ser definida como global
print(x)
# x=1 def f6():
x=1
x=6 print(x) # ok (local) 1
f3() # 6 x é global
x=4
f6() # 1
print(x) # 1 4
247
def f6():
def f8():
global x
global x
x=2
x=1
print(x)
print(x)
X=4
f6() X=6
print(x) # 4 2 2 f8()
print(x) # 1 1
Funções def f7():

Variáveis locais vs globais #print(x) # dar erro
x=2 # x local
print(x)
x=4 # x
global
f7()
print(x) # 2 4
248
 Variáveis globais não são aconselhados no Python, pois elas tornam o código
mais difícil de ler e modificar podendo levar a bugs difíceis de serem
encontrados.
Funções  É por isso que o Python força o programador a explicitar suas variáveis
Variáveis locais vs globais globais quando quiser alterá-las fora do escopo global.
249
 Passagem por referência:
 A passagem de Parâmetros no Python é feita por referência. I.e. ao

chamar uma função e passar um objeto como argumento, na verdade o que
é passado é uma referência a esse objeto e não uma cópia do objeto em
Funções si.
Passagem de Parâmetros  Contrariamente à passagem por valor, na passagem por referência, as

alterações realizadas dentro da função se reflitam automaticamente sobre
as variáveis associadas (chamadoras) fora da função.
250
def alterar_val(numero, lista):
numero = 10
lista.append(4)
v=5
lst = [1, 2, 3]
alterar_val(v, lista)
Funções print(v) # irá imprimir 10
print(lst) # irá imprimir [1,2,3,4]
Passagem de Parâmetros
Ao chamar a função alterar_val, a variável v passa seu valor 5 à variável numero

que assumirá o valor 5 dentro da função. A variável numero mudará de valor e
receberá o valo 10 dentro da função.
Como a passagem de variáveis no Python é feita por referência isto implica que a
variável v (chamadora/associada) mudará e assumirá também o valor 10.
Da mesma forma, a alteração da variável lista, dentro da função, se reflita também na
variável lst.
251
Uma função recursiva é uma função que se chama a si mesma dentro
do seu próprio corpo.
É uma técnica poderosa de programação que permite resolver
problemas de forma elegante e eficiente, dividindo-o em subproblemas
Funções menores.
Funções Recursivas
252
Cria a função Fatorial (versão recursiva):
fatorial(0)=1
fatorial(n)=1*2*3* ... *n
def fatorial(num):
if num==0:
Funções return 1
Funções Recursivas else:

return num * fatorial(num-1)
n=int(input('Valor de n: '))
print(f'Fat({n})={fatorial(n)}')
253
Cria a função Fatorial (versão iterativa):
fatorial(0)=1
fatorial(n)=1*2*3* ... *n
def fatorial2(num):
f=1
Funções for i in range(2,num+1):
Funções Iterativa f*=i
return f
n=int(input('Valor de n: '))
print(f'Fat({n})={fatorial2(n)}')
254
 Função que procura um caractere em uma string:
def achar(c,s):
i=0
>>> achar('a','Sofiane')
Funções while i < len(s):
4
Exercícios if s[i] == c:
>>> achar('b','Sofiane')
return i
-1
i+=1
return -1
255
 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
Funções while (i<len(s)) and (not achei):
if s[i]==c:
Exercícios
achei=True
p=i >>> achar('a','Sofiane')

(True,4)
i+=1 >>> achar('b','Sofiane')
(False,-1)
return(achei,p)
256
 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:
Funções if letra == c:
>>> fruta = 'banana'
Exercícios
contador +=1 >>> contar('n',fruta)
2
return(contador)
257
 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():

Funções cp+=1
Exercícios >>> frase('Maria Adora Cinema e Futebol.')
for letra in palavra:
Palavras: 5 Caracteres: 25
cc+=1
print(f'Palavras: {cp} Caracteres: {cc}')
# return(cp,cc) # a,b=frase('Boa noite') # (2,8)
258
 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'
Funções
Exercícios
>>> eMinusculo('B’)
False
>>> eMinusculo('a’)
True
259
 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

Funções vários valores.
Procedimento
260
• Cria a função menu com as seguintes quatro alternativas para cálculo:
1) Somar, 2) Subtraia, 3) Multiplicar, e 4) Dividir, dois números a
serem lidos pelo teclado.
Funções *******************
* MENU *
Exercícios: Menu *******************
* 1. Somar *
* 2. Subtrair *
* 3. Multiplicar *
* 4. Dividir *
* 5. Sair *
*******************
261
def linha(n,car):
print(car*n)
def linhal(n,car):
linha(n,car)
print()
def escreva(n,car,texto):
Funções x=n-len(texto)-2
esquerda=x//2
Exercícios: Menu direita=x//2+x%2
print(car+' '*esquerda+texto+' '*direita+car)
def cabeçalho(n,car,titulo):
print()
linha(n,car)
escreva(n,car,titulo)
linha(n,car)
262
def menu():
cabeçalho(n,car,'MENU')
escreva(n,car, '1. Adicionar ')
escreva(n,car, '2. Subtrair ')
escreva(n,car, '3. Multiplicar ')
escreva(n,car, '4. Dividir ')
escreva(n,car,'0. Sair ')
linha(n,car)
opção=input('Sua opção [0..1]: ')

Funções match opção:
Exercícios: Menu case '1': import keyboard
somar()
case '2': keyboard.read_key()
subtrair()
case '3': car='*'
multiplicar() n=26
case '4': while True:
dividir() op=menu()
case '0': if op==0:
print('Saindo...') break
case _:
print('Opção errada!’) print(Tchau!')
return opção
263
Funções
Captura de Tecla
264
Coleções de Dados
265
 Strings. fr='João bebeu água.'
 Listas. Os elementos de uma lista são colocados em sequência e para cada um deles é
determinado um índice numérico que inicia no 0.
a = [] b=[5,3,6,1] c=[8, 'João',6.5] c[1]=5
 Tuplas. Funciona da mesma forma que listas, mas os elementos são imutáveis (seus
Strings, Listas, elementos não podem ser alterados).
tuplas, Sets e a = (3,1,2,3,6) # estrutura heterogênea
Dicionários,  Sets. Conjuntos
Arrays c={8,9, 'Carlos'}
 Dicionários. Os índices dos dicionários não precisam ser numéricos.
a={'i1':'v1','i2':'2','i3':'v3'}
Separador & Delimitador
 Listas e Tuplas são estruturas indexadas. Indexação e Mutação
Homogêneos vs. Heterogêneos
 Dicionários e Sets são estruturas não indexadas.
266
 Coleções são estruturas de dados sequenciais de objeto:
 No Python destacamos os:

 Strings. Compostas por caracteres, e
Coleções de s=[2,'b,4,56,'cde']
Dados  Listas formados por elementos de qualquer tipo.
Strings, Listas, Tuplas,
lst=[2,'b',4,56,'cde']
Sets e Dicionários
 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).
267
Objeto Mutável Objeto Imutável
Listas Números (int, float)
Coleções Conjuntos
Dicionários
Strings
Tuplas
de Dados Objetos personalizados Booleanos

(Classes criadas)
Strings, Listas, Tuplas,
Sets e Dicionários
268
Coleções de Dados
Strings
269
>>> "abcdefg".index("c") # é a mesma coisa que o find
2 # apenas retorna erro qdo o substring

# não existe
>>> "abcdefg".index("d")
...
Strings
3
Manipulação de Strings
>>> "abcdefg".index("x")
...
ValueError: substring not found
270
 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.
Strings
Manipulação de Strings,
>>> a+' '+b+' '+'Cidade do Amor' >>> a+='\t\t'
Concatenação usando o +
# equivalente a a=a+'\t\
'São Luís Cidade do Amor' t'
>>> a
'São \t\t'
>>> print(a+' '+b+'\t'+'Cidade do Amor.') >>> print(a,'Luís')
São Luís
São Luís Cidade do Amor.
271
 Concatenação de strings usando o operador join:
>>> s1='Bom'
>>> s2='dia'
>>> ''.join((s1,s2)) # sem espaço

'Bomdia' # em uma tupla: (str1,str2,str3,...)
>>> ' '.join((s1,s2)) # com espaço

Strings 'Bom dia'
Manipulação de Strings,
>>> ','.join((s1,s2)) # com vírgula como separador
Concatenação usando o join # ''.join(('Ana','tem','um','filho.'))
'Bom,dia'
# 'Anatemumfilhoo.'
>>> ' '.join((s1,s2,'.')) # aqui o separador especificado é o vazio
'Bom dia .'

>>> ','.join((s1,s2))
>>> ' '.join((s1,s2,'Maria.')) 'Bom,dia'
# aqui o separador especificado é a vírgula
'Bom dia Maria.'
272
 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
Strings 'a,b,c' # de uma lista.
Operadores de >>> ''.join(['a','b','c'])

Manipulação 'abc'
>>> ' '.join(['a','b','c'])
'a b c' Conversão de uma lista para uma string usando o

Join. Ou seja, concatenando os elementos de uma
>>> ' '.join(['a','b','c']) lista.
'a b c'
273
 Conversão String <–> Lista
>>> l=['João','gosta','de','Música']
>>> s=' '.join(l) # criando um string tendo o espaço como

# separador
>>> s
Strings 'João gosta de Música'
Operadores de
Manipulação
>>> l=s.split() # divide o string em elementos, a cada espaço,

# formando uma lista
>>> l
['João', 'gosta', 'de', 'Música']
274
 Conversão String -> Lista usando o Split()
>>> s='São Luís' # A string s é convertida em uma lista l
>>> l=s.split() # por default, a divisão é feita a cada espaço.
>>> l
['São', 'Luís']
Strings >>> s.split()[0] # Como o split retorna uma lista, então podemos
Operadores de
Manipulação: split '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']

275
 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'
'João gosta de Música'

Strings
Operadores de
Manipulação >>> 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.
276
 Concatenação de strings usando o operador __add__ :
>>> s1='Boa'
>>> s2='Tarde.'
>>> s1.__add__(s2)
Strings 'BoaTarde.' # colocados juntos sem espaço no meio.
Manipulação de Strings
>>> (s1.__add__(' ')).__add__(s2)
'Boa Tarde.' # aqui um espaço é concatenado no meio
>>> s1.__add__('Tarde!')
'Boa Tarde!'
277
 Multiplicação de strings *:
>>> a*4
'São São São São'
Strings
Manipulação de Strings >>> 'Aa'*3
AaAaAa
278
 Multiplicação de strings *:
>>> print(((('Maria'+'\t')*2)+'\n')*5)
Maria Maria
Strings Maria Maria
Manipulação de Strings Maria Maria
Maria Maria
Maria Maria
279
>>> len("abcdefg") # tamanho
7
>>> "Sami".startswith("S") # inicia por ?

True
>>> "Sami".startswith("s")
Strings True
Manipulação de Strings >>> "Sami".endswith("i") # termina por ?

True
>>> "am" in "Sami" # substring ?

True
>>> "im" in "Sami"
False
280
>>> '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 parâmetro do find deve ser uma string
0
Strings >>> 'Sofiane'.find('ane')
Manipulação de Strings 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 intervalo da pesq.
4
281
>>> s='José Carlos'
>>> s.find('o')
>>> s.find('o',s.find('o'))
Strings
Manipulação de Strings 1
>>> s.find('o',s.find('o')+2) # inicia a busca a partir da posição 3

9 # (3 = 1+2)
282
 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

Strings 'a'
Slicing/Fatiamento de
Strings >>> nome[2] # 3° elemento do string
'r'
>>> 'Carla Bruni'[-1] # último elemento do string
'i'
>>> 'Carla Bruni'[-2] # penultimo elemento do string
'n'
283
 Fatiando strings:
>>> nome='Carla Bruni'
>>> nome[2:4] # do 2° índice até o 4° índice (4° não incluso)
'rl'
Strings >>> nome[2:] # do 2° até o fim (último)
Strings 'rla Bruni'
>>> nome[:2] # do início até o 2° elemento (2° não incluso)
'Ca'
>>> 'Carla Bruni'[::] # imprime tudo
'Carla Bruni'
284
>>> 'Carla Bruni'[-2:] # do penúltimo até o fim
'ni'
Strings
Slicing/Fatiamento de >>> 'Carla Bruni'[:-2] # do início até o penultimo (este não é incluso)
Strings
'Carla Bru'
285
>>> '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'
Strings >>> 'Carla Bruni'[::-1] # imprime tudo o string de tras pra frente (passo -1)
'inurB alraC' # reverte o string (a ordem das letras)

Strings Passo >>> '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'
286
 Reversão de strings:
>>> s
'Carla Bruni'
Strings >>> s=s[::-1] # imprime tudo o string de tras pra frente (passo -1)
Operadores de
Manipulação
>>> s
'inurB alraC'
287
 2ª Solução: Reversão de strings (usando o reverse das listas):
lista = list(string)
Strings lista.reverse()
Operadores de string_revertida = ''.join(lista)
Manipulação
288
 Outras operações de strings:
>>> 'ABCD'.lower() # converte tudo para minúsculos
abcd
Strings
Operadores de
Manipulação >>> 'abcd'.upper() # converte tudo para maiúsculos
ABCD
>>> 'AbcD'.swapcase() # altera maiúsculos/minúsculos
aBCd
289
 Checar se uma palavra/texto é em maiúsculo ou minúsculo:
>>> 'SOFIANE'.isupper()
True
>>> 'Sofiane'.isupper()
False
Strings >>> 'Brasil'.islower()
False
Operadores de
Manipulação >>> 'brasil'.islower()
True
>>> s.upper().isupper()
True
>>> 'São Luís, Ilha Do Amor!'.istitle() # verifica se é um title
True
290
 Checar o conteúdo de uma palavra/texto é alfanumérica:
>>> '245'.isdigit() # todos de [0,9], apernas números.
True
>>> '2 4b5'.isdigit()
False
Strings >>> 'abcx'.isalpha() # verifica se a string contém apenas caracteres
Operadores de True
Manipulação >>> 'abh! '.isalpha()
False
>>> 'ab52c'.isalnum() # verifica se a string é composta por alfanuméricos
True
>>> 'a67b5c'.isalnum()
False
291
 Checar se só há espaços na string:
>>> ‘>> >>> ''.isspace()
False
>>> ' '.isspace()

Strings
True
Operadores de
Manipulação
>>> ' '.isspace()
True
>>> ' e '.isspace()
False
292
 Adicionando espaços na string:
>>> >>>>> 'Karen'.ljust(10) # alinhamento à esquerda
'Karen '
Strings >>> 'Karen'.rjust(10) # alinhamento à direita
Operadores de ' Karen'

Manipulação
>>> 'Karen'.center(10) # centraliza o texto
' Karen '
293
 Os caracteres em branco (na esquerda e na direita) podem ser eliminados usado a função
strip:
>>> ‘>>
>>> ' Karen. '.strip()
'Karen.'
>>> 'Karen.'.rjust(15).strip()
Strings 'Karen.'
Operadores de
Manipulação >>> 'Karen.'.ljust(15).rstrip()
'Karen.'
>>> 'Karen.'.ljust(15).lstrip()
'Karen. '
294
 Outras operações de strings: Eliminando caracteres brancos
>>> ' abcd e fgh '.lstrip() # Elimina os caracteres em branco
'abcd e fgh ' # do lado esquerdo
Strings >>> ' abcd e fgh '.rstrip() # Elimina os caracteres em branco
Operadores de ' abcd e fgh' # do lado direito

Manipulação
>>> ' abcd e fgh '.strip() # Elimina os caracteres em branco
'abcd e fgh' # dos lados direitro e esquerdo
295
>>> s='PARIS cApital da frança’
>>> s.lower()
'paris capital da frança'
Strings >>> s
'PARIS cApital da frança'

Operadores de
Manipulação >>> 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úsculo
>>> s.upper() # transforma tudo em maiúsculo
'PARIS CAPITAL DA FRANÇA'
296
>>> 'Carla Bruni'.replace(' ',' - ')
'Carla - Bruni'
>>> s='Olá Carla!'

Strings >>> s.replace('Carla','Lucas')
Operadores de
Manipulação 'Olá Lucas!'
>>> s.replace('x','oo')
'Olá Carla!' # caso o caractere não existe, o python retorna

# o mesmo string
297
 Strings são imutáveis:
>>> nome='Caren'
Imagina que digitamos o nome de Caren com C e que precisamos corrigir para Karen (trocando o C pelo
K).
Intuitivamente, íamos executar o seguinte comando:
Strings >>> nome[0]='K'
isto gera erro, pós as strings no python são imutáveis.

Operadores de
Manipulação A solução é de criar uma cópia da string (nova string):
>>> novonome='K'+nome[1:]
>>> novonome
'Karen'
298
 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.

Strings
>>> a= 'Olá'
Operadores de
Manipulação >>> id(a)
1868623968
>>> a='Maria'
>>> id(a)
103937920
299
 Comparando Strings
>>> 'Fortaleza'<'Salvador'
True
>>> 'Bahia'!='Pernambuco'
Strings True
Operadores de
Manipulação
>>> 'Maranhão'>='Maranhão'
True
if Cidade_Nascimento'== 'São Luís' :
print(' Você é Ludovicense')
300
 Iterando/Percorrendo um String
>>> for c in 'Lucas': # c: caractere (uma letra)
print(c)
Strings L
Operadores de
Manipulação u
>>>
301
>>> for c in 'Lucas': # c: caractere (uma letra)
print(c,end=' ') # por default o end='\n'

Strings
Operadores de
Manipulação
L u c a s
>>>
302
>>> s='Fruta'
>>> i=0
>>> while i<len(s):

Strings
c=s[i]
Operadores de
Manipulação print(c,end=' ')
i+=1
F r u t a
>>>
303
 O comando chr imprime o caractere correspondente ao código ascii passado como
parâmetro:
>>> chr(42)
'*'
>>> chr(97)
Strings 'a'
chr >>> chr(123)
'z'
>>> chr(65)
'A'
>>> chr(91)
' Z'
304
 Imprime as letras do alfabeto:
>>> for i in range(97,123): # 97=a 123=z
print(chr(i),end=' ') # por default end='\n'
Strings abcdefghijklmnopqrstuvwxyz
chr
>>> for i in range(65,91): # 65=A 91=Z
print(chr(i),end=' ')
AB CDEFGHIJKLMNOPQRSTUVWXYZ
305
• 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',
Strings 'r','s','t','u','v','w','x','y','z']
# gerar uma lista
chr
>>> {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)
306
 Imprime as letras do alfabeto (mais um método):
>>> l=map(chr,list(range(65,91)))
Strings >>> for i in l:
chr print(i,end=' ')
ABCDEFG H IJK LM NO PQ RSTUVW

XYZ
307
Coleções de Dados
Listas
308
# É um conjunto de elementos heterogêneos e ordenados.
>>> lista1=[] # criação de uma lista vazia
>>> lista1
[]
>>> [1,2,3,4][-1] # retorna o último elemento da lista especificada a esquerda
Listas >>> lista2=[6,8,'Carla',10.5,False] # estrutura heterogênea
Criação e Acesso >>> lista2
[6,8,'Carla',10.5,False] # zero indexed
>>> lst=[4,2,1,6,0] # estrutura mutável
>>> lst[2]=5
[4,2,5,6,0]
>>> lista=[4,2,5,[2,8,[],3],10,5.4] # estrutura composta
309
 O comando list cria uma lista a partir de uma série de argumentos:
>>> lst1=list(range(5)) # 5 elementos (de 0 a 4)
[0,1,2,3,4]
Listas
Construção: operador
list >>> lst2=list(range(1,10,2)) # de 1 a 10 com passo 2
[1,3,5,7,9]
310
>>> lista=list(range(5)) # criação
[0,1,2,3,4]
>>> lista = [x*2 for x in range(8)] # criação
[0,2,4,6,8,10,12,14] # cria um objeto de tipo lista
Listas
Construção / Generators [x for x in range(10) ]
[0,1,2,3,4,5,6,7,8,9]
[x for x in range(50) if x % 4 == 0]
# [0,4,8,12,16,20,24,28,32,36,40,44,48]
311
 Listas aninhadas (Listas Compostas):
>>> lista=[6,'d',[10,8],5]
Listas >>> lista=[[5,4,8],[1,6,10,2,5,5,7]]
Listas aninhadas
312
# 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.
Listas 25
Acessando pelo índice >>> lista[1] # 2º elemento da lista.

[10]
>>> lista[2]*4
8
>>> lista[-1] # último elemento da lista

[34]
313
 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:
>>> l1=[1,2,3,4,5,6] >>> l1=[1,2,3,4,5,6]
>>> l2 = l1 >>> l3 = l1[:] # cria um clone l3 de l1

>>> l2 >>> l3 is l1
Listas [1, 2, 3, 4, 5, 6] False
Cópia de Lista: clone >>> l2 is l1 >>> l1 is l3

True False
Operador is
>>> l1 is l2
# listas com mesmo conteúdo, porém
True
# com referências diferentes
# listas equivalentes
314
 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.

Listas >>> b
Cópia de Lista: clone
[20,21,22,23,24]
Operador is
>>> 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.
315
>>> 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.
Listas [20, 31, 22, 23, 24] # as duas listas têm ids diferentes.
Cópia de Lista: clone >>> b
Operador is [20, 21, 22, 23, 24]
>>> a==b
False
>>> a is b
False
316
 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
Listas
>>> a # na nova lista.
[20, 31, 22, 23, 24] # as duas listas têm ids iguais.
>>> b
Operador is
[20, 31, 22, 23, 24]
>>> a==b # mesmo conteúdo
True
>>> a is b # mesma referências
True
317
>>> a=[1,2,3,4]
>>> b=['a','b']
>>> a[2]=b
Listas >>> a
[1, 2, ['a', 'b'], 4]
Operador is
318
>>> a=[1,2,3,4]
>>> a=[1,2,3,4]
>>> b=['a','b']
>>> a[2:5]=b
>>> a[2:2]=b >>> a
>>> a [1, 2, 'a', 'b']
[1, 2, 'a', 'b', 3, 4]

>>> a=[1,2,3,4]
>>> a=[1,2,3,4]
Listas >>> a[2:3]=b
>>> a[2:6]=b
>>> a
Cópia de Lista: clone >>> a [1, 2, 'a', 'b']
Operador is [1, 2, 'a', 'b', 4]
>>> a=[1,2,3,4]
>>> a=[1,2,3,4]
>>> a[2:]=b
>>> a[2:4]=b
>>> a
>>> a
[1, 2, 'a', 'b']
[1, 2, 'a', 'b']
319
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> x[:0] = y # inserção/concatenação a esquerda
>>> x
[4, 5, 6, 1, 2, 3]
Listas
>>> x=[1,2,3]
Operador is
>>> x[0:]=y
>>> x
[4, 5, 6]
320
>>> x[:] = []
# apaga o conteúdo de uma lista

Listas
Apagar conteúdo
321
>>> x=[1,2,3]
>>> id(x)
103175032
>>> y=x # clone >>> id(z)
>>> id(y) 103318112
Listas 103175032
>>> z is x
False
Cópia de Lista: clone >>> z=x[:]# clone
>>> y is x
Operador is
>>> z True
[1, 2, 3] # y é uma copia idêntica
# z não é (apenas de conteúdo)
x is y
False
322
>>> x = [1, 2, 3]
>>> y=x
>>> id(x)
101864432
>>> x[:]=[]
Listas >>> x
[]
Operador is >>> x is y
>>> y True
[] >>> y is x
True
>>> id(x)
101864432
323
>>> a=list(range(10,14))
>>> a
>>> a=list(range(10,14))
[10, 11, 12, 13] >>> a
>>> a[2:]=['a','b','c'] [10, 11, 12, 13]
>>> a.insert(2,['a','b','c'])
Listas >>> a
>>> a
[10, 11, 'a', 'b', 'c']
Cópia de Lista: clone [10, 11, ['a', 'b', 'c'], 12, 13]
Operador is
posição 2
324
>>> a=list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b=2*['bola']
>>> b
Listas ['bola', 'bola']
>>> a[::3]= ['a','b','c','d'] # em toda lista do início até o fim com
>>> a # passo 3
['a', 1, 2, 'b', 4, 5, 'c', 7, 8, 'd'] # o tamanho da sequencia (aqui 4) deve

# ser igual ao tamanho do fatiamento (4)
# senão dará um erro
325
>>> 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.
b
Listas
Operador de repetição *
326
 O que acontece se modificamos o valor de um elemento da lista original a:?
>>> a=[45,76,34,55]
>>> b=3*[a]
>>> a
[45, 76, 34, 55]
Listas >>> b
Operador de repetição * [45, 76, 34, 55, 45, 76, 34, 55, 45, 76, 34, 55]
>>> a[1]=200
>>> a
[45, 200, 34, 55]
>>> b
[45, 76, 34, 55, 45, 76, 34, 55, 45, 76, 34, 55]
# Não tivemos mudanças
327
 O comando copy (shallow copy) e deepcopy cria uma nova lista (cópia) a partir
de uma lista original:
import copy >>> l1=[1,[2,3],4,5,[6],7]

>>> l1=[1,2,3,4,5,6] >>> l3=copy.deepcopy(l1)
>>> l3
Listas >>> l2 = l1.copy()
>>> l2
[1, [2, 3], 4, 5, [6], 7]
Cópia de Lista: copy e [1, 2, 3, 4, 5, 6] >>> l3 is l1

deepcopy False
>>> l2 is l1 >>> l1 is l3
False False
>>> l1 is l4
False # com a cópia profunda, as sublistas são
copiadas e não referenciadas
328
import copy
l1 = [1, 2, 3]
l2 = l1.copy() # duas formas de criar copias
Listas l3 = copy.copy(l1) # superficiais
Cópia de Lista: copy e

deepcopy l1[0] = 4 # não altera a lista original
print(l2) # [1, 2, 3]
print(l3) # [1, 2, 3]
329
import copy
l1 = [1, 2, 3]
l3 = copy.deecopy(l1) # apenas uma maneira de fazer
Listas l1[0] = 4 # não altera a lista original

Cópia de Lista: copy e
print(l3) # [4, 2, 3]
deepcopy
330
 O comando shuffle permite de embaralhar uma lista (altera a
ordem dos elementos):
import random
>>> l1=[1,2,3,4,5,6]
Listas >>> random.shuffle(l1)

>>> l1
Embaralhar uma lista:
[5, 3, 1, 4, 2, 6]
shuffle
>>> random.shuffle(l1)
>>> l1
[5, 4, 3, 2, 6, 1]
331
 O comando sample permite de gerar uma amostra aleatória de n
elementos a parti de uma dada lista:
>>> l1=list(range(20))
>>> l1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
Listas
Gerar amostra a partir de >>> l2=random.sample(l1,5)
uma lista: sample >>> l2
[7, 13, 3, 10, 1]
332
import random
>>> l1=[1,2,3,4,5,6]
>>> l6=random.sample(l1,3) # gera uma sublista de 3 elementos de l1

[2, 1, 4]
>>> l6=random.sample(l1,3)
Listas [1, 4, 6]
Gerar amostra a partir de >>> l6=random.sample(l1,5) # gera uma sublista de 5 elementos de l1

uma lista: sample [1, 6, 4, 3, 5]
>>> l6=random.sample(l1,5)
[1, 6, 4, 5, 3]
333
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)
Listas >>> l7
[64, 42, 56, 44]
Gerar amostra a partir de
uma lista: sample >>> 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]
334
 O comando choice retorna um elemento aleatório a partir de uma
dada lista:
import random
Listas >>> l1=[1,2,3,4,5,6]
Gerar amostra: choise >>> random.choice(l1)

3
>>> random.choice(l1)
2
>>> random.choice(l1)
2
335
 O comando zip permite de juntar duas listas ou várias listas,
formando pares de elementos:
import random
>>> l8=zip(range(0,3),range(5,10))
Listas >>> for e in l8:

e import random
Gerar amostra a partir de
uma lista: zip (0, 5) >>> l8=zip(range(0,35),range(5,10))
(1, 6)
(2, 7) >>> for e in l8:
e
(0, 5)
(1, 6)
(2, 7)
336
 Criar uma lista intercalada a partir de outras:
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]
Listas >>> l10=l1[::2],l2[3:],l1[1::2]
Gerar listas intercaladas >>> l10
([1, 3, 5], [13, 14, 15, 16, 17, 18, 19], [2, 4, 6]) # contém 3 sublistas
>>> l10=l1[::2],l2[3:]
>>> l10
([1, 3, 5], [13, 14, 15, 16, 17, 18, 19]) # contém 2 sublistas
337
 O comando map permite de aplicar uma função (anônima ou não) a
todos os elementos de uma coleção (lista, etc.):
list(map(lambda x: x**2,lista1))
[1, 4, 9, 16, 25]
Listas
list(map(lambda x: x%2==0,lista1))
map: aplica uma função
anônima ou não em cima
[False, True, False, True, False]
de cada elemento da lista
338
 O comando map permite de aplicar uma função (anônima ou não) a todos
os elementos de uma lista:
def quadrado(x):
return x ** 2
Listas lista1 = [1, 2, 3, 4, 5]
map: aplica uma função lista2 = list(map(quadrado, lista1)) # aplicação da função quadrado
anônima ou não em cima
de cada elemento da lista print(lista2) # em
todos os elementos da lista
339
>>> l1=list(range(7))
>>> l1
[0, 1, 2, 3, 4, 5, 6]
>>> l2=list(map(lambda x:x * -1,l1)) # aplicação de uma função
# anônima (lambda), invertendo
# o sinal de cada elemento da lista
Listas >>> l2
map: aplica uma função [-1, 0, 1, 2, 3, 4, 5]
anônima ou não em cima import random
>>> l1=[1,2,3,4,5,6]
>>> l11=map(lambda x: x * -1,l1)

>>> l11
<map object at 0x00000149D9F3ADD0>
>>> list(l11)
[-1, -2, -3, -4, -5, -6]
340
 Tornar todos elementos de uma lista positivos:
>>> l1=[-2,3,-1,5,6,-3,-22,7]
>>> list(map(lambda x: abs(x),l1)) # 1ª solução
[2, 3, 1, 5, 6, 3, 22, 7]
def positiva(lst):
Listas return (map(lambda x: -x if x<0 else x, lst))
map: aplica uma função l1=[-3,-2,-1,0,1,2,3]

anônima ou não em cima l2=positiva(l1) # 2ª solução, chamando uma função
for e in l2:
print(e,end=‘’) # ou list(l2)
341
Uso do None na função lambda
quadrado = lambda x: x ** 2 if x > 0 else None

# essa função quadrado retorna x ** 2 se x for maior que 0,
# ou None senão (se x for menor ou igual a 0)
Listas print(quadrado_positivo(3)) # saída: 9

None
print(quadrado_positivo(-3)) # saída: None
abs2 = lambda x : x if x>0 else –x
list(map(abs2,[2,-3,4,-6]))
[2, 3, 4, 6]
342
 O comando filter permite de filtrar os elementos de uma lista baseando-se em um
critério:
 # retira da lista os elementos que não vereficamo critério
import random
>>> l1=[1,2,3,4,5,6]
>>> def criterio(x): return x>=0

Listas >>> criterio(-2)
False
Filtrando elementos de >>> criterio(5)
uma lista: filter 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

# neste caso aqui, os elemtndso negativos.
343
# 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
Listas ['d', 'e', 'f']
Acessando: slicing >>> 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'
>>>
344
# O slicing (fatiamento):
>>> ll=list(range(10))
>>> ll
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> ll[0]
Listas 0
>>> ll[1::2] # inicia no 1 (2º) vai até o fim com passo 2

Acessando: slicing :
[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º (índice 0) vai até o fim com passo 4
# [0, 4, 8]
345
# O slicing (fatiamento):
>>> a=list(range(3))
>>> a
[0, 1, 2]
>>> a[0]=9
Listas >>> a
Acessando: slicing : [9, 1, 2]
>>> a[1:3]
[1, 2]
>>> a[1:3]=[4,5,6]
>>> a
[9, 4, 5, 6]
>>>
346
>>> lista=list(range(2))
>>> print(lista)
[0, 1]
Listas >>> lista = [x*2 for x in list(range(5))]
Criação de Listas >>> lista
[0, 2, 4, 6, 8]
>>>
347
>>> lista
Listas [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Criação de Listas >>>
348
# 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
Listas
Percorrendo uma Lista 0
349
>>> lista=[0,6,1,2,4,3]
>>> s=0
>>> for x in lista:
s+=x # s=s+x # faça algo com a lista

Listas
Percorrendo uma Lista >>> print(s)
16
# isto é equivalente a:
>>> sum(lista)
16
350
# 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))
Listas Lista[0] = 1
Lista[1] = 2
Percorrendo uma Lista:
enumerate Lista[2] = 3
Lista[3] = 4
>>> l=[2,4,5]
>>> for x,v in enumerate(l):
l[x]=l[x]*2
[4, 8, 16]
351
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[3:6]: # o incremento é 1 por defaut
print(x)
Listas 3
>>>
352
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[7:4:-1]:
print(x)
Listas # o último elemento não é considerado
6 for x in lista[4:7]:
print(x)
5
4
>>> 5
6
353
# 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)
Listas
>>>
354
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[::-1]:
print(x) # reverse da lista

9
8
Listas 7
5
4
3
2
1
>>>
355
>>> 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)
Listas >>> for x in reversed(lista):
print(x)
Reverter uma lista
9
Percorrendo uma Lista
8 >>> lista=list(range(9))
>>> lista
7
[0, 1, 2, 3, 4, 5, 6, 7, 8]
...
>>> list(reversed(lista))
1 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>>
356
 O método reversed não altere a lista original.
 Para reverter uma lista alterando seu conteúdo original, usamos o método reverse.
>>> lst=[1,0,3,2,-4,-2]
>>> lst
[1, 0, 3, 2, -4, -2]
Listas >>> lst.reverse()
Reverter uma lista >>> lst
[-2, -4, 2, 3, 0, 1]
>>> lst.reverse()
>>> lst
[1, 0, 3, 2, -4, -2]
Ao contrário do reversed, o reverse altera a lista original.
357
lista=[2,1,3,7,5,8,6]
>>> lista
[2, 1, 3, 7, 5, 8, 6]
>>> sorted(lista)
[1, 2, 3, 5, 6, 7, 8]
# ordem crescente por default lista
Listas lista
[2, 1, 3, 7, 5, 8, 6]
Ordenar Lista usando o [2, 1, 3, 7, 5, 8, 6]

sorted sorted(lista,reverse=False)
[1, 2, 3, 5, 6, 7, 8]
>>> sorted(lista,reverse=True)
[8, 7, 6, 5, 3, 2, 1] lista
[2, 1, 3, 7, 5, 8, 6]
sorted não altera a lista original.
358
>>> lista=[2,1,3,7,5,8,6]
>>> lista.sort()
>>> lista
[1, 2, 3, 5, 6, 7, 8]
Listas
Ordenar Lista usando o
sort
sorted altera a lista original.
sort não altera a lista original.
359
# Percorrendo uma lista usando o for e sorted
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in sorted(lista,reverse=True):
print(x) # Não altera a lista original
Listas 9
...
>>>
360
import random
import random
>>> lista=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Listas >>> random.choice(lista)
>>> random.choice(lista)
0
7
Acesso aleatório a um >>> random.choice(lista)
elemento da lista >>> random.choice(lista) 1
2 9
5
361
>>> 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']

Listas >>> nova_lista[0] # 'Maria'
Listas Compostas
>>> 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)
362
# Tamanho de uma lista
>>> lista=[25,8,-3,12]
>>> lista
Listas [25, 8, -3, 12]
len
>>> len(lista)
363
# Lista é uma estrutura mutável
>>> lista=['a','b','c']
>>> lista[0]= 'A'
Listas >>> lista
Alterando elementos da ['A','b','c']

Lista
>>> lista[2]=30
['A','b',30]
364
>>> S1='João'
>>> S2='Carlos'
S1+S2
'JoãoCarlos'
>>> l1=['a,','b,','c']
Listas >>> l2=[5,3,2,8]
Concatenação >>> l1+l2
['a,', 'b,', 'c', 5, 3, 2, 8]
>>> l2*3
[5, 3, 2, 8, 5, 3, 2, 8, 5, 3, 2, 8]
365
# verificar se um elemento/símbolo pertence a uma lista
Lista=[45,23,12,8,22,0,15]
>>> 8 in lista
Listas True
in
>>> 'gato' in lista
False
366
# Operadores
l2=[1,2,3,4]
>>> print(min(l2))
Listas
1
sum min max
>>> print(max(l2))
>>> print(sum(l2))
10
367
# Acrescentar elementos à lista
>>> livros = ['Java','C','Python']
>>> livros.append('C++')
Listas >>> Lista = ['A', 'b', 'c']
Concatenação: append >>> livros >>> lista.append(28)
['Java','C','Python','C++'] >>> lista

['A', 'b', 'c', 28]
368
EM STRINGS EM LISTAS
>>> s = 'Bom ' >>> l=[]

>>> s += 'dia' >>> l.append('Bom ')
>>> s >>> l
' Bom dia ' ['Bom ']
>>> l.append('dia')
# strings não >>> l
# suportam o append ['Bom ', 'dia']
Listas
Concatenação
# observação
>>> l=[] >>> l= []
>>> l+='Bom' >>> l=l+ 'Bom'
>>> l dar erro
['B', 'o', 'm']
369
# O Join (em cima de uma string vazia) permite de transforma uma lista em uma
string
>>> lst=[]
>>> for i in range(10):
lst.append('a') # criação de uma lista usando o append
Listas >>> lst

Convertindo lista para
String ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']
>>> lst=''.join(lst)
>>> lst
'aaaaaaaaaa'
370
# Operadores
>>> livros = ['Java','C','Python']
Listas >>> livros.insert(0,'Arduino')# insere um elemento na posição zero

insert
>>> livros
['Arduino','Java','C','Python']
371
# retirar elemento pelo seu índice e retorna o elemento (removido).
lista = [1, 2, 3, 4, 5]
elemento = lista.pop(2) # Remove o elemento de índice 2 (valor 3)
# da lista e retorna o
valor
print(lista) # Resultado: [1, 2, 4, 5]
Listas print(elemento)
>>> frutas = ["laranja", "banana", "acerola"]
# Resultado: 3
pop
>>> a = frutas.pop(2)
(retira e retorna)
>>> frutas # ["laranja", "banana"]
>>> print(a)
'acerola'
print(a) # "acerola"
lista.pop(-1)
e = lista.pop(índice) lista.pop()
Tira e retorna o último elemento
pop é o contrário do append da lista (por default)
372
# retirar elementos
# A alteração é física (acontece na lista original)
>>> livros = ['Java','C','Python,'C++']
>>> livros.pop() # retira o último elemento

'C++' # é equivalente a escrever livros.pop(-1)
Listas # o -1 se refere ao último elemento
pop
>>> livros
['Java','C','Python']
>>> livros.pop(1) # retira o 2º elemento (índice 1)

'C'
>>> livros
['Java','Python']
373
# remoção de um elemento pelo índice
1
frutas = ["laranja", "banana", "acerola"]

del frutas[1]
print(frutas) # ["laranja", "acerola"]
del frutas[0:2]
Listas print(frutas) # []
del
lista = [1, 2, 3, 4, 5]
del lista[2] # Remove o elemento de índice 2 (valor 3) da lista
print(lista) # Resultado: [1, 2, 4, 5]
del lista[índice]
374
# remoção de um elemento pelo nome e não pelo índice
# retirar elementos da lista:

>>> livros = ['Java','C','Python','C++']
= ['Java', 'C', 'Python', 'C++']
Listas >>> livros.remove('C++') # retira apenas a 1ª ocorrência do elemento
remove
(remoção pelo nome e não pelo
índice) lista.remove(elemento)
375
# retirar todas as ocorrências d e um elementos em uma lista:
# Não existe um comando específico (remove_all) no Python:
def remove_all(lista, elemento):

Listas while elemento in lista:
removeall
lista.remove(elemento)
376
# Esvaziar (limpar) uma lista:
frutas = ["laranja", "banana", "acerola"]

frutas.clear()
Listas print(frutas) # [] # equivalente a frutas=[]
clear
lista.clear()
377
# Diferença entre as duas formas (clear e =[]):
lista
lista=[]
[]
Listas ["laranja", "banana", "acerola"]
clear
lista.clear() criação de uma nova lista
(vazia), novo endereço
e atribuição desta nova referência à

[]
lista
378
>>> livros= ['Java','C','Python']
# outra forma de deletar elementos em uma lista:
>>> livros[3:4]=[] # retira o elemento de posição 3 (começando no 0)

Lista >>> livros
Outra forma de deletar
['Java', 'C', 'Python']
lista[n:n+1]=[]
deleta da lista o elemento de índice n
379
pop(): Este método remove o elemento no índice especificado e retorna esse
elemento. Se nenhum índice for especificado, ele remove o último elemento da lista.
[e=lista.pop(i) tira um elemento e retorna uma cópia dele]
del(): Esta instrução remove um elemento especificado pelo seu índice ou um intervalo
de elementos especificado pelos seus índices e não retorna nada. [del lista(e) mais
rápido]
Lista
pop, del remove(), clear() remove(): Este método remove a primeira ocorrência de um elemento especificado
pelo seu nome e não pelo índice. Se o elemento não existir na lista, um erro será
levantado. Isso não retorna nada.
[lista.remove(i) remove um elemento pelo nome e não pelo
índice ] Este método remove todos os elementos da lista e não retorna nada.
clear():
380
# reverter usando ‘o reverse
Listas >>> livros.reverse() # muda a lista original

reverse
>>> livros
['C++','Python','C','Java']
381
 2ª Solução: usando o reversed:
reversed(lista)
Listas
reversed
lista = [1, 2, 3, 4, 5]
lista_revertida = list(reversed(lista))
>>> lista_revertida
[5, 4, 3, 2, 1]
382
 3ª Solução: Reversão de listas:
lista_revertida = lista[::-1]
Listas >>> lista=['a','b','c','d', 'e']

reverse >>> lista
['a', 'b', 'c', 'd', 'e']
>>> lista_r=lista[::-1]
>>> lista_r
['e', 'd', 'c', 'b', 'a']
383
# ordenar
>>> livros.sort() # muda a lista original
>>> livros
['C','C++','Java','Python']
Listas >>> l1=[8,2,1,5,4,3,7]
sort >>> l1.sort()
>>> l1
[1, 2, 3, 4, 5, 7, 8]
>>> l1.sort(reverse=True) # ordener em ordem descrecente
>>> l1
[8, 7, 5, 4, 3, 2, 1]
384
# contar ocorrência de um elemento em uma lista
>>> l2=[3,4,5,3,2,8,10,6]
Listas
count >>> l2.count(3)
385
# 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))
4
Listas >>> l2.index(3)
index
0
# gera um erro quando o elemento não existe
386
 Representação de matrizes, sob forma de lista composta:
>>> matriz=[[1,2,3],[4,5,6],[7,8,9]]
>>> matriz[1] # 2º elemento

Listas
Matrizes [4,5,6]
>> matriz[1][2] # 3º elemento da 2ª linha
387
# Criando uma lista
lista = [1, 2, 3, 4, 5]
# Acessando elementos da lista

print(lista[0]) # Saída: 1
# Removendo elementos da lista
# Modificando elementos da lista lista.remove(2)
Listas lista[2] = 10 print(lista) # Saída: [1, 10, 4, 5, 6]

print(lista) # Saída: [1, 2, 10, 4, 5]
Resumo # Percorrendo a lista
# Adicionando elementos à lista for elemento in lista:
lista.append(6) print(elemento)
print(lista) # Saída: [1, 2, 10, 4, 5, 6]
# Tamanho da lista
tamanho = len(lista)
print(tamanho) # Saída: 5
388
list.append → adiciona um elemento ao final.
list.count → conta a quantidade de um 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
Listas:
list.pop → retira e exibe algum elemento retirado, por padrão o último
Métodos
list.remove → similar ao pop, mas sem exibir a posição do elemento a retirar
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
389
Coleções de Dados
Tuplas
390
 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 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.
391
 Tupla simples:
>>> t=(2,3,4,5,6)
>>> type(t)
<class 'tuple'>
Tuplas
>>> len(t)
# Criando uma tuple utilizando parênteses
5 >>> tupla1 = (1, 2, 3)
# Criando uma tuple sem parênteses

>>> tupla2 = 4, 5, 6
392
 Tupla composta: Lista dentro de uma tuple.
>>> t=(2,3,[4,5,6])
>>> type(t)
Tuplas
Tuplas compostas <class 'tuple'>
>>> len(t)
393
 Tupla composta: lista dentro de uma tupla:
>>> t=(2,3,[4,5,6]) # tupla é uma estrutura imutável

t[2]=10
TypeError: 'tuple' object does not support item assignment
Tuplas >>> t[-1][1]
Tuplas compostas 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.
394
 Tupla composta: Tupla dentro de uma tupla:
>>> t2=(2,3,(4,5))
>>> t2
(2, 3, (4, 5))
Tuplas >>> type(t2)
Tuplas compostas <class 'tuple'>
>>> t2[-1]
(4, 5)
>>> t2[-1][0]=10
TypeError: 'tuple' object does not support item assignment
395
 Para alterar uma tupla, pode-se criar um clone dela (cópia) i.e. criar uma variável que
referência uma nova tupla com os elementos desejados, usando as técnicas de
fatiamento (slicing) e de concatenação.
 Para alterar o preço do produto caneta:

Tuplas
Tuplas t = ('Caneta', 20, 300) # vamos alterar 20 por
30
t2 = ('Caneta’, 30, 300) # vamos alterar 20 por
30
t = list(t) # transforma a tupla em uma lista
t[1] = 30 # altera o valor na posição 1 (o segundo

elemento)
t = tuple(t) # transforma a lista em uma tupla novamente
396
 Tuplas métodos: count e index
min, max e sum, len
Tuplas
Tuplas
397
def soma_tupla(tupla):
return sum(tupla)
Tuplas >>> t1=(5,4,6)
>>> soma_tupla(t1)
15
398
Tuplas
# cria uma função que faz a interseção de duas tuplas
def intersecao(t1,t2):
inter=[]
for e in t1:
Interseção if e in t2:
t1=(1,2,4,5,7,8)
inter.append(e)
t2=(2,3,5,6,8,9)
intercecao(t1,t2)
return tuple(inter)
(2, 5, 8)
399
Tuplas
# Checar o tipo de um objeto usando type ou isinstance
>>> t1=(1,2,3,4)
>>> l1=[1,2,3,4,5]
>>> isinstance(t1,tuple) # type(t1)==tuple
True
>>> isinstance(l1,tuple) # type(l1)==tuple

Checagem de tipo False
type e isinstance >>> isinstance(l1,list) # type(l1)==list
True
>>> isinstance(l1,(list,tuple)) # dois tipos possíveis
True # type(l1) in (list,tuple)
# type(l1) in [list,tuple]
400
# Criar as três funções união, Interseção e diferença de listas, tuplas
# união de listas
def uniaolst(col1,col2):
cj1=set(col1)
cj2=set(col2)
return list(cj1.union(col2)) # ou tuple
Tuplas # interseção de listas

def interseçãolst(col1,col2):
cj1=set(col1)
cj2=set(col2)
return list(cj1.intersection(col2)) # ou tuple
# diferença de listas
def diferençalst(col1,col2):
cj1=set(col1)
cj2=set(col2)
return list(cj1.difference(col2)) # ou tuple
401
def uniao(col1,col2):
cj1=set(col1)
Tuplas cj2=set(col2)
cj3=cj1.union(col2)
if type(col1)==list:
return list(cj3)
elif type(col1)==tuple:
return tuple(cj3)
402
def uniao2 (col1,col2):
cj1=set(col1)
Tuplas cj2=set(col2)
cj3=cj1.union(col2)
if isinstance(col1,(tuple,list)):
return list(cj3)
403
# Número de ocorrências e pesquisa
>>> t1=(5,6,'João',5.45)
>>> t1
(5, 6, 'João', 5.45)
>>> t1
>>> t1.count(6)
(5, 6, 'João', 5.45)
1
Tuplas >>> t1[0] >>> t2=(4,'Caneta',4,'Escolar')
Count e Index >>> t2.count(4)
5
2
t1[1] >>> t2.index(4)
6 0
>>> t2.index('Caneta')
t1[2]
1
'João'
404
Coleções de Dados
Sets
405
 Sets ou conjuntos são estruturas disponíveis do Python
(Python builtins) utilizadas para representar coleções desordenadas
de elementos únicos.
 Conjuntos têm duas características principais:

Sets  Não tem ordem {2,3,4} = {3,2,4}
Conjuntos
Por isso, conjuntos não suportam indexação e nem slicing
(fatiamento)
 Não tem redundância (não contém elementos repetidos).
406
>>> s={1,3,2,5,0}
>>> type(s)
<class 'set'>
>>> s
Sets {0, 1, 2, 3, 5}
Sets
>>> len(s)
5
407
 Conjunto vazio
>>> s={} # Conjunto vazio
>>> s
Sets {}
Sets >>> len(s)
0
>>> len({})
0
408
>>> a={2,1,0,2} # há redundância
>>> a # Python elimina as redundâncias
{0, 1, 2} # automaticamente
Sets >>> b={1,1,1,1,1,0,-1,-1} # há redundância
Sets >>> b
{0, 1, -1}
>>> len({2,2,2,2}) # não considera as redundância
409
 Um set pode ser criada a partir de um outro tipo de dados:
>>> set([1, 2, 3, 4]) # a partir de uma lista
{1, 2, 3, 4}
>>> set(('a','b','c’)) # a partir de uma tupla
Sets {'b', 'a', 'c'}

Sets: criação
>>> set('Amor.’) # a partir de uma string
{'r', 'o', 'm', 'A', '.’}
 Observa-se que conjunto não tem ordem.
 A ordem colocada aqui depende do interpretador Python.
410
 Observação: as vezes é possível usar as parênteses como
delimitadores de tuplas:
>>> t1=(1,2,3,4)
>>> t1
Sets (1, 2, 3, 4)
Sets: criação >>> type(t1)
<class 'tuple'>
411
 Criar uma lista de apenas um elemento no caso do uso das parênteses como
delimitadores de tuples:
>>> tp=(8)
>>> tp
8
Sets >>> type(tp)
Sets: criação <class 'int'>
>>> tp=(8,) # acrescentando uma virgule
>>> tp
(8,)
>>> type(tp)
<class 'tuple'>
412
 Funções podem ter tuplas como valores de retorno:
def circulo(r):
""" (numero) -> (float,float)

Recebe um numero r e retorna o comprimento da
circunferência de raio r e a área do circulo de raio r.
Sets """
Sets: criação
p = 2 * 3.14159 * r
a = 3.14159 * r **2 >>> circulo(10)
(62.8318, 314.159)
return (c, a)
413
 Intercessão
Sets  União
Sets: Operações de
conjunto
 Diferença
414
 Intercessão
>>> a={'A','m','o','r'}
>>> a
{'A', 'o', 'm', 'r'}
>>> a
Sets {'A', 'o', 'm', 'r'}
Sets: Operações de >>> b={'R','o','m','a'}

conjunto
>>> b
{'o', 'a', 'R', 'm'}
>>> a.intersection(b) # lembre-se que Python é uma linguagem case
{'o', 'm'} # sensitive.
>>> b.intersection(a)
{'o', 'm'}
415
 Intercessão vazia
Sets >>> {2,1,3,4}.intersection({7,5,6})

Sets: Operações de set() # conjunto vazio porém set() != {}
conjunto
>>>
416
 Observação: O operando esquerdo da operação deve ser um conjunto, mas o
operando direito pode ser qualquer data collection (tupla, lista, string,...)
>>> set([1,2,3,4]).intersection({4,1})
{1, 4}
>>> set([1,2,3,4]).intersection(set([4,1]))
Sets {1, 4}
Sets: Operações de >>> set([1,2,3,4]).intersection([4,1]) # com lista

conjunto {1, 4}
>>> set([1,2,3,4]).intersection((4,1)) # com tupla

{1, 4}
>>> set([1,2,3,4]).intersection('134') # com string

set()
417
 Esses métodos não alteram os conjuntos originais.
 Para mudar o primeiro conjunto usaremos o intersection_update():
>>> a={1,2,3,4,5} # a original
>>> b={2,4,6,8,10,12}
>>> a.intersection(b)
Sets {2, 4}
Sets: Operações de >>> a

conjunto
{1, 2, 3, 4, 5}
>>> a.intersection_update(b) # a é alterada para receber
>>> a # o resultado da operação
{2, 4}
418
 União
>>> a={'A', 'o', 'm', 'r'}
>>> b= {'o', 'a', 'R', 'm'}
>>> a.union(b)
Sets {'r', 'o', 'R', 'm', 'a', 'A'}
conjunto >>> b.union(a)
{'r', 'o', 'R', 'm', 'a', 'A'}
>>>
419
 Diferença
>>> a={'A', 'o', 'm', 'r'}
>>> b= {'o', 'a', 'R', 'm'}
Sets >>> a.difference(b)

Sets: Operações de {'A', 'r'}
conjunto
>>> b.difference(a)
{'a', 'R'}
420
 Diferença Simétrica
>>> a={'A', 'o', 'm', 'r'}
>>> b= {'o', 'a', 'R', 'm'}
Sets >>> a.symmetric_difference(b)

conjunto {'r', 'R', 'a', 'A'}
>>> b.symmetric_difference(a)
{'r', 'R', 'a', 'A'}
421
 A Diferença Simétrica é a união das duas diferenças:
>>> d1=a.difference(b)
>>> d1
>>> a={'A', 'o', 'm', 'r'}
{'A', 'r'} >>> b= {'o', 'a', 'R', 'm'}
>>> d2=b.difference(a)
>>> d2
Sets {'a', 'R'}

>>> d1.union(d2)
conjunto {'A', 'a', 'R', 'r'}
>>> a.symmetric_difference(b)
{'r', 'R', 'a', 'A'}
>>> a.symmetric_difference(b)==d1.union(d2)
True
>>> a.symmetric_difference(b)==d2.union(d1)
True
422
 Para alterar o conjunto original usamos o difference_update():
>>> a={1,2,3,4,5}
>>> b={2,4,6,8,10,12}
>>> a.difference(b)
Sets {1, 3, 5}
>>> a
conjunto {1, 2, 3, 4, 5}
>>> a.difference_update(b) # muda o conjunto original
>>> a # recebendo o resultado
{1, 3, 5} # da operação
423
 Além desses operadores de interseção, união e diferença, há também o
operador de pertinência in que verifica se um elemento pertence ao
conjunto:
>>> a={1,2,3,4,5}
Sets >>> 3 in a
Sets: Operações de True
conjunto
>>> 8 in a
False
424
 O operador issubset verifica se um subconjunto pertence a um conjunto:
>>> a={1,2,3,4}
>>> b={2,3}
>>> b.issubset(a)
True
Sets >>> {1}.issubset(a)
Sets: Operações de True
conjunto
>>> {4,3}.issubset(a)
True
>>> a.issubset(b)
False
425
 O operador issuperset verifica se um conjunto é superconjunto de um
outro (é o contrário de issubset):
>>> a={1,2,3,4,5,6} >>> {3,1,2,6}.issuperset({2,3})

>>> b={3,5,1} True
Sets >>> {'a'}.issuperset({'a','b','c'})
a.issubset(a)
False
conjunto True
>>> {'a','b','c'}.issuperset({'a'})
>>> a.issuperset(a)
True
True
426
 O operador isdisjoint verifica se dois conjuntos são disjuntos ou seja, se eles tiverem
uma interseção nula:
>>> {2}.isdisjoint({1,2})
False
>>> A={2,3,4}
Sets >>> B={'a','b','c'}
Sets: Operações de >>> A.isdisjoint(B)
conjunto
True
>>> A.intersection(B)
set()
>>> A.isdisjoint(B) == (A.intersection(B)==set())
True
427
 List versus set:
>>> lista=[2,1,3,6]
>>> set(lista)
{1, 2, 3, 6}
Sets >>> list(set(lista))

Sets: Operações de [1, 2, 3, 6]
conjunto
# O probelema é que o comando set pode alterar a ordem

# original da lista.
428
 Esse mecanismo de tuple assignment: é também utilizado para fazer sawp
entre variáveis:
>>> (a,b)=(b,a) # normalmente: x=a a=b b=x

>>> nome
Sets 'Karine'
>>> idade
22
conjunto
>>> peso
60.5
429
 Python possui um mecanismo muito forte de atribuição de valores às tuplas
chamado tuple assignment:
>>> (nome,idade,peso)=('Karine',22,60.5) # com parênteses

>>> nome
Sets 'Karine'
>>> idade
conjunto 22
>>> peso
60.5
430
 Adicionando um elemento a um conjunto:
 Três formas: add e | e update
cj1 = {1, 2, 3} add adicionar um

cj1.add(4) elemento
updade adicionar vários elementos
print(conjunto) # {1, 2, 3, 4}
Sets
| união de
Add, | e update >>> cj1={0, 1, 2, 3}
conjuntos
>>> cj1|{4}
{0, 1, 2, 3, 4}
>>> cj1|{4,5} cj1 = {1, 2, 3}
cj2 = {3, 4, 5}
{0, 1, 2, 3, 4, 5}
cj1.update(cj2)
>>> cj1|{6,1,2}
{0, 1, 2, 3, 6} print(cj1) # {1, 2, 3, 4, 5}
431
conjunto = {1, 2, 3}
print(conjunto) # {1, 2, 3}
# Adicionar elemento
conjunto.add(4)
print(conjunto) # {1, 2, 3, 4}
Sets # Remover elemento

Operações de Conjunto conjunto.remove(2)
print(conjunto) # {1, 3, 4}
# Atualizar elementos
conjunto.update([3, 5, 6])
print(conjunto) # {1, 3, 4, 5, 6}
432
Coleções de Dados
Dicionários
433
• Dicionário é uma estrutura de dados, semelhante ao struct e record
de Java e Pascal (registro).
Dicionários
Criação
434
Dicionário é um conjunto de chaves e seus valores associados:
>>> d1=dict()
>>> d1
{} # Criação de um
dicionário vazio
>>> d2={'nome':'Marina','idade':20}
Dicionários >>> type(d2)
Criação <class 'dict'> # tipo dicionário: dict
d3={10:'laranja', 20:'mação', 30:'banana'}
Dicionário: " d3 "

CHAVE VALOR
10 laranja
20 mação
30 banana
435
 Em um dicionário não temos índices mas apenas uma associação de
chaves e valores.
 Em vez de chamarmos um índice, chamamos a chave e obtemos um valor:
>>> d = {"chave1":"valor1", "chave2":"valor2"}

Dicionários >>> print(d["chave"])
chaves
Dicionário: "d"
CHAVE VALOR
chave 1 valor 1
chave 2 valor 2
chave 3 valor 3
d[chave2] 436
livro = {
"titulo": "A Guerra dos Tronos",
"autor": "George R. R. Martin",
"ano": 1996,
"editora": "Editora Leya",
Dicionário "genero": "Fantasia",

acesso "paginas": 694
# Qual é autor do livro
print(livro["autor"])
Print(livro["editora"])
437
livros = {
"livro1": {
"titulo": "A Guerra dos Tronos",
"autor": "George R. R. Martin",
"ano": 1996,
},
Dicionários "livro2": novo_livro,
Estrutura comporta "livro3": {
"titulo": "", novo_livro = {

"autor": "", "titulo":
"ano": 2020, "Python",
}, "autor": "J.
} Martins",
"ano": 2020,
}
438
 Qual é o primeiro livro
livros["livro1"]
Dicionários  Título do segundo livro

acesso
livros["livro2"]["titulo"]
439
 Percorrendo todos os livros (todo o dicionário)
>>> for liv in livros:

liv
Dicionários 'livro1'
acesso
'livro2'
'livro3'
440
 Percorrendo todos os livros (todo o dicionário)
livros[liv]
Dicionários {'titulo': 'A Guerra dos Tronos', 'autor': 'George R. R. Martin', 'ano': 1996}
acesso
{'titulo': 'Python', 'autor': 'J. Martins', 'ano': 2020}
{'titulo': '', 'autor': '', 'ano': 2020}
441
 Percorrendo todos os autores (todo o dicionário) mostrando so
autores:

Dicionários livros[liv]["autor"]
acesso
'George R. R. Martin'
'J. Martins'
442
 Recuperar todas as chaves de um diocionário "d"
>>> chaves = list(d.keys())
Dicionários # recupera a 2ª chave
Keys >>> segunda_chave = chaves[1] # índice 1 => 2º elemento
# valor correspondente à 2ª chave
>>> segundo_elemento = d[segunda_chave]
443
 Percorrer um dicionário op:
for i in op:
print(op[i](100, 50))
Dicionário # ou
values
for i in op.values():
print(i(100, 50))
444
 Percorrer um dicionário op:
for chave, valor in dicionario.items():

print(chave, valor)
Dicionário
items
445
# Criar dicionário de ocorrências para uma string
palavra=input("Digita a palavra: ")
palavra=palavra.lower() # upper
dicpalavra={}
Dicionário for letra in palavra:
if letra in dicpalavra:
dicpalavra[letra] +=1
else:
dicpalavra[letra] = 1
print(dicpalavra)
446
# Encontrar as chaves de um dicionário que possuem um valor específico:
def chaves_por_valor(d, valor):
Dicionário return [chave for chave, v in d.items() if v == valor]
>>> dicionario = {"a": 1, "b": 2, "c": 2, "d": 3}
>>> print(chaves_por_valor(dicionario, 2))
447
# Criar dicioário de ocorrências dos elementos de uma lista, ou de uma string
string = input("Digite a lista de números separados por espaço: ")
lista = string.split() # split(',') ou split('*')
# por default o separador é o espaço
dicelementos={}
Dicionário for el in lista:
if el in dicelementos:
dicelementos [el] +=1
else:
dicelementos [el] = 1
print(dicelementos)
448
 Para acessar os valores do dicionário, usaremos as chaves no
lugar dos índices:
>>> d1['nome'] # basta colocar o nome da chave que

Dicionários 'Marina' # o python retorna o valor associado.
Dicionários: acesso
>>> d1['idade']
20
449
 Podemos testar se uma chave pertence ao dicionário ou não usando o
operador de pertinência in:
>>> 'profissão' in d1
Dicionários False
Dicionários: in
>>> 'idade' in d1
True
450
 Para adicionar um elemento ao dicionário:
>>> produtos= {'Caneta': 20,'Caderno': 12, 'Lápis': 6}
>>> len(produtos)
>>> >>> produtos

Dicionários {'Caneta': 20, 'Caderno': 12, 'Lápis': 6}
Dicionários: adicionar
>>> produtos['Tesoura']=8
>>> produtos
{'Caneta': 20, 'Caderno': 12, 'Lápis': 6, 'Tesoura': 8}
>>> len(produtos)
451
 Podemos deletar uma chave usando o comando del:
>>> produtos= {'Caneta': 20, 'Burracha': 4, 'Caderno': 12, 'Lápis': 6}
>>> len(produtos)
4
Dicionários >>> 'Burracha' in produtos

True
Dicionários: deletar >>> del(produtos['Burracha'])
>>> len(produtos)
3
>>> produtos
{'Caneta': 20, 'Caderno': 12, 'Lápis': 6}
452
 A alteração de um valor no dicionário é feita por uma atribuição direta:
>>> produtos= {'Caneta': 20,'Caderno': 12, 'Lápis': 6}
Dicionários >>> produtos['Lápis']=4.50

>>> produtos
Dicionários: alterar
{'Caneta': 20, 'Caderno': 12, 'Lápis': 4.5}
453
 Para saber todas as chaves de um dicionário usamos o método
keys:
>>> d1={'nome': 'Marina', 'idade': 20}
>>> d1.keys()
Dicionários dict_keys(['nome', 'idade'])
Dicionários: keys
>>> produtos={'Caneta': 20, 'Caderno': 12, 'Lápis': 4.5, 'Tesoura': 8}
>>> produtos.keys()
dict_keys(['Caneta', 'Caderno', 'Lápis', 'Tesoura'])
454
 Da mesma forma, para saber todos os valores de um dicionário usamos o
método values:
>>> d1={'nome': 'Marina', 'idade': 20}
>>> d1.valuess()
Dicionários dict_values(['Marina', 20])
Dicionários: values
>>> produtos={'Caneta': 20, 'Caderno': 12, 'Lápis': 4.5, 'Tesoura': 8}
>>> produtos.values()
dict_values([20, 12, 4.5, 8])
455
 Portanto, para descompactar um dicionário em duas listas de chaves e de valores:
>>> k,v = d1.keys(), d1.values()
>>> k
Dicionários dict_keys(['nome', 'idade'])
Dicionários:
>>> v
descompactar em lista
dict_values(['Marina', 20])
456
# Aplicar uma função em cima de cada elemento de uma tupla
tupla = (1, 2, 3, 4, 5)
resultado_tupla = tuple(map(lambda x: x * 2, tupla))
print(resultado_tupla) # (2, 4, 6, 8, 10)
Listas e Tuplas # Aplicar uma função em cima de cada elemento de uma lista
Map lista = [1, 2, 3, 4, 5]

resultado_lista = list(map(lambda x: x * 2, lista))
print(resultado_lista) # [2, 4, 6, 8, 10]
457
# Função para dobrar um número
def dobrar(numero):
return numero * 2
# Aplicar a função em cima de cada elemento de uma tupla

tupla = (1, 2, 3, 4, 5)
Listas e Tuplas resultado_tupla = tuple(map(dobrar, tupla))
Map print(resultado_tupla) # (2, 4, 6, 8, 10)
# Aplicar a função em cima de cada elemento de uma lista

lista = [1, 2, 3, 4, 5]
resultado_lista = list(map(dobrar, lista))
print(resultado_lista) # [2, 4, 6, 8, 10]
458
Coleções de Dados
Arrays
459
 No Python, é mais comum usar o list para trabalhar com coleções
heterogêneas de elementos.
 A vantagem da estrutura de array é de permitir de armazenar grandes
quantidades de elementos de um único tipo.
Arrays  É uma estrutura de dados unidimensional que permite de armazenar uma

coleção ordenada de elementos do mesmo tipo, com acesso rápido via os
índices, semelhantes a Vetores.
460
import array
# Criar um array
meu_array = array.array('tipo_de_dados', [elementos])
Arrays Exemplo:
Criação, Manipulação >>> v=array.array('i',[2,1,5,6])

>>> v
array('i', [2, 1, 5, 6])
>>> type(v)
<class 'array.array'>
461
import array
# Criar um array
v=array.array('u', ['H', '\u0041', 'l', 'l', '\u0062'])
# Acessar elementos do array
Arrays >>> v
Criação, Manipulação array('u', 'HAllb')
'u' representa o tipo de dados do array. Nesse exemplo, o 'u' indica que o array irá
armazenar caracteres Unicode.
O prefixo '\u' seguido de um número hexadecimal representa um caractere Unicode
correspondente.
O array v contém os seguintes caracteres: 'H', 'A' (equivalente a '\u0041'), 'l', 'l' e 'b'
(equivalente a '\u0062').
462
>>> v.append('4')
>>> v
array('u','HAllb4')
ex=['o','c']
Arrays v.extend(ex)
v
Manipulação
array('u', ‘HAllb4oc')
>>> v.remove('A')
>>> v
array('u', 'Hllboc')
463
Tipos de dados suportados pelo módulo array
Tipo de Dado Descrição

'b' Inteiro assinado de 1 byte (signed char)
'B' Inteiro sem sinal de 1 byte (unsigned char)
'h' Inteiro assinado de 2 bytes (short)
'H' Inteiro sem sinal de 2 bytes (unsigned short)
'i' Inteiro assinado de 4 bytes (int)
'I' Inteiro sem sinal de 4 bytes (unsigned int)
Arrays 'l'
'L'
Inteiro assinado de 4 bytes (long)
Inteiro sem sinal de 4 bytes (unsigned long)

Tipos de Dados do Array
'q' Inteiro assinado de 8 bytes (long long)
'Q' Inteiro sem sinal de 8 bytes (unsigned long long)
'f' Número de ponto flutuante de 4 bytes (float)
'd' Número de ponto flutuante de 8 bytes (double)

'u' Caractere Unicode (UTF-16)
'c' Caractere de 1 byte
's' Array de caracteres
'z' Array de caracteres terminado em zero
464
# Adicionar elementos ao array
v=array.array('i',[2,1,5,6])
meu_vetor.append(3) # Saída: array('i', [2,1,5,6, 3])
meu_vetor.extend([7, 8, 9]) # Saída: array('i’, [2,1, 5, 6, 3, 7, 8, 9])
Arrays print(meu_vetor) # Saída: array('i', [1, 10, 3, 4, 5, 6, 7, 8, 9])

Manipulação
# Remover elementos do array:
meu_array.remove(3)
print(meu_vetor) # Saída: array('i', [1, 10, 4, 5, 6, 7, 8, 9])
465
Caractere | Código Unicode
-----------------------------
A | U+0041
B | U+0042
C | U+0043
Código de Tipo Tipo de Dados Descrição D | U+0044
E | U+0045
Arrays 'b' Byte Número inteiro de 1 byte (signed) F
G
| U+0046
| U+0047
'B' Byte Número inteiro de 1 byte
Unicode (\u) (unsigned) H | U+0048
'h' Short Número inteiro de 2 bytes (signed)
'H' Short Número inteiro de 2 bytes Caractere | Código Unicode
(unsigned) -----------------------------
'i' Int Número inteiro de 4 bytes (signed) a | U+0061
'I' Int Número inteiro de 4 bytes b | U+0062
(unsigned) c | U+0063
'l' Long Número inteiro de 4 bytes (signed) d | U+0064
'L' Long Número inteiro de 4 bytes e | U+0065
(unsigned) f | U+0066
'q' Long Long Número inteiro de 8 bytes (signed) g | U+0067
'Q' Long Long Número inteiro de 8 bytes (unsigned)
'f' Float Número de ponto flutuante de 4
bytes 466
'd' Double Número de ponto flutuante de 8 bytes
Array List
Definição Tipo de dado otimizado para armazenar Tipo de dado flexível que permite
elementos de um único tipo básico. armazenar elementos de
diferentes tipos.
Acesso aos elementos Acesso rápido aos elementos por meio de Acesso rápido aos elementos por
índices numéricos. meio de índices numéricos.
Tipo dos elementos Armazena elementos de um único tipo básico Pode armazenar elementos de
(ex: inteiros, ponto flutuante, etc.). diferentes tipos (ex: inteiros,
strings, dicionários, etc.).
Arrays Tamanho flexível Tamanho fixo, não pode ser facilmente Tamanho flexível, pode ser
Array Vs. List alterado. facilmente alterado.
Eficiência em Mais eficiente em termos de memória, Menos eficiente em termos de

memória especialmente para grandes quantidades de memória, mas mais flexível em
elementos. termos de tipos de elementos.
Métodos adicionais Oferece métodos específicos do módulo array, Oferece uma ampla variedade de
como append(), extend(), etc. métodos, incluindo append(),
extend(), remove(), etc.
Uso comum Útil para armazenar grandes quantidades de Útil para armazenar coleções
elementos de um único heterogêneas de elementos e
467
1. Cria uma estrutura de lista de **********************
* MENU *
dicionários [{:}] para gerenciamento de **********************
* 1. Cadastrar *
estoque de produtos (nome, código,
* 2. Listar *
preço e estique) com as opções de menu * 3. Pesquisar *
* 4. Alterar *
(Cadastrar, Mostrar, Pesquisar, Alterar e * 5. Remover *
Coleções de Remover).
* 6. Sair *
**********************
Dados Pode usar a estrutura de Menu criada Digite a opção:
Exercício
no final da seção sobre Funções (pg.
250).
468
Arquivos
469
 Um Programa comunica com o mundo externo usando operações
de entrada e saída (I/O).
 Isto é feito por meio de arquivos que são associados aos

dispositivo: Monitor, Teclado, Disco, Impressora, etc.
Arquivo?
 Geralmente, os arquivos são usados para armazenar dados, pós a
memória do computador é volátil.
 Os arquivos são organizados em um Diretório (Pasta/Folder) do

Disco.
470
 Arquivos são estruturas de dados armazenadas em disco.
 Cada arquivo tem um nome que o identifica.
Arquivo?  Em Python, um arquivo pode ser lido/escrito por meio de um objeto

da classe file.
471
 Os arquivos permitem duas operações básicas: a leitura e a escrita.
 O arquivo precisa ser aberto, para as operações de leitura ou escrita,

Arquivo? e depois tem que ser fechado.
472
• O arquivo é aberto usando a função open:
f = open(nome_do_arquivo, modo)
nome lógico nome físico
 Exemplo:
Arquivos
>>> f = open('teste.dat','w')
Abertura: open
# abertura de um arquivo chamado teste.dat no modo escrita

# para poder armazenar/escrever dados nele.
A função open retorna um objeto da classe file.

Esse objeto representa, dentro do código, o arquivo a ser manipulado.
473
• Os arquivos são organizados em pastas (diretórios) e são localizados pelo
seu caminho (path).
• O arquivo é referenciado por dois nomes:

• Um nome lógico que será usado dentro do programa
Arquivos a cada vez que se quer referenciar o arquivo.
Abertura: open É o objeto da classe file do Python. e
• Um nome físico que é nome do arquivo no disco.
Geralmente o nome é precedido pelo diretório que é o caminho do arquivo: por

exemplo "/usr/share/dict/exemplos"
474
nome_logico = "dados"
nome_fisico = "dados.txt"
nome_logico = open(nome_fisico, "r")

Arquivos # Realização de operações no arquivo: r ou w
Abertura: open arquivo.close()
475
• A função open recebe dois argumentos:
• o nome do arquivo, e
• o modo em que pretendemos usar o arquivo:

• modo w (write): abertura do arquivo para escrita
Arquivos (gravação de dados).
Abertura: open
• modo r (read): abertura do arquivo apenas para leitura dos
dados armazenados.
476
• Observação muito importante:
• Se o arquivo especificado no comando open não existe (no caso aqui
'teste.dat', f = open('teste.dat','w') ) então um novo arquivo com este nome é
automaticamente criado.
Arquivos
Abertura: open
477
 Caminho do arquivo
 Se o arquivo e o programa estão no mesmo diretório, podemos usar apenas
o nome do arquivo (“caminho relativo”).
f = open('teste.dat','w')
Arquivos
 Mas, se o arquivo e o programa estão em pastas (diretórios) diferentes,
Especificando o caminho
do arquivo? então é preciso especificar o “caminho absoluto”.
f = open('C:\Users\Labidi\Arquivos\teste.dat','w')
478
 O open retorna um objeto instancia da classe file:
>>> f = open('Arq2.dat','r')
Arquivos >>> print(f)

Objeto da classe file
<_io.TextIOWrapper name='Arq2.dat' mode='r' encoding='cp1252'>
479
 Observe-se que por default, o open abre o arquivo no modo read
(leitura):
Arquivos >>> open('arq1.dat') # não há necessidade de especificar o 'r'
Modo default de abertura <_io.TextIOWrapper name='arq1.dat' mode='r' encoding='cp1252'>

(r)
480
>>> f.write('Primeira frase de meu arquivo texto.')
Arquivos
Escrita: write
481
arquivo.write(texto) print(texto, file=arquivo)
Expressões equivalentes
O print é mais genérico que o write e pode redirecionara a saída para um arquivo.
O print é útil quando se deseja escrever dados em um arquivo de uma maneira mais
Arquivos conveniente, pois ele lida automaticamente com a formatação de strings e pode
adicionar uma nova linha no final de cada chamada de print por padrão.
Escrita: write vs. print (file)
O write é útil especialmente quando precisamos ter o controle sobre o conteúdo do

arquivo e que desejamos formatar de forma específica os dados a escrever no arquivo.
482
# abertura do arquivo no modo escrita (w)
f=open('teste.dat','w')
Arquivos
f.write('Primeira frase de meu arquivo texto.\n')
Escrita: write
f.write('Segunda frase de meu arquivo texto.\n')
f.close()
483
 Todo arquivo aberto deve ser fechado quando terminar de usá-lo com a
chamada do close.
Arquivos f.close()
Fechament0: close
484
 Leitura Total:
print (f.read())
 O read sem argumento permite de ler todo o conteúdo do arquivo de só uma vez.
 A leitura é sempre feita a partir da posição atual do cursor no arquivo.
 Leitura Parcial
Arquivos f.read(n)
Leitura Total Vs. Parcial
 A leitura de n caracteres a partir da posição atual do cursor.
 Para fazer uma leitura parcial, o read pode receber um inteiro n como parâmetro
indicando a quantidade dos caracteres que desejamos ler.
 O uso do read() após o uso do read(n) irá ler o restante do arquivo, i.e. tirando os n
primeiros caracteres já lidos pelo read(n).
485
# é possível delimitar o número de caracteres
# a serem lidos.
>>> f=open('teste.dat','r')
Arquivos >>> print(f.readl(10))

Leitura parcial: read(n)
'Primeira f' # leitura de apenas 10 caracteres
>>> f.close()
486
# escrita
f=open('Arq.txt','w')
f.write('linha1\nlinha2\nlinha3') # escreva no arquivo
f.close()
Arquivos
read/write: exemplo
# leitura
f=open('Arq.txt','r')
txt=f.read() # ler todo o conteúdo de só uma vez
print(txt)
f.close()
487
# o parâmetro do write deve ser uma string
a=28
f.write(a) # gera um erro pq a não é string
f.close()
Arquivos
Write string # 1º solução
Arq.write(str(a))
# 2º solução
Arq.write("%d"%a)
# Isso garante que o valor de a seja interpretado como um número inteiro e
formatado corretamente como uma string antes
de ser gravado no arquivo.
488
# para retornar o tamanho do arquivo em bytes
>>> import os
>>> os.path.getsize ('c:Arq1.dat')
Arquivos 48
Tamanho de um arquivo:
>>> tamanho = os.path.getsize(nome_arquivo)
getsize
>>> print(f"O tamanho do arquivo {nome_arquivo} é {tamanho} bytes.")
O tamanho do arquivo Arq.dat é 48
489
print (f.readline())
Arquivos O comando readline permite de ler a linha atual do arquivo.

Leitura: readline
Para isto, o arquivo dever ser aberto no modo leitura, o modo read
(r)
490
# abertura do arquivo no modo escrita (w)
f=open('teste.dat','r')
Arquivos print(f.readline()) # leitura de apenas 1ª linha
Leitura: readline print(f.readline()) # leitura de apenas 2ª linha
f.close()
491
# leitura de todo o conteúdo, linha a linha
# usando readline:
linha='.'
while linha !='':
Arquivos
linha=f.readline()
Leitura: readline
print(linha)
f.close()
# ao atingir o fim do arquivo, o readline retorna vazio ''

# e provoca a saída do while.
492
# leitura de todo o conteúdo, linha a linha
# usando readline:
linha=f.readline()
Arquivos while linha:
Leitura: readline print(linha)

linha=f.readline()
f.close()

493
# Os arquivos podem ser tratados como sequências, e
# admitem o uso de laços for para percorrer as linhas

# de um arquivo
Arquivos for linha in f:
Leitura: readline print(linha)
f.close()

494
# As linhas terminam com o caractere “new line”. Isto implica na impressão
# de várias linhas em branco. Para eliminar essas linhas usamos o strip.
# O strip é um método de strings que remove os espaços em branco (espaços,
# tabulações e quebras de linha) do início e do final de uma string.
# ' João Carlos '.strip() retorna 'João Carlos' (elimina os espaços do lado direito e do lado
esquerdo da string)
Arquivos f=open('Arq.txt','r')
Leitura: strip for linha in f:

print(linha.strip())
f.close()

# e provoca a saída do for.
495
Left Strip
linha.lstrip()
Right Strip
Arquivos linha.rstrip()
Leitura: lstrip e rstrip full Strip

linha.strip()
496
print (f.readlines())
Arquivos
Leitura: readlines
Leia todo o conteúdo do arquivo.
Retorna todas as linhas, tudo em uma lista.
497
# leitura de todo o conteúdo,
# usando readlines:
Arquivos linhas=f.readlines()
readlines
for linha in linhas:
print(linha,end='')
f.close()
498
 Read() Vs. readlines()
 read() retorna uma única string contendo todo o conteúdo do
arquivo.
 readlines() retorna uma lista de strings, onde cada elemento
Arquivos
representa uma linha do arquivo.
Read Vs. ReadLines
499
# leitura de todo o conteúdo, caractere a caractere,
# usando read(1) e getsize()
# 1º método
Arquivos n=os.path.getsize('Arq.txt')
read(n)
for i in range(n):
c=f.read(1) # leia apenas 1 caractere.
# imprime o arquivo caractere a caractere
print(c,end='')
f.close()
500
# Impressão caractere a caractere, 2º método:
Arquivos c=f.read(1)
while c:
read(n)
print(c,end='')
c=f.read(1)
f.close()
501
arq = open(nome_arq)
# cursor posicionado no 0
linha = arq.readline()
# lê os caracteres até o primeiro \n, inclusive,
Arquivos # e o cursor avança até o byte seguinte.
tell()
print arq.tell()
# o tell() aqui retorna a posição do cursor logo após
# a 1ª linha lida incluindo o \n, será portanto aqui 16

primeira linha\nsegunda linha\nterceira linha\n
01234567890123456789012345678901234566789012345
f.close()
502
with open('arq1.dat') as linhas:
for l in linhas:
print(l)
Arquivos # irá imprimir o conteúdo do arquivo

Uso do with
# e fechá-lo automaticamente
503
with é uma construção de controle de fluxo que é usada em conjunto com objetos que
suportam o chamado "context management" (gerenciamento de contexto).
Dentro do bloco de código, podemos trabalhar com o recurso usando o alias fornecido.
O with garante que os recursos (Arquivos, Banco de Dados, conexões de Rede, etc.)
sejam devidamente liberados no final do bloco (sem a necessidade de chamar
Arquivos explicitamente o método de fechamento.).
with
O uso do with é uma prática recomendada, pois ajuda a evitar vazamentos de recursos e
torna o código mais conciso e legível além de seguro.
504
with recurso as alias:
# Bloco de código que usa o recurso
with open('arquivo.txt', 'r') as arquivo:
conteudo = arquivo.read()
# Faça algo com o conteúdo do arquivo
# O arquivo é automaticamente fechado após sair do bloco with
import sqlite3
Arquivos with sqlite3.connect('banco_de_dados.db') as conexao:
cursor = conexao.cursor()
with # Executr consultas SQL ou outras operações no BD
# A conexão com o banco de dados é automaticamente fechada após sair do bloco
with
import fcntl
with open('arquivo.txt', 'a') as arquivo:
with fcntl.flock(arquivo, fcntl.LOCK_EX):
# Realizar operações no arquivo dentro do bloco with
# O bloqueio é liberado automaticamente após sair do bloco with
505
Modo Descrição
r Abre o arquivo somente para leitura. Este é o modo padrão. O arquivo deve existir, caso contrário, ocorrerá um erro.
Abre o arquivo para leitura e gravação. O ponteiro do arquivo é posicionado no início do arquivo e, portanto, se tiver algo já gravado, será apagado. O arquivo deve
r+ existir, caso contrário, ocorrerá um erro.
w Abre o arquivo somente para gravação. Qualquer conteúdo existente no arquivo é apagado. Se o arquivo não existir, um novo arquivo será criado.
Abre o arquivo para leitura e gravação. O ponteiro do arquivo é posicionado no início do arquivo. Qualquer conteúdo existente no arquivo é apagado. Se o arquivo
w+ não existir, um novo arquivo será criado.
a Abre o arquivo para anexação (escrita n final do arquivo) preservando o conteúdo existente. O ponteiro do arquivo é posicionado no final do arquivo.
a+ Abre o arquivo para leitura e anexação. O ponteiro do arquivo é posicionado no final do arquivo. Se o arquivo não existir, um novo arquivo será criado.
b Abre o arquivo no modo binário. Isso é útil para abrir arquivos que contêm dados binários, como imagens ou arquivos de áudio.
x Abre o arquivo para criação exclusiva (escrita). Se o arquivo já existir, a operação falhará.
t Abre o arquivo no modo de texto. Este é o modo padrão se nenhum modo for especificado.
Arquivos
Modos de abertura
506
read(n) Retorna uma string única com todo o conteúdo do arquivo. Se n é especificado,
retorna o n caracteres.
readline() Retorna a próxima linha do arquivo, incluindo a posição atual.
readlines() Retorna todo o conteúdo do arquivo em uma lista, uma linha do arquivo por
elemento da lista.
Arquivos write(s) Escreve a string s no arquivo, na posição atual ou no final do arquivo,

dependendo do modo de abertura. Esta função falha se o arquivo foi aberto com
Operações modo leitura "r“ (modo leitura).
writelines() Escreve várias linhas de só uma vez no arquivo.
seek(n) Muda a posição atual do arquivo para o valor indicado em n. Posiciona o curso
na posição n.
tell() Retorna a posição atual do cursos no arquivo.

close() Fecha o arquivo. Sempre utilizado no final da manipulação do arquivo.
507
Calcular o tamanho do arquivo texto:
import os
nome_arquivo = "arquivo.txt"
if not os.path.exists(nome_arquivo):
Arquivos print("O arquivo não existe.")
else:
getsize
tamanho = os.path.getsize(nome_arquivo)
print(f"O tamanho do arquivo {nome_arquivo} é {tamanho} bytes.")
508
Testar se o arquivo existe antes de tratar:
import os
if not os.path.exists(nome_arquivo):
print("O arquivo não existe.")
Arquivos else:
arquivo = open(nome_arquivo, "r")
exists
# Tratamento do arquivo
arquivo.close()
509
Testar se o arquivo existe antes de tratar:
try:
arquivo = open(nome_arquivo, "r")
# Tratamento do arquivo
Arquivos arquivo.close()
try-except except FileNotFoundError:
print(f"O arquivo {nome_arquivo} não existe.")
510
Se o arquivo não existe então criá-lo automaticamente e fechar.
1ª Solução:
import os
Arquivos if not os.path.exists(nome_arquivo):

arquivo = open(nome_arquivo, "w")
Cria arquivo se ele não
existe 1ª Solução arquivo.close()
print(f"O arquivo {nome_arquivo} foi criado.")
511
Se o arquivo não existe então criá-lo automaticamente e fechar.
2ª Solução:
try:
Arquivos arquivo = open(nome_arquivo, "a")
Cria arquivo se ele não arquivo.close()

existe 2ª Solução except FileNotFoundError:
arquivo.close()
print(f"O arquivo {nome_arquivo} foi criado.")
512
Para esvaziar um arquivo (deletar o seu conteúdo) basta abrir o
arquivo no modo escrita e escrever uma string vazia nele.
# Abrir o arquivo em modo de escrita

Arquivos # Escrever uma string vazia no arquivo

arquivo.write("")
Esvaziar um arquivo
# Fechar o arquivo
arquivo.close()
print("Arquivo esvaziado com sucesso.")
513
Para deletar um arquivo (deletá-lo) fisicamente usamos o comando remove.
import os
# Verificar se o arquivo existe antes de deletar
Arquivos if os.path.exists(nome_arquivo):
deletar um arquivo # Deletar o arquivo
remove os.remove(nome_arquivo)
print("Arquivo deletado com sucesso.")
else:
print("O arquivo não existe.")
514
 Cria a função que copia um arquivo texto em um outro.
def copiararquivo(arq1,arq2):
f1 = open(arq1,'r')
f2 = open(arq2,'w’)
Arquivos while 1:
Exercício texto = f1.read(20)
if not texto: # texto=='' (texto vazio)

# chamada da função:
break copiararquivo('teste.dat','teste2.dat')
f2.write(texto) f=open('teste2.dat','r')
print(f.readlines())
close(f) # impressão do arquivo cópia (f2)
f1.close()
f2.close()
515
Exemplo:
>>> f=open('Arq1.dat','w')
>>> f.write('1a linha do arquivo.\n')
21
Arquivos
>>> f.write('2a linha do arquivo.\n')
Exemplo: Escrita
21
>>> f.write('fim.')
>>> f.close()
516
>>> f=open('Arq1.dat','r')
>>> f.readline() # leia uma linha do arquivo (aqui, a 1ª).

'1a linha do arquivo.\n'
Arquivos '2a linha do arquivo.\n'

Exemplo: Leitura
'fim.'
'' # mas como o arquivo chegou ao fim
# retorna vazio.
517
>>> f.readlines() # leia todo o conteúdo do arquivo e retorna uma lista.
['1a linha do arquivo.\n', '2a linha do arquivo.\n', 'fim.' ]

'1a linha do arquivo.\n2a linha do arquivo.\nfim.'
Arquivos >>> f.read()

''
# leia uma linha do arquivo.
# já que o arquivo tá no fim, nada a ler,
Exemplo: Leitura # retorna vazio.
>>> f.read() # leia uma linha do arquivo (aqui a 1ª linha).
'1a linha do arquivo.\n2a linha do arquivo.\nfim.'
>>> f.close()
518
>>> f.seek(0) # posiciona novamente o cursor no início do arquivo.
Arquivos 0
Posicionar o cursor: seek >>> f.seek(-1,1) # recuar uma posição a partir da posição atual.
519
número de bytes a serem recuados
f.seek(offset, whence)
Arquivos ponto de referência para o recuo

Posicionar o cursor: seek
520
 Localização do arquivo
 Se nenhum caminho de diretório absoluto for especificado ao abrir o arquivo, o Python

usará o diretório de trabalho atual para salvar o arquivo.
 O diretório de trabalho atual é o diretório em que o programa Python está sendo

executado (Linha de Comando, IDE, Servidor Web, Servidor Web, Outra Aplicação), o
Arquivos que depende das configurações desse ambiente.
Diretório do Arquivo
import os
diretorio_atual = os.getcwd()
print("O diretório atual é:", diretorio_atual)
521
Escreva o arquivo caractere a caractere:
import os
arquivo='c:Arq1.dat'
f=open(arquivo,'r')
Arquivos n=os.path.getsize(arquivo)
Exercício for i in range(n):
c=f.read(1) # leia apenas 1 caractere.
print(c,end='')
f.close()
522
Escreva o arquivo linha a linha:
import os
arquivo='c:Arq1.dat'
f=open(arquivo,'r')
Arquivos f.seek(0) # posicionar o cursor no início do arquivo
Exercício
texto=f.read() # leia todo o conteúdo do arquivo texto.
for linha in texto:
print(linha,end='')
f.close()
523
 Escrevendo dados em um arquivo de só uma vez.
 Usando writelines()
 Exemplo:
Arquivos listaStr = ['primeira linha\n', 'segunda linha\n', 'terceira linha\n', \

'quarta linha\n', 'quinta linha\n’]
writelines
arq.writelines(listaStr)
# Grava de uma vez todas as linhas da lista
524
# Escrevendo dados em um arquivo de só uma vez (writelines).
linha=''
lista=[]
ok=True
Arquivos while ok:
writelines linha=input('Digita a linha para gravar (vazio para sair): ')
lista.append(linha)
ok=linha # qdo linha é vazia seu valor lógico torna-se False
frase=''.join(lista) # converte a lista de strings em uma string
f.writelines(frase) # Texto gravado no arquivo!
f.close()
525
# Extraindo as palavras de dentro das linhas do arquivo com base nas virgulas.
arq = open(nome,"r")
for linha in arq:
p1 = linha.find(",") # virgula depois do nome
nome = linha[:p1]
Arquivos p2 = linha.find(",",p1+1) # procurar a próxima vírgula
writelines n1 = float(linha[p1+1:p2])
n2 = float(linha[p2+1:])
if (n1+n2)/2 >= 7.0: # alunos aprovados
print(nome)
arq.close()
526
 Os últimos exemplos usam arquivos de texto
 Vamos trabalhar agora com arquivo de dados, por exemplo, para

Arquivos de
cadastrar produtos.
Dados
527
Mundo Externo Mundo Externo
Serialização
Dispositivos de I/O Python Disco, Banco de
(Teclado, Monitor, SERIALIZAÇÃO
Comunicação Deserialização Dados e Planilhas
Mouse, Impressora)
https://www.educba.com/python-pickle-vs-json/ 528
 Necessidades:
 Persistência de Dados (Manipulação dos Objetos no Disco),
Arquivos de
 Troca de Informações,
Dados
Necessidades  Comunicação entre Processos ou Aplicativos.
529
Mundo Externo Mundo Externo
Serialização
Dispositivos de I/O Python Disco, Banco de
(Teclado, Monitor, SERIALIZAÇÃO
Comunicação Deserialização Dados e Planilhas
Mouse, Impressora)
Mundo Externo Bibliotecas

Bibliotecas BD sqlite3, MySQLdb, psycopg2, pyodbc, etc.
Mundo Externo Bibliotecas Planilhas e CSV openpyxl, pandas, xlrd, CSV, CSV, etc.
SO, I/O e Recursos io, os, shutil, pathlib PDF PyPDF

da Máquina keyboard, mouse, pyserial,
pyttsx3, pygame, turtle, etc. Serialização Json e Pickle 530
 Serialização
 É o processo de converter um objeto em uma sequência de bytes para que possa ser
armazenado em um arquivo, transmitido pela rede ou persistido em algum formato.
Arquivos de  I.e. permite transformar um objeto em uma forma que possa ser facilmente transmitida
Dados ou armazenada.
Serialização /
DeSerialização  Deserialização
 É o processo inverso. É a conversão da sequência de bytes de volta em um objeto,
permitindo que o objeto original seja reconstruído a partir dos dados serializados.
531
Pickle (1994, Python 1.4) permite que
objetos complexos, como listas,
dicionários, classes e instâncias de
objetos personalizados, sejam
convertidos em uma sequência de
bytes e posteriormente reconstituídos
em sua forma original.
Json (JavaScript Object Notation,

2006) é amplamente utilizada na
comunidade de desenvolvimento de
software para manipulação de dados
estruturados.
532
533
Json Vs. Pickle
JSon Pickle
Formato Formato de texto legível por humanos Formato binário específico do
Python
Portabilidade Amplamente suportado por várias linguagens Específico para o Python, pode ter
problemas de compatibilidade
Bibliotecas Segurança Considerado seguro Pode executar código malicioso se
carregar um arquivo pickle
Bibliotecas de Serialização comprometido
/ Deserialização Estruturas Estruturas de dados simples (dicionários, listas, Preserva a estrutura completa de
suportadas etc.) e não suporta sets por exemplo. objetos Python, incluindo atributos,
Não preserva informações sobre os métodos dos métodos e referências internas
objetos Python (foca no formato de dados e não
na preservação dos detalhes da implementação do
objeto.).
534
import json
json_string = '{"nome": "João",

"idade": 28,
"cidade": "São Luís"} ‘

Bibliotecas # string no formato json
Json: deserialização (dicionário)
objeto_python = json.loads(json_string)
# o loads é um método da biblioteca do json que decodifica
# a string (parsea) e a converte em um objeto Python
print(objeto_python["nome"]) # João print(objeto_python["idade"])

# 28
print(objeto_python["cidade"]) # São Luís
535
 1º, vamos criar a Classe Produto
# Criar a classe Produto que vai representar os produtos
class Produto:
# Inicializar os atributos do produto

Arquivos de def __init__(self, codigo, nome, preco, categoria):
Dados: self.codigo = codigo
self.nome = nome
Criar a Classe de Dados self.preco = preco
self.categoria = categoria
# Definir um método para retornar uma string com os dados do produto
def __str__(self):
return f"{self.codigo};{self.nome};{self.preco};{self.categoria}\n“
# return f"Código: {self.codigo} - Nome: {self.nome} - Preço: {self.preco} - Categoria: {self.categoria}"
536
# Para manipular arquivos binários
import pickle
# Criar (manualmente) uma lista de produtos de exemplo
lista_de_produtos = [
Produto(1, "Arroz", 5.99, "Alimentos"),
Arquivos de Produto(2, "Feijão", 4.49, "Alimentos"),

Produto(3, "Sabonete", 2.99, "Higiene"),
Dados Produto(4, "Shampoo", 9.99, "Higiene")
Gravar Dados [1] ]

pickle # Abrir um arquivo em modo de escrita binária
arquivo = open("produtos.dat", "wb")
# Gravar a lista dos produtos no arquivo usando a função dump do módulo pickle
pickle.dump(lista_de_produtos, arquivo)
with open("produtos.dat", "wb") as arquivo:
# Fechar o arquivo pickle.dump(lista_de_produtos, arquivo)
arquivo.close()
537
# A lista_de_produtos pode ser lida a partir do teclado
# define uma lista vazia para armazenar os produtos

lista_de_produtos = []
# solicita ao usuário para inserir os dados do produto até que ele digite ‘fim’
while True:
codigo = input("Digite o código do produto ('fim' para sair): ")
if codigo == 'fim':
break
Arquivos de nome = input("Digite o nome do produto: ")
Dados
preco = float(input("Digite o preço do produto: "))
categoria = input("Digite a categoria do produto: ")
Gravar Dados [2] # cria o objeto Produto com as informações fornecidas

produto = Produto(codigo, nome, preco, categoria)
# adiciona o produto na lista

lista_de_produtos.append(produto)
# abre o arquivo para escrita binária

arquivo = open('produtos.dat', 'wb') #ou 'produtos.pkl'
# grava a lista de produtos no arquivo

pickle.dump(lista_de_produtos, arquivo)
# fecha o arquivo
arquivo.close()
538
# Mostrar o conteúdo do arquivo
# Importar o módulo pickle para lidar com arquivos binários

import pickle
# Abrir o arquivo para leitura binário

arquivo = open('produtos.dat', 'rb')
Arquivos de # Ler o conteúdo do arquivo (a lista de produtos do arquivo produtos.dat)

conteudo = arquivo.read()
Dados # Fechar o arquivo

arquivo.close()
Mostrar [1]
# Carrega a lista de produtos a partir do conteúdo do arquivo
lista_de_produtos = pickle.loads(conteudo)
# Exibe a lista de produtos

for produto in lista_de_produtos: # print(produto) # ou:
print(f"Código: {produto.codigo}")
print(f"Nome: {produto.nome}")
print(f"Preço: R${produto.preco:.2f}")
with open("produtos.dat", "rb") as arquivo:
print(f"Categoria: {produto.categoria}")
produtos = pickle.load(arquivo)
print()
539
2ª Forma de mostrar
# Lendo e mostrando o conteúdo do arquivo

while True:
try:
produto = pickle.load(arquivo)
Arquivos de print("Código: ", produto.codigo)

Dados print("Nome: ", produto.nome)
Mostrar [2] print("Preço: ", produto.preco)
print("Categoria: ", produto.categoria)
print("-" * 20)
except EOFError:
break
# Fechando o arquivo
arquivo.close()
540
# Pedir ao usuário o número de novos produtos a serem adicionados
n = int(input("Quantos novos produtos você quer adicionar? "))
# Usar um laço for para iterar n vezes

for i in range(n):
# Pedir ao usuário os dados do novo produto
Arquivos de codigo = int(input(f"Digite o código do produto {i+1}: "))
Dados nome = input(f"Digite o nome do produto {i+1}: ")
Acrescentar Dados preco = float(input(f"Digite o preço do produto {i+1}: "))
categoria = input(f"Digite a categoria do produto {i+1}: ")
# Criar um objeto da classe Produto com os dados informados

novo_produto = Produto(codigo, nome, preco, categoria)
# Adicionar o novo produto à lista de produtos

produtos.append(novo_produto)
541
2ª Forma de fazer:
# Abrindo o arquivo produtos.dat em modo "ab" para adicionar novos produtos
# o modo "ab" (append binary) para abrir o arquivo é a melhor opção para adicionar novos
dados sem sobrescrever o conteúdo já existente.
Arquivos de with open("produtos.dat", "ab") as arquivo:

Dados # Adicionando novos produtos ao final do arquivo
Acrescentar Dados
pickle.dump(Produto(5, "Shorts", 49.90, "Vestuário"), arqui
pickle.dump(Produto(6, "Chinelo", 19.90, "Calçados"), a
# A função pickle.dump() é usada duas vezes para adicionar os novos produtos
# diretamente ao final do arquivo produtos.dat, sem precisar criar uma lista
# de produtos antes.
542
import os
# Obtém o tamanho do arquivo em bytes

tamanho = os.path.getsize("produtos.dat")
Arquivos de
# Converte o tamanho para kilobytes (KB) e megabytes (MB)
Dados tamanho_kb = tamanho / 1024
tamanho_mb = tamanho_kb / 1024
# Mostra o tamanho do arquivo em KB e MB

print("Tamanho do arquivo: {:.2f} KB ({:.2f} MB)".format(tamanho_kb,
tamanho_mb))
543
# Abrindo o arquivo em modo de leitura e escrita
arquivo = open("produtos.dat", "rb+")
# Lendo todos os objetos do arquivo
while True:
try:
# Lendo um objeto
Arquivos de # Verificando se o objeto tem o código desejado

if produto.codigo == 123:
Dados # Alterando o preço do produto
produto.preco = 15.99
Alterar Dados
# Reescrevendo o objeto alterado no arquivo
arquivo.seek(-pickle.dumps(produto).__sizeof__(), 1)
pickle.dump(produto, arquivo)
break
except EOFError:
# Finalizando o loop quando o final do arquivo é alcançado
break
# Fechando o arquivo
arquivo.close()
544
while True:
try:
# Lendo um objeto
# Verificando se o objeto tem o código desejado
Arquivos de if produto.codigo == 123:
# Obtendo o tamanho do objeto
Dados tamanho_objeto = pickle.dumps(produto).__sizeof__()
Remover Dados # Reduzindo o tamanho do arquivo removendo o objeto
posicao_atual = arquivo.tell()
arquivo.truncate(posicao_atual - tamanho_objeto)
break
except EOFError:
# Finalizando o loop quando o final do arquivo é alcançado
break
545
1. Crie um arquivo onde cada linha armazena o nome do aluno, suas duas notas dos
bimestres além da média:
Maria Sousa 10.0, 8.0
Arquivos de João Carlos 5.0, 4.0
Dados Zenira Maranhão 9.0 2.5

 Escreva uma função que receba o nome do arquivo como parâmetro e que retorna
Exercícios
a relação dos alunos aprovados (média>=7).
546
2. Desenvolva um algoritmo que escreve em disco um arquivo com números
ordenados crescentemente de 1 a 100 separado por “;”.
Arquivos de 3. Desenvolva um algoritmo que escreve em disco um arquivo com números
Dados ordenados decrescentemente de 100 a 1. Cada número deve estar em uma

Exercícios linha.
547
4. Desenvolva um programa que cadastra produtos. O programa deve
registrar nome, preço e valor do estoque do produto. O usuário deve
ter as seguintes opções de menu: Cadastrar novo produto; Listar os
Arquivos de produtos cadastrados; Buscar um produto; Alterar o preço ou estoque de
Dados um produto e Remover um produto

Exercícios
548
Matemática
549
import math
x = math.sqrt(y) # para usar a raiz quadrada sqrt
# basta importar a biblioteca de matemática
# math
import math as m # o as permite dar um apelido (nome mais m.sqrt(y)

# simples) à biblioteca para ficar usando dentro
Matemática # do programa
math
from math import pi,sqrt # não é preciso importar a biblioteca de
area=math.pi*r**2 # matemática inteira
b=sqrt(25)
550
pi Aproximação de π
Matemática
math
551
>>> print(f'Seno 30 = {M.sin(30*M.pi/180):.4f}')
Seno 30 = 0.5000
>>> print(f'Coseno 30 = {M.cos(30*M.pi/180):.4f}')
Coseno 30 = 0.8660
>>> print("$Log_{10}$ 100 = %.4f" % math.log10(100))
Log10 100 = 2.0000
Matemática >>> print("Raiz Quadrada de 4 = %d " % math.sqrt(4)) 10 print("\n")

Exemplos Raiz Quadrada de 4 = 2
>>> print("Menor inteiro 2.56 = %d " % math.floor(2.56))
Menor inteiro 2.56 = 2
>>> print("\n") 13 print("Maior inteiro 2.56 = %d " % math.ceil(2.56))
Maior inteiro 2.56 = 3
552
>>> import time
>>> th = time.localtime()
>>> print(f'Dia: {th.tm_mday}')

Dia: 30
Matemática >>> print(f'Mês: {th.tm_mon}')
Tempo - Horário Mês: 5
>>> print(f'Ano: {th.tm_year}')
Ano: 2018
553
>>> print(f'Hora: {tempohorario.tm_hour}')
Hora: 20
>>> print(f'Minutos: {tempohorario.tm_min}')
Minutos: 52
>>> print(f'Segundos: {tempohorario.tm_sec}')
Segundos: 7
>>> print(f'Dia da semana: {tempohorario.tm_wday}')
Matemática Dia da semana: 2
Tempo - Horário >>> dias=['Segunda-feira','Terça-feira','Quarta-feira','Quinta-feira','Sexta-

feira','Sábado','Domingo']
>>> print(f'Dia da semana: {dias[tempohorario.tm_wday]}')
Dia da semana: Quarta-feira
>>> print(f'Dia do ano: {tempohorario.tm_yday}')
Dia do ano: 150
>>> print(f'Horário de verão: {tempohorario.tm_isdst}')
Horário de verão: 0
554
 Outra forma de fazer:
>>> import datetime
>>> hoje = datetime.datetime.now()
>>> hoje
datetime.datetime(2018, 6, 3, 23, 25, 27, 531139)
>>> str(hoje)
Matemática '2018-06-03 23:25:27.531139'
Tempo - Horário >>> repr(hoje)
'datetime.datetime(2018, 6, 3, 23, 25, 27, 531139) '

>>> hoje.day
3
>>> hoje.hour
23
>>> hoje.minute
25
555
 Criação de uma data:
>>> d1=date(2018,6,1)
>>> d2=date(1995,10,2)
>>> type(d1)
<class 'datetime.date'>
Matemática  Diferença entre duas datas:

Tempo – Horário: days
>>> delta = d2-d1
datetime.timedelta(8278)
>>> delta.days
8278
556
Classes
557
 Python é uma linguagem Orientada a Objeto.
 Um objeto é uma instância de uma Classe.
Classes  Python Trabalha com herança múltipla.
Orientação a Objeto
558
 Python é uma linguagem Orientada a Objeto.
 Um objeto é uma instância de uma Classe.
Classes  Python Trabalha com herança múltipla.
559
 Abstração
Orientação a
 Encapsulamento
Objetos
 Herança e
Pilares:
 Polimorfismo.
560
• Classes são estruturas que permitem de definir e criar objetos.
• Elas servem como um modelo (moldura) para os objetos a serem
criados.
• Uma Classe é uma abstração de entidades (objetos) do mundo real:
uma simplificação/modelagem destes.
Classe • Os objetos de uma Classe compartilham as mesmas características e
Definição comportamentos específicos (especificados na classe).
• Exemplo:
• Pessoa, Funcionário, Carro, Mamífero, Aluno, etc.
561
Classe faz um agrupamento de objetos que compartilham as
mesmas características (propriedades) e comportamentos (ações).
É uma moldura que, a partir dela, serão gerados / criados os objetos.
A partir de uma Classe, podemos gerar quantos objetos (filhos)
Classe quisermos.
Definição
562
Propriedades
Características
ESTADO
Atributos
Ações
Classe COMPORTAMENT
O
Métodos
Definição
Uma classe é dividida em duas partes: os atributos, definindo

seu estado e os métodos, definindo seu comportamento.
563
referência ao objeto atual
Classe Conta_Bancária
Atributos
titular: def consultar_saldo(self):
agência: return self.saldo
número: def sacar(self,x):
saldo: if x>self.saldo:
Classe Métodos
print('Saldo '+str(self.saldo)+' Insuficiente!')
else:
Criação de Classe self.saldo-=x
consultar_saldo() print('Saque realizado com
Sucesso!')
sacar() def depositar(self,x):
depositar()
self.saldo+=x
print('Saldo atualizado: '+str(x)+' reais.')
564
class Conta_Bancária:
def __init__(self, titular, agência, conta, saldo): construtor
self.titular = titular
self.agência = agência
self.número = conta
self.saldo = saldo # método de instanciação
def consultar_saldo(self):
return self.saldo
Classe def sacar(self,x):
Criação de Classe if x>self.saldo:
construtor print('Saldo '+str(saldo)+' é insuficiente!')

else:
self.saldo-=x
print('Saque realizado com Sucesso!')
def depositar(self,x):
self.saldo+=x
print('Saldo atualizado: '+str(x)+' reais.')
565
Classe Conta_Bancária
titular:
agência:
número:
Classe
saldo:
consultar_saldo()
sacar()
depositar()
Classe instance_of
Instanciação de Classes
Criação de Objetos titular: 'Sofiane ' titular: 'Maria' titular: 'Lucas'
instance-of
objetos
agência: 2045 agência: 2021 agência: 2045
número: 11017280 número: 11012342 número: 11013245
saldo: 2500.34 saldo: 0.0 saldo: 12680.28
minha_conta conta_2 conta_6
Cada objeto é criado instanciando a sua Classe, i.e. especificando os valores de seus atributos.
Aqui, criamos 3 objetos a partir da classe Conta_Bancária. 566
objeto instância
Classe
Instanciação de Classes
Criação de Objetos Um objeto é uma instancia
de uma classe
567
Criação dos objetos
minha_conta = Conta_Bancária('Sofiane', 2045 , 11017280, 2500.34)
conta_2 = Conta_Bancária('Maria', 2045 , 11012342, 0.0)
Classe conta_6 = Conta_Bancária('Lucas', 2021 , 11013245, 12680.28)

Instanciação de Classes # Cria objetos e atribuía valores aos atributos.
Criação de Objetos
568
Usando a notação de ponto:
Titular da conta conta_6:

conta_6.titular # 'Lucas'
Classe Qual é a minha agência?

Acesso aos Atributos minha_conta.agência # 2045
Número da conta do cliente_2?

conta_2.consultar_saldo() # 0.0
569
A evocação dos métodos é realizada pelo envio de mensagens aos objetos:
Saldo da minha conta?

minha_conta.consultar_saldo()
Classe Depositar 120 reais na conta_2

Evocando os Métodos conta_2.depositar(120)
Envio de Mensagens envio de mensagem ao objeto
Sacar 20 reais da conta_6

conta_6.sacar(20)
envio de mensagem ao objeto
570
Para permitir a criação de objetos com atributos vazios, usamos o None no
método de inicialização (construtor) __init__:
Valores que serão atribuídos por default
class Conta_Bancária:
def __init__(self, titular=None, agência=None, número=None, saldo=0.0):
self.titular = titular
self.agência = agência
Classe self.número = número
Criar objetos Vazios self.saldo = saldo # atributos de instância
Isto significa que, caso os parâmetros de inicialização dos atributos não forma
especificados, eles assumem o default de None.
outra_conta = Conta_Bancária()
# Cria um objeto conta bancária “vazio” (com os valores defaults).
(None, None, None, 0.0)

Podemos especificar outros valores por default no lugar do None como ''
571
"self" é uma convenção usada em um método de uma classe para se referir ao objeto
atual.
O self é usado como o primeiro parâmetro em todos os métodos de uma classe,
incluindo o método especial "__init__".
Classe Ao usar "self" como o primeiro parâmetro, podemos acessar os atributos e métodos do
objeto usando a sintaxe da notação do ponto "self.atributo" ou "self.método".
self
572
class Pessoa:
def __init__(self, nome):
self.nome = nome
def cumprimentar(self):
print(f"Olá, eu sou {self.nome}!")

Classe
self # Criando um objeto da classe Pessoa
p = Pessoa("João")
# Chamando o método cumprimentar
p.cumprimentar()
573
class Livro:
def __init__(self, titulo, autor, ano):
self.titulo = titulo
self.autor = autor
self.ano = ano
# Criação do método detalhes
Classes def detalhes(self):

construtor print(f"{self.titulo} - {self.autor} ({self.ano})")
# Criando uma instância da classe Livro

livro1 = Livro("Inteligências Múltiplas: A Teoria na Prática", "Howard Gardner",
1993)
# Invocando o método detalhes
livro1.detalhes() # Inteligências Múltiplas: A Teoria na Prática - Howard Gardner

(1993)
574
class Pessoa:
def __init__(self,nome): # método de inicialização dos objetos
self.nome =nome # o construtor dos objetos.
self.x = 0
self.y = 0
def andar(self, x, y): # definição do método andar.
self.x = self.x + x
self.y = self.y + y
Classes
construtor p=Pessoa('Maria')
print(p.x,p.y) #00
p.andar(0,2)
print(p.x,p.y) #02
(10,2)
p.andar(i,0)
10
print(p.x,p.y) # 10 2
575
TRANSPORTE
is-a
TERRESTRE AÉREO AQUÁTICO
Classes is-a is-a is-a
Orientação a Objeto AUTOMÓVEL AVIÃO BARCO
Herança
is-a
576
Escala de
abstração
Classe mais
Pessoa genérica
is-a
Classe mais
Funcionário específica
Classes
A SubClasse herda os atributos e métodos de todas as suas SuperClasses.
Herança
A subclasse também pode sobrescrever (redefinir) os métodos
is-a herdados, fornecendo uma nova implementação.
577
Pessoa
nome:
cpf:
endereço:
__init__(self,nome)
__apresentar__(self)
is-a
Funcionário
Salário:
Cargo:
Classes calc_sal(self)
Orientação a Objetos
Herança is-a
is-a
CREA: Idiomas: Habilitação:
Projetos: Acidentes:
calc_sal(self) calc_sal(self) calc_sal(self)

super().calc_sal(self) super().calc_sal(self) super().calc_sal(self)
Engenheiro Secretária Motorista

578
Herança é um conceito que permite de criar novas classes a
partir de classes existentes.
A subclasse estende a superclasse, adicionando ou
modificando novos atributos e/ou métodos.
É uma forma de reutilização de código, onde uma classe
derivada, também chamada de subclasse, herda os atributos e
Classes métodos de uma classe base, também chamada de superclasse.
Herança
579
A herança permite de estabelecer uma hierarquia de classes,
onde as classes mais especializadas herdam características das
classes mais genéricas.
Isso promove a organização, a modularidade e o reuso de
código.
A classe inferior herda de sua classe superior (atributos e
Classes métodos), que, por sua vez, herda de sua classe superior, etc.
Portanto, uma classe herda todas as características de todas as
Orientação a Objeto suas classes superiores na hierarquia.
Herança
580
Animal
is-a is-a
Hierarquia de
Classes Mamífero Ave
Herança
is-a is-a is-a
is-a
Cachorro Gato Pato
581
class Animal():
def som(self):
pass is-a
class Mamifero(Animal):
def som(self):
print("O mamífero faz um som característico.")
class Ave(Animal):
Hierarquia de def som(self):
Classes print("A ave faz um som característico.")

class Cachorro(Mamifero):
Criação de Hierarquia de
def som(self):
classes
print("O cachorro faz o som 'au au'.")
Implementação da class Gato(Mamifero):
Herança no Python
def som(self):
print("O cachorro faz o som 'Meow'.")
class Pato(Ave):
def som(self):
print("O pato faz o som 'uack quack'.")
is-a
582
isa vs. instanceof
Relação de Instanciação
(Objeto-Classe)
Classe Mãe
Classe Mãe
is-a
instance-of
Classe Filha 1 Classe Filha 2 Classe Filha 3
Relação de Herança
Objeto 1 Objeto 2 Objeto 3
(Classe-Classe)
583
TRANSPORTE
TERRESTRE AÉREO AQUÁTICO
Classes AUTOMÓVEL AVIÃO BARCO
Classe Raiz object
Qual é a classe raiz ?
584
É a Superclasse (a Classe Mãe).
É a classe raiz da hierarquia das
object
classes. A classe mais alta.
Ela deve ser escrita em minúsculo.
TRANSPORTE
Classes TERRESTRE AÉREO AQUÁTICO
Classe object AUTOMÓVEL AVIÃO BARCO
585
Base Class
Principal
Classe Base de todas

object as Classes do Python.
Hierarquia de
Classes
Classe raiz object Animal
Cachorro Gato
586
No Python 3, todas as classes são consideradas derivadas implicitamente da classe
object, mesmo que isto não seja especificado explicitamente.
Nas versões inferiores (2.x), não havia herança implícita, e portanto era necessário
especificar a classe object.
Hierarquia de
Classes
Classe object class Animal(object): class Animal(): class Animal:
pass pass pass
O object é opcional e é a Superclasse por default.
Essas três expressões são equivalentes.
587
Python Java
class Object {
class object: // ...
pass is-a }
class Animal extends Object {
Hierarquia de class Animal(object):
pass is-a }
// ...
Classes class Cachorro(Animal):

class Cachorro extends Animal {
// ...
Classe object pass is-a }
class Gato extends Animal {
class Gato(Animal): // ...
pass }
588
object
object fornece métodos e atributos básicos que são herdados por todas as
Hierarquia das classes em Python. Entre eles:
Classes
__init__() (o construtor).
Classe object
__str__() método para retornar uma representação em string do objeto.
__eq__() método para comparar igualdade de objetos.
589
Impressão de um objeto:
class Pessoa:
def __init__(self, nome, idade):
self.nome = nome
Hierarquia das self.idade = idade
Classes def __str__(self):
__str__ return f"Nome: {self.nome} - Idade: {self.idade}"
# Criando um objeto da classe Pessoa
p = Pessoa("João", 30)
# Utilizando a função print() no objeto
print(p) # a formatação da saída do print é feita no __str__

Nome: João - Idade: 30
590
Classes
Hierarquia de Classes
591
(Login/Create New / Boards / Add Mind-Map / *)
592
Polimorfismo é um conceito da programação orientada a objetos que permite que
objetos de diferentes classes sejam tratados de forma uniforme.
• O Polimorfismo permite que um único método seja implementado de maneira
diferente em diferentes classes,
Hierarquia de • O Polimorfismo possibilitando que o mesmo código seja reutilizado para
Classes objetos distintos.

• Isso promove a flexibilidade, a extensibilidade e a modularidade do código.
Polimorfismo
• Polimorfismo vem do grego (poli=muitas e morfos=formas).
593
object
Hierarquia de
Classes Figura
Polimorfismo
Quadrado Retângulo Círculo Triângulo

área() área() área() área()
perímetro() perímetro() perímetro() perímetro()
Implementa esta hierarquia no Python
594
# Classes de Formas Geométricas
from math import sqrt
class Figura(object):
def __init__():
pass
Hierarquia de class Quadrado(Figura):

def __init__(self,lado):
Classes self.lado=lado
Polimorfismo def __str__(self):

return f'Lado: {self.lado:.2f}'
def perímetro(self):
return (self.lado)*4
def área(self):
return (self.lado)**2
595
class Retângulo(Figura):
def __init__(self,largura,cumprimento):
self.largura=largura
self.cumprimento=cumprimento
Hierarquia de
def __str__(self):
Classes return f'Largura: {self.largura:.2f}, Cumprimento: {self.cumprimento:.2f}'
Polimorfismo
return (self.largura+self.cumprimento)*2
def área(self):
return self.largura*self.cumprimento
596
class Círculo(Figura):
def __init__(self,raio):
self.raio=raio
Hierarquia de def __str__(self):

return f'Raio: {self.raio:5.2f}'
Classes
Polimorfismo
return 2*pi*self.raio
def área(self):
return pi*self.raio**2
597
class Triângulo(Figura):
def __init__(self,lado1,lado2,lado3):
self.lado1=lado1
self.lado2=lado2
self.lado3=lado3
def __str__(self):
return f'Lado1: {self.lado1:.2f}, Lado2: {self.lado2:.2f}, Lado3: {self.lado3:.2f}'
Hierarquia de def perímetro(self):
Classes return self.lado1+self.lado2+self.lado3
def área(self):
Polimorfismo base = self.lado1
s = (self.lado1+self.lado2+self.lado3)/2
# 1. área= (base*altura)/2
# 2. Fórmula de Heron (a, b e c são os lados do triângulo)
# área = √ s(s-a)(s-b)(s-c) onde s=(a+b+c)/2 (s: semi perímetro)
área = math.sqrt(s * (s - self.lado1) * (s - self.lado2) * (s - self.lado3))
return área
def altura(self): # supondo que lado1 é a base do triângulo
return 2*self.área()/self.lado1
598
q1=Quadrado(10) t1=Triângulo(3,4,5)
print(q1) print(t1)
Lado: 10.00 Lado1: 3.00, Lado2: 4.00, Lado3: 5.00
q1.área() t1.área()
100 6.0
r2=Retângulo(6,8) t1.perímetro()
Hierarquia de print(r2) 12
Classes Largura: 6.00, Cumprimento: 8.00 t1.altura()

4.0
r2.perímetro()
Polimorfismo 28
r2.área() c1=Círculo(6)
48 print(c1)
Raio: 6.00
c1.área()
113.09733552923255
objeto.método() c1.perímetro()
37.69911184307752
599
obj.método()
O método é procurado primeiro na classe do objeto, em seguida nas

superclasses de forma sequencial, respeitando a ordem definida pela object
Hierarquia de MRO (Method Resolution Order), ou Ordem de Resolução de
Classes Métodos.
Animal
A ordem de pesquisa dos métodos segue o princípio "first-come, first-
Polimorfismo
C3 Linearization served" (primeiro que chega, primeiro que é servido). O algoritmo
MRO utilizado para determinar a MRO é chamado de "C3 Linearization".
Cachorro
ordem MRO: "Cachorro" -> "Animal" -> "object".
600
object
obj.método()
Em caso de herança simples (uma classe só pode herdar de apenas

Classe
uma classe), a definição da ordem MRO é simples e intuitiva.
Hierarquia de O algoritmo C3 Linearization apenas segue a ordem das superclasses,
Classes iniciando com a classe do objeto a quem foi enviada a mensagem, até ...
que o método é encontrado ou que a classe raiz object é atingida.
Polimorfismo
Classe
Classe
ordem MRO: []
mensagem obj
601
• A ordem MRO é mais complexa a ser determinada quando a herança é múltipla
(uma classe podendo herdar de várias classes), pois pode exigir resolver
conflitos de nomes e métodos em diferentes superclasses.
Hierarquia de • O algoritmo C3 Linearization prioriza a preservação da ordem de herança das

classes envolvidas respeitando a ordem em que essas superclasses são
Classes mencionadas na declaração da classe.
Polimorfismo • A ordem MRO é mais complexa a ser determinada, quando a herança é
múltipla, pois pode exigir resolver conflitos de nomes e métodos em
diferentes superclasses.
• Se o método não é encontrado, o sistema retorna um erro.
602
object
Classe D
[D] mensagem obj

3 Classe A
[D, C]
Classe B 4
[D, C,A]
2 Classe C
[D, C, A, B]
O C3 Linearization faz uma busca

1 Classe D
em profundidade
Aplica o algoritmo C3 Linearization para determinar a ordem MRO para esta hierarquia
ordem MRO: [D, C, A, B]
603
class A(): class B():
pass pass
#def __init__(): #def __init__():
#pass #pass
def oi(self): def oi(self):

print('Oi A!’) print('Oi B!')
Hierarquia de class C(A):

pass
class D(C,B):
Essa ordem
é significativa!
Classes #def __init__():
#pass
#def __init__():
#pass
Polimorfismo
#def oi(self): #def oi(self):
Serialização #print('Oi CA!') #print('Oi DCB!')
>>> d=D()
>>> d.oi()
Oi A!
Qual será a MRO, se invertemos a ordem a hierarquia: class D(B,C):
604
Pato é um Animal Voador
object
Hierarquia de
Classes Animal Voador
Herança Múltipla
Pato
Exemplo de Herança Múltipla
605
Evocando método da classe superior (superclasse) super()
class Animal:
self.nome = nome
def emitir_som(self):
print("O animal emite um som.")
Hierarquia de class Gato(Animal):

def __init__(self, nome, cor):
Classes self.nome=nome
#super().__init__(nome)
super() self.cor = cor
def emitir_som(self):
super().emitir_som()
# Chama o método emitir_som() da classe Animal
print("O gato faz 'miau'.")
g = Gato("Lucy", "cinza")
g.emitir_som()
O animal emite um som.
O gato faz 'miau'.
606
class Animal:
self.nome = nome Herança Múltipla no Python
def comer(self):
print(f"{self.nome} está comendo.")
def dormir(self):
print(f"{self.nome} está dormindo.")
class Voador:
def voar(self):
print(f"{self.nome}
is-a
está voando.")
# Criando um objeto da classe Pato
class Pato(Animal, Voador):
p = Pato("Dario")
Animal.__init__(self, nome) # Chamando métodos da classe Pato
Voador.__init__(self) p.comer()
p.dormir()
def fazer_som(self):
p.voar()
print(f"{self.nome} faz som de pato: Quack!") 607
p.fazer_som()
class Funcionario(Pessoa):
Hierarquia de super().__init__(nome)
Classes self.salario = 6000
super() self.matricula = 0
self.departamento = ''
608
ENCAPSULAMENTO
Garantia de
integridade dos
dados evitando as interface
modificações
indesejadas.
Classes mensagem
Encapsulamento objeto
implementação
609
• Encapsulamento é o princípio de ocultar a implementação dos métodos e
restringir/controlar o acesso aos atributos somente por meio de métodos internos,
com o objetivo de protegê-los.
• A boa prática é evitar o acesso direto aos atributos privados e utilizar os métodos
Classes de acesso apropriados para interagir com esses atributos.
Encapsulamento
• No Python, o encapsulamento é implementado de 3 formas:
610
1. Uso de convenções de Nomenclatura:
Um sublinhado único prefixado (_atributo) indica que um atributo é
considerado como "privado" e não deve ser acessado diretamente fora da classe.
Porém, é apenas uma convenção e não impede de fato o acesso direto ao atributo.
2. Uso de propriedades e decoradores @property:
O Python oferece o uso de propriedades e o decorador @property para controlar o acesso
Classes aos atributos de uma classe. Ao usar propriedades, é possível definir métodos especiais
Encapsulamento para obter e definir valores de atributos, permitindo a adição de lógica personalizada
durante essas operações.
611
class Pessoa:
def __init__(self, nome, idade):
self.nome = nome
self._idade = idade # convenção de nomenclatura
def __str__(self):
return f'Nome: {self.nome}, Idade: {self._idade}'
@property # o uso do decorador @property torna o
método
Classes def idade(self):

return self._idade
# um getter para a propriedade correspondente
Encapsulamento @idade.setter # <nome_da_propriedade.setter> pode mudar

def idade(self, valor):
if valor >= 0:
self._idade = valor
else:
raise ValueError("A idade deve ser um valor positivo.")
p = Pessoa('Mario', 20)
print(p)
p.idade = 6 # chamada do setter
print(p.idade) # chamada do getter retorna 6
612
3. usando modificadores de acesso (private e protected) para controlar o acesso aos
dados e métodos da classe.
Modificadores de acesso são palavras-chave usadas para controlar a visibilidade de
dados e métodos. Existem três modificadores de acesso em Python (Public, Private e
Protected):
Classes • Atributos privados só podem ser acessados pela classe que os define e suas subclasses.
• Os atributos protegidos podem ser acessados pela classe que os define, suas subclasses e
Encapsulamento
classes no mesmo módulo.
613
1. Public: Os membros de uma classe são considerados públicos por padrão. Isso
significa que eles podem ser acessados de qualquer lugar, tanto dentro como fora da
classe.
class Exemplo:
def __init__(self):
self.valor_publico = 10
Classes
Encapsulamento e = Exemplo()
print(e.valor_publico) # Saída: 10
614
2. Private: Os membros de uma classe podem ser tornados privados usando um sublinhado
prefixado no nome do atributo ou método. Isso indica que eles devem ser acessados
apenas de dentro da classe. No entanto, em Python, a convenção é usar um sublinhado único
antes do nome (_atributo) para indicar que o membro é privado, mas ainda é acessível.
class Exemplo:
Classes def __init__(self):

self._valor_privado = 20 # 2 undercores
Encapsulamento
e = Exemplo()
print(e._valor_privado) # Saída: 20 (acessível, mas indicado como
privado)
615
3.Protected: Em Python, não há um modificador de acesso protegido oficial como em
outras linguagens de programação. No entanto, a convenção é usar um sublinhado duplo
antes do nome (__atributo) para indicar que o membro é protegido, o que significa que ele
não deve ser acessado fora da classe, mas ainda é acessível.
class Exemplo:
def __init__(self):
Classes self.__valor_protegido = 30 # 2 undercores
Encapsulamento
e = Exemplo()
print(e.__valor_protegido) # Erro: AttributeError: 'Exemplo' object has
no attribute '__valor_protegido'
616
class Pessoa:
self._nome = nome # Atributo "privado" com um sublinhado
def get_nome(self):
return self._nome
def set_nome(self, novo_nome):
self._nome = novo_nome
p = Pessoa("João")
Classes # Acessando o atributo "privado" diretamente (não é restrito)

print(p._nome)
Encapsulamento # Acessando o atributo "privado" por meio de um método público

print(p.get_nome())
# Modificando o atributo "privado" por meio de um método público
p.set_nome("Maria")
print(p.get_nome())
O encapsulamento em Python é alcançado principalmente por meio de convenções de

nomenclatura e do uso de atributos e métodos privados implementação interna da classe ('_atributo'
e '_metodo()').
617
class Car:
# atributo privado
_speed = 0
# atributo protegido
_color = ""
@property # cria uma propriedade, tornando métodos
def color(self): # acessíveis como se fossem atributos
return self._color
Classes @cor.setter # da mesma forma para alterar
def color(self, color):
Encapsulamento self._color = color
def accelerate(self, amount):
self._speed += amount
def brake(self, amount):
self._speed -= amount
def print_speed(self):
print(self._speed)
618
Python tem suporte a metaclasses.
Uma metaclasses é uma classe que define o comportamento de
outras classes. Ela age como um molde para criar classes.
Uma metaclasse é considerada como um objeto instância de uma
Classes outra classe.

Meta Classes A principal utilidade das metaclasses é permitir a personalização e a
manipulação do comportamento das classes em tempo de criação.
Com as metaclasses, podemos adicionar ou modificar atributos,
métodos e comportamentos das classes que são criadas a partir dela.
619
Classes As metaclasses podem ser usadas para realizar tarefas avançadas,
Meta Classes como validações, controle de acesso, geração dinâmica de código, etc.
type é a classe base das metaclasses no Python.
620
class MinhaMetaclasse(type):
def __new__(cls, nome, bases, attrs):
# Adiciona um prefixo ao nome das classes
attrs['nome'] = 'Prefixo_' + attrs['nome']
# Cria a classe com a metaclasses

nova_classe = super().__new__(cls, nome, bases, attrs)
return nova_classe
Classes class MinhaClasse(metaclass=MinhaMetaclasse):
Meta Classes nome = 'MinhaClasse'
# Criando uma instância da classe
objeto = MinhaClasse()
# Acessando o atributo nome
print(objeto.nome) # Prefixo_MinhaClasse
621
 É possível atribuir um objeto a um atributo e ter a referência a
esse objeto armazenada no atributo.
 Isso permite que objetos se relacionem entre si dentro de uma

estrutura de classes.
Classes  Composição
Relacionamento de
Objetos  Agregação
 Associação
622
O amigo de uma pessoa é uma pessoa.
class Pessoa:
self.nome = nome
self.amigo = None # Inicializa o atributo amigo como None
def definir_amigo(self, amigo):

self.amigo = amigo
Pessoa
def mostrar_amigo(self):
Classes if self.amigo:
print(f"Meu amigo é {self.amigo.nome}.") amigo
Composição else:
print("Não tenho amigo definido.")
Pessoa
# Exemplo de uso
pessoa1 = Pessoa("João")
pessoa2 = Pessoa("Maria")
pessoa1.definir_amigo(pessoa2)
pessoa1.mostrar_amigo() # Meu amigo é Maria.
pessoa2.mostrar_amigo() # Não tenho amigo definido.
623
Um professor leciona várias disciplinas, e uma disciplina e dada por
um professor.
class Professor:
self.nome = nome
self.disciplinas = [] # Lista de disciplinas
class Disciplina: Professor
Classes def __init__(self, nome):

self.nome = nome
leciona
Agregação
# Exemplo de agregação
matematica = Disciplina("Matemática") Disciplina
ingles = Disciplina("Inglês")
professor_1 = Professor(“Marta")
professor_1.disciplinas.append(matematica)
professor_1.disciplinas.append(ingles)
624
class Carro:
def __init__(self, modelo):
self.modelo = modelo
self.motoristas = [] # Lista de motoristas
class Motorista:
self.nome = nome Motorista
self.carros = [] # Lista de carros
dirige
Classes
# Exemplo de associação
carro1 = Carro("Fusca")
carro2 = Carro("Gol")
Associação Carro
motorista_1 = Motorista("Carlos")
motorista_2 = Motorista("Marta")
carro1.motoristas.append(motorista_1)
motorista_1.carros.append(carro1)
Um motorista dirige vários carros, e um carro pode ser dirigido

por vários motoristas. 625
Classes abstratas são classes que não podem ser instanciadas diretamente, ou seja,
não podem ser utilizadas para criar objetos. Elas são projetadas para serem usadas
como modelos para outras classes, fornecendo uma estrutura comum e definindo
métodos que devem ser implementados nas classes derivadas.
Uma classe abstrata pode conter métodos abstratos, que são métodos declarados, mas
Classes não implementados na classe abstrata. Esses métodos devem ser implementados nas
Classes Abstratas classes derivadas para que elas possam ser instanciadas.
Em Python, as classes abstratas são definidas utilizando o módulo abc (Abstract Base
Classes). Para criar uma classe abstrata, é necessário herdar da classe ABC e usar o
decorador @abstractmethod antes dos métodos que desejamos tornar abstratos.
626
Exemplo:
from abc import ABC, abstractmethod
class Animal(ABC):
@abstractmethod
pass
class Cachorro(Animal):
print("Au Au!")
Classes class Gato(Animal):
Classes Abstratas def fazer_som(self):
print("Miau!")
# Não é possível instanciar a classe Animal diretamente
# a = Animal() # Erro: TypeError: Can't instantiate abstract class Animal with
abstract methods fazer_som
c = Cachorro()
c.fazer_som() # Au Au!
g = Gato()
g.fazer_som() # Miau!
627
Implantar a estrutura de Pilha.
class Pilha:
def __init__(self):
self.itens = []
def empilhar(self, item):

Classes self.itens.append(item)
pilha = Pilha()
Exercício: Pilhas def desempilhar(self): pilha.empilhar(1)
if not self.esta_vazia(): pilha.empilhar(2)
return self.itens.pop() pilha.empilhar(3)
def esta_vazia(self): print(pilha.desempilhar()) # 3

return len(self.itens) == 0 print(pilha.desempilhar()) # 2
def tamanho(self): print(pilha.esta_vazia()) # False

return len(self.itens) print(pilha.tamanho()) # 1
628
 Vantagens:
• A orientação a objetos permite organizar o código de forma mais modular e
reutilizável.
• Reutilização de código: podemos criar várias instâncias de uma classe, economizando
Classes tempo e esforço.
• Modularidade: a divisão do código em classes facilita a organização e manutenção

Administrar Complexidade
do programa.
• Abstração: podemos focar nos objetos e suas interações, sem se preocupar com os
detalhes de implementação.
629
Módulos & Packages
630
 Módulo é um arquivo .py que contém (agrupa) várias definições de
funções e de classes (Código Reutilisável).
 Isso organiza o código e facilita o reuso das funções e classes definidas.

Módulos
 Cada vez que precisamos usar essas funções e classes (ou algumas delas)
?
basta importar esse arquivo (o módulo)
631
• A Biblioteca (library) é um conjunto de pacotes e módulos que fornecem
funcionalidades específicas. Ela pode ser considerada como uma coleção
de pacotes.
• O Pacote (package em inglês) é um diretório que contém um ou mais

arquivos de módulo e um arquivo __init__.py que indica que o diretório
Bibliotecas deve ser considerado um pacote Python. Cada pacote pode conter outros
pacotes e módulos. Um pacote pode ser considerado como uma coleção de
módulos.
• O Módulo (module em inglês) é um arquivo Python que contém definições

e instruções Python. Ele pode ser importado em outros arquivos Python
para reutilizar o código nele contido. Um módulo é considerado como uma
unidade básica de código em Python.
632
Biblioteca
Pacote 1
Módulo 1.1
Módulo 1.2
Bibliotecas
Pacote 2 Componente
Maior
Módulo 2.1
Componentes
Menores
Módulo 2.2
633
NUMPY
Numpy
array
fft
random
Bibliotecas
Subprocees
run
call
check_output
https://www.google.com/search?q=NumPy
https://www.google.com/search?q=NumPy 634
https://www.google.com/search?q=Subprocess
import numpy as np
array = np.array([1, 2, 3, 4, 5])
print(array)
[1 2 3 4 5]
Bibliotecas
import subprocess command = "ls -l"
subprocess.call(command)
Este código executa o comando “ls –l” em um subprocesso, e a

saída do comando será impressa na console.
635
Bibliotecas Populares do
Python
1 Numpy 2 Pandas
Biblioteca para computação Biblioteca para analisar dados

científica que fornece um em Python.
objeto de matriz poderoso.
3 Matplotlib
Biblioteca de visualização de dados. É a biblioteca padrão para

visualizações em Python.
• Crie um arquivo com extensão ".py"
• Adicione seu código Python
Módulos
Criação
637
 Para importar um módulo:
import nome-modulo
 O nome do módulo é determinado pelo nome do arquivo mas sem a

Módulos extensão.
import
638
# Exemplo de módulo:
# Módulo calculo.py
def somar(a,b):
return a+b
def subtrair(a,b):
return a – b
Módulos def multiplicar(a,b):

return a * b
import: exemplo
def dividir(a,b):
return a / b
# esse arquivo será salvo com a

# extensão .py (calculo.py)
# a partir daí, qqr programa python poderá

# importar o módulo e utilizar suas definições.
639
import calculo
print(calculo.somar(1,2))
print(calculo.dividir(100,25))
Módulos
import: exemplo
640
from calculo import somar, dividir
# aqui importamos apenas 2 funções
print(somar(1,4)) #5
print(dividir(12,6)) #2
Módulos
from import # arquivos e módulos devem ficam na mesma pasta
# observe que ao usar o import, não precisamos mais colocar no nome do

# módulo
641
import calculo
from calculo import *
Módulo  As duas formas importam tudo do módulo, a diferença é que a 2ª forma

(from) elimina a necessidade de digitar “calculo" toda vez que quisermos
import *
chamar algo do módulo.
642
Importação de um módulo com um alias
import nome_do_modulo as alias
Módulo
Permite de definir um alias (apelido) para o módulo importado, tornando
alias
mais fácil a referência ao módulo ao longo do código.
643
Importação de um pacote, ou de um módulo de um pacote
import mome_pacote.nome_do_modulo
Módulo
pacote
644
# Definição de uma função
def saudacao(nome):
print("Olá, " + nome + "! Bem-vindo ao meu módulo.")
Módulo # Definição de uma variável
Exemplo de criação de mensagem = "Este é um exemplo de módulo em Python."

Módulo
645
 os - Suporte para recursos do sistema operacional (mudar o diretório
corrente, detectar o tamanho de um arquivo, deletar um arquivo, etc.).
 math – funções matemáticas.
 sys - Rotinas que controlam o ambiente de execução do Python (exemplos:
Módulos consultar o PYTHONPATH (lista de diretórios onde o Python procura

Exemplos de Pacotes módulos) e encerrar o programa)
 copy - Copia objetos.
 subprocess - Rotinas para executar processos.
646
 Package é uma unidade organizacional de código python: são usados para
organizar os módulos.
 É um diretório que contém vários módulos:

 Por exemplo, web.forms é uma referência ao módulo forms que faz parte do
package web.
Packages  O ponto permite que os autores de módulos não precisam se preocupar com
Packages Vs. Modules conflito de nomes
Packages
pacote módulo
web.forms Modules
647
 A diferença entre um diretório comum para um pacote Python é a
presença do arquivo __init__.py.
 A presença do arquivo __init__.py no diretório é necessária para que este

diretório seja considerado um pacote e para que possamos acessar seus
módulos.
Packages  O arquivo __init__.py pode inicializar uma lista chamada __all__.
Packages
__init__.py
Modules
648
Pacote: estrutura de diretórios
meu_pacote /
Packages __init__.py
modulo1.py
modulo2.py
649
# Conteúdo do arquivo init.py.py (no diretório "meu_pacote"):
# Arquivo vazio
# É necessário para indicar que este diretório é um pacote Python
# Conteúdo do arquivo modulo1.py (no diretório "meu_pacote"):
# Definição de uma função

def somar(a, b):
return a + b
Packages
Criação de Pacotes # Conteúdo do arquivo modulo2.py (no diretório "meu_pacote"):
# Definição de uma classe

class Pessoa:

self.nome = nome
def apresentar(self):
print("Olá, meu nome é", self.nome)
650
O diretório que contém os arquivos do exemplo do pacote, chamado "meu_pacote", pode
estar localizado em qualquer lugar no sistema de arquivos do seu computador. Você pode
escolher um local conveniente para armazenar seus arquivos de pacote.
para que o pacote seja reconhecido e importado corretamente no seu código Python, é
importante que o diretório do pacote esteja incluído no caminho de pesquisa do Python.
Existem algumas abordagens comuns para isso:
Packages 1. Local do script atual: Se estiver executando um script Python que desejamos importar o
pacote, o diretório do pacote pode estar no mesmo diretório do script. Nesse caso, o Python
Diretório do Pacotes já deve ser capaz de localizar o pacote sem configurações adicionais.
2. Adicionar ao sys.path: Podemos adicionar o diretório do pacote ao sys.path, que é uma
lista de diretórios onde o Python procura por módulos e pacotes. Isso pode ser feito no início
do script Python, antes de tentar importar o pacote.
3. Configurar PYTHONPATH: Outra opção é configurar a variável de ambiente

PYTHONPATH para incluir o diretório do pacote. Isso pode ser feito definindo a variável de
ambiente PYTHONPATH no sistema operacional ou no ambiente de desenvolvimento.
651
 Para criar um package:
 Criar um diretório com o nome do package;
 Criar o arquivo __init__.py (podendo ser vazio) dentro do diretório;

Packages e
 Colocar os módulos do package dentro do diretório.
652
if __name__ == "__main__":
main()
Packages
if __name__ == "__main__":
main()
653
if __name__ == "__main__":
main()
Essa estrutura permite de escrever código que é executado quando o arquivo é executado
diretamente como um script, mas não quando ele é importado como um módulo.
Quando executamos um arquivo, o interpretador Python primeiro cria um objeto de módulo para
esse arquivo. A variável __name__ deste objeto de módulo será definida como o nome do arquivo.
Packages Portanto, se executamos o arquivo diretamente, a variável __name__ será definida como
"__main__". No entanto, se importamos o arquivo de outro arquivo, a variável __name__ será
if __name__ == "__main__": definida com o nome do arquivo.
main() A instrução if __name__ == "__main__": verifica se a variável __name__ está definida como
"__main__". Se for, o código dentro da instrução if será executado. Caso contrário, o código dentro
da instrução if será ignorado.
Assim, esse código é usado para garantir que o bloco de código dentro do if seja executado
somente quando o arquivo Python for executado diretamente, e não quando ele é importado como
um módulo em outro programa.
654
 NumPy é um excelente pacote para computação científica em Python:
 Características:
• Fornece suporte para arrays multidimensionais eficientes e operações matemáticas
rápidas.
• Possibilita a manipulação de grandes conjuntos de dados numéricos de forma

Numpy eficiente.
Pacote • Inclui funções matemáticas avançadas, transformadas de Fourier, álgebra
linear, etc.
• amplamente utilizado para cálculos científicos e numéricos, especialmente em áreas

como ciência de dados, aprendizado de máquina e física.
Importação
import numpy as np
655
Exemplo de Análise de Dados usando a biblioteca Pandas
import pandas as pd
# Carregar dados de um arquivo CSV em um DataFrame
df = pd.read_csv('dados.csv')
Pandas # Realizar operações de análise de dados no DataFrame

Pacote resultado = df.describe()
656
• Matplotlib é uma biblioteca para criação de gráficos e de visualização de
dados em Python.
• Recursos:
• Oferece uma ampla variedade de gráficos: linhas, barras, dispersão,
histogramas, etc.
• Permite de criar gráficos estáticos, gráficos de dispersão, histogramas,
MatPlotLib gráficos de barras, etc.
Pacote
• Permitir de personalizar a aparência dos gráficos: cores, rótulos e
legendas.
import matplotlib.pyplot as plt
657
Existem vários pacotes disponíveis para diversas necessidades:
• scikit-learn para aprendizado de máquina,
• TensorFlow para aprendizado profundo,
•
Pacotes
Django para desenvolvimento web.
Exemplos
658
Os pacotes do Python podem ser organizados em 3 grupos:
Pacotes Python
Pacote Biblioteca Padrão

do Python
PyPI
Python
Package Index
Outros
Repositórios
3 tipos de Pacotes
Conjunto de módulos e pacotes Principal repositório de pacotes Bibliotecas de Terceiros:
que são distribuídos junto com o Python. Hospeda a maioria dos Anaconda Cloud, ActiveState,
interpretador Python (módulos pacotes (cerca de 80%), que serão etc.
de sistema, acesso à BD, de Rede, instalados usando o pip (Numpy,
Gerenciamento de Arquivos). pandas, matplotlib, Flask,
Não precisam ser instalados Django, requests, etc.).
separadamente, mas apenas
importados.
659
Python Package Index -PyPI
É o repositório dos pacotes padrão do Python.
Acessado no site:
https://pypi.org/
Pacote
Instalação de Pacotes
Repositório PyPI
660
O repositório PyPI é atualizado diariamente.
Relação dos pacotes do Python:

PyPI packages list
Pacote
Python Package Index –
PyPI
Relação completa
661
Para instalar um pacote, é preciso encontrá-lo no Repositório PyPI, copiar
o comando e executá-lo no terminal do windows:
https://pypi.org/
Pacote
Instalação de um Pacote
Buscar e instalar o pacote keyboard, por exemplo:
pip install keyboard
662
O pip instala um pacote a partir da PyPi:
https://pypi.org/
pip install keyboard
Pacote
Instalação de um Pacote
663
pip é o gerenciador de de pacotes do Python.
pip list: lista todos os pacotes Python instalados.
pip install nome-do-pacote: instala um pacote Python a partir do PyPI.

pip uninstall nome-do-pacote: desinstala um pacote Python.
pip show nome-do-pacote: exibe informações detalhadas sobre um pacote
Pacote Python instalado com pip (da PyPI).
pip install -r requirements.txt: instala todos os pacotes Python

Gerenciador de Pacotes listados em um arquivo requirements.txt. ==
pip # requirements.txt >
numpy==1.19.4 >=
pandas==1.3.0 < >= 2.8.1
pip install -r requirements.txt matplotlib==3.4.2 <= == 2.8.*
pip freeze: gera uma lista de todos os pacotes Python instalados, no formato
que pode ser usado para criar um arquivo requirements.txt.
C:\Users\windows>pip freeze
keyboard==0.13.5
C:\Users\windows>
664
Relação dos pacotes instalados:
pip list
Pacote
Listar os pacotes
instalados localmente
O comando pip list no terminal permite de listar os pacotes

Python instalados (pelo pip) no sistema.
665
Para desinstalar um pacote já instalado, usamos o comando unistall no
terminal do windows.
pip uninstall nome-pacote
Pacote
DesInstalar um Pacote
Atenção. Se o pacote a ser desinstalado tem dependências, elas também

serão desinstaladas.
666
Instalar vários pacotes Python ao mesmo tempo:
separar os nomes dos pacotes com espaços
pip install pacote1 pacote2 pacote3

Pacote
Instalação de vários
Pacotes
Exemplo:
pip install numpy pandas matplotlib
667
Um pacote com dependências é um pacote que requer que outros pacotes também
sejam instalados para que ele possa funcionar corretamente.
matplotlib pandas
Pacote numpy six numpy pytz
Pacote com dependências Biblioteca para criação de Biblioteca de machine

gráficos. learning.
tensorflow
Exemplos de pacotes com

dependências
numpy protobuf
Biblioteca para análise de dados.
668
Para facilitar e flexibilizar a execução do Python, é importante
colocá-lo no PATH do windows:
São dois caminhos a serem adicionados ao PATH: o executável do

Python e o diretório dos scripts:
C:\Users\Samsung\AppData\Local\Programs\Python>
Pacote C:\Users\Samsung\AppData\Local\Programs\Python\Python311\Scripts
PATH
C:\Users\windows\AppData\Local\Programs\Python>
C:\Users\windows\AppData\Local\Programs\Python\Python311\Scripts>
Esses caminhos dependem de cada instalação.
669
Módulo Categoria
math Math
statistics Math
random Math
fileinput Filesystems
gzip Filesystems
zipfile Filesystems
configparser Filesystems
csv Text Processing
string Text Processing
re Text Processing
readline Text Processing
collections Data Types
array Data Types
datetime Data Types
calendar Data Types
os Operating Systems
platform Operating Systems
670
Category Packages
Math NumPy, SciPy, Matplotlib Category Packages and Modules
Filesystems os, shutil

Math math, statistics, random
File Formats csv, json

Text Processing csv, string, re, readline
Word Processing docx
collections, array, datetime,
Data Types
calendar
Data Types collections, datetime
Operating Systems os, platform

Operating Systems platform, requests
Filesystems fileinput, gzip, zipfile, configparser
14/11/2023 671
Python Standard Library: https://docs.python.org/3/library/
NumPy: https://numpy.org/
SciPy: https://scipy.org/
Pacotes Matplotlib: https://matplotlib.org/
Referências
672
Exceções
673
 Muitas funções em Python fazem o programa terminar em caso de
erro (divisão por zero, entrada de um dado errado, etc.).
 Isto acontece porque uma exceção foi gerada.

Exceções
 Exceções não tratadas causam o fim do programa.
?
674
try:
programa
except:
tratamento
Exceções
Sintaxe try:
# código a ser executado "sob vigilância"
except Exception:
# caso ocorrer alguma exceção no código acima,
# trate-a aqui.
675
RuntimeError,
TypeError,
NameError
Exceções ZeroDivisionError
ValueError
Tipos de Erros
676
while True:
try:
x = int(input('Por favor, informe um número: '))
break
Exceções
Exemplo except ValueError:
print('Oops! Favor digitar um número válido... ')
677
import math
try:
x = math.sqrt(op1)
Exceções except Exception:

Exemplo print('Atenção! Não é possível calcular a raiz quadrada de um
número negativo!')
678
def divide(x, y):
try:
resultado = x / y
except ZeroDivisionError:
print("divisão por zero!")
Exceções y=1
else:
Exemplo
print("resultado é", resultado)
finally:
print("executando a cláusula finally")
>>> divide(3,2) >>> divide(3,0)

resultado é 1.5 divisão por zero!
executando a cláusula finally executando a cláusula finally
679
bFim = False
while not bFim:
try:
iNumero1 = 10
iNumero2 = 0
fResultado = iNumero1/iNumero2
Exceção print('Resultado = %.2f' %fResultado)

exemplo bFim = True
except ZeroDivisionError:
print("Você tentou dividir por zero.")
break
except TypeError:
print("Você usou um valor não numérico.")
break
680
 Interpretador Dinâmico
dir( objeto ) #lista todos os métodos do objeto
Exceções help( objeto.metodo ) #retorna o docstring do objeto,

função, método, modulo, etc.
681
Utilitários
682
 Para colocar um delay de tempo entre os comandos:
>>> import time
>>> time.sleep(5) # delay de 5 segundos
Utilitários >>> time.sleep(60) # delay de 1 minuto

Delay de tempo: sleep
683
 Para executar um comando do sistema operacional (cmd):
>>> import subprocess
Utilitários >>> subprocess.check_output(['notepad']) # abre o editor notepad

O comando:
check_output >>> subprocess.check_output(['ipconfig']) # configurações ip
>>> subprocess.check_output(['ipconfig','/all']) # atributos são separados
684
 Para listar os arquivos de um determinado diretório (o desktop nesse caso):
import os
def listar():
Utilitário path='c:\\Users\\amigo\\Desktop\\' # caminho
listdir dir = os.listdir(path)
for file in dir:
print(file)
listar()
685
 Para remover um arquivo:
import os
def etc():
Utilitários path = "caminho-diretorio"
remove dir = os.listdir(path)
for file in dir:
if file == "arquivo.txt":
os.remove(file)
686
import os # remover arquivo 2
def limpar():
pasta = "diretorio"
arquivo = str(input('digite o nome do arquivo que deseja apagar: '))
diretorio = os.listdir(pasta)
Utilitários
remove if arquivo in diretorio:
print('---removendo arquivo----')
os.remove('{}/{}'.format(pasta, arquivo))
print('%s removido da pasta %s' % (pasta, arquivo))
else:
print('este arquivo nao existe')
687
>>> import os
>>> os.getcwd() # retorna o diretor atual
'C:\\Users\\amigo\\AppData\\Local\\Programs\\Python\\Python36-32'
>>> os.chdir('c:')
Utilitários >>> os.sep

'\\' # '\\' para linux
os
>>> os.path.exists('c:\\Users')
True
688
import turtle
t = turtle.Turtle()
t.shape("turtle")
t.forward(100)
t.right(90)
Utilitários t.forward(100)
t.right(90)
t.forward(100)
t.right(90)
t.color("red")
t.forward(100)
t.right(90)
689
import turtle
t = turtle.Turtle()
Criando t.shape("turtle")
Arquivos t.forward(100)
Python t.right(90)
t.forward(100)
t.right(90)
t.forward(100)
t.right(90)
t.color("red")
t.forward(100)
t.right(90)
690
Interface Gráfica
691
 É possível redirecionar a saída do Python para uma janela de texto
específica dentro da interface gráfica.
 Tais bibliotecas geralmente fornecem widgets de texto ou caixas de

diálogo para exibir as saídas do Python.
Interface Gráfica  Existem bibliotecas específicas que permitem de criar interfaces gráficas
Bibliotecas
mais avançadas e personalizadas, para direcionar a saída do Python para
áreas específicas da interface.
 Interface Gráficas: Tkinter, PyQt ou PySide.
692
import sys
from tkinter import Tk, Text
class TextoSaida(Text):
def write(self, texto):
self.insert('end', texto)
root = Tk()
texto_saida = TextoSaida(root)
texto_saida.pack()
Interface Gráfica # Redirecionar a saída do Python para a instância de TextoSaida

sys.stdout = texto_saida
Biblioteca tkinter # Exemplo de uso
print("Olá, mundo!")
#root.mainloop()
# Redirecionar a saída do Python para a instância de TextoSaida

sys.stdout = texto_saida
# Exemplo de uso
root.mainloop()
693
import tkinter as tk
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QTextEdit
from PyQt5.QtCore import QIODevice, QTextStream
class Janela(QMainWindow):
def __init__(self):
super().__init__()
self.texto_saida = QTextEdit(self)
self.setCentralWidget(self.texto_saida)
# Redirecionar a saída do Python para a função exibir_saida
Interface Gráfica sys.stdout = self.exibir_saida
Biblioteca PyQt # Exemplo de uso
def exibir_saida(self, texto):
self.texto_saida.append(texto)
app = QApplication(sys.argv)
janela = Janela()
janela.show()
sys.exit(app.exec_())
694
import sys
from PySide6.QtWidgets import QApplication, QMainWindow
# Subclasse de QMainWindow
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
# Definir o tamanho da janela (largura x altura)
self.setGeometry(100, 100, 500, 300)
Interface Gráfica # Criar uma instância da aplicação
Biblioteca PySide app = QApplication(sys.argv)
# Criar uma instância da janela principal
window = MainWindow()
# Exibir a janela
window.show()
# Executar o loop de eventos da aplicação
sys.exit(app.exec())
695
 Em Python, utiliza-se RGB (Red, Green, Blue) para definirmos as cores.
(255, 0, 0) Vermelho
(0, 255, 0) Verde
(0, 0, 255) Azul

Interface Gráfica (255,255,0) Amarelo
Cores
(255,255,255) Branco
(0,0,0) Preto
696
Anaconda
697
 Integra o conda que é uma plataforma de gerenciamento de pacotes e
sistema de desenvolvimento.
 Dedicada os desenvolvedores Python e R.
 O Anaconda tem por intuito facilitar a instalação de pacote e portanto
AnaConda a tarefa do desenvolvedor.
 Principalmente, os pacotes científicos, com foco no processamento e

análise de dados.
698
 Para instalação de Pacotes em Conda:
conda install nome_pacote
 Exemplo:
conda install numpy

AnaConda
 Para instalar vários pacotes de só uma vez, basta coloca-los em uma lista
Instalação de Pacotes
separados por um espaço:
conda install numpy pandas
699
 Para remover um Pacotes em Conda:
conda remove nome_pacote
AnaConda  Exemplo:
Remoção de Pacotes conda remove numpy
700
 Para checar a relação dos Pacotes instalados:
conda list
AnaConda
Lista de Pacotes
701
 É aconselhado criar ambientes específicos para cada projetos, com seus pacotes
específicos, etc.
 Para tal, usamos o comando create:
conda create –n nome_ambiente lista dos pacotes
AnaConda  Exemplo:
Gerenciamento de
conda create –n t este_arquivos numpy panda
Ambientes: criação
702
 Para acessar um ambiente, usamos o comando activate no windows:
activate nome_ambiente
 No linux:
AnaConda source activate nome_ambiente
Gerenciamento de
Ambientes: aceso
703
 Para sair do ambiente, usamos o comando desactivate no windows:
desactivate nome_ambiente
 No linux:
source desactivate nome_ambiente

AnaConda
Gerenciamento de
Ambientes: acesso
704
 AnaConda é uma distribuição relativamente pesada.
 Uma opção mais leve é de usar o MiniConda que possui apenas o Conda
e o Python.
MinConda
705
 Site Oficial do AnaConda:
https://www.anaconda.com/
https://www.anaconda.com/download/
AnaConda Precisa de 3GB de HD para ser instalado.

Instalação
706
AnaConda
Instalação
707
Conclusão
708
 Python é uma linguagem muito poderosa.
 Multiparadigmas.
Conclusão
709
Aplicações do Python na Indústria
Aprendizado de Máquina Raspagem de Dados Automação
Usando bibliotecas de aprendizado de Usando bibliotecas como BeautifulSoup Use o Python para automatizar processos e
máquina, como TensorFlow, Keras, para coletar dados e informações da web. tarefas repetitivas que de outra forma
PyTorch e outros. seriam tediosas para serem feitos
manualmente.
Referências Bibliográficas
711
• Python Tutorial: https://docs.python.org/3/tutorial/
• Anaconda Documentation: https://docs.anaconda.com/
Referências • Dataquest: Python vs. Anaconda: https://www.dataquest.io/blog/python-vs-anaconda/
 Computação Gráfica em Python – Luís Eduardo Borges.
712
 HETLAND, Magnus Lie. Beginning Python From Novice to Professional. Nova York:
Apress. 2015.
 Python para desenvolvedores – Luis Eduardo Borges.
 Tutorial Python. Release 2.4.2 – Guido Van Rossum , Fred L. Drake, Jr.
Referências  Por que as pessoas usam... Python? - Emerson Henrique,

Thiago Paiva, I Jornada de Iniciação Científica da ASPER
- Ciências da Computação e Processamento de Dados.
 Computação Gráfica em Python – Luís Eduardo Borges.
713
PLATAFORMAS
714
Recursos
715
Sala de Aula Virtual
▪ Acessar o Classroom, pelo aplicativo

ou (Google Classroom) pelo site
(classroom.google.com).
▪ Se inscreve na sala “Fundamentos de
Computação” com seu Código.
apertando o botão “+” e em seguida em
“Participar da turma”
nnbobsc
716
https://classroom.google.com/c/NjE5OTQwMDkzMzM0?cjc=nnbobsc
Tecnologia Educacional
▪ Acessar o Kahoot pelo aplicativo

(kahoot!) ou pelo site (kahoot.it).
▪ Entrar como Estudante e Informar
Place your screenshot here
o
Pin para iniciar o challenge (cada
challenge tem um pin específico que
será informado na hora).
▪ Para a criação de challenges acessar o
site: create.kahoot.it
717
▪ Acessar o Mentimeter pelo

aplicativo (mentimieter) ou pelo
site (www.menti.com).
▪ Para criar:
www.mentimeter.com
▪ Concorrentes:
▫ Socrative e Poll Everywhere
718
▪ O Google Meet é um sistema de vídeo

conferência em nuvem da Google, via
web ou via aplicativo, de até 250
pessoas na versão gratuita
(Android/iOS).
▪ Pelo Aplicativo ou pelo Site:
https://meet.google.com/
▪ Para ingressar em um meeting basta
aceitar o convite ou informar o Meeting
ID.
719

Algorimos Python 28 08 2023

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Algorimos Python 28 08 2023

Enviado por

Direitos autorais:

Formatos disponíveis

Algoritmos

Sofiane Labidi, PhD.

Sofiane Labidi, PhD.

▻ Listas ........................................................................................................... 304

1. Escreva um programa que troca o conteúdo de duas variáveis.

2. Escreva um programa para verificar se um número é par ou ímpar.

4. Escreva um programa para encontrar o fatorial de um número inteiro.

Transmite ao computador como fazer isto!

 3rd Generation Language

 4th Generation Language

 5th Generation Language

Programação Orientada a Objeto

nos dois sentidos: ordem para a máquina, e

 Instrução básica = Envio de mensagem

instâncias de uma hierarquia de classes (categorias de objetos).

 Especificação da solução em termos de relações entre entidades.

 Descrevem o problema e não a solução.

 Concorrente, Paralela, Distribuída, etc.

 Cada paradigma tem suas vantagens e inconvenientes.

 É possível combinar os paradigmas?

 É interessante desenvolver linguagens que suportem diferentes paradigmas: uma

linguagens: ObjLog, CLOS, etc.

Qual é a melhor Linguagem de Programação?

• Criada a partir da linguagem ABC, C, Java e Perl.

• O nome é uma homenagem ao grupo humorístico britânico Monty Python,

Vantagens • Largo Ecossistema

public class Exemplo {

Python Código Python:

Vantagens nome = "Alice"

Saía (em Python e Java)

Olá, meu nome é Alice e tenho 25 anos.

Linguagem • Ciência de Dados

Aplicações • Sistemas de IA.

• O Compilador transforma as instruções python em instruções de

• Não é necessário abrir e fechar blocos de código com chaves, como

Os blocos são identificados pela indentação do código.

python (executa o python no modo interativo)

Linguagem Até os tipos mais básicos possuem métodos específicos.

The Collaborative Data Notebook For EDA & ETL – Noteable

Interpretadores Code, Compile & Run

Outras 3 Plataformas [Ideone, OnlineCompiler, RemoteInterview]

Python 3.11.3 Abril 15, 2023

Tutorial oficial Python.

Instalando  Checar a versão do Python

 É o Ambiente de Desenvolvimento Integrado, contendo:

Instalando  Pacote de desenvolvimento de softwares, contendo o editor de códigos.

Python  Ferramentas de Automação do processo de construção.

IDE / IDLE  Depurador (Debugger),

 Reiniciar uma cessão

Shell Python >>> _ * 5 # referência o último valor retornado

 Alt + P -> retorna última instrução

 Alt + N -> avança para a próxima instrução

 Crl+D fecha a janela / Shell Python

 Ctrl + F6 -> Reinicia o IDLE, equivalente de exit()

 Ctrl + C -> interrompe a execução (Script em looping)

 Ctrl + Espaço -> abre o “Code Complete” (complementação da digitação)

 Ctrl-Tab -> abre o “Code Complete” mais específico

 Ctrl + J -> adiciona linha e move o cursor para a mesma

File → Save / Save as... - salvar com a extensão py CTRL S

Run → Run Module - executar o arquivo python F5

 Temos um comando por linha.

 O tipo da variável é determinado pelo tipo do valor a ela atribuído.

• Dividir para Conquistar! / Administrar a complexidade!

INPUT PROCESSING OUTPUT