Módulo 1 e Módulo 2

Material de estudos.
md 2024-02-23
Módulo 1
Parte 1 - Básico de programação e da linguagem
Introdução
O que são variáveis?
Variáveis em Python são espaços físicos de memória utilizados para armazenar dados. Quando você cria uma
variável, está basicamente reservando espaço na memória do computador para armazenar valores. Esses
valores podem ser de diversos tipos, seja um número inteiro, um número com casas decimais, caracteres,
palavras e por ai vai. Em algumas linguagens, você precisa declarar explicitamente o tipo do dado que você
quer armazenar quando você cria a variável. Entretanto, em Python, você não precisa fazer isso, por isso ela é
conhecida como uma linguagem "dinamicamente tipada". Ou seja, o tipo da variável é inferido pelo valor que
ela recebe automaticamente. Por isso é importante ficar esperto com quais informações você está salvando.
1. Tipos de dados básicos
Como citado acima, existem diversos tipos de dados que podemos guardar em variáveis, vistos abaixo:
1. Inteiros (int): Representam números inteiros, positivos ou negativos, sem parte decimal. Ao
Exemplo: idade = 30
2. Ponto flutuante (float): Representam números reais, ou seja, com parte decimal, positivos ou
negativos. Como a maioria das linguagens, o separador decimal em Python é o ponto ao invés da
vírgula.
Exemplo: altura = 1.75
3. Strings (str): Sequências de caracteres, utilizadas para representar texto.
Exemplo: nome = "Maria"
4. Booleanos (bool): Possuem dois valores possíveis: True (verdadeiro) ou False (falso).
Exemplo: estudante = True
# Dica do futuro: para verificar o tipo de uma variável, podemos usar a função
`type(variavel)`. Exemplo:
> idade = 10
> type(idade)
>>> <class 'int'>
2. Outros tipos de dados mais usados
1. Listas (list): Coleções ordenadas e mutáveis de itens, que podem ser de um tipo ou de tipos
diferentes
Exemplo:
numeros = [1, 2, 3, 4, 5]
numeros = [1, 1.5, 'esse é um texto', True, 5]
2. Tuplas (tuple): Coleções ordenadas e imutáveis de itens, que podem ser de tipos diferentes.
1 / 38
Material de estudos.md 2024-02-23
Exemplo: coordenadas = (10.0, 20.0)

3. Dicionários (dict): Coleções desordenadas de pares chave-valor.
Exemplo: pessoa = {"nome": "João", "idade": 25}
4. Conjuntos (set): Coleções desordenadas de itens únicos.
Exemplo: cores = {"vermelho", "azul", "verde"}
3. Principais operadores na linguagem
1. Aritméticos
Símbolo Operação Exemplo
+ Adição 10 + 20 = 30
- Subtração 20 – 10 = 10
* Multiplicação 10 * 20 = 200
/ Divisão 20 / 10 = 2
% Módulo (resto da divisão) 22 % 10 = 2
** Exponenciação (potência) 4**2 = 16
// Divisão inteira (quociente da divisão) 9//2 = 4
O operador de divisão sempre retorna uma número do tipo float, mesmo se a divisão retornar um valor
inteiro.
> print(4 / 2)
>>> 2.0 # Tipo <float>, e não <int>
2. Comparação
Símbolo Operação Exemplo
== Igual 4 == 5 é False
!= Diferente 4 != 5 é True
> Maior que 4 > 5 é False
< Menor que 4 < 5 é True
>= Maior ou igual 4 >= 5 é False
<= Menor ou igual 4 <= 5 é True
Esses operadores sempre retornam um valor booleano (True ou False). Os operadores de igualdade e de
diferença pode ser feita entre variáveis de diferente tipos, como abaixo, onde o inteiro 2 é comparado com a
string "2":
2 / 38
>>> 2 == "2"
False
Os outros operadores retornam erros (ou Exceptions) de tipo, dados por TypeError.
3. Operadores de atribuição
Símbolo Exemplo Equivalente à
= c = 10
+= c += 5 (mesmo que c = c + 5)
-= c -= 5 (mesmo que c = c - 5)
*= c *= 5 (mesmo que c = c * 5)
/= c /= 5 (mesmo que c = c / 5)
%= c %= 5 (mesmo que c = c % 5)
**= c **= 2 (mesmo que c = c ** 2)
//= c //= 3 (mesmo que c = c // 3)
4. Lógicos Os operadores lógicos são muito usados em estruturas condicionais, como if.
Símbolo Exemplo Exemplo
True (verdade) se os dois lados forem (4 > 3) and (2 == 1) retorna False pois uma das
and
verdades, senão False afirmações não é verdadeira
True (verdade) se algum dos (4 > 3) or (2 == 1) retorna True pois pelo

or
operadores for verdade, senão False menos uma das afirmações é verdadeira
not((4 > 3) and (2 == 1)) retorna True pois

not Usado para reverter o sentido lógico
inverte o resultado dentro dos parêntesis
5. Associação ou pertencimento Usados para verificar se algum item está dentro de uma estrutura de
dados, como listas ou tuplas.
Símbolo Exemplo Exemplo
True se o valor estiver dentro da 'maça' in ['banana', 'pera', 'jabuticaba',

in
estrutura, False se não. 'maça'] retorna True
True se o valor não seja encontrado 'abobora' not in ['banana', 'pera',

not in na estrutura de dados, False se for 'jabuticaba', 'maça'] retorna True pois de fato
encontrado. 'abobora' não está na lista
Strings
3 / 38
Strings em Python podem ser criadas simplesmente ao colocar texto entre aspas simples ('...') ou aspas
duplas ("..."). Aspas triplas ('''...''' ou """...""") permitem criar strings que abrangem várias linhas.
simples = 'Hello, World!'

duplas = "Hello, World!"
multi_linha = """Esta é uma string que abrange várias linhas."""
Acessando Caracteres e Substrings
Indexação: Você pode acessar um caractere individual em uma string usando sua posição (índice),
começando do zero.
s = "Python"
print(s[0]) # Saída: P
Fatiamento (Slicing): Python permite obter substrings especificando um intervalo de índices.
print(s[1:4]) # Saída: yth`
Pode-se também utilizar indices negativos, os quais começam do fim para o início. Veja o exemplo
abaixo: ![[Pasted image 20240212201523.png]]
Métodos Comuns de Strings
A linguagem oferece muitos métodos que facilitam a manipulação de strings. Aqui estão alguns dos mais
usados:
upper() e lower(): Para converter uma string para maiúscula ou minúscula.
print("Python".upper()) # Saída: PYTHON print("Python".lower()) # Saída:

python
strip(): Para remover espaços em branco (ou outros caracteres) do início e do fim de uma string.
print(" Python ".strip()) # Saída: Python
split(): Para dividir uma string em uma lista de strings com base em um delimitador.
print("a,b,c".split(',')) # Saída: ['a', 'b', 'c']
4 / 38
join(): Para concatenar uma lista de strings em uma única string, usando uma string como separador.
print(",".join(['a', 'b', 'c'])) # Saída: a,b,c
replace(): Para substituir uma substring por outra.
print("Hello, World!".replace("World", "Python")) # Saída: Hello, Python!`
find() e index(): Para encontrar a posição de uma substring dentro de uma string. find() retorna
-1 se a substring não for encontrada, enquanto index() lança uma exceção.
print("Python".find("th")) # Saída: 2
Formatação de Strings
Python oferece várias maneiras de formatar strings:
Operador %: Um método antigo, inspirado na linguagem C.
Método format(): Mais flexível e intuitivo do que o operador %.
print("Olá, {}!".format("Mundo")) # Saída: Olá, Mundo!`
F-strings (Literal String Interpolation): Introduzido no Python 3.6, permite incorporar expressões
dentro de strings prefixando a string com f.
nome = "Mundo"
print(f"Olá, {nome}!") # Saída: Olá, Mundo!`
Para mais informações sobre strings veja esse link:

