import numpy as np

vetor = np.arange(3)

print(vetor)

[0 1 2]

print(np.exp(vetor)) # Cálculo exponencial e^0, e^1, e^2

[1. 2.71828183 7.3890561]

print(np.sqrt(vetor)) # Raiz quadrada de cada elemento

[0. 1. 1.41421356]

matriz = 10 * np.random.random((3,4))
print(matriz)
arredondado = np.floor(matriz) # Arredondamento para baixo
print(arredondado)

[[0.89198914 9.40225391 3.75857859 8.45085184] [2.58700305 9.79247821 5.17718314 4.84501262] [5.60284687 3.46467384 1.20591779 6.01311384]] [[0. 9. 3. 8.] [2. 9. 5. 4.] [5. 3. 1. 6.]]

print(arredondado.ravel()) # Converte multidimensional para unidimensional

[0. 9. 3. 8. 2. 9. 5. 4. 5. 3. 1. 6.]

arredondado.shape = (6,2) # Redimensiona o array
print(arredondado)

print(arredondado.T) # Transposição da matriz

[[0. 9.] [3. 8.] [2. 9.] [5. 4.] [5. 3.] [1. 6.]] [[0. 3. 2. 5. 5. 1.] [9. 8. 9. 4. 3. 6.]]

matriz1 = np.floor(10*np.random.random((2,2)))
print(matriz1)
matriz2 = np.floor(10*np.random.random((2,2)))
print(matriz2)

print(np.vstack((matriz1,matriz2))) # Empilhagem vertical
print(np.hstack((matriz1,matriz2))) # Empilhagem horizontal

[[5. 5.] [2. 2.]] [[9. 3.] [6. 0.]] [[5. 5.] [2. 2.] [9. 3.] [6. 0.]] [[5. 5. 9. 3.] [2. 2. 6. 0.]]

array_longo = np.floor(10*np.random.random((2,12)))
print(array_longo)
print('-'*10)

print(np.hsplit(array_longo,3)) # Divisão horizontal em 3 partes

print(np.hsplit(array_longo,(3,4))) # Divisão em pontos específicos

[[3. 9. 2. 1. 8. 0. 8. 1. 0. 3. 0. 0.] [3. 8. 8. 9. 9. 0. 7. 0. 8. 0. 2. 2.]]

[array([[3., 9., 2., 1.], [3., 8., 8., 9.]]), aray([[8., 0., 8., 1.], [9., 0., 7., 0.]]), aray([[0., 3., 0., 0.], [8., 0., 2., 2.]])] [array([[3., 9., 2.], [3., 8., 8.]]), array([[1.], [9.]]), array([[8., 0., 8., 1., 0., 3., 0., 0.], [9., 0., 7., 0., 8., 0., 2., 2.]])]

matriz_grande = np.floor(10*np.random.random((8,2)))
print(matriz_grande)
print('-'*20)
print(np.hsplit(matriz_grande,2))
print('-'*20)
print(np.vsplit(matriz_grande,2)) # Divisão vertical em 2 partes

[[7. 1.] [8. 1.] [3. 2.] [5. 0.] [4. 0.] [1. 7.] [7. 4.] [2. 2.]]

[array([[7.], [8.], [3.], [5.], [4.], [1.], [7.], [2.]]), array([[1.], [1.], [2.], [0.], [0.], [7.], [4.], [2.]])]

[array([[7., 1.], [8., 1.], [3., 2.], [5., 0.]]), array([[4., 0.], [1., 7.], [7., 4.], [2., 2.]])]

sequencia = np.arange(12)
referencia = sequencia # Referência ao mesmo objeto
print(referencia is sequencia)
referencia.shape = 3,4

print(referencia.shape)
print(sequencia.shape)

print(id(referencia))
print(id(sequencia))

print(referencia)
print(sequencia)

True (3, 4) (3, 4) 2303479872464 2303479872464 [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]]

visualizacao = sequencia.view() # Cria uma visualização, não uma cópia
print(visualizacao)

print(visualizacao is sequencia)
visualizacao.shape = 2,6

print(visualizacao.shape)
print(sequencia.shape)

visualizacao[0,2 ]= 123 # Alteração afeta ambos os arrays
print(visualizacao)
print(id(visualizacao))

print(sequencia)
print(id(sequencia))

[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] False (2, 6) (3, 4) [[ 0 1 123 3 4 5] [ 6 7 8 9 10 11]] 2303484963760 [[ 0 1 123 3] [ 4 5 6 7] [ 8 9 10 11]] 2303479872464

copia = sequencia.copy() # Cópia real, independente
print(copia)
print(copia is sequencia)

copia[0,1]=9999
print(copia)
print('-'*10)
print(sequencia)

[[ 0 1 123 3] [ 4 5 6 7] [ 8 9 10 11]] False [[ 0 9999 123 3] [ 4 5 6 7] [ 8 9 10 11]]

[[ 0 1 123 3] [ 4 5 6 7] [ 8 9 10 11]]

dados = np.sin(np.arange(20)).reshape(5,4)
print(dados)

[[ 0. 0.84147098 0.90929743 0.14112001] [-0.7568025 -0.95892427 -0.2794155 0.6569866 ] [ 0.98935825 0.41211849 -0.54402111 -0.99999021] [-0.53657292 0.42016704 0.99060736 0.65028784] [-0.28790332 -0.96139749 -0.75098725 0.14987721]]

indices = dados.argmax(axis=0) # Índices dos máximos por coluna
print(indices)

maximos = dados[indices,range(dados.shape[1])]
print(maximos)

[2 0 3 1] [0.98935825 0.84147098 0.99060736 0.6569866]

base = np.arange(0,40,10)
print(base)

# Repetição da matriz base
repetido = np.tile(base,(3,5))
print(repetido)

[ 0 10 20 30] [[ 0 10 20 30 0 10 20 30 0 10 20 30 0 10 20 30 0 10 20 30] [ 0 10 20 30 0 10 20 30 0 10 20 30 0 10 20 30 0 10 20 30] [ 0 10 20 30 0 10 20 30 0 10 20 30 0 10 20 30 0 10 20 30]]

dados_matriz = np.array([[4,3,5],[1,2,1]])
print(dados_matriz)
print('-'*10)

ordenado = np.sort(dados_matriz,axis=1)
print(ordenado)
print('-'*10)

vetor = np.array([4,3,1,2])
print(vetor)

print(np.sort(vetor))

posicoes = np.argsort(vetor) # Índices ordenados
print(posicoes)

print(vetor[posicoes]) # Array ordenado via índices

[[4 3 5] [1 2 1]]

[[3 4 5] [1 1 2]]

[4 3 1 2] [1 2 3 4] [2 3 1 0] [1 2 3 4]