Pós-Graduação: Especialização em Data Science & Big Data

Pontifícia Universidade Católica de Minas Gerais (PUC-MG)

Victor Hugo Negrisoli - Linguagens de Programação Para Ciência de Dados

Criação de ndarrays ou Arrays N-Dimensionais

import numpy as np

Arrays de 1 dimensão

# Criando um array simples de 1 dimensão (vetor)

arr_1 = np.array([1, 2, 3, 4, 5])
print(arr_1)
print(type(arr_1))

[1 2 3 4 5]
<class 'numpy.ndarray'>

# Verificando o tipo de dados do array

print(arr_1.dtype)

arr_2 = np.array(["1", "2", "3"])

print(arr_2.dtype)

int32
<U1

# Definindo um tipo de dado ao criar o array

# Passando um array de int e criando um np array como float

arr_3 = np.array([1, 2, 3, 4, 5], dtype = float)
print(arr_3)
print(arr_3.dtype)

# Passando um array de int e criando um np array como str

arr_4 = np.array([1, 2, 3, 4, 5], dtype = str)
print(arr_4)
print(arr_4.dtype)

[1. 2. 3. 4. 5.]
float64
['1' '2' '3' '4' '5']
<U1

# Precedência de tipos: str > float > int >  bool

arr_multi = np.array(['1', 2, 3.0, False])
print(arr_multi)
print(arr_multi.dtype)

arr_multi_2 = np.array([1, 2, 3.0, False, True])
print(arr_multi_2)
print(arr_multi_2.dtype)

arr_multi_bool = np.array([False, True])
print(arr_multi_bool)
print(arr_multi_bool.dtype)

['1' '2' '3.0' 'False']
<U5
[1. 2. 3. 0. 1.]
float64
[False  True]
bool

Criando arrays de 2 dimensões (matrizes)

# Recebe uma lista de listas

matriz = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matriz)
print(type(matriz))

[[1 2 3]
 [4 5 6]
 [7 8 9]]
<class 'numpy.ndarray'>

# Recebe uma lista que contem uma lista de listas, e assim continuamente

array_3d = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]])
print(array_3d)
print(type(array_3d))

[[[1 2 3]
  [4 5 6]
  [7 8 9]]

 [[1 2 3]
  [4 5 6]
  [7 8 9]]

 [[1 2 3]
  [4 5 6]
  [7 8 9]]]
<class 'numpy.ndarray'>

Criar arrays com zeros()

# A função zeros() criará um np array conforme as especificações fornecidas como parâmetro

# Uma dimensão

zeros_1d = np.zeros(5)
print(zeros_1d)

[0. 0. 0. 0. 0.]

# Duas dimensões

zeros_2d = np.zeros((5, 5)) # Cria uma matriz 5x5
print(zeros_2d)

[[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]]

# Duas dimensões especificando o tipo de dados

zeros_2d_2 = np.zeros((5, 5), dtype = str) # Cria uma matriz 5x5 de strings
print(zeros_2d_2)

[['' '' '' '' '']
 ['' '' '' '' '']
 ['' '' '' '' '']
 ['' '' '' '' '']
 ['' '' '' '' '']]

# Três dimensões

zeros_3d = np.zeros((5, 5, 5), dtype = int)
print(zeros_3d)

[[[0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]]

 [[0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]]

 [[0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]]

 [[0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]]

 [[0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]
  [0 0 0 0 0]]]

Função ones()

# Exatamente igual à função zeros, porém, cria com valor 1

ones_1d = np.ones(5)
print(ones_1d)

[1. 1. 1. 1. 1.]

# Duas dimensões

ones_2d = np.ones((5, 5), dtype = int)
print(ones_2d)

[[1 1 1 1 1]
 [1 1 1 1 1]
 [1 1 1 1 1]
 [1 1 1 1 1]
 [1 1 1 1 1]]

# Três dimensões

ones_3d = np.ones((5, 5, 5), dtype = int)
print(ones_3d)

[[[1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]]

 [[1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]]

 [[1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]]

 [[1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]]

 [[1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]
  [1 1 1 1 1]]]

Arrays preenchidos com uma faixa de valores - arange()

# Cria um np array com valores de 0 a 4

valores_1 = np.arange(5)
print(valores_1)

[0 1 2 3 4]

# Cria um np array com valores de 5 a 24

valores_2 = np.arange(5, 25)
print(valores_2)

[ 5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]

# Cria um np array com valores de 5 a 49 de 3 em 3

valores_3 = np.arange(5, 50, 3)
print(valores_3)

[ 5  8 11 14 17 20 23 26 29 32 35 38 41 44 47]

Criando arrays com espaços iguais usando linspace()

# Valores de 0 a 10 espaçados por 2

iguais_1 = np.linspace(0, 10, 2)
print(iguais_1)

[ 0. 10.]

# Valores de 0 a 100 espaçados por 15

iguais_2 = np.linspace(0, 100, 15, dtype = int)
print(iguais_2)

[  0   7  14  21  28  35  42  50  57  64  71  78  85  92 100]

# Utilizando o valor padrão para elementos não informados, o padrão é 50

iguais_3 = np.linspace(0, 1000, dtype = int)
print(iguais_3)

[   0   20   40   61   81  102  122  142  163  183  204  224  244  265
  285  306  326  346  367  387  408  428  448  469  489  510  530  551
  571  591  612  632  653  673  693  714  734  755  775  795  816  836
  857  877  897  918  938  959  979 1000]

# Ao utilizar o parâmetro endpoint, irá informar se é pra incluir o último valor

iguais_endpoint_true = np.linspace(0, 1000, dtype = int, endpoint = True)
print(iguais_endpoint_true)

iguais_endpoint_false = np.linspace(0, 1000, dtype = int, endpoint = False)
print(iguais_endpoint_false)