https://docs.python.org/3/tutorial/introduction.html#strings
Listas
Criação de Listas
Para criar uma lista, utiliza-se os colchetes para delimitar os elementos que pertencerão à lista. Os elementos
são separados por vírgulas. Por exemplo:
minha_lista = [1, 2, 3, 4, 5]
5 / 38
nomes = ["Alice", "Bob", "Charlie"]
Acesso a Elementos
Os colchetes são usados para acessar elementos específicos de uma lista através de seus índices. Os índices
em Python começam em 0, então o primeiro elemento de uma lista está no índice 0, o segundo no índice 1, e
assim por diante.
print(minha_lista[0]) # Acessa o primeiro elemento da lista, que é 1

print(nomes[2]) # Acessa o terceiro elemento da lista, que é "Charlie"
Aqui o uso de índices negativos também é permitido, seguindo a mesma lógica aplicada em strings visto
anteriormente (o elemento de índice -1 é o último, -2 o penúltimo e continua.)
Fatiamento (Slicing)
Os colchetes também são usados para fazer o fatiamento de listas, permitindo acessar subconjuntos de seus
elementos. Para isso, utiliza-se a notação [início:fim], onde início é o índice do primeiro elemento do
subconjunto e fim é o índice que marca o fim do subconjunto (o elemento neste índice não é incluído).
sublista = minha_lista[1:3] # Obtém elementos dos índices 1 a 2

print(sublista) # [2, 3]
Você pode omitir início ou fim para pegar elementos desde o início da lista ou até o final, respectivamente.
Ou seja,
sublista = minha_lista[1:] # Retorna [2, 3, 4, 5] pois pegamos do segundo

elemento (posição 1) até o último
sublista = minha_lista[:2] # Retorna [1, 2] pois pegamos o primeiro elemento até
o elemento na posição 1, já que o indice 2 não é incluído.
Modificação de Elementos
Para modificar um elemento específico em uma lista, usa-se colchetes para acessar o elemento pelo índice e
então atribuir um novo valor.
minha_lista[0] = 10
print(minha_lista) # [10, 2, 3, 4, 5]
Adição e Remoção de Elementos
6 / 38
Embora a adição e remoção de elementos geralmente envolvam métodos específicos como append(),
insert(), pop(), e remove() vistos logo no tópico seguinte, pode-se usar os colchetes para operações
como a substituição de subconjuntos de elementos ou a limpeza da lista.
minha_lista[1:3] = [20, 30] # Substitui elementos em um intervalo específico

minha_lista[:] = [] # Remove todos os elementos, deixando a lista vazia`
Métodos úteis
list.append(x)
Adiciona um item ao final da lista. Equivalente a a[len(a):] = [x].
list.extend(list2)
Estende a lista anexando todos os itens do iterável list2. Ou seja, concatena os valores de
list2 à list
list.insert(i, x)
Insere um item em uma posição dada. O primeiro argumento é o índice do elemento antes do
qual inserir, então a.insert(0, x) insere no início da lista, e a.insert(len(a), x) é
equivalente a a.append(x).
list.remove(x)
Remove o primeiro item da lista cujo valor é igual a x. Ele dá um erro do tipo ValueError se não
houver tal item.
list.pop([i])
Remove o item na posição dada na lista e o retorna. Se nenhum índice for especificado, a.pop()
remove e retorna o último item da lista. Ele levanta um IndexError se a lista estiver vazia ou o
índice estiver fora do alcance da lista.
list.clear()
Remove todos os itens da lista. Equivalente a del a[:].
list.index(x[, start[, end]])
Retorna o índice baseado em zero na lista do primeiro item cujo valor é igual a x. Levanta um
ValueError se não houver tal item.
Os argumentos opcionais start e end são interpretados como na notação de fatiamento e são
usados para limitar a busca a uma subsequência particular da lista. O índice retornado é
calculado relativo ao início da sequência completa, em vez do argumento start.
list.count(x)
Retorna o número de vezes que x aparece na lista.
list.sort(*, key=None, reverse=False)
Ordena os itens da lista (os argumentos podem ser usados para personalização da ordenação,
onde key pode receber uma função (lambda, por exemplo), e reverse inverte a ordem da lista
se True).
list.reverse()
Inverte os elementos da lista.
list.copy()
Retorna uma cópia rasa da lista. Equivalente a a[:].
7 / 38
Para mais informações, ver: https://docs.python.org/3/tutorial/datastructures.html

https://docs.python.org/3/tutorial/introduction.html#lists
Tuplas
As tuplas funcionam de maneira muito similar que as listas, mas elas têm a principal caraterística de serem
imutáveis, ou seja, elas não podem ser modificadas. Por exemplo, dada uma tupla "alturas = (1.75, 1.90, 1.50)"
não é possível alterar o segundo valor 1.90 para 1.95, por exemplo. Seria necessário criar uma nova tupla.
Diferenças para listas:

A manipulação de tuplas é mais rápida;
a imutabilidade pode ser boa em certos casos em que não desejamos que os dados não sejam
alterados;
Packing e unpacking
Packing ocorre quando atribuímos vários valores a uma única variável, e Python automaticamente os
empacota em uma tupla. Exemplo de Packing:
tupla = 1, 2, 3
print(tupla) # Saída: (1, 2, 3)
Neste exemplo, 1, 2, 3 são empacotados em uma tupla automaticamente pelo Python.
Unpacking é o processo de atribuir os valores de uma tupla a várias variáveis separadas.
Exemplo de Unpacking:
(a, b, c) = tupla
print(a) # Saída: 1
print(b) # Saída: 2
print(c) # Saída: 3
Neste exemplo, os valores da tupla tupla são desempacotados e atribuídos às variáveis a, b e c.
Sets
Um set (conjunto) em Python é uma coleção desordenada de itens únicos. Sets são usados para armazenar
múltiplos itens em uma única variável, semelhante a listas e tuplas, porém, enquanto listas e dicionários
podem conter elementos duplicados, um set não pode. Sets são particularmente úteis para eliminar itens
duplicados de uma sequência e para realizar operações matemáticas de conjuntos, como união, interseção,
diferença, e diferença simétrica.
Características:
Desordenados: Os itens não são armazenados em nenhuma ordem específica e não são indexados.
Mutáveis: Podem ser alterados após sua criação, mas os itens armazenados devem ser imutáveis.
8 / 38
Não aceitam duplicatas: Cada elemento em um set é único.

Sintaxe: Os sets são definidos por chaves {}, com itens separados por vírgulas, como meu_set = {1,
2, 3}. Para criar um set vazio, deve-se usar set(), pois {} cria um dicionário vazio.
Exemplo de Uso de Set:
''' Remoção de duplicatas'''

numeros = [1, 2, 3, 4, 4, 5]
numeros_unicos = list(set(numeros))
# numeros_unicos = [1, 2, 3, 4, 5]
''' União, interseção, diferença e diferença simétrica'''

conjunto_a = {1, 2, 3}
conjunto_b = {3, 4, 5}
set1.union(set2) # {1, 2, 3, 4, 5}
set1.intersection(set2) # {3}
set1.difference(set2) # {1, 2}
set1.symmetric_difference(set2) # {1, 2, 4, 5}
Estruturas condicionais
if
A declaração if é a estrutura condicional mais básica em Python. Ela testa uma condição e executa um bloco
de código se a condição for verdadeira.
if condição:
# execute este bloco de código
else
A declaração else complementa if, executando um bloco de código quando a condição testada por if é
falsa.
if condição:
# execute este bloco se a condição for verdadeira
else:
# execute este bloco se a condição for falsa
elif
elif, uma abreviação de "else if", permite testar múltiplas condições em sequência. Se a condição de um if
ou elif anterior for falsa, o Python testa a condição seguinte em um elif.
9 / 38
if condição1:
# execute este bloco se condição1 for verdadeira
elif condição2:
# execute este bloco se condição2 for verdadeira
else:
# execute este bloco se todas as condições anteriores forem falsas
Exemplos
Uso de if, else, e elif
idade = 20
if idade < 18:
print("Menor de idade")
elif idade >= 18 and idade < 60:
print("Adulto")
else:
print("Idoso")
# "Adulto"
Estruturas de loop
for
O laço for é usado para iterar sobre uma sequência (como uma lista, tupla, dicionário, conjunto ou string) e
executar um bloco de código para cada item.
for item in sequência:

# execute este bloco para cada item da sequência
while
O laço while continua a executar um bloco de código enquanto uma condição for verdadeira.
while condição:
# execute este bloco enquanto a condição for verdadeira
Laços Aninhados (Nested Loops)
Laços aninhados ocorrem quando um laço é colocado dentro de outro. Eles são úteis para operações que
requerem iteração através de múltiplas dimensões ou conjuntos de dados.
10 / 38
for item1 in sequência1:

for item2 in sequência2:
# este bloco é executado para cada combinação de item1 e item2
Exemplos
Iterando com for
nomes = ["Ana", "Bruno", "Carlos"]

for nome in nomes:
print(f"Olá, {nome}!")
# Olá, Ana!
# Olá, Bruno!
# Olá, Carlos!
Contando com while
contador = 5
while contador > 0:
print(contador)
contador -= 1
# 5
# 4
# 3
# 2
# 1
Laços Aninhados
for i in range(1, 3): # Range externo

for j in range(1, 4): # Range interno
print(f"i = {i}, j = {j}")
# i = 1, j = 1
# i = 1, j = 2
# i = 1, j = 3
# i = 2, j = 1
# i = 2, j = 2
# i = 2, j = 3
# outro exemplo
cores = ["vermelho", "verde", "azul"]
itens = ["carro", "bola", "lápis"]
for cor in itens:
for item in cores:
11 / 38
print(f"{cor} {item}")
# carro vermelho
# carro verde
# carro azul
# bola vermelho
# bola verde
# bola azul
# lápis vermelho
# lápis verde
# lápis azul
Funções
Uma função é um bloco de código que só é executado quando chamado. Python já vem com muitas funções
integradas, como print(), mas também permite a criação de funções definidas pelo usuário (UDFs).
As funções podem receber dados para processar (conhecidos como parâmetros) e podem retornar dados
como resultado. A definição de uma função em Python é feita usando a palavra-chave def, seguida do nome
da função, parênteses e dois pontos. O código dentro da função deve ser indentado.
Exemplo 1: Função Simples
Aqui está uma função simples que não recebe nenhum parâmetro e imprime uma mensagem:
def minha_funcao():
print("Olá, do minha_funcao!")
minha_funcao() # Chama a função

# "Olá, do minha_funcao!"
Exemplo 2: Função com Parâmetros
Funções podem receber argumentos, que são utilizados para passar dados para dentro da função.
def cumprimentar(nome):
print(f"Olá, {nome}!")
cumprimentar("Alice") # Chama a função com o argumento "Alice"
Exemplo 3: Função com Retorno
Funções podem retornar valores usando a palavra-chave return.
def somar(a, b):

return a + b
12 / 38
resultado = somar(5, 3)
print(resultado)
# 8
Exemplo 4: Funções com Valores Padrão para Parâmetros
Você pode definir um valor padrão para um ou mais parâmetros. Isso significa que a função pode ser
chamada com menos argumentos do que o definido.
def imprimir_mensagem(mensagem, repeticao=1):

for _ in range(repeticao):
print(mensagem)
imprimir_mensagem("Olá!") # Imprime "Olá!" uma vez

imprimir_mensagem("Olá!", 3) # Imprime "Olá!" três vezes
Referências
https://docs.python.org/3/contents.html https://docs.python.org/3/tutorial/introduction.html#
https://www.programiz.com/python-programming/methods/string/split
https://docs.python.org/3/tutorial/inputoutput.html https://realpython.com/python-f-strings/
https://realpython.com/python-lists-tuples/ https://docs.python.org/3/tutorial/datastructures.html
https://www.markdownguide.org/basic-syntax/ https://www.markdownguide.org/extended-syntax/
https://docs.python.org/3/tutorial/controlflow.html#tut-docstrings
Módulo 2
List comprehension
É uma forma de criar listas e inserir operações de uma maneira simples e em uma única linha. Permite, então,
aplicar fórmulas e operações para alterar seus elementos de maneira iterativa, ou seja, a cada elemento da
lista original. Uma compreensão de listas consiste de uma expressão dentro de colchetes que contém uma
expressão seguida de um for e zero ou mais operações for ou if. O resultado é uma nova lista com seus
elementos avaliados pela expressão contida dentro desses colchetes. Veja os exemplos abaixo:
Exemplo 1
# Criar uma lista com os quadrados dos números de 1 a 10

quadrados = []
for x in range(1, 11):
quadrados.append(x**2)
print(quadrados)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# Usando list comprehension

13 / 38
quadrados = [x**2 for x in range(1, 11)]

print(quadrados)
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Exemplo 2
# Filtrar números ímpares de uma lista de números

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
impares = []
for x in numeros:
if x % 2 != 0:
impares.append(x)
print(impares)
# [1, 3, 5, 7, 9]

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
impares = [x for x in numeros if x % 2 != 0]
print(impares)
# [1, 3, 5, 7, 9]
Exemplo 3
# Converter uma lista de temperaturas de Celsius para Fahrenheit

celsius = [0, 10, 20, 30.5]
fahrenheit = []
for temp in celsius:
fahrenheit.append(((9/5)*temp + 32))
print(fahrenheit)
# [32.0, 50.0, 68.0, 86.9]

celsius = [0, 10, 20, 30.5]
fahrenheit = [((9/5)*temp + 32) for temp in celsius]
print(fahrenheit)
# [32.0, 50.0, 68.0, 86.9]
Pode-se aplicar mais de um if em uma list comprehension.
Exemplo 4
divisiveis_por_2_e_3 = []
if x % 2 == 0 and x % 3 == 0:
divisiveis_por_2_e_3.append(x)
print(divisiveis_por_2_e_3)
# [6, 12, 18]
14 / 38
# Números de 1 a 20 que são divisíveis por 2 e por 3

divisiveis_por_2_e_3 = [x for x in range(1, 21) if x % 2 == 0 if x % 3 == 0]
print(divisiveis_por_2_e_3)
# [6, 12, 18]
Também podemos aplicar mais de um for.
# Mostrar todas as combinações entre elementos de duas listas se eles não forem
iguais
combs = []
for x in [1,2,3]:
for y in [3,1,4]:
if x != y:
combs.append((x, y))
print(combs)
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

combs = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
print(combs)
# [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
Dict comprehension
É o equivalente de list comprehension porém aplicado para dicionários. Dict comprehension é escrito entre
chaves e necessita de duas expressões separadas por : , onde a primeira é relacionada à chave do dicionário
e a segunda ao valor daquela chave, seguidas por for, if ou a combinação entre uma ou mais for/ifs. Veja os
exemplos abaixo.
Exemplo 1
# Criar um dicionário de números e seus quadrados

quadrados = {}
quadrados[x] = x**2
print(quadrados)
# Usando dict comprehension

quadrados = {x: x**2 for x in range(1, 6)}
print(quadrados)
Exemplo 2
# Inverter chave e valor de um dicionário

original = {'a': 1, 'b': 2, 'c': 3}
15 / 38
invertido = {}
for chave, valor in original.items():
invertido[valor] = chave
print(invertido)
# {1: 'a', 2: 'b', 3: 'c'}

original = {'a': 1, 'b': 2, 'c': 3}
invertido = {valor: chave for chave, valor in original.items()}
print(invertido)
# {1: 'a', 2: 'b', 3: 'c'}
Exemplo 3
# Filtrar itens de um dicionário baseado em uma condição

original = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
filtrado = {}
for chave, valor in original.items():
if valor > 2:
filtrado[chave] = valor
print(filtrado)
# {'c': 3, 'd': 4}

original = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
filtrado = {chave: valor for chave, valor in original.items() if valor > 2}
print(filtrado)
# {'c': 3, 'd': 4}
Exemplo 4
# Criar um dicionário a partir de duas listas

chaves = ['a', 'b', 'c']
valores = [1, 2, 3]
dicionario = {}
for i in range(len(chaves)):
dicionario[chaves[i]] = valores[i]
print(dicionario)
# {'a': 1, 'b': 2, 'c': 3}

