NumPy - Guia Rápido

NumPy é um pacote Python. Significa 'Numerical Python'. É uma biblioteca que consiste em objetos de array multidimensionais e uma coleção de rotinas para processamento de array.

Numeric, o ancestral do NumPy, foi desenvolvido por Jim Hugunin. Outro pacote Numarray também foi desenvolvido, possuindo algumas funcionalidades adicionais. Em 2005, Travis Oliphant criou o pacote NumPy incorporando os recursos do Numarray ao pacote Numeric. Existem muitos contribuidores para este projeto de código aberto.

Operações usando NumPy

Usando NumPy, um desenvolvedor pode realizar as seguintes operações -

  • Operações matemáticas e lógicas em matrizes.

  • Transformações de Fourier e rotinas para manipulação de formas.

  • Operações relacionadas com álgebra linear. NumPy possui funções embutidas para álgebra linear e geração de números aleatórios.

NumPy - um substituto para MatLab

NumPy é freqüentemente usado junto com pacotes como SciPy (Scientific Python) e Mat−plotlib(biblioteca de plotagem). Essa combinação é amplamente usada como um substituto para MatLab, uma plataforma popular para computação técnica. No entanto, a alternativa Python ao MatLab agora é vista como uma linguagem de programação mais moderna e completa.

É open source, o que é uma vantagem adicional do NumPy.

A distribuição padrão do Python não vem com o módulo NumPy. Uma alternativa leve é ​​instalar o NumPy usando o instalador de pacote Python popular,pip.

pip install numpy

A melhor maneira de habilitar o NumPy é usar um pacote binário instalável específico para o seu sistema operacional. Esses binários contêm a pilha SciPy completa (incluindo NumPy, SciPy, matplotlib, IPython, SymPy e pacotes nariz junto com o núcleo do Python).

janelas

Anaconda (de https://www.continuum.io) é uma distribuição Python gratuita para a pilha SciPy. Também está disponível para Linux e Mac.

Marquise (https://www.enthought.com/products/canopy/) está disponível como distribuição gratuita e comercial com pilha SciPy completa para Windows, Linux e Mac.

Python (x, y): é uma distribuição Python gratuita com pilha SciPy e Spyder IDE para Windows OS. (Pode ser baixado dehttps://www.python-xy.github.io/)

Linux

Os gerenciadores de pacotes das respectivas distribuições Linux são usados ​​para instalar um ou mais pacotes na pilha SciPy.

Para Ubuntu

sudo apt-get install python-numpy 
python-scipy python-matplotlibipythonipythonnotebook python-pandas 
python-sympy python-nose

Para Fedora

sudo yum install numpyscipy python-matplotlibipython 
python-pandas sympy python-nose atlas-devel

Construindo da Fonte

Core Python (2.6.x, 2.7.xe 3.2.x em diante) deve ser instalado com distutils e o módulo zlib deve ser habilitado.

O compilador GNU gcc (4.2 e superior) C deve estar disponível.

Para instalar o NumPy, execute o seguinte comando.

Python setup.py install

Para testar se o módulo NumPy está instalado corretamente, tente importá-lo do prompt do Python.

import numpy

Se não estiver instalado, a seguinte mensagem de erro será exibida.

Traceback (most recent call last): 
   File "<pyshell#0>", line 1, in <module> 
      import numpy 
ImportError: No module named 'numpy'

Como alternativa, o pacote NumPy é importado usando a seguinte sintaxe -

import numpy as np

O objeto mais importante definido no NumPy é um tipo de array N-dimensional chamado ndarray. Ele descreve a coleção de itens do mesmo tipo. Os itens da coleção podem ser acessados ​​usando um índice baseado em zero.

Cada item em um ndarray tem o mesmo tamanho de bloco na memória. Cada elemento em ndarray é um objeto de tipo de dados (chamadodtype)

Qualquer item extraído do objeto ndarray (por fatiamento) é representado por um objeto Python de um dos tipos escalares de array. O diagrama a seguir mostra uma relação entre ndarray, objeto de tipo de dados (dtype) e tipo escalar de array -

Uma instância da classe ndarray pode ser construída por diferentes rotinas de criação de array descritas posteriormente no tutorial. O ndarray básico é criado usando uma função de array em NumPy da seguinte maneira -

numpy.array

Ele cria um ndarray a partir de qualquer objeto que expõe a interface de array ou de qualquer método que retorna um array.

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

O construtor acima usa os seguintes parâmetros -

Sr. Não. Parâmetro e Descrição
1

object

Qualquer objeto que exponha o método de interface de array retorna um array ou qualquer sequência (aninhada).

2

dtype

Tipo de array de dados desejado, opcional

3

copy

Opcional. Por padrão (verdadeiro), o objeto é copiado

4

order

C (linha principal) ou F (coluna principal) ou A (qualquer) (padrão)

5

subok

Por padrão, o array retornado é forçado a ser um array de classe base. Se verdadeiro, as subclasses passaram por

6

ndmin

Especifica as dimensões mínimas da matriz resultante

Dê uma olhada nos exemplos a seguir para entender melhor.

Exemplo 1

import numpy as np 
a = np.array([1,2,3]) 
print a

O resultado é o seguinte -

[1, 2, 3]

Exemplo 2

# more than one dimensions 
import numpy as np 
a = np.array([[1, 2], [3, 4]]) 
print a

O resultado é o seguinte -

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

Exemplo 3

# minimum dimensions 
import numpy as np 
a = np.array([1, 2, 3,4,5], ndmin = 2) 
print a

O resultado é o seguinte -

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

Exemplo 4

# dtype parameter 
import numpy as np 
a = np.array([1, 2, 3], dtype = complex) 
print a

O resultado é o seguinte -

[ 1.+0.j,  2.+0.j,  3.+0.j]

o ndarrayO objeto consiste em um segmento unidimensional contíguo da memória do computador, combinado com um esquema de indexação que mapeia cada item para um local no bloco de memória. O bloco de memória contém os elementos em uma ordem maior de linha (estilo C) ou uma ordem maior de coluna (estilo FORTRAN ou MatLab).

NumPy suporta uma variedade muito maior de tipos numéricos do que Python. A tabela a seguir mostra diferentes tipos de dados escalares definidos em NumPy.

Sr. Não. Tipos de dados e descrição
1

bool_

Booleano (verdadeiro ou falso) armazenado como um byte

2

int_

Tipo inteiro padrão (igual a C long; normalmente int64 ou int32)

3

intc

Idêntico a C int (normalmente int32 ou int64)

4

intp

Número inteiro usado para indexação (igual a C ssize_t; normalmente int32 ou int64)

5

int8

Byte (-128 a 127)

6

int16

Inteiro (-32768 a 32767)

7

int32

Inteiro (-2147483648 a 2147483647)

8

int64

Inteiro (-9223372036854775808 a 9223372036854775807)

9

uint8

Inteiro sem sinal (0 a 255)

10

uint16

Inteiro sem sinal (0 a 65535)

11

uint32

Inteiro sem sinal (0 a 4294967295)

12

uint64

Número inteiro sem sinal (0 a 18446744073709551615)

13

float_

Abreviação de float64

14

float16

Flutuação de meia precisão: bit de sinal, expoente de 5 bits, mantissa de 10 bits

15

float32

Flutuação de precisão simples: bit de sinal, expoente de 8 bits, mantissa de 23 bits

16

float64

Flutuação de precisão dupla: bit de sinal, expoente de 11 bits, mantissa de 52 bits

17

complex_

Abreviação de complexo 128

18

complex64

Número complexo, representado por dois flutuadores de 32 bits (componentes reais e imaginários)

19

complex128

Número complexo, representado por dois flutuadores de 64 bits (componentes reais e imaginários)

Os tipos numéricos NumPy são instâncias de objetos dtype (tipo de dados), cada um com características únicas. Os dtypes estão disponíveis como np.bool_, np.float32, etc.

Objetos de tipo de dados (dtype)

Um objeto de tipo de dados descreve a interpretação de um bloco fixo de memória correspondente a uma matriz, dependendo dos seguintes aspectos -

  • Tipo de dados (inteiro, float ou objeto Python)

  • Tamanho dos dados

  • Ordem de bytes (little-endian ou big-endian)

  • No caso do tipo estruturado, os nomes dos campos, o tipo de dado de cada campo e parte do bloco de memória ocupada por cada campo.

  • Se o tipo de dados for um subarray, sua forma e tipo de dados

A ordem dos bytes é decidida prefixando '<' ou '>' ao tipo de dados. '<' significa que a codificação é little-endian (a menos significativa é armazenada no menor endereço). '>' significa que a codificação é big-endian (o byte mais significativo é armazenado no menor endereço).

Um objeto dtype é construído usando a seguinte sintaxe -

numpy.dtype(object, align, copy)

Os parâmetros são -

  • Object - Para ser convertido em objeto de tipo de dados

  • Align - Se verdadeiro, adiciona preenchimento ao campo para torná-lo semelhante a C-struct

  • Copy- Faz uma nova cópia do objeto dtype. Se for falso, o resultado é uma referência ao objeto de tipo de dados integrado

Exemplo 1

# using array-scalar type 
import numpy as np 
dt = np.dtype(np.int32) 
print dt

O resultado é o seguinte -

int32

Exemplo 2

#int8, int16, int32, int64 can be replaced by equivalent string 'i1', 'i2','i4', etc. 
import numpy as np 

dt = np.dtype('i4')
print dt

O resultado é o seguinte -

int32

Exemplo 3

# using endian notation 
import numpy as np 
dt = np.dtype('>i4') 
print dt

O resultado é o seguinte -

>i4

Os exemplos a seguir mostram o uso do tipo de dados estruturados. Aqui, o nome do campo e o tipo de dados escalar correspondente devem ser declarados.

Exemplo 4

# first create structured data type 
import numpy as np 
dt = np.dtype([('age',np.int8)]) 
print dt

O resultado é o seguinte -

[('age', 'i1')]

Exemplo 5

# now apply it to ndarray object 
import numpy as np 

dt = np.dtype([('age',np.int8)]) 
a = np.array([(10,),(20,),(30,)], dtype = dt) 
print a

O resultado é o seguinte -

[(10,) (20,) (30,)]

Exemplo 6

# file name can be used to access content of age column 
import numpy as np 

dt = np.dtype([('age',np.int8)]) 
a = np.array([(10,),(20,),(30,)], dtype = dt) 
print a['age']

O resultado é o seguinte -

[10 20 30]

Exemplo 7

Os exemplos a seguir definem um tipo de dados estruturado chamado student com um campo de string 'nome', um integer field 'idade' e um float field'marcas'. Este dtype é aplicado ao objeto ndarray.

import numpy as np 
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) 
print student

O resultado é o seguinte -

[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])

Exemplo 8

import numpy as np 

student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) 
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student) 
print a

