<jupyter_start><jupyter_text>![PPGI_UFRJ](imagens/ppgi-ufrj.png) Fundamentos de Ciência de Dados ---[![DOI](https://zenodo.org/badge/335308405.svg)](https://zenodo.org/badge/latestdoi/335308405) --- PPGI/UFRJ 2020.3 Prof <NAME> e <NAME> --- Módulo 2 - Numpy > Biblioteca para Computação científica com Python. Pode ser encontrada em [Numpy](https://numpy.org/doc/stable/). Esta biblioteca permite realizar operações eficientes em estruturas de dados usadas em aprendizado de máquina (machine learning): **vetores, matrizes e tensores**.  Importando a biblioteca Numpy<jupyter_code># importando a biblioteca
import numpy as np
# version do numpy
print(np.version.version)<jupyter_output><empty_output><jupyter_text>Diferença entre Arrays e Listas  Declaração de ndarray e lista<jupyter_code>my_arr = np.arange(1000000)       # ndArray
my_list = list(range(1000000))    #Lista<jupyter_output><empty_output><jupyter_text>**Vamos imprimir?**<jupyter_code>print(my_arr)
print (my_list)<jupyter_output><empty_output><jupyter_text>**O que houve com a lista?**  Criando narrays simples<jupyter_code># exemplo - vetor
v = [12, 10, -1, 4] # lista
print('v:',type(v))
# converter uma lista em vetor
v1 = np.array(v)

# verificando se é array ou Lista 
print('v1:',type(v1))
print('v1 =',v1)
#v = [1,2,3 4]<jupyter_output><empty_output><jupyter_text>**Verificando um narray**<jupyter_code># criando um vetor fila ou linha (1 dimensão)
vetor = np.array([-1, 0.5, 20, 4, -2.0, 20])
print('v:',vetor)
print('T:',len(vetor))            # verifica tamanho do nArray<jupyter_output><empty_output><jupyter_text>Métodos principais para vetores e matrizes- narray.dtype - Tipo do array- narray.ndim - Dimensões do array- narray.shape - Número de elementos em cada dimensão no array, (n,m)- narray.size - Tamanho do array (total de elementos), n *x* m- narray.reshape - Redimensão do array n *x* m<jupyter_code># exibindo detalhes do vetor narray
print('Tipo:        ',vetor.dtype)
print('Dimensao :   ',vetor.ndim)
print('Shapinng:    ',vetor.shape)
print('Tamanho:     ',vetor.size)
print('Redimensiona:',vetor.reshape(2,3))
# criar vetor coluna
vetor_c = np.array([[-1],[0.5],[20],[4],[-2.0]])
print('C:  \n',vetor_c)
print('Dim:  ',vetor_c.ndim)                 #2
print('Shape:',vetor_c.shape)                #(5,1)<jupyter_output><empty_output><jupyter_text>Observe os códigos da matriz_3x3   Uso de *ndim* > Número de dimensões da matriz<jupyter_code># criando uma matriz
matriz_3x3 = np.array([[4,6,2],[8,-1,0],[3,4,5]])
print('M:    ',matriz_3x3)
print('Dim:  ',matriz_3x3.ndim)                 #2
print('Shape:',matriz_3x3.shape)                #(3,3)<jupyter_output><empty_output><jupyter_text>Uso de *len*> Retorna o tamanho da primeira dimensão do vetor/matriz<jupyter_code># funcoes: len e shape
# tamanho do vetor/matriz:len()
print('T:',len(matriz_3x3))              # = ndim
# dimesoes do vetor/matriz: shape
print('D:',matriz_3x3.shape)<jupyter_output><empty_output><jupyter_text>Por que os resultados de *ndim* e *len* são diferentes?<jupyter_code># exemplo de tamanho e dimensao
A = np.array([[1,-1],[3, -2],[4,2]])
print('A:     \n',A)                  # imprime a matriz
print('Tam =  ',len(A))               # tamanho 
print('Dim =  ',A.ndim)               #dimensoes
print('Shape =',A.shape)              # dimensoes(linhas, coluna)<jupyter_output><empty_output><jupyter_text>Redimensionamentro de vetores e matrizes<jupyter_code># exemplo de size
print('Tam :',A.size)        # Imprime o total de elementos da matrix A
print(A)                     # Imprime a matrix A
print('')

# exemplos de reshape
B = A.reshape(2,3)           # Redimensiona o Array A de 3 linhas x 2 colunas para 2 x 3
print('Tam :',B.size) 
print(B)                     # Imprime os elementos da matrix B reshaped
print('')

# exemplo de reshape - nao alteram o tamanho da matrix
BB = A.reshape(1,6)          # Redimensiona o Array A de 2 x 3  para 1 x 6
print('BB:')                  
print(BB)                    # Imprime os elementos da matrix BB reshaped 
print('')               
B1 = A.reshape(6,1)          # Redimensiona o Array A de 2 x 3  para 6 x 1
print('B1 :', B1)            # Imprime os elementos da matrix B1 reshaped<jupyter_output><empty_output><jupyter_text>Criação de Matrizes<jupyter_code># exemplo: len, ndim, shape, size e reshape
# array (dimensão)
A1 = np.array([(1,2,3), (4,5,6), (2,7,8)])
print('A: \n',A1)
print('Dim: ',A1.shape)<jupyter_output><empty_output><jupyter_text>Criação de matriz com zeros<jupyter_code># criação de matrizes de inteiros
Z = np.zeros((2,3))
print('Z: \n',Z)
# criação de matrizes de numeros complexos, dtype indica o tipo, e.g int, float, complex
z1 = np.zeros((3,3),dtype=complex)
z1<jupyter_output><empty_output><jupyter_text>Criação de matriz com uns<jupyter_code># matriz unitaria
array = np.ones((3,3))
print(array)
# matriz de números complexos
z1 = np.ones((3,3),dtype=complex)
z1<jupyter_output><empty_output><jupyter_text>Criação de matriz diagonal<jupyter_code># matriz diagonal 1
array = np.eye(3) 
print(array)
# matriz identidade
i = np.identity(5)
print(i)<jupyter_output><empty_output><jupyter_text>Criação de matriz  up/down<jupyter_code># Matriz Diagonal
A = np.diag([1.0, 2, 3])
A
# Matriz Diagonal inversa up/down
np.flipud(A)<jupyter_output><empty_output><jupyter_text>Criaçao de matriz left/right<jupyter_code># Matriz Diagonal direita/esquerda
np.fliplr(A)<jupyter_output><empty_output><jupyter_text>Criação de matriz com número específicos<jupyter_code># preenche dados especificos numa matriz
f = np.full((3,3),3.14,dtype=float)
print(f)<jupyter_output><empty_output><jupyter_text>Criação de matriz com número randômicos<jupyter_code># numero aleatorios: matriz de inteiros
ma = np.random.randint(0, 100, (3,3))              # tente 100000 x 100000!
print(ma)
# numero aleatorios: matriz de reais
r1 = np.random.rand(4,4)
print(r1)<jupyter_output><empty_output><jupyter_text>Método *arange* > Permite preencher um vetor ou matriz ordenadamente, permite definiçao de **start**, **stop** e **step**<jupyter_code>#Preenchimento de vetor com step 1 - tamanho 10 posiçoes, crescente 
v0 = np.arange(10)
print(v0)
#Preenchimento de vetor com step 1 - tamanho 9 posições
# Argumentos (inicio, fim, passo)
v1 = np.arange(start=1, stop=10, step=1)
print(v1)
#Preenchimento de vetor com step 3 - Positivos
v2 = np.arange(start=1, stop=10, step=3)
print(v2)
# Preenche o vetor com step=3 e stop=8
v3 = np.arange(start=1, stop=8, step=3)
print(v3)
# preenche elementos com step=3 e stop = 10.1
v4 = np.arange(start=1, stop=10.1, step=3)
print(v4)
# Preenche elementos com step=4
v5 = np.arange(1, 10, 4)
print(v5)<jupyter_output><empty_output><jupyter_text>Graficamente temos ![image.png](attachment:image.png)<jupyter_code># Preenchimento de vetor com step 2 - Negativos
vn0 = np.arange(start=-10, stop=-2, step=2)
print(vn0)
#Preenchimento de vetor com step 2 - Negativos
vn1 = np.arange(-10, -2, 2)
print(vn1)
# exemplo com matrizes
A2 = np.arange(60).reshape(3,4,5)
print(A2.shape)
print(A2.ndim)
print(A2.size)
print(A2)
print("---")
#
A11 = np.arange(60).reshape(20,3)
print(A11)                                     # Se usarmos tensores, Deep Learning<jupyter_output><empty_output><jupyter_text>Gerando valores com a função linspace<jupyter_code># Return evenly spaced numbers over a specified interval.
# Returns num evenly spaced samples, calculated over the interval [start, stop].
# Geracao devalores usando a funcao: linspace
#
pesos_turma = np.linspace(50,80,num=50) # 50 kg <= peso <= 80 e numero de alunos 30
print(pesos_turma)<jupyter_output><empty_output><jupyter_text>Operações Aritméticas com Matrizes> Qualquer operação aritmética pode ser aplicada, desde que sejam de tamanhos iguais<jupyter_code># Criando as matrizes
mat1 = np.array([[1., 2., 3.], [4., 5., 6.]])
mat2 = np.array([[5, 3, 1.], [-1, 5., 6.]])
print(mat1)
#print(mat1.shape)
print(mat2)
#print(mat2.shape)<jupyter_output><empty_output><jupyter_text>**Soma de matrizes**<jupyter_code># soma
soma = mat1 + mat2
print(soma)
# Matriz
mat = np.array([[1., 2., 3.], [4., 5., 6.]])
print(mat)
z1 = np.ones((3,3),dtype=complex)
z1<jupyter_output><empty_output><jupyter_text>**Multiplicação de Matrizes**  Algebra Linear de Matrizes<jupyter_code>print(mat1 * mat2)  # mat1*mat2
print(mat1 * mat1)  # = print(mat **2)
print(mat * 2)
print(mat + (mat *2) -10)
arr1 = np.array([[0., 3., 1.], [9., 2., 11.]])
arr2 = np.array([[0., 4., 1.], [7., 2., 12.]])
print(arr1)
print(arr2)
# verificado a condição em cada posição correspondente nas matrizes
print(arr2 > arr1)
print(z1 * z1 * 4)      # Z1 é uma matriz de complexo<jupyter_output><empty_output><jupyter_text>Funções trigonométricas<jupyter_code>sin_90 = np.sin(90)                                    # sine value of degree 90 in degree
print ("Sine value of angle 90 in degree = ",sin_90)   # print sine value

                                                       # np.pi = 3.14
sin_90 = np.sin(90 * np.pi/180)                        # sine value of angle 90 in radinas
print("Sine value of angle 90 in radians = ", sin_90)


cos_180 = np.cos(180 * np.pi/180)                       # np.pi = 3.14
print("Cosine value of angle 180 in radians = ", cos_180)

tan_60 = np.tan(60)                                     # tangent value of degree 60 in degree
print("Tangent value of angle 60 in degree = ", tan_60) # print tangent value<jupyter_output><empty_output><jupyter_text>Indexação e fatiamentos em Matrizes> Visualizar algum valor do array ou mudar em valor usando o índice de indexação.   Indexação> Visualizar algúm valor do array ou mudar um valor usando o índice de indexação. Muito usado em visualizaçãpo de dados<jupyter_code># arr = np.arange(start=0, stop=10, step=1)
arr = np.arange(10) 
print(arr)                   # [0 1 2 3 4 5 6 7 8 9]
print(arr[5])                # 5 - imprime a posiçao do quinto elemento do vetor
print(arr[5:8])              # [5 6 7] - imprime a posiçao do quinto ao oitavo elemento do vetor
arr[5:8] = 12                # Atribui o valor 12 aos elementos 5o. ao 70.
print(arr)                   # [ 0 1 2 3 4 12 12 12 8 9]
#construção de matriz de float
pesos_turma = np.linspace(50,80,num=40)
print(pesos_turma)                       # imprime os pesos da turma (50 <= Peso <= 80), 40 valores
D2 = pesos_turma.reshape((4,10))         # Redimensiona a matriz para uma nova matriz de 4x10
D2                                       # visualiza a matriz 4x10
print('')
# exemplo: Visializar um elemento de uma matriz. No caso o elemento da posição (2,3) do matriz D2
d23 = D2[2,3]                            # 
print(d23)                               # visualiza elemento da posição (2,3)
d00 = D2[0,0]                            # acessa o elemento da posição (0,0)
print(d00)                               # visualiza o elemento
#Mudar o valor do elemento d23 = -1.0
D2[2,3] = -1.0        # acessa o elemento da posição (2,3) e muda o valor para -1.0
d23 = D2[2,3]         # a variavel d23 recebe o valor do elemento (2,3)
print('d23:',d23)     # visualiza o elemento d23
print('D2',D2)        # visualiza matriz D2
# Verificando condicoes para checagem de valor de elementos da Matrix
C = D2 < 60    # verifica se os elementos da matriz são maiores que 60 (True)
print(C)       
# Verificando condicoes para achar outliers e mudar
D2[D2>4] = 2   # verifica se os elementos da matriz são maiores que 4
               # e asigna valor 2 a esses elementos
E = D2         # D2 é asignado à matriz E
print(E)       # imprime a matriz E<jupyter_output><empty_output><jupyter_text>Manipulando valores que não existentes: nan e isnan > **NumPy** fornece funções de agregação que permitem calcular de forma segura valores ausentes num dataset espeficidados de forma especial pela IEEE para lidar com valores NaN de ponto flutuante. O tratamento de valores faltantes está disponível no Numpy 1.8 ou superior. Maiores detalhes https://numpy.org/doc/stable/user/misc.html e https://numpy.org/doc/1.13/neps/missing-data.htmldefinition-of-missing-data  NaN (Not a Number)> **Numpy** define funções especias para tratar valores numéricos faltantes que podem resultar em cálculos matemáticos: **nan**, **isnan**. Estas funções também são utilizadas em **pandas** para marcar valores **ausentes**. > As funções **isnull** e **notnull** devem ser usadas para detectar dados ausentes num dataset.<jupyter_code># exemplo de nan
vet = np.array ([1,-1,0], dtype = np.float64) # define um vetor
vet1 = vet/0                                  # operaçaõ de divisão*
print(vet1)                                   # [1/0, -1/0, 0/0] -> 0/0 not a number (nan)!!!
# valores de um arquivo
vet2 = np.array([0,-2.10, 4, 6, 20, 30, -10, np.NAN, 3, 5]) # vetor com valor nan
vet2<jupyter_output><empty_output><jupyter_text>ISNAN (isnan)> Função do Numpy que permite detectar valores especiais (nan).<jupyter_code># verificando se existe algum valor nao numerico nos elementos do array
vet3 = np.isnan(vet1)    # vetor com um valor nan
print(vet3)
vet4 = np.isnan(vet2)    # vetor com um valor nan
print(vet4)<jupyter_output><empty_output><jupyter_text>> O caracter **~** é usado para eliminar valores indesejados de um vetor/matriz<jupyter_code># exemplo: eliminar o elemento indesejado de um vetor
print('O:',vet1)
vet5 = vet1[~np.isnan(vet1)]
print('R:',vet5)
# exemplo: eliminar um elemento indesejado de uma matriz
M = np.array([[1, 2, np.NAN],[np.NAN, -1, 0.5],[1, 2, 4]])
M
# verificando a existencia de valores indesejados
Y1 = np.isnan(M)
print(Y1)
# eliminar valores nan numa matriz
Y2 = M[~np.isnan(M)]
Y2                    # OBS: a matriz é convertida para vetor, logo é um problema em aplicações!!!
# substituir e eliminar os elementos indesejandos de uma matriz
print('M:')
print(M)
print('D:',Y1.shape)      # verifica as dimensões da matriz
print('M[0,2]:',M[0,2])   # verifica o elemento da posição (0,2)
M[0,2] = 10               # muda valor de nan para 10
print('M[1,0]:',M[1,0])   # verific o elemento da posição (1,0)
M[1,0] = 3.14             # # muda valor de nan para 3.14
print(M)                  # visualiza a matriz<jupyter_output><empty_output><jupyter_text>Fatiamentos > Usando a função **slice** para fatiar (extrair) linhas e colunas de uma matriz<jupyter_code># Usando a funcao: slice para extrair (fatiar) linhas
Mat = np.array([[1, 2, np.NAN,-1],[np.NAN, -1, 0.5, 0.5],[1, 2, 4, -1],[3.5,5,8,0]])
print('Mat:')
print(Mat)
print()
# slice primeira linha
print('L0:',Mat[0,:])     # extrair a linha 0 da matriz
print()
print('L3:',Mat[3,:])     # extrair a linha 3 da matriz
# slice a primeira coluna
C2 = Mat[:,2]
print('C2:',Mat[:,2])   # extrair todos os elementos da coluna 2
# slice a ultima coluna
print('CF:',Mat[:,-1]) # slice a ultima coluna: -1
# slice a ultima fila: -1
print('UF:',Mat[-1,:])
print('Mat:')
print(Mat[:,:])  # visualiza a matriz completa
# slice com saída em uma submatriz
sm = Mat[1:,2:]   # slice em submatriz:
print(sm)
# slice para submatriz
sm1 = Mat[1:,:2]  # submatriz
print(sm1)
# Criando uma matriz x, com referencia y (atribuição) e uma copia z
x = np.array([[1,1,1], [2,2,2], [3,3,3]])    # matrix x
y = x                                        # y matriz refrencia de x
z = np.copy(x)                               # z é copia da matriz x
#x = np.array([[0,0,0], [1,1,1], [2,2,2]]) 

print('x:')
print(x)
print('y:')
print(y)
print('z:')
print(z)
# mudando valores
y[0,1] = -1   # mudando valores na matriz y
print('x:')
print(x)      # visualiza os valores da matriz x
z[2,0]=-1     # muda valor de um elemento de z
print('z:')
print(z)      # visualiza os valores da matriz z 
print('x = y:')
print(x==y)
print('x = z:')
print(x==z)<jupyter_output><empty_output><jupyter_text>> Uma **atribuição** no Python não copia objetos, ela cria uma ligação entre um objeto destino e um objeto fonte. Para coleções que são mutáveis (se pode mudar os valores) ou contêm itens mutáveis, às vezes é necessária uma cópia para que seja possível alterar uma ela sem alterar a outra.> **copy(x)**: retorna uma copia rasa de **x**. **deepcopy(x)**: retorna uma cópia profunda de **x**.> A diferença entre uma cópia **profunda** e **rasa** é relevante apenas para **objetos compostos** (objetos que contêm outros objetos, como listas ou instâncias de classe):> - Uma cópia **rasa** constrói um novo objeto composto e então (na medida do possível) insere nele referências aos objetos encontrados no original.> - Uma cópia **profunda** constrói um novo objeto composto e então, recursivamente, insere nele cópias dos objetos encontrados no original.> Maiores informações: [copy1]('https://numpy.org/doc/stable/reference/generated/numpy.copy.html'). [copy2]('https://docs.python.org/pt-br/3/library/copy.html')<jupyter_code># exemplo de deepcopy

import copy
a = np.array([1,'a',[-1,1,2],3,4,5],dtype=object)
print('a:',a)
c = copy.deepcopy(a)
print('c:',c)
print('Modificando ...')
c[2][1] = 'z'
print('c:',c)
print('a:',a)<jupyter_output><empty_output><jupyter_text>Estátistica básica<jupyter_code># exemplo: um narray autoprrenchido com 40 pessoas de pessoas entre 55 e 90Kg
peso_kg = np.linspace(55,90,num=40)
print('Peso em Kg:')
print(peso_kg)<jupyter_output><empty_output><jupyter_text>Exemplo de uso de funções estatísticas triviais<jupyter_code># Uso de funcoes estatisticas simples
# maximo
maximo = peso_kg.max()
print('Peso máximo :',maximo)
# minimo
minimo = peso_kg.min()
print('Peso mínimo :',minimo)
# somatorio
soma = peso_kg.sum()
print('Somatorio dos valores dos pesos :',soma)
# media aritmetica
media = peso_kg.mean()
print('Média peso do conjunto :',media)
# desvio padrao
desv = peso_kg.std()
print('Desvio padrão dos valores dos pesos :',desv)
vart = peso_kg.var()
print('Variância dos valores dos pesos :',vart)<jupyter_output><empty_output><jupyter_text>> **Observação**: Para variância e desvio padrão de **amostras**, acrescentar **ddof=1** (delta degrees of freedom). Neste caso **Grau de liberdade delta (ddof = 1)** é usado para garantir que sempre estamos usando a variancia e desvio-padrão amostral. > O desvio padrão de uma **população** é $ \sigma^{2 } = \frac{\sum(x-\mu)^{2}}{N}$. A estimativa do desvio padrão da população calculada a partir de uma **amostra** aleatória é $ s^{2} = \frac{\sum_{i=1}^{n}(x_{i}- \bar{x})^{2}}{N-1}$. Onde $\mu$ e $\bar{x}$ são as médias da população e da amostra respecticamente. **N** é a população. O divisor usado nos cálculos é **N - ddof**.> Observando que **ddof = 0** indica uso da variancia e desvio-padrão populacional e **ddof=1** indica o uso da variancia e desvio-padrão amostral.<jupyter_code>#Amostra da populaçao
desv1 = peso_kg.std(ddof=1)
print('Desvio padrão dos valores da turma :',desv1)
#Amostra da populaçao
vart1 = peso_kg.var(ddof=1)
print('Variância dos valores da turma :',vart1)<jupyter_output><empty_output><jupyter_text>Compare os valores do desvio padrão e variança da população e da amostra. Observe as diferenças  Usando o MatPlotLib junto ao NumPy para exibir dados graficamente  Vamos desenhando gráficos bem simples - Quantitative variables  > **MatplotLib** é biblioteca muito famosa para criar gráficos e é de código aberto. Com ela, podemos montar diversos tipos de gráficos. Para começar a usar a biblioteca, temos que **importar** ela ao ambiente de programação.> **MatPlotLib** é originária do **MatLab** e não é a unica bibliteca de gráficos que veremos nesse curso.<jupyter_code>from matplotlib import pyplot as plt<jupyter_output><empty_output><jupyter_text>Vamos começar do zero? A figura abaixo exibe os principais elementos de um gráficos MapPlotLib. Compreender ajudará a fazer ótimas visualizações.- Tipos de plots https://matplotlib.org/stable/tutorials/introductory/sample_plots.html- Esquema de cores https://matplotlib.org/3.1.0/gallery/color/named_colors.html- Esquema de marcadores https://matplotlib.org/stable/api/markers_api.html ![image.png](attachment:image.png)  Gráficos de linhas<jupyter_code># Suponha o faturamnento de uma loja online
# Dados são oriundo de 2 matrizes orunda dos sistemas
meses = ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho']  # Eixo X
valores = [105235, 107697, 110256, 109236, 108859, 109986]           # Eixo Y

plt.plot(meses, valores)    # O método plot cria um gráfico de linhas, note que o limite dos eixos é automatico
plt.show()                  # Show plot 

# Observe que esse gráfico foi gerado "automaticamente", ele pode ser 
# melhorado ao aplicar os conceitos da anatomia de um gráfico 
plt.plot(meses, valores)                           # Atenção para os valores dos eixos
plt.ylim(100000, 117500)                           # O método ylim cria limites para os valores do eixo Y
plt.show()<jupyter_output><empty_output><jupyter_text>Detalhando as informações no gráfico<jupyter_code>plt.plot(meses, valores)                                # Plot os dados nos eixos primários.
plt.ylim(100000, 117500) 
plt.title('Faturamento no primeiro semestre de 2020')   # Definição do Title do gráfico
plt.xlabel('Meses')                                     # label do Eixo X
plt.ylabel('Faturamento em R$')                         # label do Eixo Y
plt.show()

#ax.plot(x, x, label='linear')  
# Trabalhando com várias curvas (plots simples) no mesmo gráfico sem legendas
t = np.arange(0., 5., 0.2)
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()
x = np.linspace(0, 2, 100)
#
plt.plot(x, x, label='linear')          # Plot some data on the (implicit) primary axes.
plt.plot(x, x**2, label='quadratico')   # Plot some data on the (implicit) primary axes.
plt.plot(x, x**3, label='cubico')       # Plot some data on the (implicit) primary axes.
plt.xlabel('eixo X')                    # Add an x-label to the axes.
plt.ylabel('eixo Y')                    # Add a y-label to the axes.
plt.title("Plot Simples ")              # Add a title to the axes.
plt.legend();                           # Add a legend.
# tente substituir ---> plt.plot(x, x**3, 'g^', label='cubico')  # Veja o resultado<jupyter_output><empty_output><jupyter_text>Inserir exemplos de subplot  Exemplo de eixo secundário e escalas distintas<jupyter_code>fig, ax = plt.subplots(constrained_layout=True)

x = np.arange(0, 360, 1)
y = np.sin(2 * x * np.pi / 180)

ax.plot(x, y)
ax.set_xlabel('ângulo [graus]')
ax.set_ylabel('sinal')
ax.set_title('Senóide')

def deg2rad(x):
    return x * np.pi / 180

def rad2deg(x):
    return x * 180 / np.pi

secax = ax.secondary_xaxis('top', functions=(deg2rad, rad2deg))
secax.set_xlabel('ângulo [rad]')
plt.show()<jupyter_output><empty_output><jupyter_text>Multiplos Plots  ( Sub-plots)<jupyter_code># Exemplos de  sub plots múltiplos  
# Exemplo 01

fig, axs = plt.subplots(2, 2)
axs[0, 0].plot(x, y)                # cor default é azul
axs[0, 0].set_title('Eixo [0, 0]')
axs[0, 1].plot(x, y, 'tab:orange')  # default é linha cheia 
axs[0, 1].set_title('Eixo [0, 1]')
axs[1, 0].plot(x, -y, 'tab:green')
axs[1, 0].set_title('Eixo [1, 0]')
axs[1, 1].plot(x, -y, 'r--')         # estilo e cor
axs[1, 1].set_title('Eixo [1, 1]')

for ax in axs.flat:
    ax.set(xlabel='x-label', ylabel='y-label')

# Hide x labels and tick labels for top plots and y ticks for right plots.
for ax in axs.flat:
    ax.label_outer()<jupyter_output><empty_output><jupyter_text>Multiplos Plots  (com sub-plots)<jupyter_code># Exemplos de sub plots múltiplos  
# Exemplo 02
def f(t):
    return np.exp(-t) * np.cos(2*np.pi*t)

t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)

plt.figure(1)
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')

plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r.')
plt.show()
# Exemplos de plots múltiplos  e legenda horrivel CUIDADO)
# Exemplo 02

a = b = np.arange(0, 3, .02)
c = np.exp(a)
d = c[::-1]

# Criando Plots com labels pre-definidas.

fig, ax = plt.subplots()
ax.plot(a, c, 'k--', label='Modelo')
ax.plot(a, d, 'k:', label='Dados')
ax.plot(a, c + d, 'k', label='Total')
legend = ax.legend(loc='upper center', shadow=True, fontsize='x-large')         #Posição da legenda
legend.get_frame().set_facecolor('#01AFCD')                                     #Cor da legenda

plt.show()<jupyter_output><empty_output><jupyter_text>Exemplos de histograma<jupyter_code># Histograma
# importando a biblioteca para graficos
from matplotlib import pyplot as plt 
plt.hist(peso_kg, bins = [50, 60, 70, 80, 90, 100],color='g',alpha=0.5)  # dados, cor
plt.title("Numpy Histograma")
plt.xlabel('Distribuição de peso da turma')
plt.ylabel('Frequência de pesos')
plt.grid(True)                                                           # habilita o Grid
# show plot 
plt.show()
import matplotlib.pyplot as plt

labels = ['G1', 'G2', 'G3', 'G4', 'G5']
men_means = [20, 35, 30, 35, 27]           
women_means = [25, 32, 34, 20, 25]
men_std = [2, 3, 4, 1, 2]
women_std = [3, 5, 2, 3, 3]
width = 0.5                                   # the width of the bars: can also be len(x) sequence

fig, ax = plt.subplots()                      # fig monta as bordas(fig) e as barras (ax)

ax.bar(labels, men_means, width, yerr=men_std, label='Homens')
ax.bar(labels, women_means, width, yerr=women_std, bottom=men_means, label='Mulheres')

ax.set_ylabel('Scores')
ax.set_xlabel('Grupos')
ax.set_title('Histograma de Scores por grupo e gênero')
ax.legend()

plt.show()
import matplotlib.cbook as cbook
import matplotlib.image as image

with cbook.get_sample_data('C:\Anaconda3\Lib\site-packages\matplotlib\mpl-data\images\matplotlib_large.png') as file:
    im = image.imread(file)                         #Carrega marca d´água

fig, ax = plt.subplots()                            #Define subplot fig e ax

ax.bar(labels, men_means, width, yerr=men_std, label='Homens')
ax.bar(labels, women_means, width, yerr=women_std, bottom=men_means, label='Mulheres')

ax.set_ylabel('Scores')
ax.set_xlabel('Grupos')
ax.set_title('Histograma de Scores por grupo e gênero')
ax.legend()
ax.grid(True)   

fig.figimage(im, 10, 10, zorder=3, alpha=.7)        #Imprime marca d´água no subplot fig

plt.show()<jupyter_output><empty_output><jupyter_text>Exemplo de distribuição de probabilidades<jupyter_code>np.random.seed(19680801)

mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)

# Definindo o histograma de dados
n, bins, patches = plt.hist(x, 50, density=True, facecolor='g', alpha=0.75)

plt.xlabel('Inteligentes')
plt.ylabel('Probabilidade')
plt.title('Histograma de QI')
plt.text(60, .025, r'$\mu=100,\; \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1351575456053068, 'fraction_numerical': 0.037426503844414295, 'mean_word_length': 3.8023529411764705, 'pattern_counts': {'":': 0, '<': 176, '<?xml version=': 0, '>': 199, 'https://': 10, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 28, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '42', 'dir': 'jupyter-structured-clean-dedup', 'id': '314330', 'license': 'CC0-1.0', 'n_tokens_mistral': 10911, 'n_tokens_neox': 10248, 'n_words': 2819, 'path': '.ipynb_checkpoints/FCD_M2_1_Numpy-checkpoint.ipynb', 'repo_name': 'zavaleta/Fundamentos_DS', 'size': '26546'}