chaves = ['a', 'b', 'c']
valores = [1, 2, 3]
dicionario = {chaves[i]: valores[i] for i in range(len(chaves))}
print(dicionario)
# {'a': 1, 'b': 2, 'c': 3}
Exemplo 5
16 / 38
# Dicinário com número de vezes que um valor aparece na lista

lista = ['a', 'b', 'a', 'b', 'c', 'b']
dicionario = {}
for chave in set(lista):
dicionario[chave] = lista.count(chave)
print(dicionario)
# {'c': 1, 'b': 3, 'a': 2}

lista = ['a', 'b', 'a', 'b', 'c', 'b']
dicionario = {chave: (lista.count(chave)) for chave in set(lista)}
print(dicionario)
# {'c': 1, 'b': 3, 'a': 2}
Bibliotecas e módulos em python

Python é uma linguagem de programação poderosa e versátil, conhecida por sua simplicidade e eficácia. Uma
das características que contribuem para sua eficiência é o uso de módulos. Módulos são arquivos contendo
definições de funções, classes e variáveis que você pode incluir em seu projeto. Eles são usados para
organizar código de maneira modular, facilitando tanto a reutilização quanto a manutenção, e contém
diversas funcionalidades que ajudam na criação de códigos eficientes e de fácil leitura. Um módulo em
Python é um arquivo com extensão .py que contém código Python. Qualquer arquivo Python pode ser um
módulo, desde que contenha definições e declarações. Módulos podem definir funções, classes e variáveis,
bem como código executável. O uso de módulos ajuda a organizar o código de forma lógica, agrupando
componentes relacionados. Além disso, os módulos promovem a reusabilidade do código e a separação de
preocupações. Ao instalar o Python, diversos módulos já ficam disponíveis e podem ser importados usando a
keyword import. Veja alguns mais utilizados:
1. os
O módulo os fornece uma maneira fácil de usar funcionalidades dependentes do sistema operacional, como
ler ou escrever arquivos, manipular caminhos, etc. Exemplo 1: Listar os arquivos em um diretório.
# abaixo, no lugar de '.', pode-se colocar um caminho para uma pasta do seu
computador, listando todas as pastas e arquivos contidos nesse diretório.
# um exemplo de diretório: "C:\Users\gabri\OneDrive\Área de Trabalho"
# OBS: sempre coloque uma letra 'r' antes da string do diretório para o python
interpretar o \ de maneira literal. Sem o 'r', o \ é usado para caracteres
especiais.
import os
print(os.listdir(r'C:\Users\gabri\OneDrive\Área de Trabalho'))
# usando esse comando
Por quê usar r antes da string?
17 / 38
print('C:\some\name') # Aqui \n é um caractere especial e significa nova linha,

C:\some
ame
>>> print(r'C:\some\name') # com o r, o \ é interpretado de forma literal
C:\some\name
Exemplo 2: mostrar o nome do usuário logado no computador
import os
print(os.getlogin())
# gabri # ( nome do meu usuário no meu computador )
Exemplo 3: Verificar a Existência de um Arquivo ou Diretório
import os
caminho = 'exemplo.txt'
if os.path.exists(caminho):
print(f"O arquivo ou diretório '{caminho}' existe.")
else:
print(f"O arquivo ou diretório '{caminho}' não existe.")
2. math
O módulo math oferece acesso a funções matemáticas definidas pelo padrão C. Exemplo 1: Calcular a raiz
quadrada de um número.
import math
print(math.sqrt(16))
# 4.0
Exemplo 2: Calcular o cosseno de um ângulo.
import math
print(math.cos(math.pi))
# -1.0
3. datetime
O módulo datetime fornece classes para manipulação de datas e horas. Exemplo 1: Obter a data e hora
atuais.
18 / 38
from datetime import datetime

print(datetime.now())
# 2024-02-17 13:37:17.769068 => devolve em ano-mes-dia
hora:minuto:segundo:milisegundos
Exemplo 2: Calcular a diferença entre duas datas.
from datetime import datetime, timedelta

data_inicial = datetime(2020, 1, 1)
data_final = datetime(2020, 1, 7)
diferenca = data_final - data_inicial
print(diferenca.days)
# 6
4. time
O módulo time oferece funções para trabalhar com tempo, incluindo funções para pausas e para obter o
tempo atual. Exemplo 1: Esperar por um determinado número de segundos.
import time
time.sleep(5)
Exemplo 2: Obter o tempo atual em segundos desde a época.
import time
print(time.time())
5. getpass
O módulo getpass é utilizado para solicitar ao usuário uma senha sem exibi-la na tela. Exemplo 1: Solicitar
uma senha (semelhante à função input mas o no campo de escrita o texto é substituído por *)
import getpass
senha = getpass.getpass('Digite sua senha: ')
Exemplo 2: Puxar nome do usuário (mesma coisa que os.getlogin())
import getpass
getpass.getuser()
# gabri
19 / 38
Quando o python é instalado, muitos módulos já são pré-carregados. O link a seguir contém todos os
módulos com suas descrições que você pode usar sem precisar instalar mais nada. Módulos pré-instalados
em Python
Instalação de novos módulos

O pip é o gerenciador de pacotes padrão para Python, permitindo pesquisar, baixar e instalar pacotes
disponíveis no Python Package Index (PyPI). Ele vem pré-instalado com as versões recentes do Python. O pip
gerencia as dependências necessárias e permite atualizar ou remover pacotes instalados previamente.
Verificando a Instalação do pip
Para verificar se o pip está instalado no seu sistema, execute o seguinte comando no terminal (Linux/macOS)
ou prompt de comando (Windows):
pip --version
Atualizando o pip
É uma boa prática manter o pip atualizado. Para atualizá-lo, execute no prompt de comando:
# Linux/macOS
pip install --upgrade pip
# Windows
python -m pip install --upgrade pip
Instalando um Novo Módulo
Para instalar um novo módulo, use o comando pip install, seguido pelo nome do pacote desejado. Por
exemplo, para instalar o popular pacote de análise de dados pandas, execute:
pip install pandas
O pip baixará e instalará o pacote pandas e suas dependências.
Instalando uma Versão Específica de um Pacote
Às vezes, pode ser necessário instalar uma versão específica de um pacote para garantir a compatibilidade
com o seu projeto. Isso pode ser feito especificando a versão do pacote:
pip install pandas==1.2.3
20 / 38
Instalando Pacotes a Partir de um arquivo requirements.txt
Para projetos maiores, é comum ter um arquivo requirements.txt contendo uma lista de todos os pacotes
necessários. Para instalar todos os pacotes listados neste arquivo, execute:
pip install -r requirements.txt
Funções lambda
As funções lambda em Python são uma ferramenta poderosa e concisa, permitindo a criação de funções
anônimas em uma única linha de código. Estas funções são chamadas de "anônimas" porque não precisam
ser definidas com um nome como as funções regulares definidas com a palavra-chave def. As funções
lambda são úteis em muitas situações, especialmente quando se trabalha com operações que requerem uma
função como argumento, como as funções de ordem superior map(), filter(), e reduce(). Neste artigo,
vamos explorar o conceito de funções lambda e ver vários exemplos de como elas podem ser utilizadas. Uma
função lambda em Python é definida pela palavra-chave lambda, seguida por uma lista de argumentos, dois
pontos e a expressão que a função deve executar. A expressão é avaliada e retornada quando a função é
chamada. A sintaxe geral de uma função lambda é:
lambda arguments: expression
Vantagens das Funções Lambda
Concisão: Permite a criação de funções pequenas com menos código.

Flexibilidade: Pode ser usada dentro de outras funções ou onde objetos de função são requeridos.
Anonimato: Ideal para operações rápidas que não necessitam ser nomeadas.
Exemplos de Uso de Funções Lambda
Exemplo 1: Adicionar Dois Números. Aqui, x e y são os argumentos de entrada, e a expressão é dada por
"x+y"
add = lambda x, y: x + y
print(add(5, 3))
# 8
Podemos chamar uma função lambda sem atribuir a uma variável, passando os argumentos em uma tupla à
direita da expressão lambda entre parêntesis (aqui os argumentos são posicionais, então a ordem importa):
(lambda x, y: x + y)(5, 3)
# 8
21 / 38
Também pode-se atribuir valores padrão
(lambda x, y, z=3: x + y + z)(5, 3)