[   0   20   40   61   81  102  122  142  163  183  204  224  244  265
  285  306  326  346  367  387  408  428  448  469  489  510  530  551
  571  591  612  632  653  673  693  714  734  755  775  795  816  836
  857  877  897  918  938  959  979 1000]
[  0  20  40  60  80 100 120 140 160 180 200 220 240 260 280 300 320 340
 360 380 400 420 440 460 480 500 520 540 560 580 600 620 640 660 680 700
 720 740 760 780 800 820 840 860 880 900 920 940 960 980]

Função full()

# Criando um array preenchendo completamente com um valor informado

arr_full_01 = np.full(10, 5)
print(arr_full_01)

[5 5 5 5 5 5 5 5 5 5]

# Array de duas dimensões - Matriz 10x10 contendo apenas números 5

arr_full_02 = np.full((10, 10), 5)
print(arr_full_02)

[[5 5 5 5 5 5 5 5 5 5]
 [5 5 5 5 5 5 5 5 5 5]
 [5 5 5 5 5 5 5 5 5 5]
 [5 5 5 5 5 5 5 5 5 5]
 [5 5 5 5 5 5 5 5 5 5]
 [5 5 5 5 5 5 5 5 5 5]
 [5 5 5 5 5 5 5 5 5 5]
 [5 5 5 5 5 5 5 5 5 5]
 [5 5 5 5 5 5 5 5 5 5]
 [5 5 5 5 5 5 5 5 5 5]]

# Array de três dimensões contendo o número 5

arr_full_03 = np.full((3, 2, 2), 5)
print(arr_full_03)

[[[5 5]
  [5 5]]

 [[5 5]
  [5 5]]

 [[5 5]
  [5 5]]]

Matriz identidade com a função eye()

# Cria uma matriz identidade 5x5

identidade_01 = np.eye(5, dtype = int)
print(identidade_01)

[[1 0 0 0 0]
 [0 1 0 0 0]
 [0 0 1 0 0]
 [0 0 0 1 0]
 [0 0 0 0 1]]

Criando um array com números aleatórios

# Criando um único número aleatório entre 0 a 10

random_01 = np.random.randint(10)
print(random_01)

0

# Criando um array entre 0 e 100 de 10 elementos

random_02 = np.random.randint(0, 100, 10)
print(random_02)

[57  9 77 42 59 64 16 75 71 24]

# Criando uma matriz 10x10 entre 0 e 100

random_02 = np.random.randint(0, 100, (10, 10))
print(random_02)

[[91 62 17 45 44 87 74 91 13 37]
 [99 73 92 97 57 19 48 17 22 77]
 [11 29 63 73 27 58 76 60 24 31]
 [17 78 29 24 92 27 98 67 26 36]
 [12  8  5 52 27 46 80  0 48 61]
 [33 98 85  8 33 56 84  9 42 67]
 [ 3 81 26 21 67 84 64 83 39 72]
 [72 58  7 93 98 16 97 98 49 83]
 [ 3 61 90  8 46 15 48 98 92 34]
 [ 6  4 82 77 82 89 25 36 41 49]]

# Criando um array de 3 dimensões entre 0 e 100

random_03 = np.random.randint(0, 100, (3, 5, 5))
print(random_03)

[[[24 28 23 68 77]
  [65 74 60 90 62]
  [ 1 52 58 62  3]
  [41 54 59 42 45]
  [65 51 21 69 82]]

 [[59 43 52  1 76]
  [70 99 34 34  6]
  [33 21 43  2 12]
  [92 27 59 51  0]
  [70 27 76 47  3]]

 [[46 97 18 66 37]
  [59 80 58 13 43]
  [ 6 22 44 26 45]
  [20 75 81 87 81]
  [86  3 16 97  5]]]

# Criando 10 elementos aleatórios entre 0 e 1

random_04 = np.random.random(10)
print(random_04)

[0.31454201 0.32996763 0.28537754 0.86002767 0.16043629 0.39886386
 0.16030041 0.19337174 0.01946563 0.71371542]

# Criando uma matriz 4x5 com elementos aleatórios entre 0 e 1

random_05 = np.random.random((4, 5))
print(random_05)

[[0.77739847 0.20309218 0.27304602 0.39671365 0.22096491]
 [0.76999538 0.5012639  0.64589649 0.53285138 0.66547422]
 [0.09300376 0.40374854 0.19021008 0.91628769 0.02151731]
 [0.8611125  0.74839495 0.92969796 0.0484111  0.60415723]]

# Criando um array de três dimensões com elementos aleatórios entre 0 e 1

random_05 = np.random.random((4, 5, 5))
print(random_05)

[[[0.46711966 0.85663411 0.33354244 0.59418655 0.96098628]
  [0.64069099 0.82794649 0.40549677 0.2796922  0.75390221]
  [0.89552321 0.59876679 0.18996155 0.97926588 0.47324974]
  [0.26279656 0.10578072 0.70001707 0.89899209 0.8523673 ]
  [0.03526733 0.06410183 0.74536126 0.64109814 0.83458337]]

 [[0.46582194 0.33579359 0.20740027 0.18536625 0.93141928]
  [0.91050043 0.65507864 0.4241873  0.79514274 0.13639907]
  [0.41376508 0.7756721  0.1089945  0.98606844 0.84981006]
  [0.89181298 0.60910414 0.94716019 0.13462749 0.97704257]
  [0.66913902 0.94636063 0.35877133 0.09081011 0.44436865]]

 [[0.36493491 0.17130527 0.1869368  0.94136093 0.87056871]
  [0.4150023  0.31087379 0.63716556 0.20080362 0.51530159]
  [0.61454564 0.82318362 0.2173551  0.07302063 0.51961297]
  [0.08507252 0.14628182 0.28758695 0.92750923 0.94099537]
  [0.58573915 0.17960211 0.119082   0.62811143 0.96306548]]

 [[0.71067681 0.00994604 0.31694302 0.02405674 0.70820079]
  [0.56260592 0.43786737 0.16047624 0.20113664 0.75549414]
  [0.19795769 0.9651436  0.56913052 0.04397567 0.59769921]
  [0.72445394 0.008076   0.40726854 0.64674047 0.64285259]
  [0.50309337 0.60168251 0.03742403 0.59101286 0.12057963]]]

