Python para Iniciantes
Carregando, aguarde alguns segundos.

6 - Bibliotecas e Frameworks

O Python conta com um extenso conjunto de pacotes de bibliotecas e frameworks, que podem estar integrados no Python, serem instalados ou personalizados pelos desenvolvedores.

Os pacotes são módulos em arquivos Python que podem ser importados e reutilizadas em outros programas, contendo outros módulos como funções, classes e variáveis.

As bibliotecas são pacotes contendo atributos e métodos mais simplificados, como as funções matemáticas que não dependem umas das outras e gráficos que podem ser utilizados em diversas áreas.

Por exemplo podemos importar o pacote math de matemática que contém muitas funcionalidades matemáticas. 

import math
# Raiz quadrada de 25
print(math.sqrt(25))   # Saída: 5.0

Podemos importar apenas o método sqrt() do pacote math. 

from math import sqrt
# Raiz quadrada de 25
print(sqrt(25)) # Saída: 5.0

Tanto o pacote quanto seus atributos, métodos e funções são módulos que podem ser importados e utilizados em programas.

Os frameworks são pacotes mais especializados, realizando tarefas de maior complexidade, em que seus atributos e métodos são bastante relacionados uns aos outros e sua funcionalidade é mais extensa.

Por exemplo, o framework estatístico Scikit-Learnutiliza de um conjunto de procedimentos e métodos para realizar tarefas de aprendizado de máquina. 

import sklearn
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

# Carrega os dados do vinho
wine = load_wine()

# Separa os dados em treino e teste
dados_treino, dados_teste, alvos_treino, alvos_teste = train_test_split(wine.data, wine.target, test_size=0.2)

# Treina o modelo
modelo = LinearRegression()
modelo.fit(dados_treino, alvos_treino)

# Faz previsões para os dados de teste
alvos_previstos = modelo.predict(dados_teste)

# Avalia o desempenho do modelo
print('R2:', modelo.score(dados_teste, alvos_teste))

Também existe pacotes completos para uma determinada atividade, como os para servidores-web, produzidos sobre a plataforma do Django ou do Flask, mais leve.

Os pacotes personalizados são aqueles desenvolvidos pelos programadores dos projetos.

Ao dominar funções e módulos, você estará construindo uma base sólida para desenvolver programas mais complexos e funcionais.

A programação é uma habilidade prática, então não hesite em experimentar, criar seus próprios com atributos, funções e classes, explorando os módulos para ampliar suas habilidades com Python.

Python conta com uma biblioteca padrão robusta de pacotes de códigos que inclui uma variedade de módulos para realizar tarefas comuns, eque você pode expandir instalando nonvos pacotes e criando os seus.

6.1 - Pacotes Integrados

Módulos básicos, chamados módulos integrados, são disponibilizados na instalação padrão do Python.

Embora estes módulos sejam nativos do Python, precisam ser importados para serem utilizados. Assim, apenas o código necessário ao projeto é incluido.

6.1.1 - sys

Configurações do Interpretador Python.

O módulo sys fornece acesso a algumas variáveis usadas ou mantidas pelo interpretador Python, e também a funcionalidades específicas do sistema.

importamos o módulo os. 

import sys

As funcões sys.version e a função sys.version_info retornam a versão e as informações da versão do interpretador Python. 

print(f"Versão do sistema: {sys.version}\n")
print(f"Versão do interpretador: {sys.version_info}\n")

As funções sys.path e sys.platform retornam o caminho e a plataforma do sistema. 

print(f"Path do interpretador: {sys.path}\n")
print(f"Plataforma: {sys.platform}")

O comando sys.exit() interrompe o programa. 

sys.exit()

6.1.2 - os

Interação com o OS (Operating System, Sistema Operacional).

O módulo os fornece uma interface para interagir com funcionalidades do sistema operacional, como leitura/escrita de arquivos, manipulação de diretórios, etc.

importamos o módulo os. 

import os

A função os.getcwd() retorna o diretório de trabalho corrente. 

diretorio_original = os.getcwd()
print(f"Diretório de trabalho corrente: {diretorio_original}")

