PARADIGMAS DE LINGUAGENS DE PROGRAMAÇÃO

EM PYTHON

O que é o Python?
Uma linguagem de programação.

O que podemos fazer com esta linguagem?

Python é uma linguagem de programação versátil e poderosa que oferece uma ampla gama de
possibilidades. Aqui estão algumas das coisas que você pode fazer com Python:
1. Desenvolvimento Web
2. Automação
3. Análise de Dados
4. Inteligência Artificial e Aprendizado de Máquina
5. Automação de Testes e QA
6. Desenvolvimento de Aplicativos Desktop
7. Análise de Texto e Processamento de Linguagem Natural (NLP)
8. Automação de Redes
9. Automação de Sistemas
10. Jogos e Gráficos

Devemos salvar o arquivo com a extensão .py

Vamos usar o editor replit.com.

Operadores aritméticos em Python:

1
No replit.com crie um arquivo python do zero.

Digite o código:

a = 10
b=3

soma = a + b
subtracao = a - b
multiplicacao = a * b
divisao = a / b
divisao_inteira = a // b
resto_divisao = a % b
potencia = a ** b

print(soma, subtracao, multiplicacao, divisao, divisao_inteira, resto_divisao,

potencia)

Abra a aba do shell e digite o comando python arquivo.py e dê enter.

Tipos de dados em python

Os tipos de dados em Python são:

● Número
● String
● Lista
● Tupla
● Dicionário
● Booleano

Concatenando e printando

Crie um novo arquivo e execute no shell com o seguinte código:

nome = "Ana"
sobrenome = "Garcia"

nome_completo = nome + " " + sobrenome

print("Nome completo:", nome_completo)

2
Variáveis, entrada e saida de texto, comentários

# Este é um comentário explicativo

# Neste programa, iremos armazenar um nome em uma variável e exibi-lo na tela

# Solicita ao usuário que digite seu nome

nome = input("Digite seu nome: ")

# Exibe o nome na tela

print("Olá, " + nome + "! Bem-vindo ao programa.")

O caractere # serve para aplicar comentários no código.

O comando input serve para inserir dados.

O conceito de variável permanece o mesmo de outras linguagens.

Função len

len(objeto)
Onde objeto é o objeto do qual queremos encontrar o comprimento.

A função len() é uma função integrada do Python. Você pode usar a função len() para obter o
comprimento da string, array, lista, tupla, dicionário, etc.

Funções de conversão

str() (String)
A função str() é usada para converter outros tipos de dados em strings.
int() (Integer)
A função int() é usada para converter strings ou números de ponto flutuante em números inteiros.
float() (Floating-Point)
A função float() é usada para converter strings ou números inteiros em números de ponto flutuante.

3
Crie um arquivo novo na ide, salve e execute no terminal. Segue o script abaixo:

# Exemplo de uso dos comandos len, str, int e float

# Usando len para contar o número de caracteres em uma string

mensagem = "Olá, Python!"
tamanho_mensagem = len(mensagem)
print("Tamanho da mensagem:", tamanho_mensagem)

# Convertendo um número inteiro para uma string

numero_inteiro = 42
numero_string = str(numero_inteiro)
print("Número inteiro convertido para string:", numero_string)

# Convertendo uma string numérica para um número inteiro

string_numerica = "123"
numero_convertido = int(string_numerica)
print("String numérica convertida para número inteiro:", numero_convertido)

# Convertendo uma string numérica para um número de ponto flutuante

string_float = "3.14"
numero_float = float(string_float)
print("String numérica convertida para número de ponto flutuante:", numero_float)

As instruções de controle de fluxo podem decidir quais instruções Python devem ser executadas de
acordo com determinadas condições.

Operadores de comparação

4
Tipo de dado booleano: True, False.

Operadores booleanos (tabela verdade): True e False

As instruções de controle de fluxo geralmente começam com uma parte chamada condição, e todas
as condições são seguidas de um bloco de código chamado cláusula.

As expressões booleanas que vimos até agora poderiam ser todas consideradas condições, que é o
mesmo que expressões; uma condição é somente um nome mais específico no contexto das
instruções de controle de fluxo. As condições sempre são avaliadas como um valor booleano, ou
seja, True ou False. Uma instrução de controle de fluxo decide o que fazer conforme
sua condição seja True ou False, e quase toda instrução de controle de fluxo utiliza uma condição.

Operadores lógicos – and, or e not.

5
Usando if, else e elif no Python

Para a prática vamos criar um novo arquivo no editor e digitar o seguinte código. Logo depois rodar
no terminal.

idade = 18

if idade < 18:

print("Você é menor de idade.")
elif idade == 18:
print("Você tem exatamente 18 anos.")
else:
print("Você é maior de idade.")

Usando as estruturas de repetição

Vamos praticar este código em nosso editor com while:

contador = 0

while contador < 5:

print("Contagem:", contador)
contador += 1 # Incrementa o contador em 1 a cada iteração

print("Loop concluído!")

Veremos um exemplo do for

#o range irá gerar a sequência de 1 à 5

for numero in range(1, 6):
print("Número:", numero)

A função range() cria uma sequência de números que pode ser útil para loops:

for i in range(5): # Isso vai iterar de 0 a 4

print(i)

6
Usando break e continue

# Criação de uma lista

