1  Breve introdução ao Python

Aqui faremos uma breve introdução ao Python. Para uma introdução mais detalhada, você pode explorar: - Documentação Oficial do Python - Real Python

1.1 Variáveis e Tipos de Dados

Em Python, variáveis são usadas para armazenar informações que podem ser manipuladas ao longo do código. Existem diferentes tipos de dados que podem ser atribuídos a uma variável. Vamos explorar os principais tipos básicos em Python: int, float, str, bool, e None.

## Exemplo de variáveis e tipos de dados
nome = "Thiago"              ## String
idade = 35                   ## Inteiro (int)
saldo_bancario = 1023.75      ## Float
estudante = True              ## Booleano (bool)
endereco = None               ## None, indicando ausência de valor

## Usando o método .format() para formatar a string
print("Nome: {} (Tipo: {})".format(nome, type(nome)))
print("Idade: {} (Tipo: {})".format(idade, type(idade)))
print("Saldo Bancário: {} (Tipo: {})".format(saldo_bancario, type(saldo_bancario)))
print("Estudante: {} (Tipo: {})".format(estudante, type(estudante)))
print("Endereço: {} (Tipo: {})".format(endereco, type(endereco)))

Nome: Thiago (Tipo: <class 'str'>)
Idade: 35 (Tipo: <class 'int'>)
Saldo Bancário: 1023.75 (Tipo: <class 'float'>)
Estudante: True (Tipo: <class 'bool'>)
Endereço: None (Tipo: <class 'NoneType'>)

1.1.1 f-strings: Formatação de Strings em Python (*)

Introduzidas na versão Python 3.6, as f-strings (ou “formatted string literals”) são uma forma eficiente e legível de formatar strings, permitindo a inclusão de expressões e variáveis diretamente dentro de uma string.

A sintaxe das f-strings utiliza a letra f antes da string e permite a inclusão de expressões dentro de chaves {}. Essas expressões são avaliadas em tempo de execução, e seus resultados são inseridos na string.

## Usando f-strings para formatar a string
print(f"Nome: {nome} (Tipo: {type(nome)})")
print(f"Idade: {idade} (Tipo: {type(idade)})")
print(f"Saldo Bancário: {saldo_bancario} (Tipo: {type(saldo_bancario)})")
print(f"Estudante: {estudante} (Tipo: {type(estudante)})")
print(f"Endereço: {endereco} (Tipo: {type(endereco)})")

Nome: Thiago (Tipo: <class 'str'>)
Idade: 35 (Tipo: <class 'int'>)
Saldo Bancário: 1023.75 (Tipo: <class 'float'>)
Estudante: True (Tipo: <class 'bool'>)
Endereço: None (Tipo: <class 'NoneType'>)

1.2 O Comando help() em Python

Python possui uma função embutida chamada help(), que é muito útil para obter informações sobre funções, módulos, objetos, e classes. Ele fornece uma explicação detalhada de como determinado elemento funciona, quais parâmetros aceita e o que retorna, entre outros detalhes. Essa função é especialmente útil quando você está começando ou precisa de uma rápida referência sem ter que sair do ambiente de desenvolvimento.

help(len)

Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.

def exemplo():
    """Esta é uma função de exemplo."""
    pass

help(exemplo)

Help on function exemplo in module __main__:

exemplo()
    Esta é uma função de exemplo.

1.3 Armazenando Resultados em Variáveis

Em Python, as variáveis são usadas para armazenar resultados de cálculos ou operações para uso posterior no código. Ao armazenar um valor em uma variável, você pode acessá-lo facilmente quando precisar, sem ter que repetir o cálculo ou operação.

Quando você atribui um valor ou resultado de uma operação a uma variável, o Python guarda esse valor na memória e o associa ao nome que você escolheu para a variável. Isso permite que você reutilize o valor sempre que necessário.

resultado = 5 + 3  ## Armazenando a soma de 5 e 3 em uma variável
print(resultado)    ## Resultado: 8

8

x = 2 + 3
print(x)

5

y = 2 * x
y

10

1.4 Variáveis Lógicas

Python, assim como R, possui operadores lógicos para comparar valores e trabalhar com variáveis booleanas. Abaixo estão alguns dos principais operadores lógicos usados em Python:

##	Operador	Descrição
1	x < y	x é menor que y?
2	x <= y	x é menor ou igual a y?
3	x > y	x é maior que y?
4	x >= y	x é maior ou igual a y?
5	x == y	x é igual a y?
6	x != y	x é diferente de y?
7	not x	Negativa de x (inverte o valor lógico)
8	x or y	x ou y são verdadeiros? (ou inclusivo)
9	x and y	x e y são verdadeiros? (e lógico)
10	x ^ y	x ou y, mas não ambos, são verdadeiros? (xor lógico)

a = 5
b = 10
print(a < b)  ## True
print(a == b)  ## False

True
False

x = True
print(not x)  ## False

False

x = False
y = True
print(x or y)  ## True

True

x = True
y = False
print(x and y)  ## False

False

x = True
y = False
print(x ^ y)  ## True (apenas um dos dois é verdadeiro)

True

1.4.1 Cuidado!

Em Python, o operador ^ não é usado para exponenciação. Em vez disso, ele é o operador bitwise XOR (ou exclusivo) para manipulação de bits.

O operador XOR (ou exclusivo) compara os bits de dois números. Ele retorna 1 quando os bits são diferentes e 0 quando os bits são iguais.

a = 5   ## Em binário: 101
b = 3   ## Em binário: 011

resultado = a ** b  ## Faz XOR bit a bit

print(resultado)  ## Saída: 6 (Em binário: 110)

125

a = 5   ## Em binário: 101
b = 3   ## Em binário: 011

resultado = a ^ b  ## Faz XOR bit a bit

print(resultado)  ## Saída: 6 (Em binário: 110)

6

1.5 Caracteres/Strings em Python

Em Python, uma string é uma sequência de caracteres que pode ser usada para armazenar e manipular textos. Strings são um dos tipos de dados mais comuns e úteis, e Python oferece uma grande variedade de métodos e operações para trabalhar com elas.

As strings em Python podem ser definidas de diferentes maneiras, usando aspas simples (’) ou aspas duplas (“).

## Definindo strings
nome = 'Thiago'
cidade = "São Carlos"

• Concatenar Strings: Você pode unir duas ou mais strings usando o operador +.

## Concatenação
nome_completo = "Thiago" + " " + "Rodrigo"
print(nome_completo)  ## Resultado: Thiago Rodrigo

Thiago Rodrigo

• Repetir Strings: Você pode repetir uma string múltiplas vezes usando o operador *.

repeticao = "Oi! " * 3
print(repeticao)  ## Resultado: Oi! Oi! Oi! 

Oi! Oi! Oi! 

• Acessar Caracteres por Índice: As strings em Python são indexadas, e você pode acessar um caractere específico usando o índice (começando em 0).

nome = "Thiago"
print(nome[0])  ## Resultado: T
print(nome[-1])  ## Resultado: o (último caractere)

T
o

• Fatiar Strings (Slicing): Você pode pegar uma parte da string usando fatias (substrings).

nome = "Thiago"
print(nome[0:3])  ## Resultado: Thi (caracteres do índice 0 ao 2)

Thi

• Comprimento de Strings: Para saber quantos caracteres uma string tem, use a função len().

nome = "Thiago"
print(len(nome))  ## Resultado: 6

6

1.5.1 Métodos Úteis para Strings

• lower() e upper(): Convertem todas as letras para minúsculas ou maiúsculas, respectivamente.

nome = "Thiago"
print(nome.lower())  ## Resultado: thiago
print(nome.upper())  ## Resultado: THIAGO

thiago
THIAGO

• strip(): Remove espaços em branco no início e no final da string.

frase = "   Olá!   "
print(frase.strip())  ## Resultado: Olá!

Olá!

• replace(): Substitui parte de uma string por outra.

frase = "Eu gosto de R"
nova_frase = frase.replace("R", "Python")
print(nova_frase)  ## Resultado: Eu gosto de programação

Eu gosto de Python

• split(): Divide uma string em uma lista, utilizando um delimitador (por padrão, espaço).

frase = "Eu gosto de Python"
palavras = frase.split()
print(palavras)  ## Resultado: ['Eu', 'gosto', 'de', 'Python']

['Eu', 'gosto', 'de', 'Python']

• join(): Une uma lista de strings em uma única string, usando um delimitador.

lista = ['Thiago', 'Rodrigo', 'Ramos']
nome_completo = " ".join(lista)
print(nome_completo)  ## Resultado: Thiago Rodrigo Ramos

Thiago Rodrigo Ramos

1.6 Listas