A função os.listdir() retorna uma lista de arquivos e diretórios no diretório de trabalho corrente. 

print(f"Arquivos no diretório corrente: {os.listdir(diretorio_original)}")

A função os.mkdir() cria um diretório.

Usaremos um diretório chamado demo a partir do diretório-raiz do disco C. 

diretorio_demo = "C:/demo_y1" # "C:/demo"
print(f"os.path.exists(diretorio_demo) = {os.path.exists(diretorio_demo)}")
if os.path.exists(diretorio_demo):
    os.remove(diretorio_demo)
    print("O diretório foi removido.")
try:
    os.mkdir(diretorio_demo)
except FileExistsError:
    print("O diretório existe.")
else:
    print("O diretório foi criado.")
    print(f"os.path.exists(diretorio_demo) = {os.path.exists(diretorio_demo)}")

Observe o tratamento de erros, pois se o diretório c:/demo ja existir, uma exceção será disparada. 

try:
    os.mkdir(diretorio_demo)
except FileExistsError:
    print("O diretório existe.")
else:
    print("O diretório foi criado.")

A função os.chdir() move o diretório de trabalho para o diretório especificado. 

print(f"Diretório demo: {diretorio_demo}")

As funções isdir e isfile() testam se a referência é diretório ou arquivo. 

print(f"'{diretorio_demo}' é arquivo: {os.path.isfile(diretorio_demo)}")
print(f"'{diretorio_demo}' é diretório: {os.path.isdir(diretorio_demo)}")

O módulo os.path fornece funcionalidades para manipular caminhos de arquivos e diretórios.

A função os.path.join() junta caminhos de arquivos e diretórios. 

subdir_demo = os.path.join(diretorio_demo, 'subdir_demo')
print(f"Criar subdiretório '{subdir_demo}'")
try:
    os.mkdir(subdir_demo)
except FileExistsError:
    print("O diretório existe.")
else:
    os.chdir(subdir_demo)
print(f"Diretório corrente: {os.getcwd()}")
print(f"Arquivos no diretório corrente: {os.listdir()}")

Neste subdiretório 'subdir_demo', que é o diretório corrente, criamos um novo arquivo chamado primeiro_arquivo.txt.

Embora o módulo os possua as funções os.open(), os.write() e os.read(), usaremos a função .

A função integrada do Python open() abre um arquivo fornecendo permissões específicas e retorna um descritor de arquivo.

As premissões específicas são:

  • 'r': aberto para leitura (padrão)
  • 'w': aberto para gravação, truncando o arquivo primeiro
  • 'x': aberto para criação exclusiva, falhando se o arquivo já existir
  • 'a': aberto para escrita, acrescentando ao final do arquivo, se existir
  • 'b': modo binário
  • 't': modo de texto (padrão)
  • '+': aberto para atualização (leitura e escrita) 
primeiro_arquivo_txt = 'y1.txt'
arquivo = open(primeiro_arquivo_txt, 'w')
# Escrever conteúdo no arquivo
arquivo.write("Olá, este é um arquivo de texto.\n")
arquivo.write("Conteúdo de texto adicionado com Python usando o módulo 'os'!\n")
# Fechar o arquivo
arquivo.close()

A função write() é usada para escrever texto ou bytes no arquivo.

Verificamos novamente a relação de arquivos no diretório. 

print(f"Arquivos no diretório corrente: {os.listdir()}")

A função os.path.basename() retorna o nome do diretório do argumento. 

print(f"Nome do diretório de trabalho corrente: {os.path.basename(primeiro_arquivo_txt)}")

As funções os.path.dirname() e os.path.split() retornam o diretório pai e o nome do diretório, respectivamente.

As funções os.path.basename(), os.path.dirname(), os.path.split(), os.path.splitext(), os.path.getsize(), os.path.getmtime(), os.path.getatime() e os.path.getctime() retornam informações sobre o arquivo o nome, o diretório pai, o diretório de trabalho e o nome separados, o tamanho e os tempos (em segundos) de criação, de acesso e de modificação. 

