Big data: explicação detalhada do aplicativo básico Numpy

Aplicação básica Numpy

Numpy é uma biblioteca de computação científica Python de código aberto para processamento rápido de matrizes de dimensões arbitrárias . O Numpy suporta operações comuns de matriz e matriz . Para a mesma tarefa de cálculo numérico, usar o NumPy não apenas torna o código muito mais conciso, mas também o desempenho do NumPy é muito melhor do que o do Python nativo, que é basicamente uma diferença de um para dois ordens de magnitude. Quanto maior o tamanho, mais óbvias são as vantagens do NumPy.

O principal tipo de dados do Numpy é ndarrayque ele ndarraypode lidar com matrizes unidimensionais, bidimensionais e multidimensionais. Esse objeto é equivalente a um grande contêiner de dados rápido e flexível. O código subjacente do NumPy é escrito em linguagem C, o que resolve a limitação do GIL. ndarrayAo acessar dados, os endereços de dados e dados são contínuos, o que garante operações em lote eficientes, que são muito melhores que as do Python list; Por outro lado , os objetos fornecem mais métodos para processar dados, especialmente métodos relacionados a estatísticas, que não são ndarraynativos do Python .list

Para todos os artigos, visite a coluna: "Python Full Stack Tutorial (0 Basics)"
e recomende a atualização mais recente: " Detailed Explanation of High-frequency Interview Questions in Dachang Test". -teste de frequência nos últimos anos, combinado com seus próprios anos de experiência de trabalho, bem como a orientação de líderes de pares resumidos. O objetivo é ajudar os alunos em testes e python a passar na entrevista sem problemas e obter uma oferta satisfatória!

Diretório de artigos

- Aplicação básica Numpy

Preparação

Iniciar bloco de anotações
```
jupyter notebook
```
Dica : antes de iniciar o Notebook, é recomendável instalar as dependências relacionadas à análise de dados, incluindo os três artefatos mencionados acima e as dependências relacionadas, incluindo: numpy, pandas, matplotlib, e openpyxlassim por diante. Se você usa o Anaconda, não precisa instalá-lo separadamente.
importar
```
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
```
Nota : Se você iniciou o Notebook, mas não instalou as bibliotecas dependentes relevantes, por exemplo, numpyvocê pode entrar e executar a célula na célula do !pip install numpyNotebook para instalar o NumPy ou pode instalar várias bibliotecas de terceiros de uma só vez, que precisa estar na entrada da célula %pip install numpy pandas matplotlib. Observe que no código acima, não apenas importamos o NumPy, mas também importamos as bibliotecas pandas e matplotlib.

criar objeto array

Existem muitas maneiras de criar ndarrayobjetos. A seguir descrevemos como criar arrays unidimensionais, arrays bidimensionais e arrays multidimensionais.

matriz unidimensional

Método 1: Usando arrayuma função, listcriando um objeto de matriz

código:
```
array1 = np.array([1, 2, 3, 4, 5])
array1
```
saída:
```
array([1, 2, 3, 4, 5])
```
Método 2: Use arangeuma função para criar um objeto de matriz especificando um intervalo de valores

código:
```
array2 = np.arange(0, 20, 2)
array2
```
saída:
```
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])
```

Método 3: Use linspaceuma função para criar um objeto de matriz com um intervalo especificado de números uniformemente espaçados

código:

array3 = np.linspace(-5, 5, 101)
array3

saída:

array([-5. , -4.9, -4.8, -4.7, -4.6, -4.5, -4.4, -4.3, -4.2, -4.1, -4. ,
       -3.9, -3.8, -3.7, -3.6, -3.5, -3.4, -3.3, -3.2, -3.1, -3. , -2.9,
       -2.8, -2.7, -2.6, -2.5, -2.4, -2.3, -2.2, -2.1, -2. , -1.9, -1.8,
       -1.7, -1.6, -1.5, -1.4, -1.3, -1.2, -1.1, -1. , -0.9, -0.8, -0.7,
       -0.6, -0.5, -0.4, -0.3, -0.2, -0.1,  0. ,  0.1,  0.2,  0.3,  0.4,
        0.5,  0.6,  0.7,  0.8,  0.9,  1. ,  1.1,  1.2,  1.3,  1.4,  1.5,
        1.6,  1.7,  1.8,  1.9,  2. ,  2.1,  2.2,  2.3,  2.4,  2.5,  2.6,
        2.7,  2.8,  2.9,  3. ,  3.1,  3.2,  3.3,  3.4,  3.5,  3.6,  3.7,
        3.8,  3.9,  4. ,  4.1,  4.2,  4.3,  4.4,  4.5,  4.6,  4.7,  4.8,
        4.9,  5. ])