Em Python, listas são coleções ordenadas e mutáveis, o que significa que você pode modificar os elementos após sua criação. Elas são definidas usando colchetes [] e podem armazenar múltiplos tipos de dados, como inteiros, strings ou até mesmo outras listas.

Características principais:

• Mutáveis: você pode adicionar, remover ou modificar elementos.
• Ordenadas: os elementos mantêm a ordem em que são inseridos.
• Acesso por índice: os elementos podem ser acessados pelo índice, começando por 0.

## Criando uma lista
frutas = ['maçã', 'banana', 'laranja']

## Acessando elementos
print(frutas[1])  ## banana

## Modificando a lista
frutas.append('uva')  ## Adiciona 'uva' ao final
frutas[0] = 'kiwi'    ## Substitui 'maçã' por 'kiwi'

## Removendo um elemento
frutas.remove('banana')

print(frutas)  ## ['kiwi', 'laranja', 'uva']

banana
['kiwi', 'laranja', 'uva']

1.7 Tuplas

As tuplas em Python são semelhantes às listas, porém, diferentemente das listas, são imutáveis, ou seja, seus elementos não podem ser modificados após a criação. Elas são úteis quando você deseja garantir que uma sequência de valores permaneça inalterada. As tuplas são definidas usando parênteses (). Características principais:

• Imutáveis: uma vez criadas, seus elementos não podem ser alterados, adicionados ou removidos.
• Ordenadas: os elementos mantêm a ordem de inserção.
• Acesso por índice: assim como nas listas, os elementos podem ser acessados por índices, começando do 0.

## Criando uma tupla
coordenadas = (10, 20)

## Acessando elementos
print(coordenadas[0])  ## 10


## Tuplas podem armazenar diferentes tipos de dados
dados = ('Thiago', 30, True)

print(dados)  ## ('Thiago', 30, True)

10
('Thiago', 30, True)

### Tentando modificar a tupla (resultará em erro)
## coordenadas[0] = 15  # TypeError: 'tuple' object does not support item assignment

1.8 Dicionários

Os dicionários em Python são coleções não ordenadas de pares chave-valor. Eles permitem associar valores a uma chave específica, sendo muito úteis quando você precisa acessar elementos por meio de uma chave, em vez de um índice. Eles são definidos com chaves {}.

Características principais:

• Mutáveis: você pode adicionar, remover ou modificar pares chave-valor.
• Não ordenados: a ordem dos elementos não é garantida nas versões anteriores ao Python 3.7.
• Acesso por chave: os valores são acessados por suas chaves, que podem ser de tipos imutáveis (como strings ou números).

## Criando um dicionário
estudante = {
    'nome': 'Ana',
    'idade': 22,
    'curso': 'Estatística'
}

## Acessando valores
print(estudante['nome'])  ## Ana

## Modificando o dicionário
estudante['idade'] = 23  ## Atualiza o valor da chave 'idade'

## Adicionando um novo par chave-valor
estudante['matricula'] = 12345

## Removendo um elemento
del estudante['curso']

print(estudante)  ## {'nome': 'Ana', 'idade': 23, 'matricula': 12345}

Ana
{'nome': 'Ana', 'idade': 23, 'matricula': 12345}

1.9 Funções em Python

As funções em Python são blocos de código reutilizáveis que realizam uma tarefa específica. Elas ajudam a organizar o código, tornando-o mais modular e legível. Você pode definir suas próprias funções usando a palavra-chave def, e elas podem receber parâmetros, retornar valores ou simplesmente executar uma ação. Características principais:

• Reutilizáveis: uma vez definida, a função pode ser chamada várias vezes no código.
• Modulares: permitem dividir o código em partes menores e mais organizadas.
• Parâmetros opcionais ou obrigatórios: funções podem receber parâmetros (ou argumentos) para realizar operações com base neles.

def saudacao(nome):
    """Exibe uma saudação personalizada."""
    print(f"Olá, {nome}!")

## Chamando a função
saudacao("Thiago")  ## Olá, Thiago!

Olá, Thiago!

1.9.1 Return

Funções podem retornar valores usando a palavra-chave return. Isso permite que o resultado da função seja usado em outras partes do código.

def soma(a, b):
    """Retorna a soma de dois números."""
    return a + b

resultado = soma(3, 5)
print(resultado)  ## 8

8

1.9.2 Parâmetros Opcionais e Valores Padrão

