Introdução a gráficos 3D com Matplotlib

Antes de começarmos a criar gráficos 3D com a biblioteca Matplotlib precisamos habilitar o módulo tollkit da biblioteca. Para habilitar esse módulo precisamos importar a biblioteca mplot3d. Não se preocupe se você não instalou essa biblioteca, por padrão ela já vem com a biblioteca matplotlib. Apenas uma ressalva quanto a isso: verifique se a versão do Matplotlib é igual ou superior à versão 1.0.
Quando o módulo já tiver sido importado, é fácil criar um gráfico 3D apenas passando o valor '3d' para o parâmetro projection de qualquer método para a criação de eixos do matplotlib. Veja um exemplo abaixo:

Exemplo Python

from mpl_toolkits import mplot3d

import numpy as np
import matplotlib.pyplot as plt
    
fig = plt.figure()
eixos = plt.axes(projection="3d")
    
plt.show()

Com os nossos eixos criados já podemos começar a fazer desenhos nesses eixos. Os métodos para criar gráficos em três dimensões são muito similares aos métodos para criar gráficos em 2D, a diferença é a terminação do método que termina com 3d. Outra diferença é o número de argumentos, ao invés de passar apenas dois argumentos passaremos três, um para cada eixo. Os outros parâmetros permanecem os mesmo, como os parâmetros para alterar a cor e a linha dos gráficos. Veja um exemplo abaixo:

Exemplo Python

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
    
fig = plt.figure()
eixos = plt.axes(projection="3d")
    
z_line = np.linspace(0, 15, 1000)
x_line = np.cos(z_line)
y_line = np.sin(z_line)
eixos.plot3D(x_line, y_line, z_line, 'gray')
    
pontos_z = 15 * np.random.random(100)
pontos_x = np.cos(pontos_z) + 0.1 * np.random.randn(100)
pontos_y = np.sin(pontos_z) + 0.1 * np.random.randn(100)
eixos.scatter3D(pontos_x, pontos_y, pontos_z, c=pontos_z, cmap='viridis');
    
plt.show()

Assim como os gráficos 2D, podemos mover o gráfico 3D, dar zoom ou mudar o ângulo de visão.

Gráficos de superfície

Os gráficos de superfície são usados para visualizar um conjunto de três variáveis num cenário 3D. Com esse tipo de gráfico é possível visualizar como o valor de um eixo em relação aos outros dois. Veja um exemplo abaixo:

Exemplo Python

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
    
fig = plt.figure()
ax = plt.axes(projection="3d")
    
ax = plt.axes(projection='3d')
    
def funcao_z(x, y):
    return np.sin(np.sqrt(x ** 2 + y ** 2))
    
x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)
    
X, Y = np.meshgrid(x, y)
Z = funcao_z(X, Y)
    
ax.plot_wireframe(X, Y, Z, color='green')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
    
ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
                    cmap='viridis', edgecolor='none')
ax.set_title('Gráfico de superfícies');
    
plt.show()

Anterior Próximo

Read More

Gráficos de fluxo com Matplotlib

Um gráfico de fluxo é um tipo de gráfico 2D usado para mostrar fluxo de fluido e gradientes de campo 2D.
O método básico para criar um gráfico de fluxo no Matplotlib é:
ax.streamplot(x_grid,y_grid,x_vec,y_vec, density=espacamento)
Onde x_grid e y_grid são matrizes dos pontos x, y. As matrizes x_vec e y_vec denotam a velocidade do fluxo em cada ponto da grade. O argumento do parâmetro density=espacamento especifica a proximidade das linhas de fluxo.

Um gráfico de fluxo simples

Vamos começar com um gráfico de fluxo que contém linhas de fluxo em uma grade 10 x 10. Todas as linhas de fluxo no gráfico são paralelas e apontam para a direita.
A seção de código a seguir cria um gráfico de fluxo que contém linhas paralelas horizontais apontando para a direita.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# Se estiver usando o jupyter notebook, use:
# %matplotlib inline
    
x = np.arange(0,10)
y = np.arange(0,10)
    
X, Y = np.meshgrid(x,y)
u = np.ones((10,10)) # x-component to the right
v = np.zeros((10,10)) # y-component zero
    
fig, ax = plt.subplots()
    
ax.streamplot(X,Y,u,v, density = 0.5)
ax.set_title('Gráfico de fluxo com linhas pararelas')
plt.show()

O gráfico contém linhas de fluxo paralelas, todas apontando para a direita.