animais = [ 'gato', 'rato', 'tatu', 'pato' ]
# Loop for n vezes na lista animais
for n in animais:
# Verifica a condição n igual a tatu
if n == 'tatu':
# Passa para o próximo loop for nesse ponto
continue
# Imprime os nomes no loop for
print( n )

Ao utilizar o continue dentro de uma condição if, no caso a palavra tatu, quando esse item é
encontrado na lista ele passa para o próximo item sem executar as instruções após o continue, no
nosso caso a impressão deste item, imprimindo apenas os outros animais da lista.

Importação e fim de execução

Podemos importar módulos em Python usando o import.

Caso eu queira terminar a execução do script, posso usar o comando:

sys.exit()

7
LISTAS

Uma lista em Python é uma coleção de itens ou elementos que você pode armazenar juntos. Pense
nela como uma lista de compras onde você coloca vários itens que deseja comprar. No caso das
listas em Python, esses "itens" podem ser números, palavras, ou até mesmo outras listas. As listas
são úteis porque permitem que você organize e trabalhe com vários dados de uma vez, seja para
fazer cálculos, exibir informações ou manipular informações de maneira mais conveniente.

Cada item em uma lista possui uma posição específica chamada de "índice", que começa em 0 para
o primeiro item, 1 para o segundo e assim por diante. Isso permite que você acesse e manipule os
itens individualmente ou em grupo.

- numeros.append(valor): Adiciona o "valor" ao final da lista.

- numeros.insert(indice, valor): Insere o "valor" na posição do "índice" na lista.

- numeros.remove(valor): Remove a primeira ocorrência do "valor" da lista.

- numeros.pop(): Remove o último item da lista.

- numeros.sort(): Organiza a lista em ordem crescente.

- list(reversed(...)): Cria uma nova lista contendo os elementos em ordem inversa.

- sum(...): Retorna a soma de todos os valores da lista.

- len(...): Retorna o número de elementos da lista.

- max(...): Retorna o maior valor nos elementos na lista.

- min(...): Retorna o menor valor nos elementos na lista.

# Criando uma lista de números

numeros = [23, 10, 5, 42, 7, 18, 35]

# Acessando elementos da lista

primeiro_numero = numeros[0]
terceiro_numero = numeros[2]

# Alterando um elemento da lista

numeros[1] = 15

# Acrescentando elementos à lista

numeros.append(30)
numeros.insert(2, 12)

#Removendo elementos da lista

8
numeros.remove(7)
numeros.pop()

# Ordenando a lista
numeros.sort()

#Gerando a lista em ordem inversa

numeros_inversos = list(reversed(numeros))

#Exibindo a lista ordenada

print("Números ordenados na lista:")
for numero in numeros:
print(numero)

# Usando um loop para iterar a lista

print("Números inversos na lista:")
for numero in numeros_inversos:
print(numero)

# Usando a função range para criar uma lista de números

numeros_pares = list(range(2, 21, 2)) # Números pares de 2 a 20
print("Números gerados pelo range")
for numero in numeros_pares:
print(numero)

# Funções estatísticas usando a lista de números

soma = sum(numeros)
media = soma / len(numeros)
maior_numero = max(numeros)
menor_numero = min(numeros)

print("\nEstatísticas:")
print("Soma:", soma)
print("Média:", media)
print("Maior número:", maior_numero)
print("Menor número:", menor_numero)

Vamos atuar neste código acima.

TUPLAS

Uma tupla em Python é como uma lista, mas com uma diferença importante: as tuplas são
imutáveis, o que significa que depois de criadas, você não pode alterar seus elementos. Imagine que
uma lista é como uma sacola onde você pode adicionar, remover e alterar coisas, enquanto uma
tupla é como uma caixa selada onde os itens não podem ser mudados.

Vamos praticar usando o código abaixo:

# Criando uma tupla

9
minha_tupla = (10, 20, 30)

# Acessando elementos da tupla

primeiro_elemento = minha_tupla[0] # Pega o valor 10
segundo_elemento = minha_tupla[1] # Pega o valor 20

# Percorrendo a tupla com um loop

print("Elementos da tupla:")
for elemento in minha_tupla:
print(elemento) # Imprime cada elemento da tupla em uma linha separada

Paradigma Orientado a Objetos

É uma abordagem na programação onde organizamos os dados e o código em "objetos" que podem
conter informações (atributos) e ações (métodos). Isso ajuda a modelar o mundo real de maneira
mais próxima no software, tornando-o mais modular e reutilizável.

Encapsulamento

O encapsulamento é um princípio importante no paradigma orientado a objetos que envolve a ideia

de "esconder" os detalhes internos de um objeto e fornecer uma interface controlada para interagir
com esses detalhes. Isso é feito através da combinação de dados (atributos) e as operações que
atuam sobre esses dados (métodos) dentro de um único objeto.

Subprogramas

Subprogramas, também conhecidos como sub-rotinas ou procedimentos(funções), são blocos de

código reutilizáveis em programação que executam uma tarefa específica. Eles são usados para
dividir um programa em partes menores e mais gerenciáveis, tornando o código mais organizado,
legível e modular.

Paradigma funcional

O paradigma funcional é uma abordagem na programação onde o foco principal é em funções. Em

vez de alterar o estado de variáveis, você cria funções que transformam os dados de entrada em
dados de saída. É como uma receita de cozinha: você pega ingredientes (dados de entrada), os
processa em etapas (funções) e obtém um prato pronto (resultado).