Método 4: Use numpy.randoma função do módulo para gerar números aleatórios e criar um objeto de matriz

rende 10 $[0, 1)$ Decimais aleatórios no intervalo, código:

array4 = np.random.rand(10)
array4

saída:

array([0.45556132, 0.67871326, 0.4552213 , 0.96671509, 0.44086463,
       0.72650875, 0.79877188, 0.12153022, 0.24762739, 0.6669852 ])

rende 10 $[1, 100)$ inteiro aleatório no intervalo, código:

array5 = np.random.randint(1, 100, 10)
array5

saída:

array([29, 97, 87, 47, 39, 19, 71, 32, 79, 34])

Gera 20 $\mu=50$ ， $\sigma=10$ , o código:

array6 = np.random.normal(50, 10, 20)
array6

saída:

array([55.04155586, 46.43510797, 20.28371158, 62.67884053, 61.23185964,
       38.22682148, 53.17126151, 43.54741592, 36.11268017, 40.94086676,
       63.27911699, 46.92688903, 37.1593374 , 67.06525656, 67.47269463,
       23.37925889, 31.45312239, 48.34532466, 55.09180924, 47.95702787])

Nota : Existem muitas outras maneiras de criar um array unidimensional, como ler strings, ler arquivos, analisar expressões regulares, etc. Não discutiremos esses métodos aqui, os leitores interessados podem fazer suas próprias pesquisas.

Matriz bidimensional

Método 1: Use funções para criar objetos de matriz arraypor meio de aninhamentolist

código:

array7 = np.array([[1, 2, 3], [4, 5, 6]])
array7

saída:

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

Método 2: use as funções zeros, onese fullpara especificar a forma da matriz para criar um objeto de matriz

Use zerosa função, código:

array8 = np.zeros((3, 4))
array8

saída:

array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

Use onesa função, código:

array9 = np.ones((3, 4))
array9

saída:

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

Use fulla função, código:

array10 = np.full((3, 4), 10)
array10

saída:

array([[10, 10, 10, 10],
       [10, 10, 10, 10],
       [10, 10, 10, 10]])

Método 3: Use a função de olho para criar uma matriz de identidade

código:

array11 = np.eye(4)
array11

saída:

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

Método 4: reshapeconvertendo uma matriz unidimensional em uma matriz bidimensional

código:
```
array12 = np.array([1, 2, 3, 4, 5, 6]).reshape(2, 3)
array12
```
saída:
```
array([[1, 2, 3],
       [4, 5, 6]])
```
Dica : reshapeÉ ndarrayum método do objeto. reshapeAo usar o método, você precisa garantir que o número de elementos do array após a remodelagem seja consistente com o número de elementos do array antes da remodelagem, caso contrário, ocorrerá uma exceção.
Método 5: numpy.randomgerar números aleatórios por meio da função do módulo para criar um objeto de matriz

rende $[0, 1)$ Uma matriz bidimensional de 3 linhas e 4 colunas composta por decimais aleatórios no intervalo, o código:
```
array13 = np.random.rand(3, 4)
array13
```
saída:
```
array([[0.54017809, 0.46797771, 0.78291445, 0.79501326],
       [0.93973783, 0.21434806, 0.03592874, 0.88838892],
       [0.84130479, 0.3566601 , 0.99935473, 0.26353598]])
```
rende $[1, Uma matriz bidimensional de 3 linhas e 4 colunas composta de números inteiros aleatórios no intervalo de 100)$ , o código:
```
array14 = np.random.randint(1, 100, (3, 4))
array14
```
saída:
```
array([[83, 30, 64, 53],
       [39, 92, 53, 43],
       [43, 48, 91, 72]])
```

Matrizes multidimensionais

Crie arrays multidimensionais usando random

código:

array15 = np.random.randint(1, 100, (3, 4, 5))
array15

saída:

array([[[94, 26, 49, 24, 43],
        [27, 27, 33, 98, 33],
        [13, 73,  6,  1, 77],
        [54, 32, 51, 86, 59]],

       [[62, 75, 62, 29, 87],
        [90, 26,  6, 79, 41],
        [31, 15, 32, 56, 64],
        [37, 84, 61, 71, 71]],

       [[45, 24, 78, 77, 41],
        [75, 37,  4, 74, 93],
        [ 1, 36, 36, 60, 43],
        [23, 84, 44, 89, 79]]])