Gráfico de fluxo de um campo

Podemos construir um gráfico de fluxo que mostra linhas de campo com base em um campo vetorial 2D definido.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# Se estiver usando o jupyter notebook, use:
# %matplotlib inline
    
x = np.arange(0,2.2,0.1)
y = np.arange(0,2.2,0.1)
    
X, Y = np.meshgrid(x, y)
u = np.cos(X)*Y
v = np.sin(y)*Y
    
fig, ax = plt.subplots()
    
ax.streamplot(X,Y,u,v, density = 1)
ax.axis([0.5,2.1,0,2])
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.set_title('Gráfico de fluxo com linhas de campo')
    
plt.show()

Anterior Próximo

Read More

Gráfico de setas com Matplotlib

Gráfico de aljavas

Um gráfico de aljavas é um tipo de gráfico 2D que mostra linhas vetoriais como setas. Os gráficos com setas são úteis na Engenharia Elétrica para visualizar o potencial elétrico e útil na Engenharia Mecânica para mostrar gradientes de tensão.

» Gráfico de aljavas com uma seta

Primeiro, criaremos um gráfico de aljavas simples que contém uma seta para demonstrar como o método quiver() da biblioteca Matplotlib funciona. O método quiver() usa quatro argumentos posicionais:

Exemplo Python

ax.quiver(x_pos, y_pos, x_direct, y_direct)

x_pos e y_pos são as posições iniciais da seta e x_direct, y_direct são as direções da seta (pra onde a seta aponta).
Nosso primeiro gráfico contém uma seta no ponto inicial x_pos = 0, y_pos = 0. A direção da flecha está apontando para cima e para a direita x_direct = 1, y_direct = 1.
O exemplo de código a baixo cria um gráfico de aljavas com apenas uma seta.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# se estiver usando o Jypyter notebook, use:
# %matplotlib inline
    
fig, ax = plt.subplots()
    
x_pos = 0
y_pos = 0
x_direct = 1
y_direct = 1
    
ax.quiver(x_pos, y_pos, x_direct, y_direct)
ax.set_title('Gráfico de aljavas com uma seta')
    
plt.show()

Executando o código acima o seu gráfico deve esta assim:

Nesse exemplo o gráfico de aljava contém uma seta. A seta começa no ponto 0, 0 e termina no ponto 1, 1.

» Gráfico de aljavas com duas setas

Agora vamos adicionar uma segunda seta ao gráfico de aljava passando em dois pontos de partida e duas direções de seta.
Manteremos nossa posição inicial da seta original na origem 0,0 e apontando para cima e para a direita (na direção 1,1). Definiremos uma segunda seta com uma posição inicial de -0,5,0,5, que aponta diretamente para baixo (na direção 0, -1).
Um argumento de palavra-chave adicional para adicionar o método quiver() é scale=5. Incluir o parâmetro scale=5 dimensiona o comprimento das setas, para que as setas pareçam mais longas e apareçam melhor no gráfico de aljava.
Para ver o início e o fim de ambas as setas, definiremos os limites do eixo entre -1,5 e 1,5 usando o método ax.axis() e passaremos uma lista dos limites do eixo no formato [xmin, xmax, ymin, ymax] .
Executando o exemplo abaixo, podemos ver duas setas. Uma seta aponta para o canto superior direito e a outra seta aponta para baixo.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# se estiver usando o Jypyter notebook, use:
# %matplotlib inline
    
fig, ax = plt.subplots()
    
x_pos = [0, 0]
y_pos = [0, 0]
x_direct = [1, 0]
y_direct = [1, -1]
    
ax.quiver(x_pos, y_pos, x_direct, y_direct, scale=5)
ax.axis([-1.5, 1.5, -1.5, 1.5])
    
plt.show()

Nesse exemplo podemos ver um gráfico com duas setas. Ambas as setas começam no ponto 0,0. Uma seta aponta para o canto superior direito, a outra seta aponta para baixo.

» Gráfico de aljavas usando uma grade de malha

Um gráfico de aljava com duas setas é um bom começo, mas é entediante e repetitivo adicionar as flechas de aljava uma a uma. Para criar uma superfície 2D completa de setas, utilizaremos a função meshgrid() da biblioteca NumPy.
Primeiro, precisamos criar um conjunto de matrizes que denotem as posições iniciais x e y de cada seta no gráfico. As matrizes da posição inicial da seta serão denominadas X e Y.
Podemos usar as posições iniciais da seta x, y para definir os componentes x e y de cada direção da seta. Chamaremos a direção da seta u e v. Para esse gráfico, definiremos a direção da seta com base no ponto inicial da seta da aljava usando as equações abaixo.

