Módulo e pacotes¶

Importando módulos¶

O python possui muitas funções e operadores que nativa da própria linguagem de programação como os operadores básicos (+,-,*,/), potenciação (**) impressão de valores (print(),.format()), e etc.

No entanto, há algumas funcionalidades que você irá precisar para produzir seu código, mas que não tem nativamente na linguagem Python, podemos então importar tais funcionalidades para o nosso trabalho como módulos.

Agora vejam a definição de módulo segundo um trecho da a própria documentação do Python:

Módulos são um conjunto de códigos como funções, classes, variáveis, etc. Se você estiver fazendo um programa e ele se tornar muito grande, difícil de ler e se situar nele, é uma boa prática dividi-lo em arquivos menores, para facilitar a manutenção. Também é preferível usar um arquivo separado para uma função que você escreveria em vários programas diferentes, para não copiar a definição de função em cada um deles.

Para permitir isso, o Python tem uma maneira de colocar as definições em um arquivo e então usá-las em um script ou em uma execução interativa do interpretador. Tal arquivo é chamado de módulo; definições de um módulo podem ser importadas para outros módulos, ou para o módulo principal.

Importando um módulo¶

Para o nosso primeiro exemplo vamos importar o módulo math, um módulo que estende o Python com algumas funcionalidades matemáticas.

Execute a célula abaixo:

In [1]:

import math # Nesta linha eu estou importando o módulo math

import math # Nesta linha eu estou importando o módulo math

Feito isso, tente escrever o seguinte código e aperte Tab:

math.

Você verá todas as funções e constantes (instâncias) deste pacote, como mostra na Figura abaixo:

Agora apague a célula acima e vamos aprender a calcular a raiz quadrada. Para isso utilize a função sqrt() do módulo math.

In [2]:

num = 4
raiz = math.sqrt(num) # A função sqrt() do módulo 'math' calcula a raiz quadrada 
print(f"A raiz quadrada de {num} é {raiz}")

num = 4 raiz = math.sqrt(num) # A função sqrt() do módulo 'math' calcula a raiz quadrada print(f"A raiz quadrada de {num} é {raiz}")

A raiz quadrada de 4 é 2.0

Dica:

Teste o exemplo acima com alguns valores, como 5, 4, 3, 2, etc.

Agora vamos arredondar o resultado da raiz utilizando a função ceil().

In [3]:

num = 7
raiz = math.sqrt(num) # A função sqrt() do módulo 'math' calcula a raiz quadrada 
arredondar = math.ceil(raiz) # A função ceil() arredonda para cima um determinado valor
print(f"A raiz quadrada arredondada de {num} é {arredondar}")

num = 7 raiz = math.sqrt(num) # A função sqrt() do módulo 'math' calcula a raiz quadrada arredondar = math.ceil(raiz) # A função ceil() arredonda para cima um determinado valor print(f"A raiz quadrada arredondada de {num} é {arredondar}")

A raiz quadrada arredondada de 7 é 3

Dica:

Teste os exemplos acima com alguns valores, como 5, 4, 3, 2, etc.

Tarefa:

Vamos praticar com uma constante. Procure a constante pi no módulo Math e execute:

Tarefa:

Crie um código que aceite um ângulo em graus como entrada, e imprima na tela o seu correspondente em radianos, o seu seno, cosseno e tangente.

Observação: Utilize a função radians() para fazer a conversão de graus para radianos diretamente.

Dica: Utilize as funções sin(), cos(), tan() para calcular o seno cosseno e tangente.

A saída do programa deve ser parecida com isso:

O ângulo 45° vale 0.79 rad, tem o seno 0.71, cosseno 0.71 e tangente 1

Dica:

Teste o exemplo acima com os ângulos 0, 30, 45, 60 e 90.

Documentação do math¶

Praticamente todo módulo ou pacote do Python tem uma documentação disponível na internet. O módulo math é um módulo built-in, ou seja, ele é um módulo que já vem junto com o Python. Para estes módulos podemos olhar a própria documentação do Python. Essa documentação está disponível no menu Help>Python Reference ou no próprio site do python, na parte de Docs.

No caso do módulo de matemática, podemos utilizar o seguinte módulo direto:

https://docs.python.org/3/library/math.html

Lá podemos encontrar explicações detalhadas de todas as funções e constantes do módulo math.

Tarefa:

Buscando na documentação do módulo math, crie um programa capaz de calcular as seguintes expressões:

• $e^x$
• $x!$
• $\log_{10}(x+1)$
• $(\pi+e)^x$

Considere $x=4$.