Verificando propriedades dos arrays

# Verificando a modelagem do array, ou seja, quantidade de linhas, colunas e páginas 

print(random_02.shape)

(10, 10)

# Verificando o número de dimensões de um array 

print(random_02.ndim)

2

# Verificando outros arrays

print(random_03.shape)
print(random_03.ndim)
print('\n')
print(random_04.shape)
print(random_04.ndim)
print('\n')
print(random_05.shape)
print(random_05.ndim)

(3, 5, 5)
3


(10,)
1


(4, 5, 5)
3

# Verificando o tamanho das dimensões

print(len(random_02))
print(len(random_03))

10
3

# Verificando o tamanho das dimensões de arrays multidimensionais

print(random_02[0])
print(len(random_02[0]))

print(random_02[0][2])

[91 62 17 45 44 87 74 91 13 37]
10
17

# Verificando a quantidade de elementos

print(random_02.size)
print(random_03.size)
print(random_04.size)
print(random_05.size)

100
75
10
100

# Verificando o tipo de dados de elementos

print(random_02.dtype)
print(random_03.dtype)
print(random_04.dtype)
print(random_05.dtype)

int32
int32
float64
float64

Indexação e slicing (fatiamento) em ndarrays

# Criando os arrays para realizar as operações

arr_1d = np.random.randint(0, 10, 10)
arr_2d = np.random.randint(1, 101, (4, 5))
arr_3d = np.random.random((3, 4, 5))
print(arr_1d)
print('\n')
print(arr_2d)
print('\n')
print(arr_3d)

[5 6 7 6 9 1 7 3 8 4]


[[ 43   2  19   9  84]
 [ 85  54  27 100  97]
 [  3   3  48  58  21]
 [ 77  40   7  92  50]]


[[[0.74291959 0.89788459 0.33000439 0.76132532 0.98420983]
  [0.11123055 0.51440158 0.604782   0.23383095 0.96264546]
  [0.26229649 0.51981367 0.39615291 0.69050967 0.66954215]
  [0.94039098 0.84611174 0.61636308 0.17442602 0.03294095]]

 [[0.25458983 0.97009327 0.00562734 0.50077124 0.59038877]
  [0.14202589 0.66503095 0.610447   0.58708306 0.31883155]
  [0.00820939 0.22384556 0.70875708 0.84805628 0.74077553]
  [0.41086137 0.81537038 0.10403086 0.36962236 0.12790319]]

 [[0.86710999 0.07971897 0.22268255 0.9879453  0.47861441]
  [0.23730634 0.4010635  0.28366754 0.18876955 0.44638761]
  [0.20648917 0.99410296 0.77926067 0.64983538 0.00521068]
  [0.58073708 0.10542577 0.60650322 0.97242395 0.65922317]]]

# Acessar apenas um índice de um array de 1 dimensão

item_1 = arr_1d[1]
item_2 = arr_1d[-1]
print(item_1)
print(item_2)

6
4

# Acessar apenas um índice de um array de 2 dimensões

item_1 = arr_2d[1]
print(item_1)

item_2 = arr_2d[1][2]
print(item_2)

[ 85  54  27 100  97]
27

# Acessar apenas um índice de um array de 2 dimensões

item_1 = arr_3d[1]
print(item_1)

print('\n')

item_2 = arr_3d[1][2]
print(item_2)

print('\n')

item_3 = arr_3d[1][2][3]
print(item_3)

print('\n')

item_4 = arr_3d[1, 3]
print(item_4)

[[0.25458983 0.97009327 0.00562734 0.50077124 0.59038877]
 [0.14202589 0.66503095 0.610447   0.58708306 0.31883155]
 [0.00820939 0.22384556 0.70875708 0.84805628 0.74077553]
 [0.41086137 0.81537038 0.10403086 0.36962236 0.12790319]]


[0.00820939 0.22384556 0.70875708 0.84805628 0.74077553]


0.8480562842842151


[0.41086137 0.81537038 0.10403086 0.36962236 0.12790319]

# Acessando através de uma lista de linhas e colunas

linhas = [0, 1, 3]
colunas = [1, 2, 0]

itens = arr_2d[linhas, colunas]
print(itens)

[ 2 27 77]

# Acessando através de slicing em arrays de 1 dimensão

itens = arr_1d[:2]
print(itens)

itens = arr_1d[1:3]
print(itens)

[5 6]
[6 7]

# Acessando através de slicing em arrays de 2 dimensões (matrizes)

itens = arr_2d[:2]
print(itens)

itens = arr_2d[1:2, 3]
print(itens)

[[ 43   2  19   9  84]
 [ 85  54  27 100  97]]
[100]

# Slicing em arrays de três dimensões (faces, linhas, colunas)

print(arr_3d)

print('\n')

itens = arr_3d[0:2, 1:3, 2:4]
print(itens)

[[[0.74291959 0.89788459 0.33000439 0.76132532 0.98420983]
  [0.11123055 0.51440158 0.604782   0.23383095 0.96264546]
  [0.26229649 0.51981367 0.39615291 0.69050967 0.66954215]
  [0.94039098 0.84611174 0.61636308 0.17442602 0.03294095]]

 [[0.25458983 0.97009327 0.00562734 0.50077124 0.59038877]
  [0.14202589 0.66503095 0.610447   0.58708306 0.31883155]
  [0.00820939 0.22384556 0.70875708 0.84805628 0.74077553]
  [0.41086137 0.81537038 0.10403086 0.36962236 0.12790319]]

 [[0.86710999 0.07971897 0.22268255 0.9879453  0.47861441]
  [0.23730634 0.4010635  0.28366754 0.18876955 0.44638761]
  [0.20648917 0.99410296 0.77926067 0.64983538 0.00521068]
  [0.58073708 0.10542577 0.60650322 0.97242395 0.65922317]]]