O resultado é o seguinte -

[('abc', 21, 50.0), ('xyz', 18, 75.0)]

Cada tipo de dados integrado possui um código de caractere que o identifica exclusivamente.

  • 'b' - booleano

  • 'i' - inteiro (assinado)

  • 'u' - inteiro sem sinal

  • 'f' - ponto flutuante

  • 'c' - ponto flutuante complexo

  • 'm' - timedelta

  • 'M' - datetime

  • 'O' - objetos (Python)

  • 'S', 'a' - (byte-) string

  • 'U' - Unicode

  • 'V' - dados brutos (vazio)

Neste capítulo, discutiremos os vários atributos de array de NumPy.

ndarray.shape

Este atributo de matriz retorna uma tupla que consiste em dimensões de matriz. Ele também pode ser usado para redimensionar a matriz.

Exemplo 1

import numpy as np 
a = np.array([[1,2,3],[4,5,6]]) 
print a.shape

O resultado é o seguinte -

(2, 3)

Exemplo 2

# this resizes the ndarray 
import numpy as np 

a = np.array([[1,2,3],[4,5,6]]) 
a.shape = (3,2) 
print a

O resultado é o seguinte -

[[1, 2] 
 [3, 4] 
 [5, 6]]

Exemplo 3

NumPy também fornece uma função de remodelagem para redimensionar uma matriz.

import numpy as np 
a = np.array([[1,2,3],[4,5,6]]) 
b = a.reshape(3,2) 
print b

O resultado é o seguinte -

[[1, 2] 
 [3, 4] 
 [5, 6]]

ndarray.ndim

Este atributo de matriz retorna o número de dimensões de matriz.

Exemplo 1

# an array of evenly spaced numbers 
import numpy as np 
a = np.arange(24) 
print a

O resultado é o seguinte -

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

Exemplo 2

# this is one dimensional array 
import numpy as np 
a = np.arange(24) 
a.ndim  

# now reshape it 
b = a.reshape(2,4,3) 
print b 
# b is having three dimensions

O resultado é o seguinte -

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

numpy.itemsize

Este atributo de matriz retorna o comprimento de cada elemento da matriz em bytes.

Exemplo 1

# dtype of array is int8 (1 byte) 
import numpy as np 
x = np.array([1,2,3,4,5], dtype = np.int8) 
print x.itemsize

O resultado é o seguinte -

1

Exemplo 2

# dtype of array is now float32 (4 bytes) 
import numpy as np 
x = np.array([1,2,3,4,5], dtype = np.float32) 
print x.itemsize

O resultado é o seguinte -

4

numpy.flags

O objeto ndarray possui os seguintes atributos. Seus valores atuais são retornados por esta função.

Sr. Não. Atributo e descrição
1

C_CONTIGUOUS (C)

Os dados estão em um único segmento contíguo de estilo C

2

F_CONTIGUOUS (F)

Os dados estão em um único segmento contíguo no estilo Fortran

3

OWNDATA (O)

A matriz possui a memória que usa ou a toma emprestada de outro objeto

4

WRITEABLE (W)

A área de dados pode ser gravada. Definir como False bloqueia os dados, tornando-os somente leitura

5

ALIGNED (A)

Os dados e todos os elementos são alinhados de forma adequada para o hardware

6

UPDATEIFCOPY (U)

Este array é uma cópia de algum outro array. Quando este array é desalocado, o array base será atualizado com o conteúdo deste array

Exemplo

O exemplo a seguir mostra os valores atuais dos sinalizadores.

import numpy as np 
x = np.array([1,2,3,4,5]) 
print x.flags

O resultado é o seguinte -

C_CONTIGUOUS : True 
F_CONTIGUOUS : True 
OWNDATA : True 
WRITEABLE : True 
ALIGNED : True 
UPDATEIFCOPY : False

Uma nova ndarray O objeto pode ser construído por qualquer uma das seguintes rotinas de criação de array ou usando um construtor ndarray de baixo nível.

numpy.empty

Ele cria uma matriz não inicializada da forma e do tipo especificados. Ele usa o seguinte construtor -

numpy.empty(shape, dtype = float, order = 'C')

O construtor assume os seguintes parâmetros.

Sr. Não. Parâmetro e Descrição
1

Shape

Forma de uma matriz vazia em int ou tupla de int

2

Dtype

Tipo de dados de saída desejado. Opcional

3

Order

'C' para matriz de linha principal de estilo C, 'F' para matriz de coluna principal de estilo FORTRAN

Exemplo

O código a seguir mostra um exemplo de uma matriz vazia.

import numpy as np 
x = np.empty([3,2], dtype = int) 
print x

O resultado é o seguinte -

[[22649312    1701344351] 
 [1818321759  1885959276] 
 [16779776    156368896]]

Note - Os elementos em uma matriz mostram valores aleatórios, pois não são inicializados.

numpy.zeros

Retorna uma nova matriz de tamanho especificado, preenchida com zeros.

numpy.zeros(shape, dtype = float, order = 'C')

O construtor assume os seguintes parâmetros.

Sr. Não. Parâmetro e Descrição
1

Shape

Forma de uma matriz vazia em int ou sequência de int

2

Dtype

Tipo de dados de saída desejado. Opcional

3

Order

'C' para matriz de linha principal de estilo C, 'F' para matriz de coluna principal de estilo FORTRAN

Exemplo 1

# array of five zeros. Default dtype is float 
import numpy as np 
x = np.zeros(5) 
print x

O resultado é o seguinte -

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

Exemplo 2

import numpy as np 
x = np.zeros((5,), dtype = np.int) 
print x

Agora, a saída seria a seguinte -

[0  0  0  0  0]

Exemplo 3

# custom type 
import numpy as np 
x = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])  
print x

Ele deve produzir a seguinte saída -

[[(0,0)(0,0)]
 [(0,0)(0,0)]]

numpy.ones

Retorna uma nova matriz de tamanho e tipo especificados, preenchida com uns.

numpy.ones(shape, dtype = None, order = 'C')

O construtor assume os seguintes parâmetros.

Sr. Não. Parâmetro e Descrição
1

Shape

Forma de uma matriz vazia em int ou tupla de int

2

Dtype

Tipo de dados de saída desejado. Opcional

3

Order

'C' para matriz de linha principal de estilo C, 'F' para matriz de coluna principal de estilo FORTRAN

Exemplo 1

# array of five ones. Default dtype is float 
import numpy as np 
x = np.ones(5) 
print x

O resultado é o seguinte -

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

Exemplo 2

import numpy as np 
x = np.ones([2,2], dtype = int) 
print x

Agora, a saída seria a seguinte -

[[1  1] 
 [1  1]]

Neste capítulo, discutiremos como criar um array a partir de dados existentes.

numpy.asarray

Essa função é semelhante a numpy.array, exceto pelo fato de ter menos parâmetros. Esta rotina é útil para converter a sequência Python em ndarray.

numpy.asarray(a, dtype = None, order = None)

O construtor assume os seguintes parâmetros.

Sr. Não. Parâmetro e Descrição
1

a

Dados de entrada em qualquer formato, como lista, lista de tuplas, tuplas, tupla de tuplas ou tupla de listas

2

dtype

Por padrão, o tipo de dados de entrada é aplicado ao ndarray resultante

3

order

C (linha principal) ou F (coluna principal). C é o padrão

Os exemplos a seguir mostram como você pode usar o asarray função.

Exemplo 1

# convert list to ndarray 
import numpy as np 

x = [1,2,3] 
a = np.asarray(x) 
print a

Sua saída seria a seguinte -

[1  2  3]

Exemplo 2

# dtype is set 
import numpy as np 

x = [1,2,3]
a = np.asarray(x, dtype = float) 
print a

Agora, a saída seria a seguinte -

[ 1.  2.  3.]

Exemplo 3

# ndarray from tuple 
import numpy as np 

x = (1,2,3) 
a = np.asarray(x) 
print a

Sua saída seria -

[1  2  3]

Exemplo 4

# ndarray from list of tuples 
import numpy as np 

x = [(1,2,3),(4,5)] 
a = np.asarray(x) 
print a

Aqui, a saída seria a seguinte -

[(1, 2, 3) (4, 5)]

numpy.frombuffer

Esta função interpreta um buffer como uma matriz unidimensional. Qualquer objeto que expõe a interface do buffer é usado como parâmetro para retornar umndarray.

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

O construtor assume os seguintes parâmetros.

Sr. Não. Parâmetro e Descrição
1

buffer

Qualquer objeto que expõe interface de buffer

2

dtype

Tipo de dados do ndarray retornado. O padrão é flutuar

3

count

O número de itens para ler, padrão -1 significa todos os dados

4

offset

A posição inicial a partir da qual ler. O padrão é 0

Exemplo

Os exemplos a seguir demonstram o uso de frombuffer função.

import numpy as np 
s = 'Hello World' 
a = np.frombuffer(s, dtype = 'S1') 
print a

Aqui está o resultado -

['H'  'e'  'l'  'l'  'o'  ' '  'W'  'o'  'r'  'l'  'd']

numpy.fromiter

Esta função constrói um ndarrayobjeto de qualquer objeto iterável. Uma nova matriz unidimensional é retornada por esta função.

numpy.fromiter(iterable, dtype, count = -1)

Aqui, o construtor usa os seguintes parâmetros.

Sr. Não. Parâmetro e Descrição
1

iterable

Qualquer objeto iterável

2

dtype

Tipo de dados da matriz resultante

3

count

O número de itens a serem lidos do iterador. O padrão é -1, o que significa que todos os dados devem ser lidos

Os exemplos a seguir mostram como usar o integrado range()função para retornar um objeto de lista. Um iterador desta lista é usado para formar umndarray objeto.

Exemplo 1

# create list object using range function 
import numpy as np 
list = range(5) 
print list

Seu resultado é o seguinte -

[0,  1,  2,  3,  4]

Exemplo 2

# obtain iterator object from list 
import numpy as np 
list = range(5) 
it = iter(list)  

# use iterator to create ndarray 
x = np.fromiter(it, dtype = float) 
print x

Agora, a saída seria a seguinte -

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

Neste capítulo, veremos como criar um array a partir de intervalos numéricos.

numpy.arange

Esta função retorna um ndarrayobjeto que contém valores uniformemente espaçados dentro de um determinado intervalo. O formato da função é o seguinte -

numpy.arange(start, stop, step, dtype)

O construtor assume os seguintes parâmetros.

Sr. Não. Parâmetro e Descrição
1

start

O início de um intervalo. Se omitido, o padrão é 0

2

stop

O fim de um intervalo (sem incluir este número)

3

step

Espaçamento entre valores, o padrão é 1

4

dtype