Observação: Teste usar a função pow() no lugar do operador **.

A saída deve ser parecida com essa:

Para o valor de x:  1
e^1=2.72
1!=1
log10(1+1)!=0.30
(pi+e)^1!=5.86

from ... import ...¶

É muito chato toda vez que for utilizar alguma funcionalidade da função math, ter que escrever math. no início. Através da sintaxe:

from [módulo] import [função1], [função2], [constante1], [etc]

Podemos incluir somente as funções e constantes que desejamos trabalhar e eliminamos a necessidade de utilizar math. no início. Veja o exemplo:

from math import pi
pi

3.141592653589793

Vejamos um exemplo de como calcular o fatorial:

In [4]:

# Utilizando import
import math 
numero = 5
fat = math.factorial(numero)
print(f"O fatorial de {numero} é {fat}.")

# Utilizando import import math numero = 5 fat = math.factorial(numero) print(f"O fatorial de {numero} é {fat}.")

O fatorial de 5 é 120.

Percebemos agora, a maneira mais simples de importar um módulo, que é simplesmente digitando import e o nome do módulo logo em seguida. Na hora de chamar a função factorialprecisamos especificar que ela pertence ao módulo em questão, por isso a chamamos com math.factorial().

Agora suponha que iremos usar apenas a função factorial, sem usar as outras funções do módulo de matemática, a outra forma de faze-lo é:

In [5]:

# Utilizando from import
from math import factorial
numero = 5
fat = factorial(numero)
print(f"O fatorial de {numero} é {fat}.")

# Utilizando from import from math import factorial numero = 5 fat = factorial(numero) print(f"O fatorial de {numero} é {fat}.")

O fatorial de 5 é 120.

Tarefa:

Refaça a tarefa abaixo importando todas as funções necessárias utilizando a notação from import

Crie um código que aceite um ângulo em graus como entrada, e imprima na tela o seu correspondente em radianos, o seu seno, cosseno e tangente.

from ... import *¶

Caso não soubermos as funções que iremos utilizar, ou se iremos utilizar muitas funções de um determinado módulo, podemos importar todas as funções deste módulo utilizando a notação:

from [módulo] import *

In [6]:

from math import *
ang_graus = 120
ang_rad = ang_graus*pi/180 #Observe que estamos utilizando a constante pi
print(f"O seno de {ang_graus}° é {ang_rad:.2g}")

from math import * ang_graus = 120 ang_rad = ang_graus*pi/180 #Observe que estamos utilizando a constante pi print(f"O seno de {ang_graus}° é {ang_rad:.2g}")

O seno de 120° é 2.1

import * é prático! Mas tome cuidado!

Segue alguns motivos para não usar o import *:

• Seu código não fica legível
• Não fica implícito no código da onde vem aquela função
• Caso um ou mais módulos tenham duas funções com o mesmo nome, você não tem como escolher, sempre será selecionada a última função importada!
• Bugs inesperados
• Etc

Isso não quer dizer que usar o import * é sempre ruim. Ele pode ser prático em códigos pequenos, ou em módulos que você já conhece bem e que você saiba o que está fazendo.

Para mais detalhes clique aqui.

Outros módulos built-in¶

Além do módulo math, existem outros módulos built-in e você pode encontrá-los na documentação do Python, em Library reference (A página tem o título Python Library Standard )

Esta página mostra diversos módulos em formas de categorias.

Para continuarmos os nossos exercícios vamos utilizar uma outro módulo de matemática, o módulo random. Ele está na seção Numeric and Mathematical Modules. Vamos ver um exemplo com a função random():

In [7]:

from random import random # A função random() gera um float pseudo aleatório de 0.0 <= x < 1.0
from math import floor # A função ceil() arredonda para baixo

from random import random # A função random() gera um float pseudo aleatório de 0.0 <= x < 1.0 from math import floor # A função ceil() arredonda para baixo

In [8]:

aleatorio=floor(10*random()) # Gera um número pseudo aleatório de 0 a 9
aleatorio

aleatorio=floor(10*random()) # Gera um número pseudo aleatório de 0 a 9 aleatorio

Out[8]:

5

Observe que nesse exemplo para conseguir esse efeito combinamos duas funções de módulos diferentes.

Tarefa:

Olhando a documentação do módulo random refaça o exemplo sem utilizar o módulo math.

Tarefa:

Lendo a documentação indique quais módulos são mais adequados para:

• Trabalhar com o tempo (Horas, dias, semanas).
• Trabalhar com diretórios e arquivos.
• Trabalhar com tabelas do tipo csv.
• Trabalhar com funções do sistema operacional.