X_direção = COS(X_{posição_inicial})
Y_direção = SIN(Y_{posição_inicial})

A seção de código abaixo cria as matrizes das posições X e Y usando a função np.meshgrid() da biblioteca NumPy.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# se estiver usando o Jypyter notebook, use:
# %matplotlib inline
    
x = np.arange(0,2.2,0.2)
y = np.arange(0,2.2,0.2)
    
X, Y = np.meshgrid(x, y)
u = np.cos(X) * Y
v = np.sin(y) * Y

Em seguida, podemos construir o gráfico de aljava usando o método quiver() do Matplotlib. Lembre-se de que o método quiver() aceita quatro argumentos posicionais:

ax.quiver(x_pos, y_pos, x_direct, y_direct)

Nesse gráfico de aljava, x_pos e y_pos são matrizes 2D que contêm as posições iniciais das setas e x_direct, y_direct são matrizes 2D que contêm as direções das setas.
Os comandos ax.xaxis.set_ticks([]) e ax.yaxis.set_ticks([]) remove as marcas de seleção do eixo e ax.set_aspect('equal') define a proporção da plotagem para 1:1.

Exemplo Python

fig, ax = plt.subplots(figsize=(7,7))
ax.quiver(X,Y,u,v)
    
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.axis([-0.2, 2.3, -0.2, 2.3])
ax.set_aspect('equal')
    
plt.show()

Agora vamos construir outro gráfico de aljava em que os componentes Î e ĵ (a direção) das setas de força, ⃗F dependem do ponto inicial da seta x, y de acordo com a função:

Novamente, usaremos a função meshgrid() do NumPy para criar as matrizes da posição inicial da seta e aplicar nossa função ⃗F às matrizes do ponto inicial da seta X e Y.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# se estiver usando o Jupyter notebook, use:
# %matplotlib inline
    
x = np.arange(-1,1,0.1)
y = np.arange(-1,1,0.1)
    
X, Y = np.meshgrid(x, y)
u = np.cos(X)*Y
v = np.sin(Y)*Y
    
X,Y = np.meshgrid(x,y)
    
u = X/5
v = -Y/5
    
fig, ax = plt.subplots(figsize=(9,9))
    
ax.quiver(X,Y,u,v)
    
ax.xaxis.set_ticks([])
ax.yaxis.set_ticks([])
ax.set_aspect('equal')
    
plt.show()

Anterior Próximo

Read More

Gráficos de contorno com Matplotlib

Com a biblioteca Matplotlib podemos criar gráficos de contorno de uma maneira muita rápida. Um gráfico de contorno pode ser muito útil em algumas áreas, como na engenharia Civil. Na engenharia Civil um gráfico de contorno pode mostrar o contorno de uma construção ou elevação. Já na engenharia Mecânica o mesmo tipo de gráfico pode mostrar um gradiente de tensão na superfície de uma peça.

Método plt.contourf()

Para podermos criar um gráfico de contorno precisaremos necessariamente usar o método contour(). Um exemplo de como chamar o método contour() pode ser visto abaixo:

Exemplo Python

ax.contour(X, Y, Z)

X, Y e Z são matrizes 2D com os seus elementos representando um ponto do gráfico. As arrays X e Y são pontos de coordenadas de x e y. Já a array Z é uma matriz que determinada a altura do contorno. Essa representação é feita num gráfico 2D através de uma cor.
No exemplo abaixo vamos utilizar a função np.meshgrid() para criarmos duas arrays 2D utilizando uma matriz 1D.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# Se estiver usando o Jupyter notebook, inclua:
# %matplotlib inline
        
        
x = np.arange(-3.0, 3.0, 0.1)
y = np.arange(-3.0, 3.0, 0.1)
X, Y = np.meshgrid(x, y)
        
Z = np.sin(X)*np.cos(Y)
        
fig, ax = plt.subplots(figsize=(6, 6))
        
ax.contour(X, Y, Z)
        
plt.show()

Ao executar o código acima você deve ter como resultado um gráfico como esse:

Método plt.contourf()

O método contourf() da biblioteca Matplotlib é semelhante ao método contourf(), a única diferença entre esses dois métodos é que o primeiro método criar um gráfico preenchido e o segundo não. Para chamar o método contourf passamos os mesmos parâmetros que passamos para o método contour. Veja um exemplo abaixo:

Exemplo Python

ax.contourf(X, Y, Z)
    

X e Y são arrays 2D dos pontos x e y, e Z é uma matriz 2D de pontos que determina a cor das áreas no gráfico 2D.
A próxima parte do código cria uma gráfico de contorno sombreada usando o método contourf() da biblioteca Matplotlib.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
# se estiver utilizando o Jupyter notebook, use:
# %matplotlib inline
        
        
x = np.arange(-3.0, 3.0, 0.1)
y = np.arange(-3.0, 3.0, 0.1)
        
X, Y = np.meshgrid(x, y)
        
Z = np.sin(X)*np.cos(Y)
        
fig, ax = plt.subplots(figsize=(6,6))
        
ax.contourf(X,Y,Z)
        
plt.show()

Executando esse código o seu gráfico deve estar igual a este:

Barras coloridas no gráfico de contorno

Nos gráfico de contorno utilizamos as cores parar representar uma determinada altura, mas sem saber a qual altura uma cor representar isso não é muito útil. Para resolver esse problema, nos gráficos de contornos, normalmente é adicionada uma barra colorida representando a altura. Essa barra funciona como uma legenda do gráfico.
As barras de cores utilizadas nos gráficos de contorno são adicionadas com o método colorbar(). Por essa barra não pertencer ao gráfico ela precisa ser adicionada. Para fazer isso passamos um gráfico de contorno para o método colorbar(). Assim, toda vez que você precisar adicionar uma barra de cores a um gráfico, um objeto plot precisar estar disponível. E a saída do método contourf() é um objeto plot.
Nos exemplos anteriores, a saída do método contourf() não era atribuída a nenhuma variável. Mas, para adicionar uma barra de cores no nosso gráfico, vamos precisar da saída desse método. Assim podemos passar um objeto plot para o método colorbar().

Exemplo Python

cf = ax.contourf(X,Y,Z)
fig.colorbar(cf, ax = ax)

cf é o objeto plot criado pelo método contourf(). O objeto eixocontém o gráfico de contorno, ax é passado para o método colorbar()junto com o objeto plot.

Executando o exemplo abaixo criamos um gráfico de contorno preenchido com uma barra de cores posicionada ao lado do gráfico.

Exemplo Python

import numpy as np
import matplotlib.pyplot as plt
        
x = np.arange(-3.0, 3.0, 0.1)
y = np.arange(-3.0, 3.0, 0.1)
        
X, Y = np.meshgrid(x, y)
        
Z = np.sin(X)*np.cos(Y)
        
fig, ax = plt.subplots(figsize=(6,6))
        
ax.set_aspect('equal')
cf = ax.contourf(X,Y,Z)
fig.colorbar(cf, ax = ax)
        
plt.show()

Executando código acima o gráfico é esse:

Mapas de cores

