Numpy

arrays em numpy são diferentes de listas ou listas de listas. Eles são mais eficientes e ninguém usa listas ou lista de listas em aplicações cientificas, que precisam ser eficientes tanto em memoria utilizada como em tempo de execução.

Veja os 3 primeiros videos em <https://www.youtube.com/watch?v=rN0TREj8G7U&list=PLeo1K3hjS3uset9zIVzJWqplaWBiacTEU> que mostra bem os conceitos basicos de numpy.

<https://www.datacamp.com/community/tutorials/python-numpy-tutorial> é um texto tambem bom

https://docs.scipy.org/doc/numpy-1.15.1/user/quickstart.html é user guide do numpy mas eu acho o texto um pouco difícil para aprender.

numpy não vem pre-instalado no Python.

import numpy as np

(há um pacote de arrays no standard library array https://docs.python.org/3/library/array.html mas que nao é usado na prática, nao sei bem por que).

criação array

https://numpy.org/doc/stable/reference/routines.array-creation.html

np.array (inicializa os valores)

• 1D (inicializa com uma lista)

• 2D - lista de linhas

• 3 e nD - tensor

• ndim (numero de dimensões)

• shape (tamanho da cada dimensão)

import numpy as np

a = np.array([5,4,3.1,2,5])
a
X = np.array([[1,2,3],[10,20,30],[100,200,300]])
X
X.ndim
X.shape

Sem valores iniciais diferentes

• np.ones , np.zeros, np.eye (identidade) , np.empty

Indexação de arrays

https://numpy.org/doc/stable/reference/arrays.indexing.html

• tradicional

X = np.arange(1000).reshape((10,100)) 
X.shape # 10 linhas 100 colunas

X[2,3] 

• por slices

X[0:4,8]
X[:,8]
X[0:4,8:10]

• menos dimensões

X[1] - 2a linha

• por outro array ou lista

arr = np.array([3,39,29,12])
lis = [3,39,29,12]

X[3,arr]
X[3,lis]

• por array booleano

arr
arr[np.array([True,False,False,True])

e = np.array([True,False,False,True,False,False,True,False,False,True,False])
X[e,8]

• indexacao por array de inteiros e por boleanos é comum em outras linguagens que tem array como tipo pre definido (R, Matlab, julia)

indexação por 2 arrays - cuidado

Usar 2 arrays ou 2 listas para os indexadores ao mesmo tempo NAO faz o que vc esperaria. O numpy faz a indexação par a par nas 2 listas

X[[3,4], [11,12] ] 
X[np.array([3,4]), np.array([11,12]) ] 

X[3,11]
X[4,12]

X[[3,4], [11,12,13,14] ] 

mas veja que com slices isso funciona como esperado

X[3:5,11:15]

para ter o efeito esperado com multiplas listas de indexadores use o np.ix_

X[ np.ix_(np.array([3,4]), np.array([11,12,13,14])) ]


X[ np.ix_([3,4], [11,12,13,14]) ] - funciona para listas de indices

LEIA a parte de indexação do manual do numpy https://numpy.org/doc/stable/reference/arrays.indexing.html

• np.newaxis
• ...
• np.slice

Operações em arrays

• + - * / funcionam para array (operação elemento por elemento)

• * não é a multiplicação de matrizes (isso é o método dot)

a = np.array([10,20,30])
b = np.array([1,2,3])
a+b
a*b
a/b

• multiplicação de matrizes (como em algebra linear)

a.dot(b)

np.dot(a,b)

• comparacoes funcionam para arrays (elemento por elemento)

a = np.array([1,2,3])
b = np.array([1,4,3])
a == b
np.greater(a,b)

diferente de listas que verificam se as 2 listas sao iguais

[1,2,3] == [1,4,3]

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

broadcast

os argumentos não precisam ter a mesmas ndim (inclusive atribuição)

a+2
4*X
np.array([1,2,3]) == 1

X % 2 == 0

• broadcast para array 2D e mais é mais complicado. https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html

indexação avançada + broadcast ( exemplo)

Rodar in ipython

import numpy as np

def g1():
    global x
    for i in range(x.shape[0]):
        for j in range(x.shape[1]):
            if x[i,j] < 0.5:
                x[i,j]=0.0
    return None
    
def g2():
    global x
    x[x<0.5]=0.0
    return None
    
y = np.random.rand(4000,30)
x = np.array(y,copy=True)
%timeit g1()
x = np.array(y,copy=True)
%timeit g2()

x<0.5 é um array 2D booleano que sever para indexar os elementos de x que vao trocar de valor

tipo

• arrays numpy sao implementados como arrays em C - memoria contigua
• tipo np.int16 np.int32 np.float32
• e não o inteiro do Python que é sem limite

X.dtype
a.dtype

• existe o tipo caracter e sequencia de caracter
• existe o tipo np.object para apontador para qq coisa

c = np.array("qwert")
c.dtype
c = np.array(["qwert","asd","longo muitoooooooooooooooo longo",57])
c.dtype

reshape

• a operacao de modificar o formato de um array é barata. Não há copia dos dados

a = np.array([1,2,3,4,5,6,7,8,9,10,11,12])
a
b=a.reshape((3,4))
b
c = np.reshape(a,(1,12))

note a diferença entre a e c

np.info

np.info(a)
np.info(b)

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

• shape

• type

• itemsize

• fortran

  • ordem fortran 1,3,5… - column major
  • ordem C 1,2,3,.. row major

• stride https://stackoverflow.com/questions/53097952/how-to-understand-numpy-strides-for-layman como achar o proximo elemento, na linha (stride[1]) e na coluna (stride[0])

• data - o block de memoria com os dados brutos do array. O Python reusa o data sempre que possível, trocando o stride para representar diferentes “formatos” do array. Veja que o reshape reusa o data.

  np.info(c) reusa o data tambem.

Funçoes em numpy

Funções elemento por elemento

• np.log

• + - / *

• np.add

• np.greater >

• np.logical_and

Funções que agregam varios valores

• np.all
• np.sum https://numpy.org/doc/stable/reference/generated/numpy.sum.html#numpy.sum
• np.amax

axis - faz a operação agregação nessa dimensão - sobram as outras

a = np.arange(24).reshape(3,4,2)
a

np.sum(a,axis=0)

np.amax(a,axis=(1,2))

Junta e quebra arrays

https://numpy.org/doc/stable/reference/routines.array-manipulation.html#joining-arrays

• concatenate - numa dimensão que ja existe - para arrays 2D vstack e hstack para juntar na vertical ou na horizontal
• stack numa nova dimensão

Algebra linear

https://numpy.org/doc/stable/reference/routines.linalg.html

• produto de matrizes e vetores
• inversão de matrizes
• fatoração de matrizes
• auto-vetores e auto-valores

I/O

Formato interno para matrizes npy

• save
• load

Texto

• savetxt
• loadtxt

csv

• pacote da standard library csv

• funcão do pandas pandas.read_csv

bibliotecas de algebra linear

as operações (e algumas funções - autovalores e auto vetores, determinantes, etc) do numpy são implementadas por bibliotecas de baixo nivel que operam diretamente no data

Bibliotecas de algebra linear de baixo nivel

• BLAS http://www.netlib.org/blas/
• openBLAS https://github.com/xianyi/OpenBLAS/releases
• LAPACK http://www.netlib.org/lapack/lug/
• MKL https://software.intel.com/en-us/mkl
• ATLAS
• Armadillo http://arma.sourceforge.net/

contiguous indica se o data pode ser enviado diretamente para a biblioteca de baixo nivel. Se nao, o numpy cria uma nova versão do array (copiado o data) de forma que possa ser usada pela biblioteca!

Loops mais complexos

de uma olhada no 4a video de https://www.youtube.com/playlist?list=PLeo1K3hjS3uset9zIVzJWqplaWBiacTEU que fala sobre uma função util para fazer iteração em arrays.

Cython

Extensões tipo C do python https://cython.org/

• sintaxe de controle do python
• declaração de tipos de variáveis locais
• pode incluir operações/funções do python (mas isso torna o código mais lento pois tem que haver a conversão para objetos python)

Veja a função Primes em https://cython.readthedocs.io/en/latest/src/tutorial/cython_tutorial.html

curso sobre cython https://nyu-cds.github.io/python-cython/

Ha poucos sites discutindo cython + numpy