pa = "primeiro_arquivo.txt"
demo_pa = f"c:/demo/{pa}"
print(f"pa               : {pa}")
print(f"demo_pa          : {demo_pa}")
print()
print(f"Nome             : {os.path.basename(demo_pa)}")
print(f"Diretório        : {os.path.dirname(demo_pa)}")
print(f"Diretório e nome : {os.path.split(demo_pa)}")
print(f"Nome e extensão  : {os.path.splitext(pa)}")
print(f"Tamanho          : {os.path.getsize(pa)} bytes")
print(f"Criação          : {os.path.getmtime(pa)} segundos")
print(f"Acesso           : {os.path.getatime(pa)} segundos")
print(f"Modificação      : {os.path.getctime(pa)} segundos")

O conteúdo do arquivo pode ser lido depois de criado. 

with open(primeiro_arquivo_txt, 'r') as arquivo:
    conteudo = arquivo.read()
    print(conteudo)

Repare como a instrução with implica, ao término do bloco, no fechamento automático do arquivo.

Os arquivos podem ser binários. 

# Abrir o arquivo em modo de escrita binária ('wb')
segundo_arquivo_bin = 'y1.bin'
arquivo = open(segundo_arquivo_bin, 'wb')
# Escrever bytes no arquivo
arquivo.write(b"Este conteudo texto sera salvo no arquivo no formato binario.\n")
arquivo.write(b"Repare que contem apenas caracterer ASCII, acentos nao sao permitidos.")
# Fechar o arquivo
arquivo.close()

Verificamos novamente a relação de arquivos no diretório. 

print(f"Arquivos no diretório corrente: {os.listdir()}")

O conteúdo do arquivo pode ser lido depois de criado. 

with open(segundo_arquivo_bin, 'rb') as arquivo:
    print("*** conteúdo binário:")
    conteudo = arquivo.read()
    print(conteudo)
    print()
    print("*** conteúdo ASCII:")
    # conteúdo convertido para string
    print(conteudo.decode('utf-8'))

Embora seja possível usar as funções do pacote os para operações de baixo nível, em muitos casos, as funções open(), read(), write() e close() nativos do Python são mais convenientes e suficientes para a manipulação de arquivos de texto e binários.

A função os.rename() é usada para renomear arquivos. 

primeiro_arquivo_txt_renomeado = 'y1_renomeado.txt'
os.rename(primeiro_arquivo_txt, primeiro_arquivo_txt_renomeado)
print(f"Arquivos no diretório corrente: {os.listdir()}")

Para remover os arquivos, utilizamos a função os.remove(). 

os.remove(segundo_arquivo_bin)
print(f"Arquivos no diretório corrente: {os.listdir()}")

Removemos os arquivos restantes. 

os.remove(primeiro_arquivo_txt_renomeado)
print(f"Arquivos no diretório corrente: {os.listdir()}")

Novamente o diretório está vazio.

Retornamos ao diretório original. 

os.chdir(diretorio_demo)

A função os.rename() também é usada para renomear diretórios. 

novo_diretorio_renomeado = 'subdir_demo_renomeado'
os.rename(subdir_demo, novo_diretorio_renomeado)
print(f"Arquivos no diretório corrente: {os.listdir()}")

A função os.rmdir() é usada para remover diretórios. 

os.rmdir(novo_diretorio_renomeado)

6.1.3 - math

Funções Matemáticas.

O módulo math fornece funções matemáticas padrão, como seno, cosseno, exponenciais, etc. 