Paradigma lógico

O paradigma lógico é uma abordagem onde você descreve as relações entre diferentes fatos e regras
em um sistema. É como um conjunto de enigmas e pistas: você fornece as pistas (fatos e regras) ao
sistema, e ele deduz as respostas (soluções) baseadas nas pistas dadas.

DICIONÁRIOS

Um dicionário em Python é uma coleção de pares chave-valor. Cada chave é conectada a um valor,
e você pode usar uma chave para acessar o valor associado a ela. O valor de uma chave pode ser um
número, uma string, uma lista ou até mesmo outro dicionário. De fato, podemos usar qualquer

10
objeto que possa ser criado em Python como valor de um dicionário.

Em Python, um dicionário é representado entre chaves, {}, com uma série de pares chave-valor
entre elas, como mostramos a seguir:
alien_0 = {'color': 'green', 'points': 5}

Para printar o valor associado a uma chave, especifique o nome do dicionário e coloque a chave
entre colchetes, como vemos a seguir:

alien_color = {'color': 'green'}

print(alien_color['color'])

Vamos praticar:

# criar um dicionário vazio

d = {}

# adicionar itens ao dicionário

d["nome"] = "Ana"
d["idade"] = 25
d["profissão"] = "médica"

# acessar um valor pelo sua chave

print(d["nome"]) # Ana

# alterar um valor pelo sua chave

d["idade"] = 26

# remover um item pelo sua chave

del d["profissão"]

# imprimir todo o dicionário

print(d) # {'nome': 'Ana', 'idade': 26}
Para iterar sobre um dicionário em Python, você pode usar um laço for com o método items() do
dicionário, que retorna uma lista de tuplas com cada par chave-valor.

Exemplo da lista de tuplas retornada pelo items:

([('nome', 'Ana'), ('idade', 26), ('profissão', 'médica')])

Vamos praticar:

# criar um dicionário
d = {"nome": "Ana", "idade": 26, "profissão": "médica"}

# iterar sobre o dicionário usando items()

for chave, valor in d.items():
# imprimir cada chave e valor
print(chave, valor)

11
# saída:
# nome Ana
# idade 26
# profissão médica

Para criar uma função em Python, você precisa usar a palavra-chave def, seguida do nome da
função e dos parâmetros entre parênteses. O corpo da função deve estar indentado e pode conter um
return para devolver um valor. Vamos praticar:

def soma(x, y):

resultado = x + y
return resultado

z = soma(3, 5)
print(z)

Se você quiser criar uma função sem parâmetros, você pode deixar os parênteses vazios. Vamos
praticar:

def hello():
print("Olá, mundo!")

hello()

Declarando constantes

A regra de nomeação das constantes no Python segue um padrão parecido com o de variáveis, com
a diferença de que todas as letras são maiúsculas e separadas por underline “_”. Porém, por possuir
tipagem dinâmica, os valores atribuídos à constantes podem ser alterados sem problemas:

MINHA_CONSTANTE = 10

print(MINHA_CONSTANTE) # 10

PROGRAMAÇÃO ORIENTADA A OBJETOS

- Objeto
- Classe
- Atributos
- Métodos

O que são estes 4 elementos acima?

Exemplo 1:

12
class Dog():
#Uma tentativa simples de modelar um cachorro

def __init__(self, name, age):

#Inicializa os atributos name e age
self.name = name
self.age = age

def sit(self):
#Simula um cahorro sentado em resposta a um comando
print(self.name.title() + " is now sitting.")

def roll_over(self):
#Simula um cachorro rolando em resposta a um comando
print(self.name.title() + " rolled over!")

my_dog = Dog('willie', 6)
your_dog = Dog('lucy', 3)

print("My dog's name is " + my_dog.name.title() + ".")

print("My dog is " + str(my_dog.age) + " years old.")

print("My dog's name is " + your_dog.name.title() + ".")

print("My dog is " + str(your_dog.age) + " years old.")

my_dog.sit()
my_dog.roll_over()

your_dog.sit()
your_dog.roll_over()

O método __init__() é um método especial (construtor) que o Python executa automaticamente

sempre que criamos uma nova instância de uma classe.

O parâmetro self é obrigatório na definição dos métodos e deve estar antes dos demais parâmetros.
Ele dá acesso aos atributos e métodos da classe à instância criada.

Qualquer variável prefixada com self está disponível a todos os métodos da classe; além
disso, podemos acessar essas variáveis por meio de qualquer instância criada a partir da classe.

Acessando atributos

Para acessar os atributos de uma instância utilize a notação de ponto. Neste exemplo
acessamos o valor do atributo name de my_dog escrevendo:
my_dog.name

.title()

13
Faz com que o valor do atributo comece com letra maiúscula.

Usamos o ponto para chamar o método para ser executado:

my_dog.sit()

Criando várias instâncias

Você pode criar tantas instâncias de uma classe quantas forem necessárias.

my_dog = Dog('willie', 6)
your_dog = Dog('lucy', 3)

Definindo um valor padrão para o atributo

Modificando valores de atributos

my_dog = Dog('willie', 6)
your_dog = Dog('lucy', 3)

Modificando o valor de um atributo com um método

def update_odometer(self, mileage):

self.odometer_reading = mileage

Herança

Exemplo:

class Cachorro(Animal): → Classe Cachorro herda da classe Animal

# Definir a superclasse Animal