Apelidando módulos (alias)¶

Uma outra forma de importar módulos é renomeando-o. Observe novamente o exemplo do fatorial:

In [9]:

import math as m
numero = 7
fat = m.factorial(numero)
print("O fatorial de {} é {}.".format(numero, fat))

import math as m numero = 7 fat = m.factorial(numero) print("O fatorial de {} é {}.".format(numero, fat))

O fatorial de 7 é 5040.

Observe que a sintaxe import math as m tornou o mesmo módulo disponível agora por um nome diferente, no caso, mat. Dessa forma, podemos chamar uma função do módulo como m.função, como mostrado acima.

Essa funcionalidade é particularmente útil quando o nome do módulo é grande e a tarefa de escreve-lo diversas vezes torna-se chata, como é mostrado abaixo:

import matplotlib.pyplot as plt # Submódulo para plotar gráficos

Sempre prefira essa notação de import [nome_do_pacote] as [novo_nome_do_pacote]ao invés de apenas import * , pois desta forma você deixa o código legível e evita a tarefa chata de ter que escrever o nome completo do módulo toda vez que vai utilizar uma funcionalidade do módulo.

Tarefa:

Considere o código abaixo, substitua o from math import * por ìmport math as m:

In [10]:

from math import *
ang_graus = 90
ang_rad = ang_graus*pi/180 #Observe que estamos utilizando a constante pi
print(f"O seno de {ang_graus}° é {sin(ang_rad):.2g} rad.")

from math import * ang_graus = 90 ang_rad = ang_graus*pi/180 #Observe que estamos utilizando a constante pi print(f"O seno de {ang_graus}° é {sin(ang_rad):.2g} rad.")

O seno de 90° é 1 rad.

Pacotes do Anaconda¶

Como dito anteriormente, podemos ver os módulos como se fossem caixas com diversas funções úteis dentro, e que podemos acessa-las com um import.

classDiagram
	class Math{
		<>
		pi
		e
		inf
		etc
		ceil(x)
		comb(n,k)
		copysign(x,y)
		etc()
	}

Figura 1: Representação do módulo Math.

No python, também há o conceito de Pacote. Podemos ver os pacotes como módulos que contém outros módulos separados por temática. Na imagem abaixo temos o pacote Game. Dentro deste pacote existem outros módulos.

classDiagram
    Game .. Som
    Game .. Imagem
    Game .. Fase

    class Game {
        <>
    }

    class Som {
        <>
        +volumeEfeito
        +volumeMusica
        +reproduzirEfeito()
        +reproduzirMusica()
        +mudarVolume()
    }

    class Imagem {
        <>
        +qualidade
        +filtros
        +mudarQualidade()
        +mudarFiltros()
    }

    class Fase {
        <>
        +mundo
        +numero
        +chefe
        +entrar()
        +derrotarChefe()
    }

Figura 2: Conceito de pacote.

O nosso pacote fictício agora possui vários sub-módulos, cada um deles com diversas funções diferentes e de modo mais organizado na visão do programador.

Muitos dos pacotes utilizados pela comunidade Python não vem por padrão na linguagem. Por sorte o Anaconda trás diversos pacotes úteis para o programador Python. Desta forma não precisamos nos preocupar em instalar muitos pacotes utilizados na comunidade Python. Podemos citar alguns exemplos de pacotes que vem junto com o Anaconda:

• Numpy - Computação científica e gerenciamento de arrays e matrizes
• Scipy - Computação científica (Extensão do NumPy)
• Sympy - Variáveis simbólicas
• Pandas - Análise de dados
• Matplotlib - Gráficos e plotagens
• Plotly - Plotagem de gráficos dinâmicos
• Seaborn - Plotagem de gráficos estatísticos
• TensorFlow - Tensores e Inteligência Artificial (Google)
• Keras - Inteligência artificial (Google)
• PyTorch - Inteligência Artificial (Meta)
• Scikit-learn - Machine Learning
• OpenCV - Processamento de imagens
• Pillow - Visualização e processamento de imagens

Pode ser que na sua máquina estes pacotes não estejam instalados. Entretanto podemos instalá-los utilizando o terminal e utilizando o comando:

conda install [pacote]

O conda é o gerenciador de pacotes do Anaconda. Através desse comando podemos instalar, pesquisar e desinstalar pacotes. Abaixo segue alguns comandos que podemos utilizar no gerenciador de pacotes do Anaconda.