[[[0.604782   0.23383095]
  [0.39615291 0.69050967]]

 [[0.610447   0.58708306]
  [0.70875708 0.84805628]]]

Indexação com booleanos

# Array para utilizar

arr_booleano_1d = np.random.randint(1, 501, (10))
arr_booleano_2d = np.random.randint(1, 501, (5, 5))
arr_booleano_3d = np.random.randint(1, 501, (3, 2, 5))

print(arr_booleano_1d)
print('\n')
print(arr_booleano_2d)
print('\n')
print(arr_booleano_3d)

[300 202 495 112 285  50 244 258 372 160]


[[267 131 324 335 379]
 [430 319  73 378 361]
 [ 10 257 479 287  23]
 [244 221 346 202 499]
 [443  72 360 178  31]]


[[[ 95 170 426 323 257]
  [232 495 467 168 458]]

 [[141 216 443 403 286]
  [132 419 460 485 174]]

 [[260 283  44 280 321]
  [ 35  16 330 239  95]]]

# Filtrando o array 1D por todos os elementos que sejam maiores que 300

filtro = arr_booleano_1d[arr_booleano_1d > 300]
print(filtro)

[495 372]

# Filtrando o array 2D por todos os elementos que sejam maiores que 50

filtro = arr_booleano_2d[arr_booleano_2d > 300]
print(filtro)

[324 335 379 430 319 378 361 479 346 499 443 360]

# Retorna um array de booleanos comparando elementos que sejam maiores que 50

booleanos = arr_booleano_3d > 300
print(booleanos)

[[[False False  True  True False]
  [False  True  True False  True]]

 [[False False  True  True False]
  [False  True  True  True False]]

 [[False False False False  True]
  [False False  True False False]]]

# Calcular a média dos elementos dos arrays

media_1d = arr_booleano_1d.mean()
media_2d = arr_booleano_2d.mean()
media_3d = arr_booleano_3d.mean()

print(media_1d)
print(media_2d)
print(media_3d)

247.8
265.96
271.76666666666665

Manipulando Arrays NumPy

Adicionar, alterar e remover elementos

# Criando arrays para utilizar

arr_1d = np.random.randint(1,200, 12)
arr_2d = np.random.randint(1,200, (3,4))
arr_3d = np.random.randint(1,200, (2,3,6))

print(arr_1d)
print(arr_1d.dtype)
print('\n')
print(arr_2d)
print(arr_2d.dtype)
print('\n')
print(arr_3d)
print(arr_3d.dtype)

[109   1  54  98  61 147 102   4 159 115  66 183]
int32


[[179 145 197  10]
 [ 32  47 160   9]
 [  6  66  77  97]]
int32


[[[197  56  40  71 185  50]
  [186 172 189  72  31  14]
  [ 88 128 190 118 184 128]]

 [[140  61 136 125  67 173]
  [128 185  18 122  28  85]
  [165 144 157  38  47 136]]]
int32

# Alterando elementos de um array de 1 dimensão

valor_anterior = arr_1d[0]
print('Valor anterior: {}'.format(str(valor_anterior)))

arr_1d[0] = 12

print('Valor atual: {}'.format(str(arr_1d[0])))

Valor anterior: 24
Valor atual: 12

# Alterando elementos de um array de 2 dimensões

valor_anterior = arr_2d[0][0]
print('Valor anterior: {}'.format(str(valor_anterior)))

arr_2d[0][0] = 12

print('Valor atual: {}'.format(str(arr_2d[0][0])))

Valor anterior: 108
Valor atual: 12

# Alterando elementos de um array de 3 dimensões

valor_anterior = arr_3d[0][0][0]
print('Valor anterior: {}'.format(str(valor_anterior)))

arr_3d[0][0][0] = 12

print('Valor atual: {}'.format(str(arr_3d[0][0][0])))

Valor anterior: 197
Valor atual: 12

# Adicionando novos elementos a um array de 1 dimensão

arr_1d_add = np.append(arr_1d, [1, 2, 3])
print(arr_1d_add)

[109   1  54  98  61 147 102   4 159 115  66 183   1   2   3]

# Adicionando novos elementos a um array de 2 dimensões

arr_2d_add = np.append(arr_2d, [1, 2, 3])
print(arr_2d_add)

[179 145 197  10  32  47 160   9   6  66  77  97   1   2   3]

# Adicionando novos elementos a um array de 3 dimensões

arr_3d_add = np.append(arr_3d, [1, 2, 3])
print(arr_3d_add)

[ 12  56  40  71 185  50 186 172 189  72  31  14  88 128 190 118 184 128
 140  61 136 125  67 173 128 185  18 122  28  85 165 144 157  38  47 136
   1   2   3]

# Removendo elementos a um array de 1 dimensão

arr_1d_delete = np.delete(arr_1d_add, [0, 1, 2])
print(arr_1d_delete)

[ 98  61 147 102   4 159 115  66 183   1   2   3]

# Removendo elementos a um array de 2 dimensões

arr_2d_delete = np.delete(arr_2d_add, [0, 1, 2])
print(arr_2d_delete)

[ 10  32  47 160   9   6  66  77  97   1   2   3]

# Removendo elementos a um array de 3 dimensões

arr_3d_delete = np.delete(arr_3d_add, [0, 1, 2])
print(arr_3d_delete)