Tipo de dados do ndarray resultante. Se não for fornecido, o tipo de dados de entrada é usado

Os exemplos a seguir mostram como você pode usar esta função.

Exemplo 1

import numpy as np 
x = np.arange(5) 
print x

Sua saída seria a seguinte -

[0  1  2  3  4]

Exemplo 2

import numpy as np 
# dtype set 
x = np.arange(5, dtype = float)
print x

Aqui, a saída seria -

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

Exemplo 3

# start and stop parameters set 
import numpy as np 
x = np.arange(10,20,2) 
print x

Seu resultado é o seguinte -

[10  12  14  16  18]

numpy.linspace

Esta função é semelhante a arange()função. Nesta função, em vez do tamanho do passo, o número de valores uniformemente espaçados entre o intervalo é especificado. O uso desta função é o seguinte -

numpy.linspace(start, stop, num, endpoint, retstep, dtype)

O construtor assume os seguintes parâmetros.

Sr. Não. Parâmetro e Descrição
1

start

O valor inicial da sequência

2

stop

O valor final da sequência, incluído na sequência se o ponto final for definido como verdadeiro

3

num

O número de amostras com espaçamento uniforme a serem geradas. O padrão é 50

4

endpoint

Verdadeiro por padrão, portanto, o valor de parada é incluído na sequência. Se for falso, não está incluído

5

retstep

Se verdadeiro, retorna amostras e avança entre os números consecutivos

6

dtype

Tipo de dados de saída ndarray

Os exemplos a seguir demonstram o uso linspace função.

Exemplo 1

import numpy as np 
x = np.linspace(10,20,5) 
print x

Sua saída seria -

[10.   12.5   15.   17.5  20.]

Exemplo 2

# endpoint set to false 
import numpy as np 
x = np.linspace(10,20, 5, endpoint = False) 
print x

A saída seria -

[10.   12.   14.   16.   18.]

Exemplo 3

# find retstep value 
import numpy as np 

x = np.linspace(1,2,5, retstep = True) 
print x 
# retstep here is 0.25

Agora, a saída seria -

(array([ 1.  ,  1.25,  1.5 ,  1.75,  2.  ]), 0.25)

numpy.logspace

Esta função retorna um ndarrayobjeto que contém os números uniformemente espaçados em uma escala logarítmica. Os pontos finais de início e parada da escala são índices da base, geralmente 10.

numpy.logspace(start, stop, num, endpoint, base, dtype)

Os parâmetros a seguir determinam a saída de logspace função.

Sr. Não. Parâmetro e Descrição
1

start

O ponto de partida da sequência é o início básico

2

stop

O valor final da sequência é base stop

3

num

O número de valores entre o intervalo. O padrão é 50

4

endpoint

Se verdadeiro, stop é o último valor no intervalo

5

base

Base de espaço de log, o padrão é 10

6

dtype

Tipo de dados da matriz de saída. Se não for fornecido, depende de outros argumentos de entrada

Os exemplos a seguir irão ajudá-lo a entender o logspace função.

Exemplo 1

import numpy as np 
# default base is 10 
a = np.logspace(1.0, 2.0, num = 10) 
print a

Sua saída seria a seguinte -

[ 10.           12.91549665     16.68100537      21.5443469  27.82559402      
  35.93813664   46.41588834     59.94842503      77.42636827    100.    ]

Exemplo 2

# set base of log space to 2 
import numpy as np 
a = np.logspace(1,10,num = 10, base = 2) 
print a

Agora, a saída seria -

[ 2.     4.     8.    16.    32.    64.   128.   256.    512.   1024.]

O conteúdo do objeto ndarray pode ser acessado e modificado por indexação ou divisão, assim como os objetos de contêiner embutidos do Python.

Conforme mencionado anteriormente, os itens no objeto ndarray seguem o índice baseado em zero. Três tipos de métodos de indexação estão disponíveis -field access, basic slicing e advanced indexing.

O fatiamento básico é uma extensão do conceito básico do Python de fatiar para n dimensões. Um objeto de fatia Python é construído dandostart, stop, e step parâmetros para o embutido slicefunção. Este objeto de fatia é passado para a matriz para extrair uma parte da matriz.

Exemplo 1

import numpy as np 
a = np.arange(10) 
s = slice(2,7,2) 
print a[s]

Seu resultado é o seguinte -

[2  4  6]

No exemplo acima, um ndarray objeto é preparado por arange()função. Em seguida, um objeto de fatia é definido com valores de início, parada e etapa 2, 7 e 2, respectivamente. Quando este objeto de fatia é passado para o ndarray, uma parte dele começando com o índice 2 até 7 com uma etapa de 2 é fatiada.

O mesmo resultado também pode ser obtido fornecendo os parâmetros de corte separados por dois pontos: (iniciar: parar: passo) diretamente para o ndarray objeto.

Exemplo 2

import numpy as np 
a = np.arange(10) 
b = a[2:7:2] 
print b

Aqui, obteremos a mesma saída -

[2  4  6]

Se apenas um parâmetro for colocado, um único item correspondente ao índice será retornado. Se: for inserido na frente dele, todos os itens desse índice em diante serão extraídos. Se dois parâmetros (com: entre eles) forem usados, os itens entre os dois índices (sem incluir o índice de parada) com a etapa padrão um serão divididos.

Exemplo 3

# slice single item 
import numpy as np 

a = np.arange(10) 
b = a[5] 
print b

Seu resultado é o seguinte -

5

Exemplo 4

# slice items starting from index 
import numpy as np 
a = np.arange(10) 
print a[2:]

Agora, a saída seria -

[2  3  4  5  6  7  8  9]

Exemplo 5

# slice items between indexes 
import numpy as np 
a = np.arange(10) 
print a[2:5]

Aqui, a saída seria -

[2  3  4]

A descrição acima se aplica a sistemas multidimensionais ndarray também.

Exemplo 6

import numpy as np 
a = np.array([[1,2,3],[3,4,5],[4,5,6]]) 
print a  

# slice items starting from index
print 'Now we will slice the array from the index a[1:]' 
print a[1:]

O resultado é o seguinte -

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

Now we will slice the array from the index a[1:]
[[3 4 5]
 [4 5 6]]

O fatiamento também pode incluir reticências (...) para fazer uma tupla de seleção do mesmo comprimento que a dimensão de uma matriz. Se reticências forem usadas na posição da linha, ele retornará um ndarray composto de itens nas linhas.

Exemplo 7

# array to begin with 
import numpy as np 
a = np.array([[1,2,3],[3,4,5],[4,5,6]]) 

print 'Our array is:' 
print a 
print '\n'  

# this returns array of items in the second column 
print 'The items in the second column are:'  
print a[...,1] 
print '\n'  

# Now we will slice all items from the second row 
print 'The items in the second row are:' 
print a[1,...] 
print '\n'  

# Now we will slice all items from column 1 onwards 
print 'The items column 1 onwards are:' 
print a[...,1:]

O resultado deste programa é o seguinte -

Our array is:
[[1 2 3]
 [3 4 5]
 [4 5 6]] 
 
The items in the second column are: 
[2 4 5] 

The items in the second row are:
[3 4 5]

The items column 1 onwards are:
[[2 3]
 [4 5]
 [5 6]]

É possível fazer uma seleção de ndarray que é uma sequência não tupla, objeto ndarray do tipo de dados inteiro ou booleano ou uma tupla com pelo menos um item sendo um objeto de sequência. A indexação avançada sempre retorna uma cópia dos dados. Contra isso, o fatiamento apresenta apenas uma visão.

Existem dois tipos de indexação avançada - Integer e Boolean.

Indexação Inteira

Esse mecanismo ajuda a selecionar qualquer item arbitrário em uma matriz com base em seu índice N-dimensional. Cada matriz inteira representa o número de índices nessa dimensão. Quando o índice consiste em tantas matrizes de inteiros quantas as dimensões do ndarray de destino, ele se torna direto.

No exemplo a seguir, um elemento da coluna especificada de cada linha do objeto ndarray é selecionado. Portanto, o índice da linha contém todos os números da linha e o índice da coluna especifica o elemento a ser selecionado.

Exemplo 1

import numpy as np 

x = np.array([[1, 2], [3, 4], [5, 6]]) 
y = x[[0,1,2], [0,1,0]] 
print y

Sua saída seria a seguinte -

[1  4  5]

A seleção inclui elementos em (0,0), (1,1) e (2,0) da primeira matriz.

No exemplo a seguir, os elementos colocados nos cantos de uma matriz 4X3 são selecionados. Os índices de linha de seleção são [0, 0] e [3,3], enquanto os índices de coluna são [0,2] e [0,2].

Exemplo 2

import numpy as np 
x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) 
   
print 'Our array is:' 
print x 
print '\n' 

rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols] 
   
print 'The corner elements of this array are:' 
print y

O resultado deste programa é o seguinte -

Our array is:                                                                 
[[ 0  1  2]                                                                   
 [ 3  4  5]                                                                   
 [ 6  7  8]                                                                   
 [ 9 10 11]]
 
The corner elements of this array are:                                        
[[ 0  2]                                                                      
 [ 9 11]]

A seleção resultante é um objeto ndarray contendo elementos de canto.

A indexação avançada e básica podem ser combinadas usando uma fatia (:) ou reticências (…) com uma matriz de índice. O exemplo a seguir usa fatia para linha e índice avançado para coluna. O resultado é o mesmo quando a fatia é usada para ambos. Mas o índice avançado resulta em cópia e pode ter um layout de memória diferente.

Exemplo 3

import numpy as np 
x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) 

print 'Our array is:' 
print x 
print '\n'  

# slicing 
z = x[1:4,1:3] 

print 'After slicing, our array becomes:' 
print z 
print '\n'  

# using advanced index for column 
y = x[1:4,[1,2]] 

print 'Slicing using advanced index for column:' 
print y

A saída deste programa seria a seguinte -

Our array is:
[[ 0  1  2] 
 [ 3  4  5] 
 [ 6  7  8]
 [ 9 10 11]]
 
After slicing, our array becomes:
[[ 4  5]
 [ 7  8]
 [10 11]]

Slicing using advanced index for column:
[[ 4  5]
 [ 7  8]
 [10 11]]

Indexação de matriz booleana

Esse tipo de indexação avançada é usado quando o objeto resultante deve ser o resultado de operações booleanas, como operadores de comparação.

Exemplo 1

Neste exemplo, os itens maiores que 5 são retornados como resultado da indexação booleana.

import numpy as np 
x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) 

print 'Our array is:' 
print x 
print '\n'  

# Now we will print the items greater than 5 
print 'The items greater than 5 are:' 
print x[x > 5]

A saída deste programa seria -

Our array is: 
[[ 0  1  2] 
 [ 3  4  5] 
 [ 6  7  8] 
 [ 9 10 11]] 
 