import math
print(f"math.sqrt(25) = ", math.sqrt(25))
print(f"math.pow(2, 3) = ", math.pow(2, 3))
print(f"math.pi = ", math.pi)
print(f"math.e = ", math.e)
print(f"math.sin(math.pi / 2) = ", math.sin(math.pi / 2))
print(f"math.cos(math.pi / 2) = ", math.cos(math.pi / 2))
print(f"math.tan(math.pi / 4) = ", math.tan(math.pi / 4))
print(f"math.log(math.e) = ", math.log(math.e))
print(f"math.log10(100) = ", math.log10(100))
print(f"math.factorial(5) = ", math.factorial(5))
print(f"math.ceil(4.5) = ", math.ceil(4.5))
print(f"math.floor(4.5) = ", math.floor(4.5))
print(f"math.trunc(4.5) = ", math.trunc(4.5))
print(f"math.gcd(10, 15) = ", math.gcd(10, 15))
print(f"math.lcm(10, 15) = ", math.lcm(10, 15))
print(f"math.sinh(0) = ", math.sinh(0))
print(f"math.cosh(0) = ", math.cosh(0))
print(f"math.tanh(0) = ", math.tanh(0))
print(f"math.asinh(0) = ", math.asinh(0))
print(f"math.acosh(1) = ", math.acosh(1))
print(f"math.atanh(0) = ", math.atanh(0.5))
print(f"math.isfinite(0) = ", math.isfinite(0))
print(f"math.isinf(0) = ", math.isinf(0))
print(f"math.isnan(0) = ", math.isnan(0))
print(f"math.erf(0) = ", math.erf(0))
print(f"math.erfc(0) = ", math.erfc(0))
print(f"math.gamma(0) = ", math.gamma(0.5))
print(f"math.lgamma(0) = ", math.lgamma(0.5))
print(f"math.sqrt(-1) = ", math.sqrt(4))
print(f"math.isclose(0, 0) = ", math.isclose(0, 0))
print(f"math.isclose(0, 0, rel_tol=1e-9) = ", math.isclose(0, 0, rel_tol=1e-9))
print(f"math.isclose(0, 0, abs_tol=1e-9) = ", math.isclose(0, 0, abs_tol=1e-9))
print(f"math.isclose(0, 0, rel_tol=1e-9, abs_tol=1e-9) = ", math.isclose(0, 0, rel_tol=1e-9, abs_tol=1e-9))
print(f"math.isclose(math.nan, math.nan) = ", math.isclose(math.nan, math.nan))
print(f"math.isclose(math.nan, math.nan, rel_tol=1e-9) = ", math.isclose(math.nan, math.nan, rel_tol=1e-9))
print(f"math.isclose(math.nan, math.nan, abs_tol=1e-9) = ", math.isclose(math.nan, math.nan, abs_tol=1e-9))
print(f"math.isclose(math.nan, math.nan, rel_tol=1e-9, abs_tol=1e-9) = ", math.isclose(math.nan, math.nan, rel_tol=1e-9, abs_tol=1e-9))

6.1.4 - random

Geração de Números Aleatórios.

O módulo random é usado para gerar números pseudoaleatórios. 

import random
print(f"random.randint(1, 10) = ", random.randint(1, 10))
print(f"random.random() = ", random.random())
print(f"random.uniform(1, 10) = ", random.uniform(1, 10))
print(f"random.randrange(1, 10) = ", random.randrange(1, 10))
print(f"random.choice([1, 2, 3, 4, 5]) = ", random.choice([1, 2, 3, 4, 5]))
print(f"random.choices([1, 2, 3, 4, 5], k=2) = ", random.choices([1, 2, 3, 4, 5], k=2))
print(f"random.sample([1, 2, 3, 4, 5], 2) = ", random.sample([1, 2, 3, 4, 5], 2))
print(f"random.shuffle([1, 2, 3, 4, 5]) = ", random.shuffle([1, 2, 3, 4, 5]))
print(f"random.gauss(0, 1) = ", random.gauss(0, 1))
print(f"random.triangular(0, 10, 5) = ", random.triangular(0, 10, 5))
print(f"random.betavariate(0.5, 0.5) = ", random.betavariate(0.5, 0.5))
print(f"random.expovariate(0.5) = ", random.expovariate(0.5))
print(f"random.gammavariate(0.5, 0.5) = ", random.gammavariate(0.5, 0.5))
print(f"random.lognormvariate(0.5, 0.5) = ", random.lognormvariate(0.5, 0.5))
print(f"random.normalvariate(0.5, 0.5) = ", random.normalvariate(0.5, 0.5))
print(f"random.vonmisesvariate(0.5, 0.5) = ", random.vonmisesvariate(0.5, 0.5))
print(f"random.paretovariate(0.5) = ", random.paretovariate(0.5))
print(f"random.weibullvariate(0.5, 0.5) = ", random.weibullvariate(0.5, 0.5))