[ 71 185  50 186 172 189  72  31  14  88 128 190 118 184 128 140  61 136
 125  67 173 128 185  18 122  28  85 165 144 157  38  47 136   1   2   3]

Comparação entre arrays

# Comparando dois arrays e printando se são iguais

arr_1d_1 = np.random.randint(0, 10, 20)
arr_1d_2 = np.random.randint(0, 10, 20)

print(arr_1d_1 == arr_1d_2)

[False False False False  True False False False False False False False
 False False  True False False False False False]

# Comparando um elemento específico

arr_1d_1 == 1

array([False, False, False, False, False, False, False, False, False,
       False,  True, False,  True, False, False, False, False, False,
       False, False])

# Retorna apenas onde os elementos são iguais a 3

print(arr_1d_1[arr_1d_1 == 3])

[3 3]

Operações entre arrays e escalares

# Criando um array de 1 dimensão, um array apenas com números ímpares entre 1 a 20 e um que é a multiplicação do 1º array

arr_1d = np.arange(1, 11)
arr_2d = np.arange(1, 20, 2)
arr_3d = 2 * arr_1d
print(arr_1d)
print(arr_2d)
print(arr_3d)

[ 1  2  3  4  5  6  7  8  9 10]
[ 1  3  5  7  9 11 13 15 17 19]
[ 2  4  6  8 10 12 14 16 18 20]

# Criando um array com a soma todos os valores por 4

arr_soma = arr_1d + 4
print(arr_1d)
print(arr_soma)

[ 1  2  3  4  5  6  7  8  9 10]
[ 5  6  7  8  9 10 11 12 13 14]

# Adição, subtração, multiplicação, divisão entre arrays

# Soma 

print('Soma')

arr_soma_2 = arr_1d + arr_soma
print(arr_soma_2)

# ou então

arr_soma_2 = np.add(arr_1d, arr_soma)
print(arr_soma_2)
print('\n')

# Subtração
print('Subtração')

arr_subtracao = arr_1d - arr_soma
print(arr_subtracao)

# ou então

arr_subtracao = np.subtract(arr_1d, arr_soma)
print(arr_subtracao)
print('\n')

# Multiplicação
print('Multiplicação')

arr_mult = arr_1d * arr_soma
print(arr_mult)

# ou então

arr_mult = np.multiply(arr_1d, arr_soma)
print(arr_mult)
print('\n')

# Divisão
print('Divisão')

arr_divisao = arr_1d / arr_soma
print(arr_divisao)

# ou então

arr_divisao = np.divide(arr_1d, arr_soma)
print(arr_divisao)

Soma
[ 6  8 10 12 14 16 18 20 22 24]
[ 6  8 10 12 14 16 18 20 22 24]


Subtração
[-4 -4 -4 -4 -4 -4 -4 -4 -4 -4]
[-4 -4 -4 -4 -4 -4 -4 -4 -4 -4]


Multiplicação
[  5  12  21  32  45  60  77  96 117 140]
[  5  12  21  32  45  60  77  96 117 140]


Divisão
[0.2        0.33333333 0.42857143 0.5        0.55555556 0.6
 0.63636364 0.66666667 0.69230769 0.71428571]
[0.2        0.33333333 0.42857143 0.5        0.55555556 0.6
 0.63636364 0.66666667 0.69230769 0.71428571]

# Quadrado dos valores do array

arr_quadrado = np.sqrt(arr_1d)
print(arr_quadrado)

[1.         1.41421356 1.73205081 2.         2.23606798 2.44948974
 2.64575131 2.82842712 3.         3.16227766]

Funções de soma, média, máximo, mínimo, mediana, desvio padrão

# Criando um array numpy para testar as funções

dados = np.random.randint(1, 101, (5,10))
print(dados)

[[27 23 94 31 89 56 14 56  4 72]
 [73  3  6 36 28 76 94 69 27 57]
 [28 56  3 44 53 57 96 38 61 13]
 [45 92  8 68 39 17 72 71 16 13]
 [35 95 52  1 83 85 93 96 88 75]]

# Soma normal e com eixo

soma_dados = dados.sum()
soma_dados_eixo_colunas = dados.sum(axis = 0)
soma_dados_eixo_linhas = dados.sum(axis = 1)

print(soma_dados)
print(soma_dados_eixo_colunas)
print(soma_dados_eixo_linhas)

2528
[208 269 163 180 292 291 369 330 196 230]
[466 469 449 441 703]

# Utilizando a função built-in do Python é o mesmo que a soma no eixo da coluna

soma_dados_built_in = sum(dados)

print(soma_dados_eixo_colunas)
print(soma_dados_built_in)

[208 269 163 180 292 291 369 330 196 230]
[208 269 163 180 292 291 369 330 196 230]

# Valores máximos e mínimos gerais e por eixo

maior_geral = dados.max()
menor_geral = dados.min()
maior_colunas = dados.max(axis = 0)
menor_colunas = dados.max(axis = 0)
maior_linhas = dados.max(axis = 1)
menor_linhas = dados.max(axis = 1)

print('Maior geral: {}'.format(str(maior_geral)))
print('Menor geral: {}'.format(str(menor_geral)))
print('Maior colunas: {}'.format(str(maior_colunas)))
print('Menor colunas: {}'.format(str(menor_colunas)))
print('Maior linhas: {}'.format(str(maior_linhas)))
print('Menor linhas: {}'.format(str(menor_linhas)))

Maior geral: 96
Menor geral: 1
Maior colunas: [73 95 94 68 89 85 96 96 88 75]
Menor colunas: [73 95 94 68 89 85 96 96 88 75]
Maior linhas: [94 94 96 92 96]
Menor linhas: [94 94 96 92 96]

# Soma acumulada geral e por eixos

soma_acumulada_geral = dados.cumsum()
soma_acumulada_colunas = dados.cumsum(axis = 0)
soma_acumulada_linhas = dados.cumsum(axis = 1)