class Animal:
# Construtor da superclasse
def __init__(self, nome, idade):

14
 self.nome = nome
self.idade = idade

# Método da superclasse
def fazer_som(self):
print(f"Eu sou um {self.nome} e eu faço som!")

# Definir a subclasse Cachorro que herda de Animal

class Cachorro(Animal):
# Construtor da subclasse
def __init__(self, nome, idade, raca):
# Chamar o construtor da superclasse
super().__init__(nome, idade)
self.raca = raca

# Sobrescrever o método da superclasse

def fazer_som(self):
print(f"Eu sou um {self.nome} da raça {self.raca} e eu faço au au!")

# Criar um objeto da subclasse

cachorro = Cachorro("Rex", 3, "Labrador")

# Acessar os atributos herdados

print(cachorro.nome)
print(cachorro.idade)

# Chamar o método sobrescrito

cachorro.fazer_som()

O f foi usado no início do print para que o valor da variável fosse interpolado com uso das chaves.

Dicionários com dicionários

# criando um dicionário com outros dicionários

dispositivos = {
"teclado": {
"marca": "Logitech",
"modelo": "K120"
},
"mouse": {
"marca": "Microsoft",
"modelo": "Basic Optical Mouse"
},
"impressora": {
"marca": "HP",

15
 "modelo": "DeskJet 2720"
}
}

# acessando valores dentro do dicionário

print(dispositivos["teclado"]["marca"]) # output: Logitech
print(dispositivos["mouse"]["modelo"]) # output: Basic Optical Mouse

Dicionários com listas

alfabeto = {
'a': ['Alice', 'Adam', 'Amanda'],
'b': ['Bob', 'Bill', 'Beth'],
'c': ['Charlie', 'Cathy', 'Chris']
}

print(alfabeto['a'][0])

Flag

Uma flag é um mecanismo que serve para controlar (interrompendo ou permitindo a execução de
alguns comandos) a "lógica" de um programa. Geralmente, atua como uma variável booleana
indicando que uma condição é verdadeira ou falsa.

Usando o while com flag e o comando input:

flag = True
while flag:
entrada = input("Digite algo: ")
if entrada == "sair":
flag = False
else:
print("Você digitou:", entrada)
print("Fim do programa!")

No exemplo, a flag é a variável flag. Ela é inicializada como True e o laço while é executado
enquanto a flag for True. Quando o usuário digita “sair”, a flag é definida como False e o laço while
é interrompido.

16
Criando gráficos com o Python parte 1

A visualização de dados envolve a exploração de dados por meio de representações visuais.

As pessoas usam Python para tarefas que trabalham intensamente com dados, como genética,
pesquisas sobre o clima, análises políticas e econômicas e muito mais.

Criar gráficos com Python é uma habilidade importante na área de ciência de dados. O Python
possui várias ferramentas para esta área de conhecimento.

A ciência de dados é uma área multidisciplinar que envolve a coleta, limpeza, análise e
interpretação de dados para obter insights (compreensão sobre algo) e tomar decisões.

Entre no site do replit.com. Crie um novo Repl e escolha a Linguagem Python. Dê um título ao
Repl e clique OK.

No painel esquerdo crie um arquivo chamado grafico1.py.

Abra o arquivo.

Na aba direita do Shell digite o seguinte comando: pip install --user matplotlib
Pressione enter para instalação da biblioteca.

Matplotlib

Vamos gerar um gráfico linear simples usando o matplotlib.

O matplotlib é uma biblioteca matemática para construção de gráficos.

Digite o seguinte código no arquivo grafico1.py:

import matplotlib.pyplot as plt

input_values = [1, 2, 3, 4, 5]

squares = [1, 4, 9, 16, 25]

plt.plot(input_values, squares, linewidth=5)

#Define o título do gráfico e nomeia os eixos

plt.title("Square numbers", fontsize=24)

plt.xlabel("Value", fontsize=14)

plt.ylabel("Square of Value", fontsize=14)

#Define o tamanho dos rótulos das marcações

17
plt.tick_params(axis='both', labelsize=14)

plt.savefig("grafico1.pdf")

Vamos entender o código acima.

Inicialmente importamos o módulo pyplot usando o alias plt para que não seja necessário digitar
pyplot repetidamente.

O módulo pyplot contém várias funções que ajudam a gerar gráficos.

A função plot() é uma das funções mais utilizadas da biblioteca matplotlib em Python. Ela é usada
para criar gráficos de linhas.

Criamos duas listas acima, uma com inteiros e outra com o quadrado destes inteiros e passamos
para função plot. O parâmetro linewidth controla a espessura da linha gerada por plot().

A função title() define um título para o gráfico. Os parâmetros fontsize, que aparecem
repetidamente pelo código, controlam o tamanho do texto no gráfico.

As funções xlabel() e ylabel() permitem definir um título para cada um dos eixos.

O parâmetro fontsize é usado para definir o tamanho da fonte do título que aparece nos eixos do
gráfico.

A função tick_params() estiliza os rótulos dos eixos x e y. Os argumentos mostrados aqui afetam o
eixo x quanto o eixo y (axes='both') e definem o tamanho da fonte dos rótulos das marcações com
14 (labelsize=14).

A função plt.savefig() é usada para salvar um gráfico gerado pela biblioteca matplotlib.

Execute o código.

Vamos ao segundo exercício. Crie o arquivo grafico2.py no replit:

import matplotlib.pyplot as plt

x_values = [1, 2, 3, 4, 5]

y_values = [1, 4, 9, 16, 25]

plt.scatter(x_values, y_values)

#Define o título do gráfico e nomeia os eixos

plt.title("Square numbers", fontsize=24)

plt.xlabel("Value", fontsize=14)

plt.ylabel("Square of Value", fontsize=14)

#Define o tamanho dos rótulos das marcações

18
plt.tick_params(axis='both', labelsize=14)

plt.savefig("grafico2.pdf")

Entendendo o código.

Utilizamos o mesmo código do outro exemplo só que usando o scatter.

Para imprimir pontos individuais, utilize a função scatter(). Passe o único par (x, y) do ponto em
que você estiver interessado para scatter(), e esse valor deverá ser plotado. Observe que o par de
valores em x e y define a posição dos pontos: (2-> posição do ponto no eixo x, 4-> posição do ponto
no eixo y).

Execute o código.

Pygal

O Pygal é uma biblioteca que gera gráficos em formato SVG (Scalable Vector Graphics), que são
vetoriais e escaláveis, o que significa que eles podem ser redimensionados sem perder qualidade.

Crie o arquivo grafico3.py.

Abra o Shell ao lado e instale a biblioteca Pygal com o comando: pip install --user pygal

ou %pip install pygal ou !pip install pygal==3.0.0

Pressione enter para instalar a biblioteca.

Digite no arquivo grafico3.py o seguinte código:

import pygal

bar_chart = pygal.Bar()

bar_chart.title = 'Vendas por mês - Ano 2023'