The items greater than 5 are:
[ 6  7  8  9 10 11]

Exemplo 2

Neste exemplo, os elementos NaN (não é um número) são omitidos usando ~ (operador de complemento).

import numpy as np 
a = np.array([np.nan, 1,2,np.nan,3,4,5]) 
print a[~np.isnan(a)]

Sua saída seria -

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

Exemplo 3

O exemplo a seguir mostra como filtrar os elementos não complexos de uma matriz.

import numpy as np 
a = np.array([1, 2+6j, 5, 3.5+5j]) 
print a[np.iscomplex(a)]

Aqui, a saída é a seguinte -

[2.0+6.j  3.5+5.j]

O termo broadcastingrefere-se à capacidade do NumPy de tratar matrizes de diferentes formatos durante as operações aritméticas. As operações aritméticas em matrizes geralmente são feitas em elementos correspondentes. Se duas matrizes tiverem exatamente o mesmo formato, essas operações serão realizadas sem problemas.

Exemplo 1

import numpy as np 

a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print c

Seu resultado é o seguinte -

[10   40   90   160]

Se as dimensões de dois arrays forem diferentes, as operações elemento a elemento não serão possíveis. No entanto, as operações em matrizes de formas não semelhantes ainda são possíveis no NumPy, por causa da capacidade de transmissão. A menor matriz ébroadcast para o tamanho da matriz maior para que tenham formatos compatíveis.

A transmissão é possível se as seguintes regras forem satisfeitas -

  • Matriz com menor ndim do que o outro é prefixado com '1' em sua forma.

  • O tamanho em cada dimensão da forma de saída é o máximo dos tamanhos de entrada nessa dimensão.

  • Uma entrada pode ser usada no cálculo, se seu tamanho em uma dimensão particular corresponder ao tamanho de saída ou seu valor for exatamente 1.

  • Se uma entrada tem um tamanho de dimensão de 1, a primeira entrada de dados nessa dimensão é usada para todos os cálculos ao longo dessa dimensão.

Diz-se que um conjunto de matrizes é broadcastable se as regras acima produzirem um resultado válido e uma das seguintes opções for verdadeira -

  • Matrizes têm exatamente a mesma forma.

  • Matrizes têm o mesmo número de dimensões e o comprimento de cada dimensão é um comprimento comum ou 1.

  • A matriz com poucas dimensões pode ter sua forma prefixada com uma dimensão de comprimento 1, de modo que a propriedade declarada acima seja verdadeira.

O programa a seguir mostra um exemplo de transmissão.

Exemplo 2

import numpy as np 
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]]) 
b = np.array([1.0,2.0,3.0])  
   
print 'First array:' 
print a 
print '\n'  
   
print 'Second array:' 
print b 
print '\n'  
   
print 'First Array + Second Array' 
print a + b

A saída deste programa seria a seguinte -

First array:
[[ 0. 0. 0.]
 [ 10. 10. 10.]
 [ 20. 20. 20.]
 [ 30. 30. 30.]]

Second array:
[ 1. 2. 3.]

First Array + Second Array
[[ 1. 2. 3.]
 [ 11. 12. 13.]
 [ 21. 22. 23.]
 [ 31. 32. 33.]]

A figura a seguir demonstra como a matriz b é transmitido para se tornar compatível com a.

O pacote NumPy contém um objeto iterador numpy.nditer. É um objeto iterador multidimensional eficiente com o qual é possível iterar sobre um array. Cada elemento de um array é visitado usando a interface Iterator padrão do Python.

Vamos criar um array 3X4 usando a função arange () e iterar sobre ele usando nditer.

Exemplo 1

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)

print 'Original array is:'
print a
print '\n'

print 'Modified array is:'
for x in np.nditer(a):
   print x,

O resultado deste programa é o seguinte -

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Modified array is:
0 5 10 15 20 25 30 35 40 45 50 55

Exemplo 2

A ordem da iteração é escolhida para corresponder ao layout da memória de um array, sem considerar uma ordem particular. Isso pode ser visto iterando sobre a transposição da matriz acima.

import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4) 
   
print 'Original array is:'
print a 
print '\n'  
   
print 'Transpose of the original array is:' 
b = a.T 
print b 
print '\n'  
   
print 'Modified array is:' 
for x in np.nditer(b): 
   print x,

O resultado do programa acima é o seguinte -

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Transpose of the original array is:
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]

Modified array is:
0 5 10 15 20 25 30 35 40 45 50 55

Ordem de Iteração

Se os mesmos elementos forem armazenados usando a ordem do estilo F, o iterador escolhe a maneira mais eficiente de iterar em uma matriz.

Exemplo 1

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'

print 'Transpose of the original array is:'
b = a.T
print b
print '\n'

print 'Sorted in C-style order:'
c = b.copy(order='C')
print c
for x in np.nditer(c):
   print x,

print '\n'

print 'Sorted in F-style order:'
c = b.copy(order='F')
print c
for x in np.nditer(c):
   print x,

Sua saída seria a seguinte -

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Transpose of the original array is:
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]

Sorted in C-style order:
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55

Sorted in F-style order:
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0 5 10 15 20 25 30 35 40 45 50 55

Exemplo 2

É possível forçar nditer objeto para usar uma ordem específica, mencionando-a explicitamente.

import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4) 

print 'Original array is:' 
print a 
print '\n'  

print 'Sorted in C-style order:' 
for x in np.nditer(a, order = 'C'): 
   print x,  
print '\n' 

print 'Sorted in F-style order:' 
for x in np.nditer(a, order = 'F'): 
   print x,

Sua saída seria -

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Sorted in C-style order:
0 5 10 15 20 25 30 35 40 45 50 55

Sorted in F-style order:
0 20 40 5 25 45 10 30 50 15 35 55

Modificando Valores de Matriz

o nditer objeto tem outro parâmetro opcional chamado op_flags. Seu valor padrão é somente leitura, mas pode ser definido para o modo de leitura e gravação ou somente gravação. Isso habilitará a modificação de elementos do array usando este iterador.

Exemplo

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print 'Original array is:'
print a
print '\n'

for x in np.nditer(a, op_flags = ['readwrite']):
   x[...] = 2*x
print 'Modified array is:'
print a

Seu resultado é o seguinte -

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Modified array is:
[[ 0 10 20 30]
 [ 40 50 60 70]
 [ 80 90 100 110]]

Loop Externo

O construtor da classe nditer tem um ‘flags’ parâmetro, que pode assumir os seguintes valores -

Sr. Não. Parâmetro e Descrição
1

c_index

O índice C_order pode ser rastreado

2

f_index

O índice Fortran_order é rastreado

3

multi-index

Os tipos de índices com um por iteração podem ser rastreados

4

external_loop

Faz com que os valores fornecidos sejam matrizes unidimensionais com vários valores em vez de matrizes com dimensão zero

Exemplo

No exemplo a seguir, os arrays unidimensionais correspondentes a cada coluna são percorridos pelo iterador.

import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4) 

print 'Original array is:' 
print a 
print '\n'  

print 'Modified array is:' 
for x in np.nditer(a, flags = ['external_loop'], order = 'F'): 
   print x,

O resultado é o seguinte -

Original array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Modified array is:
[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]

Iteração de transmissão

Se duas matrizes são broadcastable, um combinado nditerobjeto é capaz de iterar sobre eles simultaneamente. Supondo que uma matriza tem dimensão 3X4, e há outra matriz b da dimensão 1X4, o iterador do seguinte tipo é usado (matriz b é transmitido para o tamanho de a)

Exemplo

import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4) 

print 'First array is:' 
print a 
print '\n'  

print 'Second array is:' 
b = np.array([1, 2, 3, 4], dtype = int) 
print b  
print '\n' 

print 'Modified array is:' 
for x,y in np.nditer([a,b]): 
   print "%d:%d" % (x,y),

Sua saída seria a seguinte -

First array is:
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

Second array is:
[1 2 3 4]

Modified array is:
0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4

Várias rotinas estão disponíveis no pacote NumPy para manipulação de elementos no objeto ndarray. Eles podem ser classificados nos seguintes tipos -

Mudando de forma

Sr. Não. Forma e descrição
1 remodelar

Dá uma nova forma a uma matriz sem alterar seus dados

2 plano

Um iterador 1-D sobre a matriz

3 achatar

Retorna uma cópia da matriz recolhida em uma dimensão

4 ravel

Retorna uma matriz achatada contígua

Transpor Operações

Sr. Não. Operação e descrição
1 transpor

Permuta as dimensões de uma matriz

2 ndarray.T

O mesmo que self.transpose ()

3 rollaxis

Rola o eixo especificado para trás

4 swapaxes

Intercambia os dois eixos de uma matriz

Mudando Dimensões

Sr. Não. Dimensão e descrição
1 difundir

Produz um objeto que imita a transmissão

2 broadcast_to

Transmite uma matriz para uma nova forma

3 expand_dims

Expande a forma de uma matriz

4 aperto

Remove entradas unidimensionais da forma de uma matriz

Juntando Arrays

Sr. Não. Matriz e descrição
1 concatenar

Une uma sequência de matrizes ao longo de um eixo existente

2 pilha

Une uma sequência de matrizes ao longo de um novo eixo

3 empacotar

Empilha matrizes em sequência horizontalmente (coluna)

4 vstack

Empilha matrizes em sequência verticalmente (linha sábia)

Dividindo matrizes

Sr. Não. Matriz e descrição
1 Dividido

Divide uma matriz em várias submatrizes

2 hsplit

Divide uma matriz em várias submatrizes horizontalmente (coluna)

3 vsplit

Divide um array em vários subarrays verticalmente (linha)

Adicionando / Removendo Elementos

Sr. Não. Elemento e descrição
1 redimensionar

Retorna uma nova matriz com a forma especificada

2 acrescentar

Acrescenta os valores ao final de uma matriz

3 inserir

Insere os valores ao longo do eixo fornecido antes dos índices fornecidos

4 excluir

Retorna uma nova matriz com submatrizes ao longo de um eixo excluído

5 único

Encontra os elementos únicos de uma matriz

A seguir estão as funções para operações bit a bit disponíveis no pacote NumPy.

Sr. Não. Operação e descrição
1 bitwise_and

Calcula operação AND bit a bit de elementos da matriz

2 bitwise_or

Calcula operação OR bit a bit de elementos da matriz

3 invertido

Calcula NÃO bit a bit

4 desvio à esquerda

Desloca bits de uma representação binária para a esquerda

5 deslocamento para a direita

Desloca bits da representação binária para a direita

As funções a seguir são usadas para realizar operações de string vetorizadas para matrizes de dtype numpy.string_ ou numpy.unicode_. Eles são baseados nas funções de string padrão na biblioteca integrada do Python.

Sr. Não. Descrição da função
1 adicionar()