print('Soma acumulada geral: {}'.format(str(soma_acumulada_geral)))
print('Soma acumulada colunas: {}'.format(str(soma_acumulada_colunas)))
print('Soma acumulada linhas: {}'.format(str(soma_acumulada_linhas)))

Soma acumulada geral: [  27   50  144  175  264  320  334  390  394  466  539  542  548  584
  612  688  782  851  878  935  963 1019 1022 1066 1119 1176 1272 1310
 1371 1384 1429 1521 1529 1597 1636 1653 1725 1796 1812 1825 1860 1955
 2007 2008 2091 2176 2269 2365 2453 2528]
Soma acumulada colunas: [[ 27  23  94  31  89  56  14  56   4  72]
 [100  26 100  67 117 132 108 125  31 129]
 [128  82 103 111 170 189 204 163  92 142]
 [173 174 111 179 209 206 276 234 108 155]
 [208 269 163 180 292 291 369 330 196 230]]
Soma acumulada linhas: [[ 27  50 144 175 264 320 334 390 394 466]
 [ 73  76  82 118 146 222 316 385 412 469]
 [ 28  84  87 131 184 241 337 375 436 449]
 [ 45 137 145 213 252 269 341 412 428 441]
 [ 35 130 182 183 266 351 444 540 628 703]]

# Média geral por eixos

media_geral = dados.mean()
media_colunas = dados.mean(axis = 0)
media_linhas = dados.mean(axis = 1)

print('Média geral: {}'.format(str(media_geral)))
print('Média colunas: {}'.format(str(media_colunas)))
print('Média linhas: {}'.format(str(media_linhas)))

Média geral: 50.56
Média colunas: [41.6 53.8 32.6 36.  58.4 58.2 73.8 66.  39.2 46. ]
Média linhas: [46.6 46.9 44.9 44.1 70.3]

# Desvio Padrão geral por eixos

desvio_padrao_geral = dados.std()
desvio_padrao_colunas = dados.std(axis = 0)
desvio_padrao_linhas = dados.std(axis = 1)

print('Desvio Padrão geral: {}'.format(str(desvio_padrao_geral)))
print('Desvio Padrão colunas: {}'.format(str(desvio_padrao_colunas)))
print('Desvio Padrão linhas: {}'.format(str(desvio_padrao_linhas)))

Desvio Padrão geral: 30.346769185532747
Desvio Padrão colunas: [16.96584805 36.58086932 35.59550533 21.62406067 23.96330528 23.40427311
 31.1409698  19.0682983  30.92830419 27.62607464]
Desvio Padrão linhas: [29.88042838 29.6797911  25.12548507 28.61625412 29.80285221]

# Mediana geral por eixos

mediana_geral = np.median(dados)
mediana_colunas = np.median(dados, axis = 0)
mediana_linhas = np.median(dados, axis = 1)

print('Mediana geral: {}'.format(str(mediana_geral)))
print('Mediana colunas: {}'.format(str(mediana_colunas)))
print('Mediana linhas: {}'.format(str(mediana_linhas)))

Mediana geral: 54.5
Mediana colunas: [35. 56.  8. 36. 53. 57. 93. 69. 27. 57.]
Mediana linhas: [43.5 46.5 48.5 42.  84. ]

Concatenação e cópia de Arrays

# Criando o array para testes

arr_2d_1 = np.random.randint(1, 50,(4,5))
arr_2d_2 = np.random.randint(50, 100,(4,5))

print(arr_2d_1)
print('\n')
print(arr_2d_2)

[[37 42 26 21 47]
 [ 7  8 43 35 13]
 [33 20 18 47 38]
 [ 8 14 26 40 19]]


[[61 84 77 83 85]
 [86 69 84 85 65]
 [87 60 95 51 69]
 [63 99 77 75 76]]

# Alterando via referência de memória sem usar copy()

arr_2d_3 = arr_2d_2
arr_2d_3[arr_2d_3 < 70] = - 1

print(arr_2d_2)
print('\n')
print(arr_2d_3)

[[-1 84 77 83 85]
 [86 -1 84 85 -1]
 [87 -1 95 -1 -1]
 [-1 99 77 75 76]]


[[-1 84 77 83 85]
 [86 -1 84 85 -1]
 [87 -1 95 -1 -1]
 [-1 99 77 75 76]]

# Alterando utilizando copy() - cria uma nova referência na memória e não modifica o array copiado

arr_2d_3 = arr_2d_2.copy()
arr_2d_3[arr_2d_3 < 90] = - 2

print(arr_2d_2)
print('\n')
print(arr_2d_3)

[[-1 84 77 83 85]
 [86 -1 84 85 -1]
 [87 -1 95 -1 -1]
 [-1 99 77 75 76]]


[[-2 -2 -2 -2 -2]
 [-2 -2 -2 -2 -2]
 [-2 -2 95 -2 -2]
 [-2 99 -2 -2 -2]]

Ordenando elementos em um Array

# Criando os arrays para ordenar

sort_1d = np.random.randint(1, 99, 15)
sort_2d = np.random.randint(1, 99, (10, 10))

print(sort_1d)
print('\n')
print(sort_2d)

[31 71 88 67 25 71 84 46 89 28 69 98 10  2 21]


[[54 64 28 33 66 91 46 40 11 19]
 [41 10 38 40 66 13 75 94 27 33]
 [91 87 55 50 60 22 15 44 57 91]
 [68 58 26 75 62 43 69 13 33 16]
 [26 59 61 74 24 11 60  9 20 60]
 [23 96 93 77 36 13 42 36  8 95]
 [ 5 18 42 37 28 44  8 24 84 94]
 [54 11 27  3 54 86 51 17 86 53]
 [78 93 30 51 91 61 25 65 75 58]
 [20 27 91 23 85  6 80 89 15 12]]