# 11
E passar os argumentos com keyword, permitindo colocar em qualquer ordem:
(lambda x, y, z=3: x + y + z)(y=3, x=5)

# 11
*args e **kwargs também funcionam aqui.
# Exemplo com *args

(lambda *args: sum(args))(1, 2, 3, 5)
>>> 11
# Exemplo com **kwargs

(lambda **kwargs: sum(kwargs.values()))(um=1, dois=2, tres=3)
>>> 6
Exemplo 2: Passar strings de uma lista para maiúsculo (sem e com condições). Aqui, a função map() aplica a
função lambda a cada um dos itens contidos na lista ["maçã", "banana", "cereja", "damasco"]
frutas = ["maçã", "banana", "cereja", "damasco"]

filtradas = list(map(lambda s: s.upper(), frutas))
print(filtradas)
# ['MAÇÃ', 'BANANA', 'CEREJA', 'DAMASCO']
Aqui, estamos filtrando a lista ['maçã', 'banana', 'cereja', 'damasco'] retornando os elementos que
contém a letra 'e'.
frutas = ["maçã", "banana", "cereja", "damasco"]

filtradas = list(filter(lambda s: 'e' in s, frutas))
print(filtradas)
# ['cereja']
A função filter() tem a seguinte sintaxe: filter(função, sequencia) -> onde podemos passar uma
função (definida por def ou lambda, por exemplo), e uma sequencia ou iterador (como listas e
chaves de dicionários). Ela, por padrão, retorna um objeto filter. Esse objeto pode ser aplicado a
funções como list() para gerar uma lista ou set() para gerar um set.
22 / 38
Exemplo 2: Combinar Elementos de Duas Listas. Aqui, somamos o n-ésimo elemento da lista 1 com o n-
ésimo elemento da lista 2. Nesse caso, como colocamos 2 argumentos na função lambda (x e y), precisamos
passar 2 argumentos (lista1 e lista2) na função map().
lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
combinados = list(map(lambda x, y: x + y, lista1, lista2))
print(combinados)
# [5, 7, 9]
A função map() tem a seguinte sintaxe: map(função, argumentos) -> onde podemos passar uma função
(definida por def ou lambda, por exemplo), e os argumentos que a função irá receber. Se ela espera
receber 4 argumentos, devemos passar 4 argumentos em map. Exemplo: map(função, arg1, arg2, arg3,
arg4). Ela, por padrão, retorna um objeto map. Semelhante à função filter, pode ser aplicado a funções
como list() para gerar uma lista ou set() para gerar um set.
Exemplo 3: Ordenar uma Lista de Strings por Comprimento. Aqui, usa-se o método .sort que possui o
parâmetro key que recebe funções. Nesse caso, recebe o comprimento de cada item da lista que, então, é
usado como item de ordenação. Ou seja, o valor de tamanho de cada string determina a posição de cada uma
na lista ordenada.
strings = ["banana", "pera", "maçã", "carambola"]

strings.sort(key=lambda s: len(s))
print(strings)
# ['pera', 'maçã', 'banana', 'carambola']
Aqui vemos outro exemplo usando .sort:
# ordenar a lista de tuplas pela idade (terceiro item, indice 2)

student_tuples = [
('john', 'A', 15),
('jane', 'B', 12),
('dave', 'B', 10),
]
student_tuples.sort(key=lambda student: student[2]) # Ordena por idade
print(student_tuples)
# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
Exceções e erros em Python: try, except, else, finally

O tratamento de erros em qualquer linguagem é fundamental, visto que erros e falhas acontecem mesmo
com os programadores mais experientes. Esses erros, também chamados de exceções (exceptions, em inglês),
podem ser tratados em Python através de blocos try e except, com a adição opcional de else e finally
para maior controle e clareza no fluxo de execução.
23 / 38
Entendendo Exceções e Erros
Exceções são eventos que ocorrem durante a execução de um programa, interrompendo o fluxo normal de
instruções. Em Python, erros encontrados durante a execução são tratados como exceções que devem ser
capturadas e tratadas adequadamente para evitar a falha do programa.
A Sintaxe Básica: try e except
O tratamento de exceções em Python é realizado com os blocos try e except. O bloco try contém o código
que pode gerar uma exceção, enquanto o bloco except captura e trata a exceção.
Exemplo 1: Tratamento Simples de Exceções. Aqui, vamos tentar dividir um número por zero. Em Python,
quando fazemos isso, acontece um erro:
resultado = 10 / 0
>>> ZeroDivisionError Traceback (most recent call last)

[~\AppData\Local\Temp\ipykernel_47896\1473461131.py] in ----> 1 resultado = 10 / 0
ZeroDivisionError: division by zero
Caso isso ocorresse no meio de um script maior, esse erro iria fazer todo o script parar imediatamente. Muitas
vezes, não queremos isso, e para termos mais controle, usamos try e except.
try:
resultado = 10 / 0
except ZeroDivisionError:
print("Não é possível dividir por zero.")
# Não é possível dividir por zero.
Neste exemplo, a tentativa (try) de divisão por zero gera uma exceção ZeroDivisionError, que é capturada
e tratada pelo bloco except, evitando assim que o programa falhe. Nesse caso, o programa encerra
normalmente.
Caso não soubermos qual tipo de exceção irá ocorrer, podemos escrever de maneira mais genérica usando a
classe "Exception", que é a superclasse para a maioria das exceções embutidas. Faz-se isso assim:
# Tentativa de dividir um número por zero

try:
# Bloco de código onde você suspeita que um erro pode ocorrer
resultado = 10 / 0
except Exception as e:
# Trata qualquer exceção capturando a superclasse Exception
print("Ocorreu um erro:", e)
# Ocorreu um erro: division by zero
24 / 38
# Tentativa de concatenar uma string com um valor inteiro

try:
a = '23' + 23
except Exception as e:
# Trata qualquer exceção capturando a superclasse Exception
print("Ocorreu um erro:", e)
# Ocorreu um erro: can only concatenate str (not "int") to str
Uso de else
O bloco else é opcional e, se presente, deve seguir os blocos try e except. Ele é executado se o bloco try
não gerar uma exceção. Exemplo 2: Uso de else
try:
resultado = 10 / 5
except ZeroDivisionError:
print("Não é possível dividir por zero.")
else:
print("Resultado:", resultado)
# Resultado: 2.0
Aqui, como a divisão é bem-sucedida, o bloco else é executado, imprimindo o resultado da operação.
Uso de finally
O bloco finally é executado após a conclusão dos blocos try, except (e opcionalmente else),
independentemente de uma exceção ter sido lançada ou não. É ideal para realizar tarefas de limpeza, como
fechar arquivos ou liberar recursos externos.
Exemplo 3: Uso de finally Aqui, arquivo é definido como "None" inicialmente. Se a abertura do arquivo
falhar, arquivo permanecerá None, e o if arquivo: no bloco finally evitará a tentativa de fechar um
arquivo não aberto, prevenindo o NameError. Se o arquivo for aberto com sucesso, arquivo não será mais
None, e arquivo.close() será chamado com segurança no bloco finally.
arquivo = None
try:
arquivo = open("sensores_temperatura.txt", "r")
print("O arquivo foi aberto com sucesso.")
except FileNotFoundError: # Tipo de erro quando o arquivo não foi encontrado
print("O arquivo não foi encontrado.")
finally:
if arquivo: # Se arquivo não for encontrado, continuará igual a None e não
entrará nesse if
arquivo.close()
print("O arquivo foi fechado.")
# O arquivo não foi encontrado.
25 / 38
Tratando Múltiplas Exceções
Você pode capturar diferentes exceções em múltiplos blocos except para tratá-las de maneira específica.
Exemplo 4: Múltiplos Blocos Except
try:
valor = int(input("Digite um número: "))
resultado = 10 / valor
except ValueError: # Se for inserido algo que não é convertível para inteiro, como
uma string
print("Erro: Por favor, insira um valor inteiro válido.")
except ZeroDivisionError: # se valor inserido for zero
print("Erro: Divisão por zero não é permitida.")
else:
print("Nenhuma exceção ocorreu. O resultado é", resultado)
finally:
print("Este bloco é executado sempre, ocorrendo exceção ou não.")
## Se for inserido uma string:
# Erro: Por favor, insira um valor inteiro válido.
# Este bloco é executado sempre, ocorrendo exceção ou não.
## Se for inserido um número inteiro. Ex: 1