Retorna concatenação de string elemento a elemento para duas matrizes de str ou Unicode

2 multiplicar()

Retorna a string com concatenação múltipla, elemento a elemento

3 Centro()

Retorna uma cópia da string dada com elementos centralizados em uma string de comprimento especificado

4 capitalizar()

Retorna uma cópia da string com apenas o primeiro caractere maiúsculo

5 título()

Retorna a versão em maiúsculas do título elemento a elemento da string ou Unicode

6 mais baixo()

Retorna uma matriz com os elementos convertidos em minúsculas

7 superior()

Retorna uma matriz com os elementos convertidos em maiúsculas

8 Dividido()

Retorna uma lista de palavras na string, usando separatordelimiter

9 linhas de divisão ()

Retorna uma lista das linhas do elemento, quebrando nos limites da linha

10 faixa()

Retorna uma cópia com os caracteres iniciais e finais removidos

11 Junte-se()

Retorna uma string que é a concatenação das strings na sequência

12 substituir()

Retorna uma cópia da string com todas as ocorrências de substring substituídas pela nova string

13 decodificar()

Chama str.decode element-wise

14 codificar()

Chama str.encode element-wise

Essas funções são definidas na classe de matriz de caracteres (numpy.char). O pacote Numarray mais antigo continha a classe chararray. As funções acima na classe numpy.char são úteis na execução de operações de string vetorizadas.

De forma bastante compreensível, NumPy contém um grande número de várias operações matemáticas. NumPy fornece funções trigonométricas padrão, funções para operações aritméticas, manipulação de números complexos, etc.

Funções trigonométricas

NumPy tem funções trigonométricas padrão que retornam razões trigonométricas para um determinado ângulo em radianos.

Example

import numpy as np 
a = np.array([0,30,45,60,90]) 

print 'Sine of different angles:' 
# Convert to radians by multiplying with pi/180 
print np.sin(a*np.pi/180) 
print '\n'  

print 'Cosine values for angles in array:' 
print np.cos(a*np.pi/180) 
print '\n'  

print 'Tangent values for given angles:' 
print np.tan(a*np.pi/180)

Aqui está o resultado -

Sine of different angles:                                                     
[ 0.          0.5         0.70710678  0.8660254   1.        ]

Cosine values for angles in array:
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01
   6.12323400e-17]

Tangent values for given angles:                                              
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00
   1.63312394e+16]

arcsin, arcos, e arctanfunções retornam o inverso trigonométrico de sin, cos e tan do ângulo fornecido. O resultado dessas funções pode ser verificado pornumpy.degrees() function convertendo radianos em graus.

Example

import numpy as np 
a = np.array([0,30,45,60,90]) 

print 'Array containing sine values:' 
sin = np.sin(a*np.pi/180) 
print sin 
print '\n'  

print 'Compute sine inverse of angles. Returned values are in radians.' 
inv = np.arcsin(sin) 
print inv 
print '\n'  

print 'Check result by converting to degrees:' 
print np.degrees(inv) 
print '\n'  

print 'arccos and arctan functions behave similarly:' 
cos = np.cos(a*np.pi/180) 
print cos 
print '\n'  

print 'Inverse of cos:' 
inv = np.arccos(cos) 
print inv 
print '\n'  

print 'In degrees:' 
print np.degrees(inv) 
print '\n'  

print 'Tan function:' 
tan = np.tan(a*np.pi/180) 
print tan
print '\n'  

print 'Inverse of tan:' 
inv = np.arctan(tan) 
print inv 
print '\n'  

print 'In degrees:' 
print np.degrees(inv)

Seu resultado é o seguinte -

Array containing sine values:
[ 0.          0.5         0.70710678  0.8660254   1.        ]

Compute sine inverse of angles. Returned values are in radians.
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633] 

Check result by converting to degrees:
[  0.  30.  45.  60.  90.]

arccos and arctan functions behave similarly:
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01          
   6.12323400e-17] 

Inverse of cos:
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633] 

In degrees:
[  0.  30.  45.  60.  90.] 

Tan function:
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00          
   1.63312394e+16]

Inverse of tan:
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]

In degrees:
[  0.  30.  45.  60.  90.]

Funções para arredondamento

numpy.around ()

Esta é uma função que retorna o valor arredondado para a precisão desejada. A função assume os seguintes parâmetros.

numpy.around(a,decimals)

Onde,

Sr. Não. Parâmetro e Descrição
1

a

Dados de entrada

2

decimals

O número de decimais para arredondar. O padrão é 0. Se negativo, o número inteiro é arredondado para a posição à esquerda da vírgula decimal

Example

import numpy as np 
a = np.array([1.0,5.55, 123, 0.567, 25.532]) 

print 'Original array:' 
print a 
print '\n'  

print 'After rounding:' 
print np.around(a) 
print np.around(a, decimals = 1) 
print np.around(a, decimals = -1)

Ele produz a seguinte saída -

Original array:                                                               
[   1.       5.55   123.       0.567   25.532] 

After rounding:                                                               
[   1.    6.   123.    1.   26. ]                                               
[   1.    5.6  123.    0.6  25.5]                                          
[   0.    10.  120.    0.   30. ]

numpy.floor ()

Esta função retorna o maior inteiro não maior que o parâmetro de entrada. O chão doscalar x é o maior integer i, de tal modo que i <= x. Observe que em Python, o revestimento sempre é arredondado de 0.

Example

import numpy as np 
a = np.array([-1.7, 1.5, -0.2, 0.6, 10]) 

print 'The given array:' 
print a 
print '\n'  

print 'The modified array:' 
print np.floor(a)

Ele produz a seguinte saída -

The given array:                                                              
[ -1.7   1.5  -0.2   0.6  10. ]

The modified array:                                                           
[ -2.   1.  -1.   0.  10.]

numpy.ceil ()

A função ceil () retorna o teto de um valor de entrada, ou seja, o teto do scalar x é o menor integer i, de tal modo que i >= x.

Example

import numpy as np 
a = np.array([-1.7, 1.5, -0.2, 0.6, 10]) 

print 'The given array:' 
print a 
print '\n'  

print 'The modified array:' 
print np.ceil(a)

Ele produzirá a seguinte saída -

The given array:                                                              
[ -1.7   1.5  -0.2   0.6  10. ]

The modified array:                                                           
[ -1.   2.  -0.   1.  10.]

Matrizes de entrada para realizar operações aritméticas como add (), subtract (), multiply () e divide () devem ter a mesma forma ou obedecer às regras de transmissão de array.

Exemplo

import numpy as np 
a = np.arange(9, dtype = np.float_).reshape(3,3) 

print 'First array:' 
print a 
print '\n'  

print 'Second array:' 
b = np.array([10,10,10]) 
print b 
print '\n'  

print 'Add the two arrays:' 
print np.add(a,b) 
print '\n'  

print 'Subtract the two arrays:' 
print np.subtract(a,b) 
print '\n'  

print 'Multiply the two arrays:' 
print np.multiply(a,b) 
print '\n'  

print 'Divide the two arrays:' 
print np.divide(a,b)

Ele produzirá a seguinte saída -

First array:
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

Second array:
[10 10 10]

Add the two arrays:
[[ 10. 11. 12.]
 [ 13. 14. 15.]
 [ 16. 17. 18.]]

Subtract the two arrays:
[[-10. -9. -8.]
 [ -7. -6. -5.]
 [ -4. -3. -2.]]

Multiply the two arrays:
[[ 0. 10. 20.]
 [ 30. 40. 50.]
 [ 60. 70. 80.]]

Divide the two arrays:
[[ 0. 0.1 0.2]
 [ 0.3 0.4 0.5]
 [ 0.6 0.7 0.8]]

Vamos agora discutir algumas das outras funções aritméticas importantes disponíveis no NumPy.

numpy.reciprocal ()

Esta função retorna o recíproco do argumento, elemento a elemento. Para elementos com valores absolutos maiores do que 1, o resultado é sempre 0 devido à maneira como o Python lida com a divisão de inteiros. Para o inteiro 0, um aviso de estouro é emitido.

Exemplo

import numpy as np 
a = np.array([0.25, 1.33, 1, 0, 100]) 

print 'Our array is:' 
print a 
print '\n'  

print 'After applying reciprocal function:' 
print np.reciprocal(a) 
print '\n'  

b = np.array([100], dtype = int) 
print 'The second array is:' 
print b 
print '\n'  

print 'After applying reciprocal function:' 
print np.reciprocal(b)

Ele produzirá a seguinte saída -

Our array is:                                                                 
[   0.25    1.33    1.      0.    100.  ]

After applying reciprocal function:                                           
main.py:9: RuntimeWarning: divide by zero encountered in reciprocal
  print np.reciprocal(a)
[ 4.         0.7518797  1.               inf  0.01     ]

The second array is:
[100]

After applying reciprocal function:
[0]

numpy.power ()

Esta função trata os elementos da primeira matriz de entrada como base e os retorna elevados à potência do elemento correspondente na segunda matriz de entrada.

import numpy as np 
a = np.array([10,100,1000]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying power function:' 
print np.power(a,2) 
print '\n'  

print 'Second array:' 
b = np.array([1,2,3]) 
print b 
print '\n'  

print 'Applying power function again:' 
print np.power(a,b)

Ele produzirá a seguinte saída -

Our array is:                                                                 
[  10  100 1000]

Applying power function:
[    100   10000 1000000]

Second array:
[1 2 3]

Applying power function again:
[        10      10000 1000000000]

numpy.mod ()

Esta função retorna o restante da divisão dos elementos correspondentes na matriz de entrada. A funçãonumpy.remainder() também produz o mesmo resultado.

import numpy as np 
a = np.array([10,20,30]) 
b = np.array([3,5,7]) 

print 'First array:' 
print a 
print '\n'  

print 'Second array:' 
print b 
print '\n'  

print 'Applying mod() function:' 
print np.mod(a,b) 
print '\n'  

print 'Applying remainder() function:' 
print np.remainder(a,b)

Ele produzirá a seguinte saída -

First array:                                                                  
[10 20 30]

Second array:                                                                 
[3 5 7]

Applying mod() function:                                                      
[1 0 2]

Applying remainder() function:                                                
[1 0 2]

As funções a seguir são usadas para realizar operações em uma matriz com números complexos.

  • numpy.real() - retorna a parte real do argumento de tipo de dados complexo.

  • numpy.imag() - retorna a parte imaginária do argumento de tipo de dados complexo.

  • numpy.conj() - retorna o conjugado complexo, que é obtido mudando o sinal da parte imaginária.

  • numpy.angle()- retorna o ângulo do argumento complexo. A função possui parâmetro de grau. Se verdadeiro, o ângulo em grau é retornado, caso contrário, o ângulo é em radianos.

import numpy as np 
a = np.array([-5.6j, 0.2j, 11. , 1+1j]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying real() function:' 
print np.real(a) 
print '\n'  

print 'Applying imag() function:' 
print np.imag(a) 
print '\n'  

print 'Applying conj() function:' 
print np.conj(a) 
print '\n'  

print 'Applying angle() function:' 
print np.angle(a) 
print '\n'  

print 'Applying angle() function again (result in degrees)' 
print np.angle(a, deg = True)

Ele produzirá a seguinte saída -

Our array is:
[ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]

Applying real() function:
[ 0. 0. 11. 1.]

Applying imag() function:
[-5.6 0.2 0. 1. ]

Applying conj() function:
[ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]

Applying angle() function:
[-1.57079633 1.57079633 0. 0.78539816]

Applying angle() function again (result in degrees)
[-90. 90. 0. 45.]

NumPy tem algumas funções estatísticas úteis para encontrar mínimo, máximo, desvio padrão percentual e variância, etc. dos elementos fornecidos na matriz. As funções são explicadas a seguir -

numpy.amin () e numpy.amax ()

Essas funções retornam o mínimo e o máximo dos elementos na matriz fornecida ao longo do eixo especificado.

Exemplo

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]]) 