bar_chart.x_labels = [

'Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out',

'Nov', 'Dez'

bar_chart.add('Vendas', [5, 7, 8, 12, 15, 20, 22, 23, 18, 12, 6, 4])

bar_chart.render_to_file('grafico_colunas.svg')

Este código cria um gráfico de colunas que mostra as vendas por mês.

19
Vamos entender o código.

Na primeira linha importamos a biblioteca Pygal.

bar_chart = pygal.Bar()

Esta linha de código cria um objeto de gráfico de colunas. O objeto é armazenado na variável.

bar_chart.title = 'Vendas por mês - Ano 2023'

Esta linha de código define o título do gráfico como “Vendas por mês – Ano 2023”.

bar_chart.x_labels = [

'Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out',

'Nov', 'Dez'

Esta linha de código define os rótulos do eixo X do gráfico como os nomes dos meses.

bar_chart.add('Vendas', [5, 7, 8, 12, 15, 20, 22, 23, 18, 12, 6, 4])

Esta linha de código adiciona uma série de dados ao gráfico. A série é rotulada como “Vendas”.

bar_chart.render_to_file('grafico_colunas.svg')

Esta linha de código cria o gráfico em um arquivo chamado grafico_colunas.svg.

Execute o código.

Crie o arquivo grafico4.py e insira nele o seguinte código:

import pygal

# Crie um gráfico de colunas

bar_chart = pygal.Bar()

# Adicione dados ao gráfico

bar_chart.add('Mouse', [1450, 3500, 2500, 1000])

bar_chart.add('Teclado', [2000, 2500, 6500, 4300])

bar_chart.add('Monitor', [3000, 2000, 1000, 4000])

# Defina o título do gráfico

20
bar_chart.title = 'Vendas em (R$) do Primeiro Trimestre de 2024 - Mouse, Teclado, Monitor'

# Defina os rótulos do eixo x e y

bar_chart.x_labels = ['Janeiro', 'Fevereiro', 'Março', 'Abril']

bar_chart.y_labels = [0, 2000, 4000, 6000, 8000]

# Defina a legenda do eixo y

bar_chart.y_title = 'Vendas em R$'

# Renderize o gráfico em um arquivo SVG

bar_chart.render_to_file('grafico_colunas.svg')

No exemplo acima criamos um gráfico, porém com 3 colunas.

Definimos os dados das colunas do gráfico, rótulos, legenda e geramos um arquivo de imagem com
o resultado. Execute o arquivo Python e visualize o resultado.

Criando gráficos com o Python parte 2

Nesta parte do aprendizado aprenderemos a gerar gráficos importando dados de arquivos.

Crie no replit um arquivo chamado climajulho2014.csv com o seguinte conteúdo:

Data,Temperatura Máxima em °F
01/07/2014,64
02/07/2014,71
03/07/2014,64
04/07/2014,59
05/07/2014,69
06/07/2014,62
07/07/2014,61
08/07/2014,55
09/07/2014,57
10/07/2014,61
11/07/2014,57
12/07/2014,59
13/07/2014,57
14/07/2014,61
15/07/2014,64
16/07/2014,61
17/07/2014,59

21
18/07/2014,63
19/07/2014,60
20/07/2014,57
21/07/2014,69
22/07/2014,63
23/07/2014,62
24/07/2014,59
25/07/2014,57
26/07/2014,57
27/07/2014,61
28/07/2014,59
29/07/2014,61
30/07/2014,61
31/07/2014,66

Dica importante: ao criar o arquivo csv acima, evite linhas em branco no meio ou final do arquivo,
espaços em branco e caracteres especiais.

Crie agora o arquivo grafico5.py com o seguinte conteúdo:

import csv

import matplotlib.pyplot as plt

filename = 'climajulho2014.csv'

with open(filename) as f:

reader = csv.reader(f)

header_row = next(reader)

print(header_row)

Execute o arquivo e observe que a saída é o cabeçalho de nossa planilha.

Vamos entender o código.

O módulo csv permite extrair rapidamente os valores em que estivermos interessados de uma
planilha.

A variável filename aponta para o nome do arquivo.

with open(filename) as f: Abre o arquivo CSV e armazena seu conteúdo em um objeto de arquivo
chamado `f`.

22
reader = csv.reader(f): Cria um objeto reader que permite ler dados de um arquivo csv.

O objeto reader permite que você percorra sobre as linhas do arquivo CSV, retornando uma lista de
valores para cada linha.

O csv.reader em Python é uma função que permite ler dados de um arquivo csv.

Quando você chama a função next(reader), ela retorna a próxima linha do arquivo CSV.

Chamamos next() apenas uma vez para obter a primeira linha do arquivo, que contém os
cabeçalhos.

header_row = next(reader): Armazena a primeira linha do arquivo, que contém os cabeçalhos das
colunas.

print(reader_row): imprime o valor do cabeçalho das colunas.

Extraindo e lendo dados

A parte em negrito deve ser alterada no arquivo grafico5.py.

import csv

import matplotlib.pyplot as plt

filename = 'climajulho2014.csv'

with open(filename) as f:

reader = csv.reader(f)

header_row = next(reader)

highs = []

try:

for row in reader:

highs.append(row[1])

except IndexError as e:

print(f"Erro: {e} na linha {reader.line_num}")

23
print(highs)

Criamos uma lista vazia e adicionamos em um laço os valores da segunda coluna da planilha. Salve
o arquivo e depois execute o comando para rodar o código.

Ele exibe a lista de valores de temperatura.

No código fornecido, o loop for row in reader percorre cada linha do arquivo CSV que foi lido
usando a função reader do módulo csv.

A cada repetição do laço a variável row contém uma lista de valores para cada linha do arquivo
CSV.

O erro list index out of range ocorre quando você tenta acessar um índice inválido em uma
lista. Isso geralmente acontece quando você está tentando acessar um índice que não existe na
lista.

row[0] => equivale aos dados da primeira coluna do arquivo csv.

row[1] => equivale aos dados da segunda coluna do arquivo csv.

Um erro pode ocorrer na linha highs.append(row[1]). Isso pode acontecer se a linha atual não tiver
um valor na segunda coluna (índice 1). Por exemplo, se a linha (do arquivo csv) tiver apenas um
valor ou estiver vazia, você receberá esse erro.

O bloco try e except é uma construção em Python usada para lidar com exceções. Ele permite que
você tente executar um bloco de código e capture qualquer exceção que possa ocorrer durante a
execução desse bloco. O bloco try contém o código que pode gerar uma exceção, enquanto o bloco
except especifica o código a ser executado caso uma exceção seja lançada.

O erro IndexError é uma exceção em Python que ocorre quando você tenta acessar um índice
inválido em uma lista. IndexError é uma classe.

A linha except IndexError as e: captura essa exceção e atribui o objeto de exceção a uma variável
chamada e. Isso permite que você acesse informações adicionais sobre o erro, como a mensagem de
erro específica.

A variável e contém o objeto de exceção IndexError e reader.line_num contém o número da linha

atual durante a leitura do arquivo.

A linha print(f"Erro: {e} na linha {reader.line_num}") é responsável por imprimir uma mensagem
de erro caso ocorra um IndexError durante a leitura do arquivo CSV.

Execute o arquivo acima.

24
Gerando Relatórios

A parte em negrito deve ser alterada no arquivo grafico5.py.

import csv

import matplotlib.pyplot as plt

filename = 'climajulho2014.csv'

with open(filename) as f:

reader = csv.reader(f)

header_row = next(reader)

highs = []

try:

for row in reader:

highs.append(row[1])

except IndexError as e:

print(f"Erro: {e} na linha {reader.line_num}")

plt.plot(highs, c='red')

plt.title("Temperatura máxima por dia, Julho 2014", fontsize=20)

plt.xlabel('', fontsize=16)

plt.ylabel("Temperatura (ºF)", fontsize=16)

plt.tick_params(axis='both', labelsize=10)

25
plt.savefig("relatorioclima.pdf")

Salve e execute o arquivo. Abra o relatório gerado.

Passamos a lista de temperaturas máximas e pintamos a linha de vermelho em plt.plot(highs,

c='red').

Criando um Mapa e imprimindo dados no mapa

Instale no bash esta biblioteca: pip install pygal_maps_world

Vamos criar o arquivo grafico6.py com o seguinte conteúdo:

import pygal.maps.world

# Crie um mapa mundi

mapa_mundi = pygal.maps.world.World()

# Defina o título do mapa

mapa_mundi.title = 'População Mundial por País'

# Adicione dados ao mapa

mapa_mundi.add('Ásia', {'cn': 1376049000, 'in': 1293859294, 'jp': 126573481, 'bd':

152408774})

mapa_mundi.add('África', {'ng': 206139587, 'eg': 102334404, 'et': 114963588, 'za': 59622350})

mapa_mundi.add('Europa', {'ru': 144526636, 'de': 83783942, 'gb': 67886011, 'fr': 65273511})

mapa_mundi.add('América do Norte', {'us': 331449281, 'mx': 127318112, 'ca': 37742154})

mapa_mundi.add('América do Sul', {'br': 213993437, 'ar': 45376763, 'co': 50882884})

# Renderize o mapa

26
mapa_mundi.render_to_file('populacao_mundial.svg')

Baixe o arquivo svg, abra ele no navegador, e aponte para os países para ver os dados impressos
quando você aponta.

O Pygal tem um dicionário interno com as abreviaturas dos países.

O comando pygal.maps.world.World() é usado para criar um objeto de mapa mundial usando a

biblioteca Pygal. Este objeto é usado para imprimir dados em um mapa mundial. Você pode
especificar os países que deseja imprimir usando seus códigos de país.

Este comando define o título do mapa: mapa_mundi.title.

O método add adiciona um rótulo para cada continente, e os dados (vindo de um dicionário)
inserindo o número de população ao país específico.

Crie um gráfico do tipo pizza extraindo dados de um arquivo JSON

Crie o arquivo dados.json no replit com o seguinte conteúdo:

"venda": 1000,

"vendedor": "João"

},

"venda": 2000,

"vendedor": "Maria"

},