# Nenhuma exceção ocorreu. O resultado é 10.0
# Este bloco é executado sempre, ocorrendo exceção ou não.
raise e assert
Além dos blocos try, except, else, e finally para tratamento de exceções, Python fornece duas outras
palavras-chave importantes para o controle de erros: raise e assert. Esses comandos são usados para criar
exceções de maneira controlada e realizar verificações de sanidade em seu código, respectivamente. Eles são
ferramentas cruciais para garantir a correção e a robustez dos programas.
raise
Suponha que você esteja escrevendo uma função que processa transações. Se uma transação for inválida e
crítica, você pode querer interromper o script de análise e alertar o chamador sobre o problema.
def processar_transacao(transacao_eh_valida):
if not transacao_eh_valida:
raise ValueError("Transação inválida.")
# Processamento da transação
processar_transacao(None)
>>> ------------------------------------
>>> ValueError Traceback (most recent call last)
>>> 1 def processar_transacao(transacao_eh_valida):
>>> 2 if not transacao_eh_valida:
26 / 38
>>> ----> 3 raise ValueError("Transação inválida.")

>>> 4 # Processamento da transação
>>> 5 processar_transacao(None)
>>> ValueError: Transação inválida.
Assim, é possível invocar exceções de maneira controlada e personalizar de acordo com o problema que
desejamos capturar. Além disso, podemos substituir a keyword ValueError por Exception para invocarmos uma
exceção mais genérica.
assert
assert é uma instrução que permite ao programador verificar se uma condição específica é verdadeira. Se a
condição avaliada por assert for False, uma exceção AssertionError será levantada. Isso é útil para
realizar verificações de sanidade em seu código para garantir que um estado inválido nunca seja alcançado,
ou para verificar se uma variável possua um valor esperado. Por exemplo, podemos usar assert antes do
return de uma função para verificar se o output está correto. A sintaxe de uma assertion é dada por:
[!NOTE] Sintaxe de uma assertion assert expressão[, assertion_message]
Onde assertion_message é uma mensagem (opcional) que pode ser mostrada quando a expressão for False e,
então, o erro AssertionError ocorrer. Exemplo:
>>> numero = 42
>>> assert numero > 0, f"é esperado que numero seja maior que zero, mas numero =
{number}"
# Expressão é verdadeira
>>> numero = -42

>>> assert numero > 0, f"é esperado que numero seja maior que zero, mas numero =
{number}"
# Expressão é falsa, portanto ocorre o erro AssertionError
Traceback (most recent call last):
...
AssertionError: é esperado que numero seja maior que zero, mas numero = -42
É possível colocar mais de uma expressão verificadora usando as keywords and e or. Também podemos usar
in e out. Abaixo, espera-se que valores não seja vazio e que contenha valores numéricos. Aqui, a função
isinstance checa se cada variável dentro de valores é int ou float e retorna uma lista com valores True ou False.
Em seguida, a função all() verifica se todos os valores dessa lista são True, retornando True se sim. Caso
qualquer um for False, all() então retorna False.
def calcular_media(valores):
# Verifica se 'valores' não é vazio (portanto False) e todos os elementos são
numéricos
assert valores and all(isinstance(x, (int, float)) for x in valores), "A lista
deve conter pelo menos um valor numérico e não pode ser vazia."
return sum(valores) / len(valores)
27 / 38
# Exemplo de uso correto

print(calcular_media([10, 20, 30])) # Saída: 20.0
# Exemplo que falhará na asserção

print(calcular_media([])) # Levanta AssertionError
>>> AssertionError: A lista deve conter pelo menos um valor numérico e não pode
ser vazia.
# print(calcular_media([10, 'não numérico', 20])) # Levanta AssertionError
>>> AssertionError: A lista deve conter pelo menos um valor numérico e não pode
ser vazia.
Existe a keyword any() que é semelhante à all() mas retorna True se qualquer uma for True.
[!NOTE] Código explicado: all, any e isinstance
valores = [10, 20, '30']

[isinstance(x, (int, float)) for x in valores] # list comprehension
>>> [True, True, False]
all([True, True, False])
False any([True, True, False])
True
Generators
Generators são implementados através de funções, mas ao invés de retornar um valor único, um generator é
capaz de produzir uma sequência de resultados ao longo do tempo, pausando a execução da função e
retomando-a conforme necessário. Isso é alcançado com o uso da palavra-chave yield.
Quando uma função contém pelo menos uma declaração yield, ela se torna um generator. Ao chamar a
função, o código contido dentro dela não é executado imediatamente. Em vez disso, um objeto generator é
retornado. Esse objeto pode ser iterado com um loop for ou com a função next(), que continua a execução
da função até encontrar a próxima declaração yield. Isso evita executar todas as iterações de um loop
imediatamente, rodando o próximo iterador somente quando for solicitado.
Vantagens
Eficiência de Memória: Generators não armazenam todos os itens na memória de uma vez. Eles geram
cada item sob demanda, o que é especialmente útil para sequências grandes ou infinitas.
Conciso: Generators podem tornar o código mais legível e expressivo.
Reutilizável: Assim como os iteradores, os generators podem ser reutilizados em diferentes partes do
programa.
Criação
28 / 38
Um generator pode ser criado da mesma forma que uma list comprehension, porém inserindo a expressão
dentro de parêntesis.
quadrados = (x**2 for x in range(1, 4))

print(quadrados)
>>> <generator object <genexpr> at 0x000001DD9E466DD0>
next(quadrados)
>>> 1
next(quadrados)
>>> 4
next(quadrados)
>>> 9
next(quadrados)
>>>---------------------------------------------------------------------------
>>>StopIteration Traceback (most recent call last)
>>>StopIteration:
Além disso, podem ser criados da mesma forma que funções, porém no lugar da palavra-chave return de
retorno da função colocamos yield.
def fibonacci(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b
fib_generator = fibonacci(10)
print(fib_generator)
>>> <generator object fibonacci at 0x000001DD9E4792E0>
next(fib_generator)
>>> 0
next(fib_generator)
>>> 1
next(fib_generator)
>>> 1
next(fib_generator)
>>> 2
next(fib_generator)
>>> 3
next(fib_generator)
>>> 5
next(fib_generator)
>>> 8
Pode-se iterar pelos valores de um generator usando loops também, como for.
for x in fibonacci(10):
print(x, end=', ')
>>> 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,
29 / 38
Módulo 3
Leitura e Escrita de Arquivos de Texto em Python
Abrindo Arquivos
Para ler ou escrever em um arquivo, primeiro você precisa abri-lo usando a função embutida open(). Essa
função retorna um objeto de arquivo que fornece métodos e atributos para interagir com o conteúdo do
arquivo.
f = open('meuarquivo.txt', 'r')
No exemplo acima, o arquivo meuarquivo.txt é aberto no modo de leitura ('r'). Outros modos comuns
incluem escrita ('w'), anexar ('a'), e modos que permitem atualização ('r+', 'w+', 'a+').
Modo Explicação
r Abre o arquivo somente para leitura. O arquivo deve existir, ou um erro será levantado.
w Abre o arquivo para escrita, criando um novo arquivo ou sobrescrevendo o existente.
a Abre o arquivo para anexar conteúdo no final, criando um novo arquivo se não existir.
r+ Abre o arquivo para leitura e escrita. O arquivo deve existir.
w+ Abre o arquivo para leitura e escrita, criando um novo arquivo ou sobrescrevendo o existente.
a+ Abre o arquivo para leitura e escrita, anexando o novo conteúdo no final.
Leitura de Arquivos
Há várias maneiras de ler o conteúdo de um arquivo:
1. Lendo todo o conteúdo
conteudo = f.read()
print(conteudo)
2. Lendo linha por linha
for linha in f:
print(linha, end='')
# ou ainda usando .readline()

f.readline()
>>> 'This is the first line of the file.\n'
30 / 38
f.readline()
>>> 'Second line of the file\n'
f.readline()
>>> '' # quando chega no final do arquivo, retorna uma string vazia (end of file
ou EOF)
3. Lendo linhas com uma lista
linhas = f.readlines() # observe que aqui escreve-se .readlines(), com 's' no