print 'Our array is:' 
print a  
print '\n'  

print 'Applying amin() function:' 
print np.amin(a,1) 
print '\n'  

print 'Applying amin() function again:' 
print np.amin(a,0) 
print '\n'  

print 'Applying amax() function:' 
print np.amax(a) 
print '\n'  

print 'Applying amax() function again:' 
print np.amax(a, axis = 0)

Ele produzirá a seguinte saída -

Our array is:
[[3 7 5]
[8 4 3]
[2 4 9]]

Applying amin() function:
[3 3 2]

Applying amin() function again:
[2 4 3]

Applying amax() function:
9

Applying amax() function again:
[8 7 9]

numpy.ptp ()

o numpy.ptp() função retorna o intervalo (máximo-mínimo) de valores ao longo de um eixo.

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying ptp() function:' 
print np.ptp(a) 
print '\n'  

print 'Applying ptp() function along axis 1:' 
print np.ptp(a, axis = 1) 
print '\n'   

print 'Applying ptp() function along axis 0:'
print np.ptp(a, axis = 0)

Ele produzirá a seguinte saída -

Our array is:
[[3 7 5]
[8 4 3]
[2 4 9]]

Applying ptp() function:
7

Applying ptp() function along axis 1:
[4 5 7]

Applying ptp() function along axis 0:
[6 3 6]

numpy.percentile ()

O percentil (ou um centil) é uma medida usada em estatísticas que indica o valor abaixo do qual uma determinada porcentagem de observações em um grupo de observações cai. A funçãonumpy.percentile() leva os seguintes argumentos.

numpy.percentile(a, q, axis)

Onde,

Sr. Não. Argumento e Descrição
1

a

Matriz de entrada

2

q

O percentil a ser calculado deve estar entre 0-100

3

axis

O eixo ao longo do qual o percentil deve ser calculado

Exemplo

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying percentile() function:' 
print np.percentile(a,50) 
print '\n'  

print 'Applying percentile() function along axis 1:' 
print np.percentile(a,50, axis = 1) 
print '\n'  

print 'Applying percentile() function along axis 0:' 
print np.percentile(a,50, axis = 0)

Ele produzirá a seguinte saída -

Our array is:
[[30 40 70]
 [80 20 10]
 [50 90 60]]

Applying percentile() function:
50.0

Applying percentile() function along axis 1:
[ 40. 20. 60.]

Applying percentile() function along axis 0:
[ 50. 40. 60.]

numpy.median ()

Mediané definido como o valor que separa a metade superior de uma amostra de dados da metade inferior. onumpy.median() função é usada conforme mostrado no programa a seguir.

Exemplo

import numpy as np 
a = np.array([[30,65,70],[80,95,10],[50,90,60]]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying median() function:' 
print np.median(a) 
print '\n'  

print 'Applying median() function along axis 0:' 
print np.median(a, axis = 0) 
print '\n'  
 
print 'Applying median() function along axis 1:' 
print np.median(a, axis = 1)

Ele produzirá a seguinte saída -

Our array is:
[[30 65 70]
 [80 95 10]
 [50 90 60]]

Applying median() function:
65.0

Applying median() function along axis 0:
[ 50. 90. 60.]

Applying median() function along axis 1:
[ 65. 80. 60.]

numpy.mean ()

A média aritmética é a soma dos elementos ao longo de um eixo dividido pelo número de elementos. onumpy.mean()função retorna a média aritmética dos elementos na matriz. Se o eixo é mencionado, ele é calculado ao longo dele.

Exemplo

import numpy as np 
a = np.array([[1,2,3],[3,4,5],[4,5,6]]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying mean() function:' 
print np.mean(a) 
print '\n'  

print 'Applying mean() function along axis 0:' 
print np.mean(a, axis = 0) 
print '\n'  

print 'Applying mean() function along axis 1:' 
print np.mean(a, axis = 1)

Ele produzirá a seguinte saída -

Our array is:
[[1 2 3]
 [3 4 5]
 [4 5 6]]

Applying mean() function:
3.66666666667

Applying mean() function along axis 0:
[ 2.66666667 3.66666667 4.66666667]

Applying mean() function along axis 1:
[ 2. 4. 5.]

numpy.average ()

A média ponderada é uma média resultante da multiplicação de cada componente por um fator que reflete sua importância. onumpy.average()A função calcula a média ponderada dos elementos em uma matriz de acordo com seus respectivos pesos dados em outra matriz. A função pode ter um parâmetro de eixo. Se o eixo não for especificado, a matriz será achatada.

Considerando uma matriz [1,2,3,4] e pesos correspondentes [4,3,2,1], a média ponderada é calculada somando o produto dos elementos correspondentes e dividindo a soma pela soma dos pesos.

Média ponderada = (1 * 4 + 2 * 3 + 3 * 2 + 4 * 1) / (4 + 3 + 2 + 1)

Exemplo

import numpy as np 
a = np.array([1,2,3,4]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying average() function:' 
print np.average(a) 
print '\n'  

# this is same as mean when weight is not specified 
wts = np.array([4,3,2,1]) 

print 'Applying average() function again:' 
print np.average(a,weights = wts) 
print '\n'  

# Returns the sum of weights, if the returned parameter is set to True. 
print 'Sum of weights' 
print np.average([1,2,3, 4],weights = [4,3,2,1], returned = True)

Ele produzirá a seguinte saída -

Our array is:
[1 2 3 4]

Applying average() function:
2.5

Applying average() function again:
2.0

Sum of weights
(2.0, 10.0)

Em uma matriz multidimensional, o eixo de computação pode ser especificado.

Exemplo

import numpy as np 
a = np.arange(6).reshape(3,2) 

print 'Our array is:' 
print a 
print '\n'  

print 'Modified array:' 
wt = np.array([3,5]) 
print np.average(a, axis = 1, weights = wt) 
print '\n'  

print 'Modified array:' 
print np.average(a, axis = 1, weights = wt, returned = True)

Ele produzirá a seguinte saída -

Our array is:
[[0 1]
 [2 3]
 [4 5]]

Modified array:
[ 0.625 2.625 4.625]

Modified array:
(array([ 0.625, 2.625, 4.625]), array([ 8., 8., 8.]))

Desvio padrão

O desvio padrão é a raiz quadrada da média dos desvios quadrados da média. A fórmula para o desvio padrão é a seguinte -

std = sqrt(mean(abs(x - x.mean())**2))

Se a matriz for [1, 2, 3, 4], sua média será 2,5. Portanto, os desvios quadrados são [2,25, 0,25, 0,25, 2,25] e a raiz quadrada de sua média dividida por 4, ou seja, sqrt (5/4) é 1,1180339887498949.

Exemplo

import numpy as np 
print np.std([1,2,3,4])

Ele produzirá a seguinte saída -

1.1180339887498949

Variância

A variância é a média dos desvios quadrados, ou seja, mean(abs(x - x.mean())**2). Em outras palavras, o desvio padrão é a raiz quadrada da variância.

Exemplo

import numpy as np 
print np.var([1,2,3,4])

Ele produzirá a seguinte saída -

1.25

Uma variedade de funções relacionadas à classificação estão disponíveis no NumPy. Essas funções de classificação implementam diferentes algoritmos de classificação, cada um deles caracterizado pela velocidade de execução, desempenho do pior caso, o espaço de trabalho necessário e a estabilidade dos algoritmos. A tabela a seguir mostra a comparação de três algoritmos de classificação.

tipo Rapidez pior caso área de trabalho estábulo
'ordenação rápida' 1 O (n ^ 2) 0 não
'mergesort' 2 O (n * log (n)) ~ n / 2 sim
'heapsort' 3 O (n * log (n)) 0 não

numpy.sort ()

A função sort () retorna uma cópia classificada do array de entrada. Possui os seguintes parâmetros -

numpy.sort(a, axis, kind, order)

Onde,

Sr. Não. Parâmetro e Descrição
1

a

Matriz a ser classificada

2

axis

O eixo ao longo do qual a matriz deve ser classificada. Se nenhum, a matriz é achatada, classificando no último eixo

3

kind

O padrão é quicksort

4

order

Se a matriz contém campos, a ordem dos campos a serem classificados

Exemplo

import numpy as np  
a = np.array([[3,7],[9,1]]) 

print 'Our array is:' 
print a 
print '\n'

print 'Applying sort() function:' 
print np.sort(a) 
print '\n' 
  
print 'Sort along axis 0:' 
print np.sort(a, axis = 0) 
print '\n'  

# Order parameter in sort function 
dt = np.dtype([('name', 'S10'),('age', int)]) 
a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt) 

print 'Our array is:' 
print a 
print '\n'  

print 'Order by name:' 
print np.sort(a, order = 'name')

Ele produzirá a seguinte saída -

Our array is:
[[3 7]
 [9 1]]

Applying sort() function:
[[3 7]
 [1 9]]

Sort along axis 0:
[[3 1]
 [9 7]]

Our array is:
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]

Order by name:
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]

numpy.argsort ()

o numpy.argsort()A função executa uma classificação indireta na matriz de entrada, ao longo do eixo dado e usando um tipo especificado de classificação para retornar a matriz de índices de dados. Esta matriz de índices é usada para construir a matriz ordenada.

Exemplo

import numpy as np 
x = np.array([3, 1, 2]) 

print 'Our array is:' 
print x 
print '\n'  

print 'Applying argsort() to x:' 
y = np.argsort(x) 
print y 
print '\n'  

print 'Reconstruct original array in sorted order:' 
print x[y] 
print '\n'  