6.1.5 - datetime

Manipulação de Datas e Horas.

O módulo datetime fornece classes para trabalhar com datas e horas. 

from datetime import datetime
current_time = datetime.now()
current_date = datetime.today()
print(f"current_time = ", current_time)
print(f"current_date = ", current_date)
print(f"current_time.year = ", current_time.year)
print(f"current_time.month = ", current_time.month)
print(f"current_time.day = ", current_time.day)
print(f"current_time.hour = ", current_time.hour)
print(f"current_time.minute = ", current_time.minute)
print(f"current_time.second = ", current_time.second)
print(f"current_time.microsecond = ", current_time.microsecond)

6.1.6 - json

Processamento JSON.

O módulo json facilita a codificação e decodificação de dados JSON. 

import json
data = {"nome": "João", "idade": 30}
json_data = json.dumps(data)
j = json.loads(json_data)
print(j)

6.1.7 - urllib

Manipulação de URLs.

O módulo urllib é usado para trabalhar com URLs, incluindo abrir URLs, codificar parâmetros de consulta, etc. 

from urllib.request import urlopen
response = urlopen("https://www.cieda.com.br")
response.read()
print(f"response.url = ", response.url)
print(f"response.info() = ", response.info())
print(f"response.getcode() = ", response.getcode())
print(f"response.geturl() = ", response.geturl())

6.1.8 - re

Expressões Regulares.

O módulo re fornece suporte para expressões regulares, permitindo a busca e manipulação de strings complexas. 

import re
pattern = re.compile(r'\b\w+\b')
result = pattern.findall("Isso é uma frase.")
print(f"result = ", result)

6.1.9 - collections

Tipos de Dados Especializados.

O módulo collections fornece alternativas especializadas para os tipos de dados incorporados, como namedtuple, Counter, defaultdict, entre outros. 

from collections import Counter
contagem_palavras = Counter(["maçã", "banana", "maçã"])
print(f"contagem_palavras = ", contagem_palavras)

6.2 - Pacotes Instalados

Esses são apenas alguns exemplos dos muitos módulos disponíveis na biblioteca padrão do Python.

Para criação de gráficos em Python, uma das bibliotecas mais populares é a matplotlib. Ela é extremamente versátil e permite a criação de uma variedade de gráficos, desde simples gráficos de linha até gráficos mais complexos, como gráficos de dispersão, histogramas e gráficos 3D. Abaixo, vou falar sobre a matplotlib e também mencionar brevemente a seaborn, que é uma biblioteca construída sobre a matplotlib para visualizações estatísticas mais atraentes.

6.2.1 - matplotlib

Criação de Gráficos.

A matplotlib é uma biblioteca de plotagem 2D que produz gráficos de alta qualidade em vários formatos. Ela oferece uma grande flexibilidade na criação e personalização de gráficos.

Exemplo básico de gráfico de linha: 

import matplotlib.pyplot as plt

# Dados
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

# Criar o gráfico de linha
plt.plot(x, y)

# Adicionar rótulos e título
plt.xlabel('Eixo X')
plt.ylabel('Eixo Y')
plt.title('Gráfico de Linha')

# Exibir o gráfico
plt.show()

Para instalar a Matplotlib, você pode usar o seguinte comando: 

pip install matplotlib

6.2.2 - seaborn

Visualizações Estatísticas Atraentes.

A Seaborn é uma biblioteca construída sobre a Matplotlib que fornece uma interface de alto nível para criar visualizações estatísticas atraentes.

Exemplo de gráfico de dispersão com seaborn: 

import seaborn as sns
import matplotlib.pyplot as plt
import random

# Dados
x = list(range(1, 101))
y = random.sample(range(1, 300), 100)

# Criar o gráfico de dispersão usando seaborn
sns.scatterplot(x=x, y=y)

# Adicionar rótulos e título
plt.xlabel('Eixo X')
plt.ylabel('Eixo Y')
plt.title('Gráfico de Dispersão com Seaborn')

# Exibir o gráfico
plt.show()