Você pode definir parâmetros opcionais em uma função, atribuindo valores padrão a eles.

def saudacao(nome="amigo"):
    """Exibe uma saudação personalizada, com um nome padrão."""
    print(f"Olá, {nome}!")

saudacao()         ## Olá, amigo!
saudacao("Rafael")  ## Olá, Rafael!

Olá, amigo!
Olá, Rafael!

1.9.3 Lambda

Python também oferece funções anônimas (ou funções lambda), que são funções curtas e sem nome. Elas são úteis quando você precisa de uma função simples e temporária.

## Função lambda para multiplicar dois números
multiplicar = lambda x, y: x * y
print(multiplicar(3, 4))  ## 12

12

1.10 Loops

Os loops são estruturas fundamentais de programação que permitem executar um bloco de código repetidamente enquanto uma condição for verdadeira ou para cada item de uma sequência. Python oferece dois tipos principais de loops: for e while.

1.10.1 for

O loop for é usado para iterar sobre uma sequência (como uma lista, tupla, string ou range) e executar um bloco de código para cada item dessa sequência. É especialmente útil quando o número de iterações é conhecido ou quando você deseja percorrer uma estrutura de dados.

## Iterando sobre uma lista
frutas = ['maçã', 'banana', 'laranja']
for fruta in frutas:
    print(fruta)

maçã
banana
laranja

## Iterando de 0 a 4
for i in range(5):
    print(i)

0
1
2
3
4

frutas = ['maçã', 'banana', 'laranja']
for i, fruta in enumerate(frutas):
    print(i, fruta)

0 maçã
1 banana
2 laranja

1.10.2 while

O loop while executa um bloco de código repetidamente enquanto uma condição for verdadeira. Ele é útil quando o número de iterações não é conhecido antecipadamente e depende de uma condição dinâmica.

## Loop enquanto o valor de x for menor que 5
x = 0
while x < 5:
    print(x)
    x += 1

0
1
2
3
4

1.10.3 Controle de Loops: break e continue

break: interrompe o loop imediatamente, mesmo que a condição ainda seja verdadeira (no caso do while) ou ainda restem itens na sequência (no caso do for).

continue: pula para a próxima iteração do loop, ignorando o código restante naquela iteração.

for i in range(10):
    if i == 5:
        break  ## Interrompe o loop quando i é igual a 5
    print(i)

0
1
2
3
4

for i in range(5):
    if i == 3:
        continue  ## Pula a iteração quando i é igual a 3
    print(i)

0
1
2
4

1.11 Estruturas Condicionais: if, else e elif em Python

As estruturas condicionais em Python permitem que o programa tome decisões e execute blocos de código diferentes com base em condições específicas. As principais instruções condicionais são if, else e elif.

1.11.1 if

A instrução if é usada para executar um bloco de código se uma condição for verdadeira. Se a condição avaliada for True, o bloco de código indentado após o if será executado.

idade = 20
if idade >= 18:
    print("Você é maior de idade")

Você é maior de idade

1.11.2 else

A instrução else é usada para executar um bloco de código se a condição do if for falsa. É como uma segunda opção, caso a primeira condição não seja atendida.

idade = 16
if idade >= 18:
    print("Você é maior de idade")
else:
    print("Você é menor de idade")

Você é menor de idade

1.11.3 elif

A instrução elif (abreviação de else if) permite testar múltiplas condições. Se a condição if for falsa, o Python verificará a condição do elif. Você pode ter vários blocos elif em uma estrutura condicional.

nota = 85
if nota >= 90:
    print("Aprovado com excelência")
elif nota >= 70:
    print("Aprovado")
else:
    print("Reprovado")

Aprovado

1.11.4 Operadores lógicos

As condições podem usar operadores lógicos para combinar mais de uma verificação:

• and: todas as condições devem ser verdadeiras.
• or: pelo menos uma condição deve ser verdadeira.
• not: inverte o resultado da condição.

idade = 20
possui_carteira = True

if idade >= 18 and possui_carteira:
    print("Você pode dirigir")
else:
    print("Você não pode dirigir")

Você pode dirigir

1.12 Bibliotecas Essenciais para Estatística: NumPy, Pandas e Matplotlib

Em Python, as bibliotecas NumPy, Pandas, e Matplotlib são amplamente utilizadas para análise de dados e computação científica. Elas fornecem ferramentas poderosas para lidar com grandes volumes de dados, realizar cálculos matemáticos eficientes e criar visualizações de alta qualidade. Vamos detalhar cada uma delas:

1.12.1 NumPy

NumPy (Numerical Python) é uma biblioteca fundamental para cálculos matemáticos em Python. Ela fornece suporte para arrays e matrizes multidimensionais, além de uma coleção de funções para operações com esses arrays. Principais características:

• Array multidimensional (ndarray): O ndarray é a estrutura central da NumPy, oferecendo suporte a vetores e matrizes de várias dimensões, com operações eficientes em termos de memória e tempo de execução.
• Operações vetorizadas: Permite realizar operações em todos os elementos de um array sem a necessidade de loops explícitos.
• Funções matemáticas: Inclui uma vasta gama de funções para álgebra linear, estatística, trigonometria, entre outros.

import numpy as np

## Criando um array NumPy
array = np.array([1, 2, 3, 4, 5])

## Operações elementares
print(array * 2)  ## Multiplicação por escalar: [2 4 6 8 10]

## Matrizes e operações matriciais
matriz = np.array([[1, 2], [3, 4]])
print(np.dot(matriz, matriz))  ## Multiplicação de matrizes

[ 2  4  6  8 10]
[[ 7 10]
 [15 22]]

dados = np.array([1, 2, 3, 4, 5])
media = np.mean(dados)
print(media)  ## Saída: 3.0

3.0

mediana = np.median(dados)
print(mediana)  ## Saída: 3.0

3.0

variancia = np.var(dados)
print(variancia)  ## Saída: 2.0

2.0

desvio_padrao = np.std(dados)
print(desvio_padrao)  ## Saída: 1.4142135623730951

1.4142135623730951

minimo = np.min(dados)
maximo = np.max(dados)
print(minimo, maximo)  ## Saída: 1 5

1 5

p25 = np.percentile(dados, 25)
p50 = np.percentile(dados, 50)
p75 = np.percentile(dados, 75)
print(p25, p50, p75)  ## Saída: 2.0 3.0 4.0

2.0 3.0 4.0

1.12.2 Pandas

Pandas é uma biblioteca poderosa para manipulação de dados em Python, frequentemente usada em projetos de ciência de dados, análise estatística e processamento de dados tabulares. Ela oferece estruturas de dados como DataFrames e Series que facilitam a organização, limpeza e análise de dados, tornando-a uma das ferramentas mais populares para lidar com grandes volumes de dados.

1.12.2.1 Séries

Uma Series é uma coluna de dados unidimensional, semelhante a um array de NumPy, mas com rótulos (índices) associados a cada valor. A Series pode armazenar qualquer tipo de dado, como inteiros, floats, strings, ou objetos.

import pandas as pd

## Criando uma Series
s = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
print(s)

## Acessando elementos por índice
print(s['b'])  ## Saída: 2

a    1
b    2
c    3
d    4
e    5
dtype: int64
2

1.12.2.2 DataFrame

O DataFrame é a estrutura de dados mais importante do Pandas. Ele é uma tabela bidimensional (semelhante a uma planilha ou tabela SQL) com rótulos para as linhas e colunas. Cada coluna de um DataFrame é uma Series, e as colunas podem ter diferentes tipos de dados.

## Criando um DataFrame a partir de um dicionário
dados = {
    'Nome': ['Ana', 'Pedro', 'João'],
    'Idade': [23, 34, 19],
    'Cidade': ['São Paulo', 'Rio de Janeiro', 'Curitiba']
}

df = pd.DataFrame(dados)
print(df)

    Nome  Idade          Cidade
0    Ana     23       São Paulo
1  Pedro     34  Rio de Janeiro
2   João     19        Curitiba

1.12.2.3 Operações Essenciais com DataFrames

1. Selecionar Colunas
2. Filtragem de Dados
3. Alteração de Dados
4. Agrupamento e Agregação
5. Tratamento de Dados Faltantes

## Selecionando uma única coluna
print(df['Nome'])

0      Ana
1    Pedro
2     João
Name: Nome, dtype: object

## Selecionando múltiplas colunas
print(df[['Nome', 'Cidade']])

    Nome          Cidade
0    Ana       São Paulo
1  Pedro  Rio de Janeiro
2   João        Curitiba

## Filtrando o DataFrame para mostrar apenas pessoas com mais de 20 anos
filtro = df[df['Idade'] > 20]
print(filtro)

    Nome  Idade          Cidade