print 'Reconstruct the original array using loop:' 
for i in y: 
   print x[i],

Ele produzirá a seguinte saída -

Our array is:
[3 1 2]

Applying argsort() to x:
[1 2 0]

Reconstruct original array in sorted order:
[1 2 3]

Reconstruct the original array using loop:
1 2 3

numpy.lexsort ()

função executa uma classificação indireta usando uma sequência de chaves. As chaves podem ser vistas como uma coluna em uma planilha. A função retorna uma matriz de índices, usando os quais os dados classificados podem ser obtidos. Observe que a última chave é a chave primária de classificação.

Exemplo

import numpy as np 

nm = ('raju','anil','ravi','amar') 
dv = ('f.y.', 's.y.', 's.y.', 'f.y.') 
ind = np.lexsort((dv,nm)) 

print 'Applying lexsort() function:' 
print ind 
print '\n'  

print 'Use this index to get sorted data:' 
print [nm[i] + ", " + dv[i] for i in ind]

Ele produzirá a seguinte saída -

Applying lexsort() function:
[3 1 0 2]

Use this index to get sorted data:
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

O módulo NumPy possui várias funções para pesquisar dentro de um array. Estão disponíveis funções para encontrar o máximo, o mínimo e os elementos que satisfazem uma determinada condição.

numpy.argmax () e numpy.argmin ()

Essas duas funções retornam os índices dos elementos máximo e mínimo, respectivamente, ao longo do eixo fornecido.

Exemplo

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]]) 

print 'Our array is:' 
print a 
print '\n' 

print 'Applying argmax() function:' 
print np.argmax(a) 
print '\n'  

print 'Index of maximum number in flattened array' 
print a.flatten() 
print '\n'  

print 'Array containing indices of maximum along axis 0:' 
maxindex = np.argmax(a, axis = 0) 
print maxindex 
print '\n'  

print 'Array containing indices of maximum along axis 1:' 
maxindex = np.argmax(a, axis = 1) 
print maxindex 
print '\n'  

print 'Applying argmin() function:' 
minindex = np.argmin(a) 
print minindex 
print '\n'  
   
print 'Flattened array:' 
print a.flatten()[minindex] 
print '\n'  

print 'Flattened array along axis 0:' 
minindex = np.argmin(a, axis = 0) 
print minindex
print '\n'

print 'Flattened array along axis 1:' 
minindex = np.argmin(a, axis = 1) 
print minindex

Ele produzirá a seguinte saída -

Our array is:
[[30 40 70]
 [80 20 10]
 [50 90 60]]

Applying argmax() function:
7

Index of maximum number in flattened array
[30 40 70 80 20 10 50 90 60]

Array containing indices of maximum along axis 0:
[1 2 0]

Array containing indices of maximum along axis 1:
[2 0 1]

Applying argmin() function:
5

Flattened array:
10

Flattened array along axis 0:
[0 1 1]

Flattened array along axis 1:
[0 2 0]

numpy.nonzero ()

o numpy.nonzero() função retorna os índices de elementos diferentes de zero na matriz de entrada.

Exemplo

import numpy as np 
a = np.array([[30,40,0],[0,20,10],[50,0,60]]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying nonzero() function:' 
print np.nonzero (a)

Ele produzirá a seguinte saída -

Our array is:
[[30 40 0]
 [ 0 20 10]
 [50 0 60]]

Applying nonzero() function:
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

numpy.where ()

A função where () retorna os índices dos elementos em uma matriz de entrada onde a condição fornecida é satisfeita.

Exemplo

import numpy as np 
x = np.arange(9.).reshape(3, 3) 

print 'Our array is:' 
print x  

print 'Indices of elements > 3' 
y = np.where(x > 3) 
print y  

print 'Use these indices to get elements satisfying the condition' 
print x[y]

Ele produzirá a seguinte saída -

Our array is:
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

Indices of elements > 3
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))

Use these indices to get elements satisfying the condition
[ 4. 5. 6. 7. 8.]

numpy.extract ()

o extract() função retorna os elementos que satisfazem qualquer condição.

import numpy as np 
x = np.arange(9.).reshape(3, 3) 

print 'Our array is:' 
print x  

# define a condition 
condition = np.mod(x,2) == 0 

print 'Element-wise value of condition' 
print condition  

print 'Extract elements using condition' 
print np.extract(condition, x)

Ele produzirá a seguinte saída -

Our array is:
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

Element-wise value of condition
[[ True False True]
 [False True False]
 [ True False True]]

Extract elements using condition
[ 0. 2. 4. 6. 8.]

Vimos que os dados armazenados na memória de um computador dependem da arquitetura que a CPU usa. Pode ser little-endian (o menos significativo é armazenado no menor endereço) ou big-endian (o byte mais significativo no menor endereço).

numpy.ndarray.byteswap ()

o numpy.ndarray.byteswap() a função alterna entre as duas representações: bigendian e little-endian.

import numpy as np 
a = np.array([1, 256, 8755], dtype = np.int16) 

print 'Our array is:' 
print a  

print 'Representation of data in memory in hexadecimal form:'  
print map(hex,a)  
# byteswap() function swaps in place by passing True parameter 

print 'Applying byteswap() function:' 
print a.byteswap(True) 

print 'In hexadecimal form:' 
print map(hex,a) 
# We can see the bytes being swapped

Ele produzirá a seguinte saída -

Our array is:
[1 256 8755]

Representation of data in memory in hexadecimal form:
['0x1', '0x100', '0x2233']

Applying byteswap() function:
[256 1 13090]

In hexadecimal form:
['0x100', '0x1', '0x3322']

Ao executar as funções, algumas delas retornam uma cópia do array de entrada, enquanto outras retornam a visualização. Quando o conteúdo é fisicamente armazenado em outro local, é chamadoCopy. Se, por outro lado, uma visão diferente do mesmo conteúdo de memória é fornecida, nós a chamamos deView.

Sem Cópia

As atribuições simples não fazem a cópia do objeto da matriz. Em vez disso, ele usa o mesmo id () do array original para acessá-lo. oid() retorna um identificador universal do objeto Python, semelhante ao ponteiro em C.

Além disso, qualquer mudança em um deles é refletida no outro. Por exemplo, a mudança da forma de um mudará a forma do outro também.

Exemplo

import numpy as np 
a = np.arange(6) 

print 'Our array is:' 
print a  

print 'Applying id() function:' 
print id(a)  

print 'a is assigned to b:' 
b = a 
print b  

print 'b has same id():' 
print id(b)  

print 'Change shape of b:' 
b.shape = 3,2 
print b  

print 'Shape of a also gets changed:' 
print a

Ele produzirá a seguinte saída -

Our array is:
[0 1 2 3 4 5]

Applying id() function:
139747815479536

a is assigned to b:
[0 1 2 3 4 5]
b has same id():
139747815479536

Change shape of b:
[[0 1]
 [2 3]
 [4 5]]

Shape of a also gets changed:
[[0 1]
 [2 3]
 [4 5]]

Exibir ou cópia superficial

NumPy tem ndarray.view()método que é um novo objeto de array que olha para os mesmos dados do array original. Ao contrário do caso anterior, a mudança nas dimensões da nova matriz não altera as dimensões do original.

Exemplo

import numpy as np 
# To begin with, a is 3X2 array 
a = np.arange(6).reshape(3,2) 

print 'Array a:' 
print a  

print 'Create view of a:' 
b = a.view() 
print b  

print 'id() for both the arrays are different:' 
print 'id() of a:'
print id(a)  
print 'id() of b:' 
print id(b)  

# Change the shape of b. It does not change the shape of a 
b.shape = 2,3 

print 'Shape of b:' 
print b  

print 'Shape of a:' 
print a

Ele produzirá a seguinte saída -

Array a:
[[0 1]
 [2 3]
 [4 5]]

Create view of a:
[[0 1]
 [2 3]
 [4 5]]

id() for both the arrays are different:
id() of a:
140424307227264
id() of b:
140424151696288

Shape of b:
[[0 1 2]
 [3 4 5]]

Shape of a:
[[0 1]
 [2 3]
 [4 5]]

A fatia de uma matriz cria uma visualização.

Exemplo

import numpy as np 
a = np.array([[10,10], [2,3], [4,5]]) 

print 'Our array is:' 
print a  

print 'Create a slice:' 
s = a[:, :2] 
print s

Ele produzirá a seguinte saída -

Our array is:
[[10 10]
 [ 2 3]
 [ 4 5]]

Create a slice:
[[10 10]
 [ 2 3]
 [ 4 5]]

Deep Copy

o ndarray.copy()função cria uma cópia profunda. É uma cópia completa do array e seus dados e não compartilha com o array original.

Exemplo

import numpy as np 
a = np.array([[10,10], [2,3], [4,5]]) 

print 'Array a is:' 
print a  

print 'Create a deep copy of a:' 
b = a.copy() 
print 'Array b is:' 
print b 

#b does not share any memory of a 
print 'Can we write b is a' 
print b is a  

print 'Change the contents of b:' 
b[0,0] = 100 

print 'Modified array b:' 
print b  

print 'a remains unchanged:' 
print a

Ele produzirá a seguinte saída -

Array a is:
[[10 10]
 [ 2 3]
 [ 4 5]]

Create a deep copy of a:
Array b is:
[[10 10]
 [ 2 3]
 [ 4 5]]
Can we write b is a
False

Change the contents of b:
Modified array b:
[[100 10]
 [ 2 3]
 [ 4 5]]

a remains unchanged:
[[10 10]
 [ 2 3]
 [ 4 5]]

O pacote NumPy contém uma biblioteca Matrix numpy.matlib. Este módulo possui funções que retornam matrizes em vez de objetos ndarray.

matlib.empty ()

o matlib.empty()função retorna uma nova matriz sem inicializar as entradas. A função assume os seguintes parâmetros.

numpy.matlib.empty(shape, dtype, order)

Onde,

Sr. Não. Parâmetro e Descrição
1

shape

int ou tupla de int definindo a forma da nova matriz

2

Dtype

Opcional. Tipo de dados da saída

3

order

C ou F

Exemplo

import numpy.matlib 
import numpy as np 

print np.matlib.empty((2,2)) 
# filled with random data

Ele produzirá a seguinte saída -

[[ 2.12199579e-314,   4.24399158e-314] 
 [ 4.24399158e-314,   2.12199579e-314]]

numpy.matlib.zeros ()

Esta função retorna a matriz preenchida com zeros.

import numpy.matlib 
import numpy as np 
print np.matlib.zeros((2,2))

Ele produzirá a seguinte saída -

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

numpy.matlib.ones ()

Esta função retorna a matriz preenchida com 1s.

import numpy.matlib 
import numpy as np 
print np.matlib.ones((2,2))

Ele produzirá a seguinte saída -

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

numpy.matlib.eye ()