Comando	Função
install [pacote]	Instala um pacote
--help	Ajuda
uninstall [pacote]	Remove um pacote
search [palavra]	Procura por um determinado pacote baseado em uma palavra
update	Faz o update de todos os pacotes do Anaconda

Pacote Numpy¶

É um pacote fundamental para computação científica em Python. Ele fornece suporte para arrays multidimensionais e funções matemáticas de alto desempenho, como operações de álgebra linear, funções trigonométricas, dentre outras.

A documentação do numpy está disponível aqui.

A documentação recomenda que o NumPy seja importado com o alias np, que deixa a escrita do código mais concisa. Para importá-lo siga a linha de código abaixo:

import numpy as np

Por exemplo, podemos reescrever o código para cálculo de fatorial usando o numpy:

In [11]:

import numpy as np

import numpy as np

In [12]:

num = 4
raiz = np.sqrt(num) # A função sqrt() do módulo 'math' calcula a raiz quadrada 
print(f"A raiz quadrada de {num} é {raiz}")

num = 4 raiz = np.sqrt(num) # A função sqrt() do módulo 'math' calcula a raiz quadrada print(f"A raiz quadrada de {num} é {raiz}")

A raiz quadrada de 4 é 2.0

Tarefa:

Buscando na documentação do módulo Numpy, crie um programa capaz de calcular as seguintes expressões:

• $e^x$
• $x!$
• $\log_{10}(x+1)$
• $(\pi+e)^x$

Considere $x=4$.

Tarefa:

Crie um código que receba as notas do bimestre de 4 alunos conforme a tabela abaixo, compute a média e arredonde pra cima. Você deverá usar o módulo NumPy e consultar a documentação para entender a função que arredonda e usa-la no seu programa. O código deverá imprimir na tela a média final de cada um e o quanto cada aluno ganhou de nota no arredondamento.

Aluno	N1	N2	N3	N4
Pedrinho	7.00	8.75	8.3	5.60
Joãozinho	7.00	7.00	8.1	9.00
Juninho	6.40	7.50	8.45	9.00

Pacote IPython (Saídas ricas)¶

Nos capítulos anteriores vimos que o print() é a principal função de impressão do Python, mas não é a única. Neste capítulo será introduzido as saídas do IPython.

A saída IPython é muito rica, com ela podemos mostrar:

• Audio
• Videos (Inclusive do Youtube)
• Videos do Youtube
• LaTeX
• Equações
• HTML (E código JavaScript)
• Figuras
• Sites (IFrame)
• Markdown
• Dentre outros

Mais detalhes podem ser vistos na documentação.

Primeiro importamos o sub-módulo display do IPython:

In [ ]:

In [13]:

# Importando o IPython.display
import IPython.display as ipy

# Importando o IPython.display import IPython.display as ipy

Agora veja alguns exemplos:

Audio:

In [14]:

# Posso reproduzir um audio qualquer no meu notebook
ipy.Audio(url="http://www.w3schools.com/html/horse.ogg")

# Posso reproduzir um audio qualquer no meu notebook ipy.Audio(url="http://www.w3schools.com/html/horse.ogg")

Out[14]:

Imagem:

In [15]:

# Posso mostrar imagens no meu notebook
ipy.Image(url='http://www.google.fr/images/srpr/logo3w.png')

# Posso mostrar imagens no meu notebook ipy.Image(url='http://www.google.fr/images/srpr/logo3w.png')

Out[15]:

Código HTML (Linguagem da Web):

In [16]:

ipy.HTML('<p style="color:blue">Um texto azul em HTML.</p>')