final, ao contrário de .readline() visto acima.
for linha in linhas:
Após a leitura, sempre feche o arquivo para liberar recursos do sistema e evitar problemas (como corrupção
do arquivo) usando f.close().
Escrita em Arquivos
Para escrever em um arquivo, você deve abri-lo no modo de escrita ('w') ou anexar ('a').
f = open('meuarquivo.txt', 'w')
f.write('Hello, world!\n')
f.close()
Se o arquivo já existir e for aberto no modo de escrita, o conteúdo anterior será apagado. Se for aberto no
modo de anexar, o novo conteúdo será adicionado ao final do arquivo.
Uso do with
A instrução com a palavra-chave with simplifica o manejo de arquivos garantindo que eles sejam fechados
automaticamente após a conclusão do bloco indentado (com espaços antes da linha).
Leitura com with
with open('meuarquivo.txt', 'r') as f:

conteudo = f.read()
print(conteudo)
Escrita com with
with open('meuarquivo.txt', 'w') as f:

f.write('Goodbye, world!\n')
31 / 38
f.closed # verifica se arquivo foi fechado

>>> True
Exemplo Prático: Criando um Gerador de Quadrados
Vamos aplicar os conceitos de leitura e escrita de arquivos para criar um arquivo de texto com os quadrados
dos primeiros 10 números inteiros, similar ao exemplo de gerador fornecido.
Escrevendo os Quadrados em um Arquivo
with open('quadrados.txt', 'w') as f:

for numero in range(10):
f.write(f'{numero**2}\n')
Lendo e Imprimindo os Quadrados
with open('quadrados.txt', 'r') as f:

for linha in f:
Exemplo de uso:
Vamos considerar que você tem um arquivo de texto chamado dados_sensores.txt com leituras de
sensores de temperatura e o horário de cada leitura. O arquivo pode ter o seguinte formato:
2023-02-15 08:00:00, 20.5

2023-02-15 08:15:00, 21.0
2023-02-15 08:30:00, 20.8
2023-02-15 08:45:00, 21.5
2023-02-15 09:00:00, 22.0
...
Cada linha contém um timestamp seguido pela temperatura medida naquele momento, separados por uma
vírgula. Para gerar um arquivo com dados simulados com o formato acima, podemos usar um código como o
abaixo.
from datetime import datetime, timedelta

import random # biblioteca random para gerar números aleatórios
# Definindo o timestamp inicial

timestamp_inicial = datetime(2023, 2, 15)
# Criando os dados
32 / 38
dados = []
for i in range(50):
# Calculando o timestamp atual
timestamp_atual = timestamp_inicial + timedelta(minutes=15*i)
# Gerando uma temperatura aleatória
temperatura = random.uniform(18.0, 28.0)
# Formatando a string de dados
linha = f"{timestamp_atual.strftime('%Y-%m-%d %H:%M:%S')},
{temperatura:.2f}\n"
dados.append(linha)
# Caminho do arquivo
caminho_arquivo = "/mnt/data/dados_sensores.txt"
# Escrevendo os dados no arquivo

with open(caminho_arquivo, "w") as arquivo:
arquivo.writelines(dados)
caminho_arquivo
No código acima, vale destacar que o método strftime formata um dado do tipo datetime (no caso, a
variável timestamp_inicial) de acordo com uma codificação. Mais detalhes podem ser vistos em:
https://strftime.org/ e https://strftime.net/ (este último permite criar diferentes configurações).
Agora, suponha que você queira abrir esse arquivo em Python, ler os dados, e calcular:
1. A temperatura média.
2. A temperatura máxima e mínima.
3. A variação de temperatura (diferença entre a temperatura máxima e mínima).
Para isso podemos usar o código abaixo:
# Inicializa as variáveis necessárias

temperaturas = []
timestamps = []
# Abre o arquivo para leitura

with open('dados_sensores.txt', 'r') as f:
for linha in f:
# Separa o timestamp e a temperatura
timestamp, temperatura = linha.strip().split(', ')
# Adiciona os dados às listas correspondentes
timestamps.append(timestamp)
temperaturas.append(float(temperatura))
# Calcula a temperatura média

temperatura_media = sum(temperaturas) / len(temperaturas)
# Encontra a temperatura máxima e mínima

temperatura_max = max(temperaturas)
33 / 38
temperatura_min = min(temperaturas)
# Calcula a variação de temperatura

variacao_temperatura = temperatura_max - temperatura_min
# Imprime os resultados
print(f"Temperatura Média: {temperatura_media:.2f}°C")
print(f"Temperatura Máxima: {temperatura_max:.2f}°C")
print(f"Temperatura Mínima: {temperatura_min:.2f}°C")
print(f"Variação de Temperatura: {variacao_temperatura:.2f}°C")
Este script primeiro inicializa duas listas para armazenar os valores de temperatura e os timestamps. Em
seguida, abre o arquivo dados_sensores.txt para leitura, percorre cada linha do arquivo, extrai o timestamp
e a temperatura, converte a temperatura para um número de ponto flutuante (float) e adiciona esses valores
às listas correspondentes. Após ler todos os dados, o script calcula e imprime a temperatura média, máxima,
mínima, e a variação de temperatura.
Arquivos CSV
CSV é um formato simples e amplamente utilizado para armazenar dados tabulares, onde cada linha do
arquivo representa um registro e cada registro consiste em um ou mais campos separados por vírgulas. O
módulo csv da biblioteca padrão do Python simplifica a leitura e escrita de arquivos CSV.
Lendo Arquivos CSV
Para ler dados de um arquivo CSV, você pode usar o módulo csv junto com um reader:
import csv
with open('dados.csv', newline='') as csvfile:

leitor = csv.reader(csvfile)
for linha in leitor:
print(linha) # Cada 'linha' é uma lista com os campos do registro
Escrevendo Arquivos CSV
Para escrever dados em um arquivo CSV, utilize um writer do módulo csv:
import csv
dados = [['nome', 'cidade', 'idade'], ['John Doe', 'New York', 30], ['Jane Doe',
'Los Angeles', 25]]
with open('dados.csv', 'w', newline='') as csvfile:

escritor = csv.writer(csvfile)
escritor.writerows(dados) # Escreve múltiplas linhas
34 / 38
Arquivos JSON
JSON é um formato leve para troca de dados, fácil para humanos lerem e escreverem, e fácil para máquinas
parsearem e gerarem. Python oferece suporte nativo ao JSON através do módulo json, que permite codificar
e decodificar dados em JSON de maneira simples. Um arquivo JSON é interpretado como um dicionário em
Python, portanto após ser carregado em um script, ele passa a ser um.
Estrutura do JSON
O JSON é estruturado em dois tipos de estruturas básicas:
Coleções de pares nome/valor (objetos em JavaScript): No contexto do JSON, são representadas por
objetos (dicionários em Python) delimitados por chaves {}. Cada par nome/valor é separado por uma
vírgula.
{
"nome": "John Doe",
"idade": 30
}
Listas ordenadas de valores (arrays em JavaScript): No JSON, são representadas por arrays (listas em
Python) delimitadas por colchetes []. Cada valor dentro do array é separado por uma vírgula.
["maçã", "banana", "cereja"]
O Python fornece o módulo json, que permite codificar (converter dados em Python para uma string JSON) e
decodificar (converter uma string JSON para dados em Python) com facilidade.
Decodificação de JSON (Parsing)
Para converter uma string JSON em um objeto Python, você pode usar a função json.loads() (load string):
import json
json_string = '{"nome": "Jane Doe", "idade": 25, "cidade": "Los Angeles"}'