Reformule uma matriz unidimensional e bidimensional em uma matriz multidimensional

Ajuste a forma de um array unidimensional para um array multidimensional, o código:

array16 = np.arange(1, 25).reshape((2, 3, 4))
array16

saída:

array([[[ 1,  2,  3,  4],
        [ 5,  6,  7,  8],
        [ 9, 10, 11, 12]],

       [[13, 14, 15, 16],
        [17, 18, 19, 20],
        [21, 22, 23, 24]]])

Ajuste a forma de um array bidimensional em um array multidimensional, o código:

array17 = np.random.randint(1, 100, (4, 6)).reshape((4, 3, 2))
array17

saída:

array([[[60, 59],
        [31, 80],
        [54, 91]],

       [[67,  4],
        [ 4, 59],
        [47, 49]],

       [[16,  4],
        [ 5, 71],
        [80, 53]],

       [[38, 49],
        [70,  5],
        [76, 80]]])

Leia a imagem para obter a matriz tridimensional correspondente

código:

array18 = plt.imread('guido.jpg')
array18

saída:

array([[[ 36,  33,  28],
        [ 36,  33,  28],
        [ 36,  33,  28],
        ...,
        [ 32,  31,  29],
        [ 32,  31,  27],
        [ 31,  32,  26]],

       [[ 37,  34,  29],
        [ 38,  35,  30],
        [ 38,  35,  30],
        ...,
        [ 31,  30,  28],
        [ 31,  30,  26],
        [ 30,  31,  25]],

       [[ 38,  35,  30],
        [ 38,  35,  30],
        [ 38,  35,  30],
        ...,
        [ 30,  29,  27],
        [ 30,  29,  25],
        [ 29,  30,  25]],

       ...,

       [[239, 178, 123],
        [237, 176, 121],
        [235, 174, 119],
        ...,
        [ 78,  68,  56],
        [ 75,  67,  54],
        [ 73,  65,  52]],

       [[238, 177, 120],
        [236, 175, 118],
        [234, 173, 116],
        ...,
        [ 82,  70,  58],
        [ 78,  68,  56],
        [ 75,  66,  51]],

       [[238, 176, 119],
        [236, 175, 118],
        [234, 173, 116],
        ...,
        [ 84,  70,  61],
        [ 81,  69,  57],
        [ 79,  67,  53]]], dtype=uint8)

Explicação : O código acima lê guido.jpgo arquivo de imagem nomeado no caminho atual. A imagem no sistema do computador geralmente é composta de pixels em várias linhas e colunas, e cada pixel é composto de três cores primárias de vermelho, verde e azul, portanto, pode ser representado por uma matriz tridimensional. A leitura de imagens usa funções matplotlibde biblioteca .imread

propriedades do objeto array

sizeAtributo: o número de elementos da matriz

código:

array19 = np.arange(1, 100, 2)
array20 = np.random.rand(3, 4)
print(array19.size, array20.size)

saída:

50 12

shapeAtributo: a forma da matriz

código:

print(array19.shape, array20.shape)

saída:

(50,) (3, 4)

dtypeAtributo: o tipo de dados dos elementos da matriz

código:
```
print(array19.dtype, array20.dtype)
```
saída:
```
int64 float64
```
ndarrayO tipo de dados do elemento de objeto pode se referir à tabela mostrada abaixo.
ndimAtributo: Dimensões do array

código:
```
print(array19.ndim, array20.ndim)
```
saída:
```
1 2
```
itemsizeAtributo: o número de bytes de espaço de memória ocupado por um único elemento da matriz

código:
```
array21 = np.arange(1, 100, 2, dtype=np.int8)
print(array19.itemsize, array20.itemsize, array21.itemsize)
```
saída:
```
8 8 1
```
Descrição : Ao usar arangepara criar um objeto de matriz, dtypeespecifique o tipo de dados do elemento por meio do parâmetro. Pode-se ver que np.int8representa um inteiro com sinal de 8 bits, que ocupa apenas 1 byte de espaço de memória, e o intervalo de valores é $[-128,_127]$ _
nbytesAtributo: o número de bytes de espaço de memória ocupado por todos os elementos do array

código:
```
print(array19.nbytes, array20.nbytes, array21.nbytes)
```
saída:
```
400 96 50
```