"venda": 3000,

"vendedor": "Pedro"

27
Crie o arquivo grafico7.py e digite o seguinte conteúdo:

import json

import matplotlib.pyplot as plt

# Carrega o arquivo JSON externo

with open('dados.json') as f:

dados = json.load(f)

# Extrai o valor da chave "venda" em cada dicionário

vendas = [d["venda"] for d in dados]

# Extrai o valor da chave "vendedor" em cada dicionário

vendedores = [d["vendedor"] for d in dados]

# Cria o gráfico de pizza

plt.pie(vendas, labels=vendedores, autopct='%.2f%%')

# Exibe o gráfico

plt.savefig("relatoriovendas.pdf")

A opção autopct='%.2f%%' exibe a porcentagem de venda de cada vendedor com duas casas
decimais.

28
Tratamento de exceções em Python

Exceções são erros que ocorrem em um programa. Tratamento de exceções é o mecanismo que
permite ao programa lidar com as exceções de forma controlada e evitar que o programa termine
abruptamente.

Podemos tratar os erros com os comandos: try, except e finally.

Digite o código abaixo, salve com o nome erro.py:

try:

# código que pode gerar uma exceção

x = int(input("Digite um número: "))

except ValueError:

# código que trata a exceção

print("Valor inválido")

finally:

# código que é executado sempre

print("Fim do programa")

Execute o mesmo no Shell. Se você digitar um número não há erro, se inserir um texto, o erro
ocorre.

A exceção “ValueError” acontece quando uma função recebe um argumento que está com um
valor inadequado.

29
Trabalhando com arquivos

Existem recursos no Python para abertura de arquivos em modo de gravação e modo de leitura.

Para trabalhar com arquivos em Python, você precisa usar a função open(), que recebe o nome do
arquivo e o modo de abertura (leitura, escrita, etc.).

No replit.com, onde ficam os arquivos, crie um arquivo chamado de teste.txt.

Digite no arquivo o texto dev. Salve o arquivo.

Digite o seguinte código e salve como leitura.py:

# abrir um arquivo para leitura

arquivo = open("teste.txt", "r")

# ler o conteúdo do arquivo

conteudo = arquivo.read()

# exibir o conteúdo do arquivo

print(conteudo)

# fechar o arquivo

arquivo.close()

Execute o arquivo acima e veja que a saída será o conteúdo do arquivo txt.

Agora iremos realizar uma alteração no arquivo gravando conteúdo nele.

Crie um arquivo como o nome de grava.py e digite nele o seguinte conteúdo:

# abrir um arquivo para escrita

arquivo = open("teste.txt", "w")

# escrever algo no arquivo

arquivo.write("Olá, mundo!")

# fechar o arquivo

arquivo.close()

# abrir o arquivo novamente para leitura

arquivo = open("teste.txt", "r")

# ler o conteúdo do arquivo

30
conteudo = arquivo.read()

# exibir o conteúdo do arquivo

print(conteudo)

# fechar o arquivo

arquivo.close()

Execute o arquivo acima e observe que o conteúdo dele foi modificado, pois gravamos algo nele.

Criando gráficos com o Python parte 3

Uma API web é uma parte de um sistema projetada para interagir com programas que usam URLs
bem específicos a fim de requisitar determinadas informações.

Esse tipo de requisição é conhecido como chamada de API.

Os dados solicitados serão devolvidos em formato JSON ou outros.

A maioria das aplicações que depende de fontes de dados externas, como aquelas que se integram a
sites de mídias sociais, contam com chamadas de API.

O pacote requests permite que um programa Python solicite facilmente informações a um site e
analise a resposta devolvida. Vamos acessar o replit e instalar esse pacote. No Shell execute o
comando como:

pip install --user requests

Depois de instalar, crie um arquivo chamado dadosapi.py e digite o seguinte código:

import requests

# latitude e longitude desejadas

latitude = -8.0522404

longitude = -34.9286096

# URL da API de clima

url = f"https://api.open-meteo.com/v1/forecast?
latitude={latitude}&longitude={longitude}&hourly=temperature_2m"

# Fazendo uma requisição GET para a URL

31
response = requests.get(url)

# Verificando se a requisição foi bem sucedida

if response.status_code == 200:

# Convertendo a resposta em JSON para um objeto Python

data = response.json()

# Exibindo os dados na tela