dados = json.loads(json_string)
print(dados) # Saída: {'nome': 'Jane Doe', 'idade': 25, 'cidade': 'Los Angeles'}
Para ler dados JSON de um arquivo e convertê-los em um objeto Python, use json.load():
import json
with open('dados.json', 'r') as arquivo:
35 / 38
dados = json.load(arquivo)
print(dados)
Codificação de JSON (Serialização)
Para converter um objeto Python (como dicionários, listas, strings, inteiros, e assim por diante) em uma string
JSON, use a função json.dumps() (dump string):
import json
dados = {
"nome": "John Doe",
"idade": 30,
"casado": False,
"filhos": ["Alice", "Bob"]
}
json_string = json.dumps(dados, indent=4) # `indent` melhora a legibilidade para

humanos
print(json_string)
Para escrever dados JSON diretamente em um arquivo, use json.dump():
import json
with open('dados_saida.json', 'w') as arquivo:

json.dump(dados, arquivo, indent=4)
Dicas e Práticas Recomendadas
CSV:
Use o parâmetro delimiter='' em csv.reader e csv.writer se seus dados não usarem
vírgula como separador. Dentro das aspas, coloque o delimitador necessário.
Use exceções e assertions para lidar com arquivos malformados ou dados inesperados.
JSON:
Aproveite json.dumps() para converter um objeto Python em uma string JSON formatada.
Use json.loads() para analisar uma string JSON e convertê-la em um objeto Python.
Introdução às Bibliotecas de Análise de Dados - Pandas

A análise de dados é uma parte crucial da ciência de dados, ajudando a transformar informações brutas em
insights úteis. Python, sendo uma das linguagens de programação mais populares no mundo da ciência de
dados, é reforçada por um ecossistema robusto de bibliotecas projetadas especificamente para análise de
dados. Entre essas bibliotecas, o Pandas se destaca como uma ferramenta essencial para a manipulação e
análise de dados em Python.
36 / 38
O que é Pandas?
Pandas é uma biblioteca de código aberto que proporciona estruturas de dados de alta performance e fáceis
de usar, além de ferramentas de análise de dados para Python. Seu nome deriva de "panel data", um termo
econômico para conjuntos de dados que incluem observações ao longo do tempo para os mesmos
indivíduos. Desenvolvido por Wes McKinney, o Pandas se tornou um componente indispensável no kit de
ferramentas de todo analista de dados que trabalha com Python.
Características Principais
Estruturas de Dados: O Pandas introduz duas novas estruturas de dados para Python: DataFrame e
Series, que são construídas sobre a biblioteca NumPy, permitindo uma manipulação de dados rápida
e eficiente.
Facilidade de Manipulação: Permite limpar, transformar, modificar, agregar e pivotar dados com
facilidade.
Leitura e Escrita de Dados: Fornece ferramentas para ler e escrever dados em diferentes formatos,
como CSV, Excel, SQL, JSON, entre outros.
Integração: Funciona bem com outras bibliotecas, incluindo bibliotecas de visualização de dados como
Matplotlib, permitindo análises complexas e visualizações com menos esforço.
Instalação
Para instalar o Pandas, você pode usar o pip, o gerenciador de pacotes do Python. Para isso, pesquise por
"Anaconda Prompt" no Menu Iniciar do computador e abra a opção que aparecer. Em seguida, escreva e
execute o comando abaixo na janela que abrir:
pip install pandas
Estruturas de Dados em Pandas
DataFrame
Um DataFrame é uma estrutura de dados bidimensional, semelhante a uma planilha ou uma tabela SQL, com
colunas de diferentes tipos. É a estrutura principal do Pandas para armazenar e manipular conjuntos de dados
tabulares com rótulos de eixo (linhas e colunas).
Series
Uma Series, por sua vez, é uma estrutura de dados unidimensional que pode armazenar dados de qualquer
tipo (inteiro, string, float, objetos Python, etc.). É basicamente uma coluna de um DataFrame.
Exemplos Práticos
Criando um DataFrame
Um DataFrame é uma estrutura de dados bidimensional, semelhante a uma tabela de banco de dados ou
uma planilha de Excel:
37 / 38
import pandas as pd
data = {
'Nome': ['John Doe', 'Jane Doe'],
'Idade': [28, 34],
'Cidade': ['New York', 'Chicago']
}
df = pd.DataFrame(data)
print(df)
38 / 38

Módulo 1 e Módulo 2

Enviado por

Direitos autorais:

Formatos disponíveis

Módulo 1 e Módulo 2

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

Módulo 1 e Módulo 2

Enviado por

Direitos autorais:

Formatos disponíveis

Material de estudos.

O que são variáveis?

1. Tipos de dados básicos

2. Outros tipos de dados mais usados

Exemplo: coordenadas = (10.0, 20.0)

3. Principais operadores na linguagem

Símbolo Operação Exemplo

% Módulo (resto da divisão) 22 % 10 = 2

** Exponenciação (potência) 4**2 = 16

// Divisão inteira (quociente da divisão) 9//2 = 4

Símbolo Operação Exemplo

> Maior que 4 > 5 é False

< Menor que 4 < 5 é True

>= Maior ou igual 4 >= 5 é False

<= Menor ou igual 4 <= 5 é True

Símbolo Exemplo Equivalente à

**= c **= 2 (mesmo que c = c ** 2)

//= c //= 3 (mesmo que c = c // 3)

Símbolo Exemplo Exemplo

True (verdade) se algum dos (4 > 3) or (2 == 1) retorna True pois pelo

not((4 > 3) and (2 == 1)) retorna True pois

Símbolo Exemplo Exemplo

True se o valor estiver dentro da 'maça' in ['banana', 'pera', 'jabuticaba',

True se o valor não seja encontrado 'abobora' not in ['banana', 'pera',

simples = 'Hello, World!'

Acessando Caracteres e Substrings

Fatiamento (Slicing): Python permite obter substrings especificando um intervalo de índices.

print(s[1:4]) # Saída: yth`

Métodos Comuns de Strings

upper() e lower(): Para converter uma string para maiúscula ou minúscula.

print("Python".upper()) # Saída: PYTHON print("Python".lower()) # Saída:

print(" Python ".strip()) # Saída: Python

print("a,b,c".split(',')) # Saída: ['a', 'b', 'c']

print(",".join(['a', 'b', 'c'])) # Saída: a,b,c

replace(): Para substituir uma substring por outra.

print("Hello, World!".replace("World", "Python")) # Saída: Hello, Python!`

Python oferece várias maneiras de formatar strings:

Operador %: Um método antigo, inspirado na linguagem C.

Método format(): Mais flexível e intuitivo do que o operador %.

print("Olá, {}!".format("Mundo")) # Saída: Olá, Mundo!`

Para mais informações sobre strings veja esse link:

nomes = ["Alice", "Bob", "Charlie"]

print(minha_lista[0]) # Acessa o primeiro elemento da lista, que é 1

sublista = minha_lista[1:3] # Obtém elementos dos índices 1 a 2

sublista = minha_lista[1:] # Retorna [2, 3, 4, 5] pois pegamos do segundo

Adição e Remoção de Elementos

minha_lista[1:3] = [20, 30] # Substitui elementos em um intervalo específico

Para mais informações, ver: https://docs.python.org/3/tutorial/datastructures.html

Diferenças para listas:

Neste exemplo, 1, 2, 3 são empacotados em uma tupla automaticamente pelo Python.

Unpacking é o processo de atribuir os valores de uma tupla a várias variáveis separadas.

Neste exemplo, os valores da tupla tupla são desempacotados e atribuídos às variáveis a, b e c.

Não aceitam duplicatas: Cada elemento em um set é único.

Exemplo de Uso de Set:

''' Remoção de duplicatas'''

''' União, interseção, diferença e diferença simétrica'''

Uso de if, else, e elif

for item in sequência:

Laços Aninhados (Nested Loops)

for item1 in sequência1:

Exponenciação (potência) 42 = 16

= c = 2 (mesmo que c = c ** 2)