flatAtributo: Iterator para os elementos do array (após a unidimensionalização)

código:

from typing import Iterable

print(isinstance(array20.flat, np.ndarray), isinstance(array20.flat, Iterable))

saída:

False True

baseAtributo: o objeto base do array (se o array compartilhar o espaço de memória de outros arrays)

código:
```
array22 = array19[:]
print(array22.base is array19, array22.base is array21)
```
saída:
```
True False
```
Explicação : O código acima usa a operação de divisão do array, que é semelhante à listdivisão do tipo em Python, mas os detalhes não são exatamente os mesmos. O seguinte explicará especificamente este ponto de conhecimento. Através do código acima, pode-se descobrir que ndarrayo novo objeto array obtido após o fatiamento compartilha os dados na memória com o objeto array original, então o array22atributo baseé array19o objeto array correspondente.

Indexação e fatiamento de arrays

Semelhante às listas em Python, ndarrayos objetos NumPy podem executar operações de indexação e divisão. Os elementos na matriz podem ser obtidos ou modificados por meio da indexação, e uma parte da matriz pode ser retirada por meio da divisão.

Operação de índice (índice comum)

Matriz unidimensional, código:

array23 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
print(array23[0], array23[array23.size - 1])
print(array23[-array23.size], array23[-1])

saída:

1 9
1 9

Matriz bidimensional, código:

array24 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(array24[2])
print(array24[0][0], array24[-1][-1])
print(array24[1][1], array24[1, 1])

saída:

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

código:

array24[1][1] = 10
print(array24)
array24[1] = [10, 11, 12]
print(array24)

saída:

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

operação de fatia (índice de fatia)

O fatiamento é uma sintaxe como esta [开始索引:结束索引:步长]. Ao especificar o índice inicial (o valor padrão é infinitesimal), o índice final (o valor padrão é infinito) e o tamanho do passo (o valor padrão é 1), os elementos da parte especificada são obtidos da matriz e uma nova matriz é formada. Como o índice inicial, o índice final e o tamanho da etapa têm valores padrão, todos eles podem ser omitidos e o segundo dois-pontos também pode ser omitido se o tamanho da etapa não for especificado. A operação de divisão de uma matriz unidimensional listé muito semelhante à divisão de tipos em Python e não será repetida aqui. Para a divisão de uma matriz bidimensional, você pode consultar o seguinte código, que se acredita ser muito fácil de entender.

código:
```
print(array24[:2, 1:])
```
saída:
```
[[2 3]
 [5 6]]
```
código:
```
print(array24[2])
print(array24[2, :])
```
saída:
```
[7 8 9]
[7 8 9]
```
código:
```
print(array24[2:, :])
```
saída:
```
[[7 8 9]]
```
código:
```
print(array24[:, :2])
```
saída:
```
[[1 2]
 [4 5]
 [7 8]]
```
código:
```
print(array24[1, :2])
print(array24[1:2, :2])
```
saída:
```
[4 5]
[[4 5]]
```
código:
```
print(array24[::2, ::2])
```
saída:
```
[[1 3]
 [7 9]]
```
código:
```
print(array24[::-2, ::-2])
```
saída:
```
[[9 7]
 [3 1]]
```
Em relação às operações de indexação e fatiamento de arrays, você pode usar as duas imagens a seguir para melhorar sua impressão. Essas duas imagens são do livro "Data Analysis with Python"pandas , que é um clássico na área de análise de dados Python escrito pelo autor da biblioteca, Wes McKinney Textbook, os leitores interessados podem comprar e ler o livro original.

índice sofisticado

A indexação sofisticada refere-se ao uso de arrays de inteiros para indexação. Os arrays de inteiros mencionados aqui podem ser NumPy ndarrayou tipos iteráveis como Python liste tuplepodem usar índices positivos ou negativos.

Indexação sofisticada de arrays 1D, código:

array25 = np.array([50, 30, 15, 20, 40])
array25[[0, 1, -1]]

saída:

array([50, 30, 40])

Indexação sofisticada de arrays 2D, código:

array26 = np.array([[30, 20, 10], [40, 60, 50], [10, 90, 80]])
# 取二维数组的第1行和第3行
array26[[0, 2]]

saída:

array([[30, 20, 10],
       [10, 90, 80]])

código:

# 取二维数组第1行第2列，第3行第3列的两个元素
array26[[0, 2], [1, 2]]

saída:

array([20, 80])

código:

# 取二维数组第1行第2列，第3行第2列的两个元素
array26[[0, 2], 1]

saída:

array([20, 90])

índice booleano

O índice booleano serve para indexar os elementos do array através de um array do tipo booleano.O array do tipo booleano pode ser construído manualmente, ou pode ser gerado por operações relacionais.

código:

array27 = np.arange(1, 10)
array27[[True, False, True, True, False, False, False, False, True]]

saída:

array([1, 3, 4, 9])

código:

array27 >= 5

saída:

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

código:

# ~运算符可以实现逻辑变反，看看运行结果跟上面有什么不同
~(array27 >= 5)

saída:

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

código:

array27[array27 >= 5]

saída:

array([5, 6, 7, 8, 9])

Dica : embora a operação de divisão crie um novo objeto de matriz, a nova matriz e a matriz original compartilham os dados na matriz. Simplificando, se os dados na matriz forem modificados por meio do novo objeto de matriz ou do objeto de matriz original, a modificação é realmente o mesmo bloco de dados. baseA indexação sofisticada e a indexação booleana também criarão um novo objeto de matriz, e a nova matriz copia os elementos da matriz original. A relação entre a nova matriz e a matriz original não compartilha dados. Isso também pode ser entendido a partir das propriedades da matriz array mencionado acima. Preste atenção ao usá-lo.

Caso: Processando uma imagem por fatiamento de matriz

Aprender o conhecimento básico é sempre chato e carece de um senso de realização, então ainda chegamos a um caso para demonstrar o uso da indexação de array e das operações de fatiamento aprendidas acima. Como mencionamos anteriormente, as imagens podem ser representadas por uma matriz tridimensional e, em seguida, a imagem pode ser processada operando na matriz tridimensional correspondente à imagem, conforme mostrado abaixo.

Leia a imagem para criar um objeto de matriz tridimensional.

guido_image = plt.imread('guido.jpg')
plt.imshow(guido_image)

Execute o corte reverso no eixo 0 da matriz para realizar a inversão vertical da imagem.

plt.imshow(guido_image[::-1])

Fatie o eixo 1 da matriz ao contrário para realizar a inversão horizontal da imagem.

plt.imshow(guido_image[:,::-1])

Corte a cabeça de Guido.

plt.imshow(guido_image[30:350, 90:300])

Métodos de Objetos Array

Métodos estatísticos

Os métodos estatísticos incluem principalmente: sum(), mean(), std(), var(), min(), max(), , argmin(), argmax()etc. cumsum(), que são usados respectivamente para somar, média, desvio padrão, variância, máximo, mínimo, soma cumulativa, etc. dos elementos na matriz, consulte o seguinte código.

array28 = np.array([1, 2, 3, 4, 5, 5, 4, 3, 2, 1])
print(array28.sum())
print(array28.mean())
print(array28.max())
print(array28.min())
print(array28.std())
print(array28.var())
print(array28.cumsum())

saída:

30
3.0
5
1
1.4142135623730951
2.0
[ 1  3  6 10 15 20 24 27 29 30]

Outros métodos

all()/ any()Método: Determina se todos os elementos da matriz são True/ determina se a matriz possui elementos ativos True.
astype()Método: copie a matriz e converta os elementos na matriz para o tipo especificado.

dump()Método: salve a matriz em um arquivo, você pode load()criar uma matriz carregando dados do arquivo salvo por meio da função NumPy.

código:

array31.dump('array31-data')
array32 = np.load('array31-data', allow_pickle=True)
array32

saída:

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

fill()Método: Preencha o elemento especificado na matriz.
flatten()Método: achatar uma matriz multidimensional em uma matriz unidimensional.

código:
```
array32.flatten()
```
saída:
```
array([1, 2, 3, 4, 5, 6])
```
nonzero()Método: Retorna o índice do elemento diferente de zero.
round()Método: arredondar os elementos da matriz.

sort()Método: Classifica a matriz no local.

código:

array33 = np.array([35, 96, 12, 78, 66, 54, 40, 82])
array33.sort()
array33

saída:

array([12, 35, 40, 54, 66, 78, 82, 96])

swapaxes()E transpose()método: Troca os eixos especificados pelo array.

código:

# 指定需要交换的两个轴，顺序无所谓
array32.swapaxes(0, 1)

saída:

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

código:

# 对于二维数组，transpose相当于实现了矩阵的转置
array32.transpose()

saída:

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

tolist()Método: converta o array em Python list.