print(f"Latitude: {latitude}")

print(f"Longitude: {longitude}")

print(f"Temperatura: {data['hourly']['temperature_2m'][0]}°C")

else:

print('Ocorreu um erro ao fazer a requisição:', response.status_code)

Execute o código acima.

Este script usa a biblioteca requests do Python para fazer uma requisição GET para a API de clima
do Open-Meteo. Ele usa a latitude e longitude especificadas para construir a URL da API e, em
seguida, faz uma requisição GET para essa URL.

Se a requisição for bem sucedida, ele converte a resposta em um objeto Python usando o
método .json() e, em seguida, exibe algumas informações sobre o clima na localização especificada.

Vamos agora aprender a gerar um gráfico lendo os dados de uma API.

Digite o código abaixo e salve como dadosapi2.py:

import matplotlib.pyplot as plt

import requests

url = 'https://datausa.io/api/data?drilldowns=Nation&measures=Population'

response = requests.get(url)

data = response.json()['data']

32
pop_data = {}

for item in data:

year = str(item['Year'])

population = item['Population']

pop_data[year] = population

plt.bar(pop_data.keys(), pop_data.values())

plt.title('População dos Estados Unidos por Ano')

plt.xlabel('Ano')

plt.ylabel('População em milhões')

# rótulos do eixo y

for label in plt.gca().get_yticklabels():

text = float(label.get_text())/1000000

label.set_text(text)

# Adicione linhas horizontais para cada número no eixo y

for y in plt.gca().get_yticks():

plt.axhline(y, color='black', linestyle='dashed', linewidth=0.5)

plt.savefig("populacao.pdf")

Execute o código e abra o pdf exportado.

Entendendo o que foi feito:

`import requests`

A `requests` é uma biblioteca para fazer solicitações HTTP.

url = 'https://datausa.io/api/data?drilldowns=Nation&measures=Population'

Esta linha está definindo uma variável chamada url que contém a URL da API do DataUSA. Esta

33
URL é usada para acessar dados sobre a população dos Estados Unidos.

response = requests.get(url)

Esta linha está usando a função get() da biblioteca requests para fazer uma solicitação GET para a
URL especificada. A resposta da solicitação é armazenada na variável response.

data = response.json()['data']

Esta linha está convertendo a resposta da solicitação em um objeto JSON usando o método json().
Em seguida, ela está acessando o valor da chave 'data' desse objeto JSON e armazenando-o na
variável data. O valor da chave 'data' é uma lista de dicionários, onde cada dicionário contém dados
sobre a população dos Estados Unidos em um determinado ano.

pop_data = {}

Esta linha está criando um novo dicionário vazio chamado pop_data. Um dicionário é uma estrutura
de dados em Python que armazena pares de chave-valor.

for item in data:

Esta linha está iniciando um loop for que itera sobre cada item na lista data. Cada item é um
dicionário que contém dados sobre a população dos Estados Unidos em um determinado ano.

year = str(item['Year'])

Esta linha está acessando o valor da chave 'Year' no dicionário item e convertendo-o em uma string.
O resultado é armazenado na variável year.

population = item['Population']

Esta linha está acessando o valor da chave 'Population' no dicionário item e armazenando-o na
variável population.

pop_data[year] = population

Esta linha está adicionando um novo par de chave-valor ao dicionário pop_data. A chave é o ano e
o valor é a população correspondente.

`plt.bar(pop_data.keys(), pop_data.values())`

`plt.title('População dos Estados Unidos por Ano')`

`plt.xlabel('Ano')`

`plt.ylabel('População em milhões')`

Essas linhas estão criando um gráfico de barras da população ao longo do tempo. O título do gráfico
e os rótulos dos eixos x e y também são definidos.

O comando plt.bar(pop_data.keys(), pop_data.values()) está criando um gráfico de barras onde o

eixo x representa os anos e o eixo y representa as populações correspondentes a cada ano.

34
pop_data.keys(): Este método retorna as chaves do dicionário pop_data.
pop_data.values(): Este método retorna os valores do dicionário pop_data.

`for label in plt.gca().get_yticklabels():`

Este é um loop `for` que itera sobre cada rótulo do eixo y do gráfico atual. A variável `label` em
cada iteração do loop é um objeto de texto que representa um rótulo do eixo y.

`label.get_text()`

Este método retorna o texto do rótulo atual como uma string. Ele é usado para obter o valor
numérico do rótulo do eixo y como uma string.

`label.set_text(text)`

Este método define o texto do rótulo atual para a string fornecida como argumento. Ele é usado para
atualizar o texto do rótulo do eixo y com a string formatada.

for y in plt.gca().get_yticks():

Esta linha está iniciando um loop for que itera sobre cada valor no eixo y do gráfico atual. Portanto,
a variável y em cada iteração do loop é um valor no eixo y.

plt.axhline(y, color='black', linestyle='dashed', linewidth=0.5)

Esta linha está desenhando uma linha horizontal no gráfico para cada valor no eixo y. A função
axhline() do matplotlib é usada para desenhar uma linha horizontal. O primeiro argumento é a
posição y da linha horizontal, que neste caso é o valor atual do eixo y. Os argumentos subsequentes
especificam a cor, o estilo da linha e a largura da linha.

`plt.savefig("populacao.pdf")`

Esta linha está salvando o gráfico como um arquivo PDF chamado "populacao.pdf".

35