0    Ana     23       São Paulo
1  Pedro     34  Rio de Janeiro

## Alterando o valor de uma célula
df.loc[0, 'Idade'] = 24
## Alterando uma coluna inteira
df['Idade'] = df['Idade'] + 1

## Agrupando por 'Cidade' e calculando a média de 'Idade'
agrupado = df.groupby('Cidade')['Idade'].mean()
print(agrupado)

Cidade
Curitiba          20.0
Rio de Janeiro    35.0
São Paulo         25.0
Name: Idade, dtype: float64

## Verificando valores faltantes
print(df.isnull().sum())

## Removendo linhas com dados faltantes
df_limpo = df.dropna()

## Preenchendo valores faltantes
df['Idade'].fillna(df['Idade'].mean())

Nome      0
Idade     0
Cidade    0
dtype: int64

0    25
1    35
2    20
Name: Idade, dtype: int64

1.12.2.4 Estatísticas e Operações com Dados

Pandas facilita o cálculo de estatísticas descritivas, como média, desvio padrão, contagem, entre outras.

## Estatísticas descritivas
print(df.describe())

           Idade
count   3.000000
mean   26.666667
std     7.637626
min    20.000000
25%    22.500000
50%    25.000000
75%    30.000000
max    35.000000

## Soma, contagem e média de colunas específicas
print(df['Idade'].sum())
print(df['Idade'].count())
print(df['Idade'].mean())

80
3
26.666666666666668

1.12.3 Matplotlib: Biblioteca de Visualização de Dados em Python

Matplotlib é uma biblioteca poderosa e flexível para visualização de dados em Python. Ela permite criar uma ampla gama de gráficos, desde simples gráficos de linha até visualizações complexas e altamente customizadas. Embora outras bibliotecas como Seaborn ou Plotly sejam populares para visualizações avançadas, Matplotlib continua sendo o núcleo para muitas dessas bibliotecas e é amplamente utilizado por sua versatilidade e integração com NumPy e Pandas.

A maneira mais comum de usar Matplotlib é através do submódulo pyplot, que fornece uma interface simples para criar gráficos. A estrutura básica de um gráfico com pyplot envolve definir os dados e criar o gráfico com funções que controlam o comportamento do gráfico.

import matplotlib.pyplot as plt

## Dados
x = [0, 1, 2, 3, 4]
y = [0, 1, 4, 9, 16]

## Criando um gráfico de linha
plt.plot(x, y)

## Adicionando título e rótulos aos eixos
plt.title('Gráfico de Quadrados')
plt.xlabel('Eixo X')
plt.ylabel('Eixo Y')

## Exibindo o gráfico
plt.show()

1.12.3.1 Tipos de Gráficos Comuns

1.12.3.1.1 Linha

x = [0, 1, 2, 3, 4]
y = [0, 1, 4, 9, 16]
plt.plot(x, y)
plt.title('Gráfico de Linha')
plt.show()

1.12.3.1.2 Dispersão

plt.scatter(x, y)
plt.title('Gráfico de Dispersão')
plt.show()

1.12.3.1.3 Barras

categorias = ['A', 'B', 'C']
valores = [5, 7, 3]
plt.bar(categorias, valores)
plt.title('Gráfico de Barras')
plt.show()

1.12.3.1.4 Histograma

import numpy as np

dados = np.random.randn(1000)
plt.hist(dados, bins=30, color='skyblue', edgecolor='black')
plt.title('Histograma de Dados Aleatórios')
plt.show()

1.12.3.1.5 Pizza

tamanhos = [15, 30, 45, 10]
labels = ['A', 'B', 'C', 'D']
plt.pie(tamanhos, labels=labels, autopct='%1.1f%%')
plt.title('Gráfico de Pizza')
plt.show()

1.12.3.2 Customização

1.12.3.2.1 Alterando Cores e Estilos de Linha

plt.plot(x, y, color='red', linestyle='--', marker='o')  ## Linha vermelha com marcador
plt.title('Gráfico Customizado')
plt.show()

1.12.3.2.2 Adicionando Títulos e Rótulos aos Eixos

plt.plot(x, y)
plt.title('Título do Gráfico')
plt.xlabel('Eixo X')
plt.ylabel('Eixo Y')
plt.show()

1.12.3.2.3 Legendas