# Ordenação simples em array de 1 dimensão

sort_1d.sort()
print(sort_1d)

[ 2 10 21 25 28 31 46 67 69 71 71 84 88 89 98]

# Ordenação simples, por linhas e colunas em array de 2 dimensões

sort_normal = sort_2d.copy()
sort_colunas = sort_2d.copy()
sort_linhas = sort_2d.copy()

sort_colunas.sort()
print(sort_normal)
print('\n')

sort_colunas.sort(axis = 0)
print(sort_colunas)
print('\n')

sort_linhas.sort(axis = 1)
print(sort_linhas)

[[54 64 28 33 66 91 46 40 11 19]
 [41 10 38 40 66 13 75 94 27 33]
 [91 87 55 50 60 22 15 44 57 91]
 [68 58 26 75 62 43 69 13 33 16]
 [26 59 61 74 24 11 60  9 20 60]
 [23 96 93 77 36 13 42 36  8 95]
 [ 5 18 42 37 28 44  8 24 84 94]
 [54 11 27  3 54 86 51 17 86 53]
 [78 93 30 51 91 61 25 65 75 58]
 [20 27 91 23 85  6 80 89 15 12]]


[[ 3  8 15 20 23 27 41 44 61 74]
 [ 5 11 17 24 26 37 42 54 66 75]
 [ 6 11 18 24 28 40 54 60 69 86]
 [ 8 12 20 27 36 42 54 64 75 91]
 [ 9 13 23 33 38 46 60 66 84 91]
 [10 13 26 33 40 53 60 68 86 91]
 [11 16 27 33 43 57 62 78 89 93]
 [13 19 28 36 51 58 75 85 91 94]
 [15 22 44 50 55 59 77 87 91 94]
 [25 30 51 58 61 65 80 93 95 96]]


[[11 19 28 33 40 46 54 64 66 91]
 [10 13 27 33 38 40 41 66 75 94]
 [15 22 44 50 55 57 60 87 91 91]
 [13 16 26 33 43 58 62 68 69 75]
 [ 9 11 20 24 26 59 60 60 61 74]
 [ 8 13 23 36 36 42 77 93 95 96]
 [ 5  8 18 24 28 37 42 44 84 94]
 [ 3 11 17 27 51 53 54 54 86 86]
 [25 30 51 58 61 65 75 78 91 93]
 [ 6 12 15 20 23 27 80 85 89 91]]

Transposição de Arrays

# Criar o array para transpor

arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(arr)

[[1 2 3 4]
 [5 6 7 8]]

# O atributo T ou a função transpose() irão mostrar o array transposto, porém, não modificará o array

print(arr.T)
print('\n')
print(arr.transpose())
print('\n')
print(arr)

[[1 5]
 [2 6]
 [3 7]
 [4 8]]


[[1 5]
 [2 6]
 [3 7]
 [4 8]]


[[1 2 3 4]
 [5 6 7 8]]

Reshaping de Arrays - alterando o formato de um Array

# Utilizando a função reshape, é possível alterar o formato do array, um ndarray 4x5 pode tornar-se 5x4

arr = np.arange(1, 25)
print(arr)
print(arr.shape)

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
(24,)

# Alterando o shape do array para 2 linhas e 12 colunas 

arr.shape = (2, 12)
print(arr)

[[ 1  2  3  4  5  6  7  8  9 10 11 12]
 [13 14 15 16 17 18 19 20 21 22 23 24]]

# Alterando o shape do array para 3 linhas e 8 colunas 

arr.shape = (3, 8)
print(arr)

[[ 1  2  3  4  5  6  7  8]
 [ 9 10 11 12 13 14 15 16]
 [17 18 19 20 21 22 23 24]]

# A função reshape() não altera o array, apenas mostra o reshaping

print(arr.reshape(4, 6))
print('\n')
print(arr)

[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]
 [13 14 15 16 17 18]
 [19 20 21 22 23 24]]


[[ 1  2  3  4  5  6  7  8]
 [ 9 10 11 12 13 14 15 16]
 [17 18 19 20 21 22 23 24]]

# Linearizar um array em 1 dimensão com as funções flatten() e ravel()

arr_linear_1 = arr.flatten()
arr_linear_2 = arr.ravel()

print(arr_linear_1)
print(arr_linear_2)

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]

Concatenação de Arrays

# Criando arrays para concatenar

arr_1 = np.random.randint(1,101,(3, 9))
arr_2 = np.random.randint(1,101,(5, 9))
arr_3 = np.random.randint(1,101,(5, 4))

print(arr_1)
print('\n')
print(arr_2)
print('\n')
print(arr_3)

[[31 68  6 80 45  3 39 79 58]
 [53 67 19 75 84 96 54 77 94]
 [26 76 87 17 35 31 37 98  7]]


[[32 59 47 43 60 25 75 75 42]
 [75 48 76 98 98 42 37 40 46]
 [13 66 82 98 31 18 74 27 65]
 [25 18 35 50 18 77 63 34  6]
 [19 58  5  3  3 25 67 98 47]]


[[16 67 10 80]
 [86 95 31  8]
 [98 69 30 39]
 [20 24 19 29]
 [80 56 69 22]]

# Utilizando a concatenação vertical pelo eixo das colunas utilizando concatenate axis = 0 ou com vstack (faz direto)

concat_1 = np.concatenate((arr_1, arr_2), axis = 0)
vstack = np.vstack((arr_1, arr_2))

print(concat_1)
print('\n')
print(vstack)

[[31 68  6 80 45  3 39 79 58]
 [53 67 19 75 84 96 54 77 94]
 [26 76 87 17 35 31 37 98  7]
 [32 59 47 43 60 25 75 75 42]
 [75 48 76 98 98 42 37 40 46]
 [13 66 82 98 31 18 74 27 65]
 [25 18 35 50 18 77 63 34  6]
 [19 58  5  3  3 25 67 98 47]]