Esta função retorna uma matriz com 1 ao longo dos elementos diagonais e zeros em outros lugares. A função assume os seguintes parâmetros.

numpy.matlib.eye(n, M,k, dtype)

Onde,

Sr. Não. Parâmetro e Descrição
1

n

O número de linhas na matriz resultante

2

M

O número de colunas, o padrão é n

3

k

Índice da diagonal

4

dtype

Tipo de dados da saída

Exemplo

import numpy.matlib 
import numpy as np 
print np.matlib.eye(n = 3, M = 4, k = 0, dtype = float)

Ele produzirá a seguinte saída -

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

numpy.matlib.identity ()

o numpy.matlib.identity()função retorna a matriz de identidade do tamanho fornecido. Uma matriz identidade é uma matriz quadrada com todos os elementos diagonais como 1.

import numpy.matlib 
import numpy as np 
print np.matlib.identity(5, dtype = float)

Ele produzirá a seguinte saída -

[[ 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.]]

numpy.matlib.rand ()

o numpy.matlib.rand() função retorna uma matriz do tamanho fornecido preenchida com valores aleatórios.

Exemplo

import numpy.matlib 
import numpy as np 
print np.matlib.rand(3,3)

Ele produzirá a seguinte saída -

[[ 0.82674464  0.57206837  0.15497519] 
 [ 0.33857374  0.35742401  0.90895076] 
 [ 0.03968467  0.13962089  0.39665201]]

Noteque uma matriz é sempre bidimensional, enquanto ndarray é uma matriz n-dimensional. Ambos os objetos são conversíveis.

Exemplo

import numpy.matlib 
import numpy as np  

i = np.matrix('1,2;3,4') 
print i

Ele produzirá a seguinte saída -

[[1  2] 
 [3  4]]

Exemplo

import numpy.matlib 
import numpy as np  

j = np.asarray(i) 
print j

Ele produzirá a seguinte saída -

[[1  2] 
 [3  4]]

Exemplo

import numpy.matlib 
import numpy as np  

k = np.asmatrix (j) 
print k

Ele produzirá a seguinte saída -

[[1  2] 
 [3  4]]

O pacote NumPy contém numpy.linalgmódulo que fornece todas as funcionalidades necessárias para álgebra linear. Algumas das funções importantes neste módulo são descritas na tabela a seguir.

Sr. Não. Descrição da função
1 ponto

Produto escalar das duas matrizes

2 vdot

Produto escalar dos dois vetores

3 interior

Produto interno das duas matrizes

4 matmul

Produto de matriz das duas matrizes

5 determinante

Calcula o determinante da matriz

6 resolver

Resolve a equação da matriz linear

7 inv

Encontra o inverso multiplicativo da matriz

Matplotlib é uma biblioteca de plotagem para Python. Ele é usado junto com o NumPy para fornecer um ambiente que é uma alternativa de código aberto eficaz para MatLab. Ele também pode ser usado com kits de ferramentas gráficas como PyQt e wxPython.

O módulo Matplotlib foi escrito pela primeira vez por John D. Hunter. Desde 2012, Michael Droettboom é o desenvolvedor principal. Atualmente, Matplotlib ver. 1.5.1 é a versão estável disponível. O pacote está disponível em distribuição binária, bem como na forma de código-fonte em www.matplotlib.org .

Convencionalmente, o pacote é importado para o script Python, adicionando a seguinte instrução -

from matplotlib import pyplot as plt

Aqui pyplot()é a função mais importante na biblioteca matplotlib, que é usada para plotar dados 2D. O seguinte script traça a equaçãoy = 2x + 5

Exemplo

import numpy as np 
from matplotlib import pyplot as plt 

x = np.arange(1,11) 
y = 2 * x + 5 
plt.title("Matplotlib demo") 
plt.xlabel("x axis caption") 
plt.ylabel("y axis caption") 
plt.plot(x,y) 
plt.show()

Um objeto ndarray x é criado a partir de np.arange() function como os valores no x axis. Os valores correspondentes noy axis são armazenados em outro ndarray object y. Esses valores são plotados usandoplot() função do submódulo pyplot do pacote matplotlib.

A representação gráfica é exibida por show() função.

O código acima deve produzir a seguinte saída -

Em vez do gráfico linear, os valores podem ser exibidos discretamente, adicionando uma string de formato ao plot()função. Os seguintes caracteres de formatação podem ser usados.

Sr. Não. Descrição do personagem
1

'-'

Estilo de linha sólida

2

'--'

Estilo de linha tracejada

3

'-.'

Estilo de linha traço-ponto

4

':'

Estilo de linha pontilhada

5

'.'

Marcador de ponto

6

','

Marcador de pixel

7

'o'

Marcador de círculo

8

'v'

Marcador Triangle_down

9

'^'

Marcador Triangle_up

10

'<'

Marcador Triangle_left

11

'>'

Marcador Triangle_right

12

'1'

Marcador Tri_down

13

'2'

Marcador Tri_up

14

'3'

Marcador tri_esquerdo

15

'4'

Marcador tri_right

16

's'

Marcador quadrado

17

'p'

Marcador de pentágono

18

'*'

Marcador estrela

19

'h'

Marcador hexágono1

20

'H'

Marcador hexágono2

21

'+'

Marcador positivo

22

'x'

Marcador X

23

'D'

Marcador de diamante

24

'd'

Marcador de diamante fino

25

'|'

Marcador Vline

26

'_'

Marcador Hline

As seguintes abreviações de cores também são definidas.

Personagem Cor
'b' Azul
'g' Verde
'r' Vermelho
'c' Ciano
'm' Magenta
'você' Amarelo
'k' Preto
'W' Branco

Para exibir os círculos que representam pontos, em vez da linha no exemplo acima, use “ob” como a string de formato na função plot ().

Exemplo

import numpy as np 
from matplotlib import pyplot as plt 

x = np.arange(1,11) 
y = 2 * x + 5 
plt.title("Matplotlib demo") 
plt.xlabel("x axis caption") 
plt.ylabel("y axis caption") 
plt.plot(x,y,"ob") 
plt.show()

O código acima deve produzir a seguinte saída -

Gráfico de onda senoidal

O seguinte script produz o sine wave plot usando matplotlib.

Exemplo

import numpy as np 
import matplotlib.pyplot as plt  

# Compute the x and y coordinates for points on a sine curve 
x = np.arange(0, 3 * np.pi, 0.1) 
y = np.sin(x) 
plt.title("sine wave form") 

# Plot the points using matplotlib 
plt.plot(x, y) 
plt.show()

subtrama ()

A função subplot () permite que você plote coisas diferentes na mesma figura. No script a seguir,sine e cosine values são plotados.

Exemplo

import numpy as np 
import matplotlib.pyplot as plt  
   
# Compute the x and y coordinates for points on sine and cosine curves 
x = np.arange(0, 3 * np.pi, 0.1) 
y_sin = np.sin(x) 
y_cos = np.cos(x)  
   
# Set up a subplot grid that has height 2 and width 1, 
# and set the first such subplot as active. 
plt.subplot(2, 1, 1)
   
# Make the first plot 
plt.plot(x, y_sin) 
plt.title('Sine')  
   
# Set the second subplot as active, and make the second plot. 
plt.subplot(2, 1, 2) 
plt.plot(x, y_cos) 
plt.title('Cosine')  
   
# Show the figure. 
plt.show()

O código acima deve produzir a seguinte saída -

Barra()

o pyplot submodule fornece bar()função para gerar gráficos de barras. O exemplo a seguir produz o gráfico de barras de dois conjuntos dex e y matrizes.

Exemplo

from matplotlib import pyplot as plt 
x = [5,8,10] 
y = [12,16,6]  

x2 = [6,9,11] 
y2 = [6,15,7] 
plt.bar(x, y, align = 'center') 
plt.bar(x2, y2, color = 'g', align = 'center') 
plt.title('Bar graph') 
plt.ylabel('Y axis') 
plt.xlabel('X axis')  

plt.show()

Este código deve produzir a seguinte saída -

NumPy tem um numpy.histogram()função que é uma representação gráfica da distribuição de frequência dos dados. Retângulos de igual tamanho horizontal correspondendo ao intervalo de classe chamadosbin e variable height correspondente à frequência.

numpy.histogram ()

A função numpy.histogram () usa a matriz de entrada e os bins como dois parâmetros. Os elementos sucessivos na matriz bin agem como o limite de cada bin.

import numpy as np 
   
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) 
np.histogram(a,bins = [0,20,40,60,80,100]) 
hist,bins = np.histogram(a,bins = [0,20,40,60,80,100]) 
print hist 
print bins

Ele produzirá a seguinte saída -

[3 4 5 2 1]
[0 20 40 60 80 100]

plt ()

Matplotlib pode converter esta representação numérica do histograma em um gráfico. oplt() function do submódulo pyplot leva a matriz que contém os dados e a matriz bin como parâmetros e converte em um histograma.

from matplotlib import pyplot as plt 
import numpy as np  
   
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) 
plt.hist(a, bins = [0,20,40,60,80,100]) 
plt.title("histogram") 
plt.show()

Ele deve produzir a seguinte saída -

Os objetos ndarray podem ser salvos e carregados dos arquivos do disco. As funções IO disponíveis são -

  • load() e save() funções manipulam / numPy arquivos binários (com npy extensão)

  • loadtxt() e savetxt() funções lidam com arquivos de texto normais

NumPy apresenta um formato de arquivo simples para objetos ndarray. este.npy file armazena dados, forma, dtype e outras informações necessárias para reconstruir o ndarray em um arquivo de disco de forma que o array seja recuperado corretamente, mesmo se o arquivo estiver em outra máquina com arquitetura diferente.

numpy.save ()

o numpy.save() arquivo armazena a matriz de entrada em um arquivo de disco com npy extensão.

import numpy as np 
a = np.array([1,2,3,4,5]) 
np.save('outfile',a)

Para reconstruir a matriz de outfile.npy, usar load() função.

import numpy as np 
b = np.load('outfile.npy') 
print b

Ele produzirá a seguinte saída -

array([1, 2, 3, 4, 5])

As funções save () e load () aceitam um parâmetro booleano adicional allow_pickles. Um pickle em Python é usado para serializar e desserializar objetos antes de salvar ou ler de um arquivo de disco.

savetxt ()

O armazenamento e recuperação de dados de array em formato de arquivo de texto simples é feito com savetxt() e loadtxt() funções.

Exemplo

import numpy as np 

a = np.array([1,2,3,4,5]) 
np.savetxt('out.txt',a) 
b = np.loadtxt('out.txt') 
print b

Ele produzirá a seguinte saída -

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

As funções savetxt () e loadtxt () aceitam parâmetros opcionais adicionais, como cabeçalho, rodapé e delimitador.