plt.plot(x, y, label='Quadrados')
plt.plot(x, [i**3 for i in x], label='Cubos')
plt.title('Gráfico com Legenda')
plt.legend()  ## Adiciona legenda
plt.show()

1.12.3.2.4 Ajustando os Eixos

plt.plot(x, y)
plt.xlim(0, 5)
plt.ylim(0, 20)
plt.title('Ajuste de Eixos')
plt.show()

1.12.3.2.5 Subplot

## Criando uma figura com dois gráficos lado a lado
plt.figure(figsize=(10, 4))

plt.subplot(1, 2, 1)  ## 1 linha, 2 colunas, 1º gráfico
plt.plot(x, y)
plt.title('Gráfico de Linha')

plt.subplot(1, 2, 2)  ## 1 linha, 2 colunas, 2º gráfico
plt.bar(categorias, valores)
plt.title('Gráfico de Barras')

plt.tight_layout()
plt.show()

1.12.3.3 Integração com Pandas

import pandas as pd

## Criando um DataFrame
dados = {
    'Dia': [1, 2, 3, 4, 5],
    'Vendas': [200, 300, 250, 400, 350]
}
df = pd.DataFrame(dados)

## Plotando os dados
df.plot(x='Dia', y='Vendas', kind='line')
plt.title('Vendas ao Longo dos Dias')
plt.show()

1.13 Exercícios

1.13.1 Exercício 1.

Execute as seguintes operações no Python e interprete os resultados:

• Use a função math.log() para calcular o logaritmo natural de 10 e depois o logaritmo na base 10 de 1000.
• Descubra a função que calcula a raiz quadrada de um número utilizando a função help(), e aplique-a ao número 144.

1.13.2 Exercício 2.

Armazene o resultado de 2 * 7 em uma variável chamada resultado. Use resultado para calcular o valor de resultado ** 2.

Liste todas as variáveis no ambiente do Python usando a função globals(). Exclua a variável resultado usando del e verifique novamente as variáveis presentes.

1.13.3 Exercício 3.

Crie um vetor NumPy v contendo os números 4, 8, 15, 16, 23, 42. Use subsetting para selecionar: - O segundo e o quarto elemento. - Todos os elementos exceto o terceiro. - Os elementos que são maiores que 10.

Multiplique cada elemento do vetor NumPy v por 2 e armazene o resultado em um novo vetor v2.

1.13.4 Exercício 4.

Verifique se 8 > 5 e se 8 == 10.

Crie dois vetores NumPy lógicos a = np.array([True, False, True]) e b = np.array([False, True, False]). Aplique os operadores &, | e np.logical_xor() nesses vetores.

1.13.5 Exercício 5.

Escreva uma função soma_quadrados que receba dois números como argumentos e retorne a soma de seus quadrados. Teste sua função com os números 3 e 4.

Modifique a função soma_quadrados para que o segundo argumento tenha um valor padrão de 2. Teste a função chamando-a com apenas um argumento.

1.13.6 Exercício 6.

Escreva um laço for que calcule a soma dos números de 1 a 100.

Crie um laço while que multiplique os números de 1 a 6 e retorne o resultado.

1.13.7 Exercício 7.

Crie duas variáveis com o seu primeiro e último nome. Use a função f-string para juntar as duas variáveis em uma frase que diga “Meu nome completo é [nome completo]”.

Altere o separador para um traço - e junte novamente as variáveis.

1.13.8 Exercício 8.

Crie um DataFrame com os dados fictícios a seguir utilizando pandas:

Nome	Idade	Cidade
Ana	23	São Paulo
Pedro	34	Rio de Janeiro
João	19	Curitiba

Filtre as observações onde a idade é maior que 20.

Ordene o DataFrame pela coluna Idade em ordem decrescente.

1.13.9 Exercício 9.

Usando o DataFrame criado no exercício anterior, crie um gráfico de barras (plt.bar) que mostre a idade de cada pessoa.

No gráfico anterior, mude a cor de cada barra.

1.13.10 Exercício 10.

Crie um DataFrame com os dados de temperatura de uma semana:

Dia	Temperatura (°C)
Seg	22
Ter	24
Qua	19
Qui	21
Sex	23
Sáb	25
Dom	20

Agora, responda às perguntas abaixo:

1. Filtre todos os dias em que a temperatura foi maior que 21°C.
2. Calcule a média das temperaturas da semana.
3. Crie um gráfico de linha (plt.plot) que mostre a variação da temperatura ao longo da semana.