O esquema de cores usado nos gráficos de contornos podem ser mudados. O método mais rápido de se fazer isso é usando o método get_cmap() da biblioteca Matplotlib. Na biblioteca Matplotlib existem vários mapas de cores que você pode usar nos seus gráficos. Para ver quais mapas de cores estão disponíveis acesse a documentação da biblioteca (https://matplotlib.org). Já com o mapa de cores precisamos passar esse objeto para o método ou contourf().

Exemplo Python

meu_mapc = plt.get_cmap('gist_earth')
ax.contourf(X, Y, Z, cmap = meu_mapc)

No exemplo abaixo vamos alterar a cor padrão dos gráficos de contorno.

Exemplo Python

import matplotlib.pyplot as plt
import numpy as np
        
x = np.arange(-3.0, 3.0, 0.1)
y = np.arange(-3.0, 3.0, 0.1)
        
X, Y = np.meshgrid(x, y)
        
Z = np.sin(X)*np.cos(Y)
        
fig, ax = plt.subplots(figsize=(6,6))
        
meu_mapc = plt.get_cmap('plasma')
ax.set_aspect('equal')
ax.set_title('Mapa de cores: plasma')
cf = ax.contourf(X,Y,Z, cmap = meu_mapc)
        
fig.colorbar(cf, ax = ax)
        
plt.show()

Executando esse código o seu gráfico deve estar igual a este:

Anterior Próximo

Read More

Como você executa um loop while no Python?

O que é um "loop while"?

Um loop while consiste em uma condição e, até que essa condição seja verdadeira, um conjunto de instruções é executado repetidamente.
Um loop while é a única construção de repetição necessária. O loop for, pode ser duplicado usando um loop while e com mais controle.

A sintaxe é a seguinte:

Exemplo

Aqui está uma olhada no código do loop while:

Exemplo

x = 4
y = 0
while (y <= 10 ): # o loop while vai ser executado enquanto y for menor ou igual a 10
  y += x
  x += 1

# o loop vai iterar 3 vezes
print("O valor de x é: ", x)
print("O valor de y é: ", y)

Explicação

No código acima, o loop while é executado enquanto a condição y <= 10 estiver sendo atendida. As instruções nas linhas 4 e 5 são executadas se a expressão entre parênteses for avaliada como verdadeira. br Quando a expressão é avaliada como falsa, o programa sai do loop e imprime os valores finais de x e y. Abaixo está uma ilustração do código acima para ajudar a ilustrar a lógica.

Fonte: How do you execute a 'while loop' in Python?
Licença: Creative Commons -Attribution -ShareAlike 4.0 (CC-BY-SA 4.0)

Read More

Como try/except é usado em Python?

Manipulação de exceção

Uma exceção é um erro que ocorre enquanto o programa está executando. Quando esse erro ocorre, o programa é interrompido e gera uma exceção, que é manipulada para impedir que o programa trave.

try/except

As exceções geradas por um programa são capturadas no bloco try e tratadas no bloco except.

• Try: Permite testar um bloco de código quanto a erros.
• Except: permite lidar com o erro.

Exemplos

Vamos dar uma olhada em um exemplo simples de try/excption.

Exemplo

try:
  print(x)
except:
  print("Um erro ocorreu")

Como x não está definido em nenhum lugar do código, ocorrerá uma exceção; portanto, o bloco de exceção executará e exibirá a mensagem.
Você pode definir quantos blocos de exceção desejar para erros diferentes, como mostrado abaixo.

Exemplo

try:
  print(x)
except ValueError: #você receberá esse erro se houver um problema com o conteúdo do objeto ao qual você tentou atribuir o valor
  print("Dados não numéricos encontrados")
except NameError: #você receberá esse erro se o programa encontrar um nome que não reconheça
  print("A variável x não foi definida")
except:
  print("Algum erro aconteceu")

Você também pode usar a palavra-chave else para definir o código que deve ser executado se nenhum erro for gerado.

Exemplo

try:
  print("Hello World")
except ValueError:
  print("Dados não numéricos encontrados")
except NameError:
  print("A variável x não foi definida")
except:
  print("Algum erro aconteceu")
else:
  print("Nada de errado aconteceu")

Fonte: How is try/except used in Python?
Licença: Creative Commons -Attribution -ShareAlike 4.0 (CC-BY-SA 4.0)

Read More

O que são tuplas em Python?

O que é tupla?

Uma tupla é uma lista imutável de objetos Python, o que significa que não pode ser alterada de forma alguma depois de criada. Ao contrário dos sets, as tuplas são uma coleção ordenada.

Criando uma tupla

Agora vamos dar uma olhada no exemplo de uma tupla.

Exemplo

tupleExmp = ("alpha","bravo","charlie")
print(tupleExmp)

Depois que uma tupla é criada, os itens não podem ser adicionados ou removidos e seus valores não podem ser alterados. Alterar a tupla acima gera um erro.

Exemplo

tupleExmp = ("alpha","bravo","charlie")
tupleExmp[0] = "100" # um erro será lançado

Acessando itens de tupla

Os índices de tupla são baseados em zero, como em uma lista; portanto, o primeiro elemento de uma tupla não vazia é sempre a tupla[0].
Os índices selecionados são contados a partir do final da tupla, assim como as lista.

Exemplo

tupleExmp = ("alpha","bravo","charlie")
print(tupleExmp[1]) # mostra o segundo elemento
print(tupleExmp[-1]) # mostra o último elemento

Você também pode percorrer os valores da tupla usando um loop for.

Exemplo

tupleExmp = ("alpha","bravo","charlie")
for item in tupleExmp:
  print(item)

Comprimento de uma tupla

O comprimento de uma tupla pode ser encontrado usando a função len().

Exemplo

tupleExmp = ("alpha","bravo","charlie")
print(len(tupleExmp))

Fonte: What are tuples in Python?
Licença: Creative Commons -Attribution -ShareAlike 4.0 (CC-BY-SA 4.0)

Read More