[[31 68  6 80 45  3 39 79 58]
 [53 67 19 75 84 96 54 77 94]
 [26 76 87 17 35 31 37 98  7]
 [32 59 47 43 60 25 75 75 42]
 [75 48 76 98 98 42 37 40 46]
 [13 66 82 98 31 18 74 27 65]
 [25 18 35 50 18 77 63 34  6]
 [19 58  5  3  3 25 67 98 47]]

# Utilizando a concatenação horizontal pelo eixo das linhas utilizando concatenate axis = 1 ou com hstack (faz direto)

concat_2 = np.concatenate((arr_2, arr_3), axis = 1)
hstack = np.hstack((arr_2, arr_3))

print(concat_2)
print('\n')
print(hstack)

[[32 59 47 43 60 25 75 75 42 16 67 10 80]
 [75 48 76 98 98 42 37 40 46 86 95 31  8]
 [13 66 82 98 31 18 74 27 65 98 69 30 39]
 [25 18 35 50 18 77 63 34  6 20 24 19 29]
 [19 58  5  3  3 25 67 98 47 80 56 69 22]]


[[32 59 47 43 60 25 75 75 42 16 67 10 80]
 [75 48 76 98 98 42 37 40 46 86 95 31  8]
 [13 66 82 98 31 18 74 27 65 98 69 30 39]
 [25 18 35 50 18 77 63 34  6 20 24 19 29]
 [19 58  5  3  3 25 67 98 47 80 56 69 22]]

Dividindo arrays

# Dividindo o primeiro array concatenado em 2 pelo eixo das colunas | divisão vertical com vsplit() 

vsplit = np.vsplit(concat_1, 2)
print(concat_1)
print('\n')
print(vsplit[0])
print('\n')
print(vsplit[1])

[[31 68  6 80 45  3 39 79 58]
 [53 67 19 75 84 96 54 77 94]
 [26 76 87 17 35 31 37 98  7]
 [32 59 47 43 60 25 75 75 42]
 [75 48 76 98 98 42 37 40 46]
 [13 66 82 98 31 18 74 27 65]
 [25 18 35 50 18 77 63 34  6]
 [19 58  5  3  3 25 67 98 47]]


[[31 68  6 80 45  3 39 79 58]
 [53 67 19 75 84 96 54 77 94]
 [26 76 87 17 35 31 37 98  7]
 [32 59 47 43 60 25 75 75 42]]


[[75 48 76 98 98 42 37 40 46]
 [13 66 82 98 31 18 74 27 65]
 [25 18 35 50 18 77 63 34  6]
 [19 58  5  3  3 25 67 98 47]]

# Dividindo o primeiro array concatenado em 3 pelo eixo das linhas | divisão horizontal com hsplit() 

hsplit = np.hsplit(concat_1, 3)

print(concat_1)
print('\n')
print(hsplit[0])
print('\n')
print(hsplit[1])
print('\n')
print(hsplit[2])

[[31 68  6 80 45  3 39 79 58]
 [53 67 19 75 84 96 54 77 94]
 [26 76 87 17 35 31 37 98  7]
 [32 59 47 43 60 25 75 75 42]
 [75 48 76 98 98 42 37 40 46]
 [13 66 82 98 31 18 74 27 65]
 [25 18 35 50 18 77 63 34  6]
 [19 58  5  3  3 25 67 98 47]]


[[31 68  6]
 [53 67 19]
 [26 76 87]
 [32 59 47]
 [75 48 76]
 [13 66 82]
 [25 18 35]
 [19 58  5]]


[[80 45  3]
 [75 84 96]
 [17 35 31]
 [43 60 25]
 [98 98 42]
 [98 31 18]
 [50 18 77]
 [ 3  3 25]]


[[39 79 58]
 [54 77 94]
 [37 98  7]
 [75 75 42]
 [37 40 46]
 [74 27 65]
 [63 34  6]
 [67 98 47]]

Testes de performance de funções comuns e utilizando o NumPy

# Será criada uma função em Python para comparar as somas e a mesma função no NumPy

idades = [12, 15, 14, 88, 32, 54, 41, 11, 25]

def soma(idades):
    soma = 0
    for num in idades:
        soma += num
    return soma

print(soma(idades))
print(sum(idades))
print(np.sum(idades))

292
292
292

# Gerando uma lista de idades entre 0 a 50 com 20 milhões de dados

idades = np.random.randint(0, 50, 20000000)

print(soma(idades))
print(sum(idades))
print(np.sum(idades))

489993396
489993396
489993396

Calculando o tempo de execução de cada uma das funções

%timeit soma(idades)

4.89 s ± 162 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit sum(idades)

3.88 s ± 67.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit np.sum(idades)

10.6 ms ± 78.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

numeros = np.random.randint(1000, 2000, 2000000)

def quadrados(numeros):
    quadrados = []
    for numero in numeros:
        quadrados.append(numero ** 2)
    return quadrados

def quadrados_comprehension(numeros):
    return [num * num for num in numeros]

def quadrados_map(numeros):
    return list(map(lambda n: n ** 2, numeros))

%timeit quadrados(numeros)

1.43 s ± 152 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit quadrados_comprehension(numeros)

782 ms ± 142 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit quadrados_map(numeros)

1.32 s ± 93 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit list(np.power(numeros, 2))

277 ms ± 19.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

arr = np.eye(5)
arr = arr - (np.eye(5) + 1) 

arr

array([[-1., -1., -1., -1., -1.],
       [-1., -1., -1., -1., -1.],
       [-1., -1., -1., -1., -1.],
       [-1., -1., -1., -1., -1.],
       [-1., -1., -1., -1., -1.]])

arr

array([-1,  1, -1,  3, -1,  5, -1,  7, -1,  9])