Para instalar a Seaborn, você pode usar o seguinte comando: 

pip install seaborn

Essas bibliotecas são apenas algumas das opções disponíveis para visualização em Python.

Dependendo dos requisitos específicos, outras bibliotecas como plotly, bokeh e ggplot também podem ser exploradas para criação de gráficos interativos e visualizações mais complexas.

6.2.3 - numpy

Manipulação de Arrays Numéricos.

O NumPy é uma biblioteca fundamental para computação numérica em Python. Ele fornece estruturas de dados como arrays multidimensionais (ndarrays) e funções essenciais para operações matemáticas em arrays.

Exemplo de uso: 

import numpy as np

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

# Operações matemáticas em arrays
resultado = array * 2

# Imprimir o resultado
print("Array original:", array)
print("Array multiplicado por 2:", resultado)

Para instalar o NumPy, você pode usar o seguinte comando: 

pip install numpy

6.2.4 - pandas

Manipulação de Dados em Tabelas.

O Pandas é uma biblioteca construída sobre o NumPy e fornece estruturas de dados de alto nível, como DataFrames, para facilitar a manipulação de dados tabulares. 

import pandas as pd

# Criar um DataFrame
data = {'Nome': ['Alice', 'Bob', 'Charlie'],
        'Idade': [25, 30, 35]}
df = pd.DataFrame(data)

# Operações em DataFrames
media_idade = df['Idade'].mean()

# Imprimir o resultado
print("Média de idade:", media_idade)

Para instalar o pandas, você pode usar o seguinte comando: 

pip install pandas

6.3 - Pacotes Personalizados

Os módulos são arquivos que contêm funções, classes e variáveis, que podem ser importadas e reutilizadas em outros programas, permitindo organizar e reutilizar o código de maneira mais eficiente.

Eles ajudam a organizar e dividir o código em partes mais gerenciáveis e também permitem o compartilhamento e reuso de funcionalidades.

Você pode criar seus projetos de pacotes personalizados e reutiliza-los em outros projetos.

Crie um arquivo chamado meu_modulo.py com o seguinte conteúdo: 

def dobrar_numero(numero):
    return numero * 2

def calcular_media(lista):
    return sum(lista) / len(lista)

Para utilizar as funções desse módulo em outro arquivo Python, basta importá-lo: 

import meu_modulo

numero_dobrado = meu_modulo.dobrar_numero(5)
print(numero_dobrado)

lista_notas = [8, 7, 9, 10, 6]
media_notas = meu_modulo.calcular_media(lista_notas)
print(f"A média das notas é: {media_notas}")

Neste exemplo, importamos o módulo meu_modulo e utilizamos as funções dobrar_numero e calcular_media definidas nesse módulo.

Se você desejar importar apenas algumas funções específicas do módulo,use a palavra-chave from. 

from meu_modulo import dobrar_numero
numero_dobrado = dobrar_numero(5)
print(numero_dobrado)

Dessa forma, apenas a função dobrar_numero do módulo meu_modulo foi importada, tornando-se diretamente acessível.

Arduino
Coautor
Betobyte
Autor
Autores
||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Python para Iniciantes || Python para Iniciantes || Python Básico || Matplotlib || Numpy || Seaborn || Pandas || Django || Estatística para Cientistas de Dados || Python com ML Básico || Python com ML Básico || Aulas | Introdução (Instalação, variáveis e tipos de dados, operações, formatação e comentários.) | Coleções (Listas, Tuplas, Conjuntos e Dicionários.) | Funções e Módulos (Declaração, argumentos, retorno, recursão, funções lambda.) | Estruturas de Controle (Controle Condicional (if/elif/else, match) e Controle de repetição (for, while).) | Classes (Classes, Herança e Polimorfismo.) | Bibliotecas e Frameworks (Pacotes integrados, instalados e personalizados.) | Manipulação de Arquivos (Manipulação de Arquivos) | Bancos de Dados SQL (MySQL, SQLite e PostgreSQL.) | Capítulo 9 (APIs e Web Scraping) | Capítulo 10 (Projetos Práticos) | Considerações finais () |