ipy.HTML('

Um texto azul em HTML.

')

Out[16]:

Um texto azul em HTML.

Youtube:

In [17]:

ipy.YouTubeVideo('St9pE2bv0zQ')

ipy.YouTubeVideo('St9pE2bv0zQ')

Out[17]:

Um site (IFrame):

In [18]:

# Podemos colocar um IFrame, que de forma simplificada é uma página web incorporada ao Notebook
ipy.IFrame(src="https://lucaslrodri.github.io/python-for-dummies/", width=400, height=300)

# Podemos colocar um IFrame, que de forma simplificada é uma página web incorporada ao Notebook ipy.IFrame(src="https://lucaslrodri.github.io/python-for-dummies/", width=400, height=300)

Out[18]:

Markdown:

In [19]:

TextoEmMarkdown="Este texto está em _itálico_ e este em **negrito**."

ipy.Markdown(TextoEmMarkdown)

TextoEmMarkdown="Este texto está em _itálico_ e este em **negrito**." ipy.Markdown(TextoEmMarkdown)

Out[19]:

Este texto está em itálico e este em negrito.

Função display¶

Observe que todas as vezes que digitamos as saídas Markdown sempre apareceu aquele número em colchetes que fica do lado esquerdo da célula (Exemplo [12]:). Para eliminar isso basta chamar a função ipy.Markdown() dentro da função display(). Veja abaixo:

In [20]:

TextoEmMarkdown="Este texto está em _itálico_ e este em **negrito**."

display(ipy.Markdown(TextoEmMarkdown))

TextoEmMarkdown="Este texto está em _itálico_ e este em **negrito**." display(ipy.Markdown(TextoEmMarkdown))

Este texto está em itálico e este em negrito.

Tarefa:

Vimos nos primeiros capítulos como escrever strings multi-linhas. Quando queremos escrever textos longos através da saída do IPython utilizar a notação multi-linha é util.

Faça uma lista de compras em Python e mostre-a em Markdown.

Dica: Use como base:

**Lista de compras:**

- Maça
- Banana
- Leite
- Queijo

Pacotes externos¶

Existem outros gerenciadores de pacotes além do conda. O Python Package Index (PyPI), ou simplesmente pip, é o gerenciador padrão do Python, e muitas vezes só podemos encontrar um pacote neste gerenciador. Você pode encontrar um link do site oficial do pip no próprio site do Python.

Segundo este mesmo site no momento em que este roteiro está sendo escrito existem 267182 pacotes disponíveis para instalar através desse gerenciador.

Você pode encontrar uma pequena descrição do pacote ao buscar dentro desta plataforma.

Geralmente os pacotes têm seu código fonte disponível no Github, portanto se no site pypi não tiver muita informação desse pacote, procure-o no Github, com uma simples pesquisa no Google:

Observação:

Inclusive este site está hospedado no Github.

Outro site muito relevante para encontrar documentação de pacotes em python é o Read the Docs, um site de documentação.

Por exemplo, o própria documentação do JupyterLab está hospedada lá:

https://jupyterlab.readthedocs.io/en/latest/

A sintaxe de comando do pip é muito parecida com a do conda:

Comando	Função
install [pacote]	Instala um pacote
--help	Ajuda
uninstall [pacote]	Remove um pacote
search [palavra]	Procura por um determinado pacote baseado em uma palavra
update	Faz o update de todos os pacotes do Anaconda

Mais comandos podem ser vistos aqui.

Pacotes para STEM¶

Na área de STEM (Ciência, Tecnologia, Matemática e Engenharia) existem uma infinidade de pacotes úteis que podem ser instalados através do pip (ou conda) ou seguindo as instruções no github.

Observação:

Estou dando dicas de pacotes de STEM, porque é a área que eu trabalho.

Agora vamos aos exemplos:

• Jupyter TikZ - Desenho em geral usando Jupyter (Minha biblioteca)
• Schemdraw - Desenho de circuitos elétricos e diagramas lógicos
• Control - Modelagem e projeto de sistemas de controle
• Lcapy - Linear Circuit Analysis (Análises de circuitos lineares)
• pysimCoder - Editor de blocos similar ao Simulink
• PySpice - Simulador de circuitos
• py-dss-interface - Interface do Python com o OpenDSS (Simulador para sistemas de distribuição de energia elétrica)

Tarefa:

Pesquise pacotes relevantes na internet que seja útil para a sua área e faça um resumo desse pacote.

Segue dois exemplos:

Control : Python Control Systems Library

Área: Engenharia Elétrica / Engenharia de controle e automação

Descrição: Permite a análise e operação de sistemas de controle.

Documentação: http://python-control.readthedocs.org/

Repositório (Github): https://github.com/python-control/python-control

Instalação (PyPI): https://pypi.org/project/control/

conda install -c conda-forge control slycot #Método recomendado

ou

pip install slycot   # optional; see below
pip install control

Exemplo relevante:

https://github.com/python-control/python-control/blob/master/examples/bode-and-nyquist-plots.ipynb

Foto relevante:

Lcapy : Linear Circuit Analysis

Área: Engenharia Elétrica

Descrição:

• Lcapy é um pacote para análise de circuitos lineares.
• Usa o SymPy para a análise simbólica.
• Permite o desenho de alguns esquemáticos utilizando código Python.

Documentação: http://lcapy.elec.canterbury.ac.nz/

Repositório (Github): https://github.com/mph-/lcapy

Instalação (PyPI): https://pypi.org/project/lcapy/

pip install lcapy

Exemplo relevante:

https://github.com/mph-/lcapy/blob/master/doc/examples/notebooks/superposition1.ipynb

Foto relevante: