NumPy Tutorial: Análise de dados com Python

Não perca nossa folha de trapaça NumPy GRÁTIS no final deste post

NumPy é um pacote de análise de dados Python comumente usado. Usando o NumPy, você pode acelerar seu fluxo de trabalho, e fazer interface com outros pacotes no ecossistema Python, como o Scikit-learn, que usam o NumPy sob o capô. O NumPy foi originalmente desenvolvido em meados dos anos 2000, e surgiu de um pacote ainda mais antigo chamado Numeric. Esta longevidade significa que quase todos os pacotes de análise de dados ou de aprendizado de máquina para Python alavancam o NumPy de alguma forma.

Neste tutorial, vamos caminhar usando o NumPy para analisar dados sobre a qualidade do vinho. Os dados contêm informação sobre vários atributos dos vinhos, tais como pH e fixed acidity, juntamente com uma pontuação de qualidade entre 0 e 10 para cada vinho. O índice de qualidade é a média de pelo menos 3 provadores de sabor humano. À medida que aprendemos a trabalhar com a NumPy, vamos tentando descobrir mais sobre a qualidade percebida do vinho.

Os vinhos que vamos analisar são da região do Minho em Portugal.

Os dados foram descarregados do Repositório de Aprendizagem da Máquina UCI, e estão disponíveis aqui. Aqui estão as primeiras linhas do ficheiro winequality-red.csv, que vamos utilizar ao longo deste tutorial:

"fixed acidity";"volatile acidity";"citric acid";"residual sugar";"chlorides";"free sulfur dioxide";"total sulfur dioxide";"density";"pH";"sulphates";"alcohol";"quality"7.4;0.7;0;1.9;0.076;11;34;0.9978;3.51;0.56;9.4;57.8;0.88;0;2.6;0.098;25;67;0.9968;3.2;0.68;9.8;5

Os dados estão no formato que vou chamar ssv (valores separados por ponto e vírgula) – cada registo é separado por ponto e vírgula (;), e as linhas são separadas por uma nova linha. Existem 1600 linhas no ficheiro, incluindo uma linha de cabeçalho, e 12 colunas.

Antes de começarmos, uma nota de versão rápida – vamos usar o Python 3.5. Nossos exemplos de código serão feitos usando Jupyter notebook.

Lists Of Lists for CSV Data

Antes de usar o NumPy, vamos primeiro tentar trabalhar com os dados usando o Python e o pacote csv. Podemos ler no arquivo usando o objeto csv.reader, que nos permitirá ler e dividir todo o conteúdo do arquivo ssv.

No código abaixo, nós:

• Importar o objeto csv biblioteca.
• Abrir o objeto winequality-red.csv arquivo.
  • Com o arquivo aberto, crie um novo objeto csv.reader.
    • Passar no argumento da palavra-chave delimiter=";" para ter certeza que os registros estão divididos no caractere ponto-e-vírgula ao invés do caractere vírgula padrão.
  • Chamar o tipo de lista para obter todas as linhas do arquivo.
  • Atribuir o resultado a wines.

import csvwith open('winequality-red.csv', 'r') as f: wines = list(csv.reader(f, delimiter=';'))

Após lermos os dados, podemos imprimir o primeiro 3 linhas:

print(wines)

, , ]

Os dados foram lidos numa lista de listas. Cada lista interna é uma linha do arquivo ssv. Como você deve ter notado, cada item em toda a lista de listas é representado como uma string, o que tornará mais difícil fazer cálculos.

Formataremos os dados em uma tabela para facilitar a visualização:

Como pode ver na tabela acima, lemos em três filas, a primeira das quais contém cabeçalhos de coluna. Cada linha após a linha do cabeçalho representa um vinho. O primeiro elemento de cada linha é o fixed acidity, o segundo é o volatile acidity, e assim por diante. Podemos encontrar a média quality dos vinhos. O código abaixo irá:

• Extrair o último elemento de cada linha após a linha do cabeçalho.
• Converter cada elemento extraído para um float.
• Atribuir todos os elementos extraídos para a lista qualities.
• Dividir a soma de todos os elementos em qualities pelo número total de elementos em qualities para obter a média.

qualities =) for item in wines]sum(qualities) / len(qualities)

5.6360225140712945

Embora tenhamos sido capazes de fazer o cálculo que queríamos, o código é bastante complexo, e não será divertido ter que fazer algo semelhante cada vez que quisermos calcular uma quantidade. Felizmente, podemos usar o NumPy para facilitar o trabalho com nossos dados.

Arrays 2-Dimensionais Númulos

Com o NumPy, trabalhamos com arrays multidimensionais. Mais tarde, vamos mergulhar em todos os tipos de matrizes multidimensionais possíveis, mas por enquanto, vamos nos concentrar em matrizes bidimensionais. Uma matriz bidimensional também é conhecida como matriz, e é algo com que você deve estar familiarizado. Na verdade, é apenas uma forma diferente de pensar sobre uma lista de listas. Uma matriz tem filas e colunas. Ao especificar um número de linha e um número de coluna, somos capazes de extrair um elemento de uma matriz.

Na matriz abaixo, a primeira linha é a linha do cabeçalho, e a primeira coluna é a coluna fixed acidity:

Se escolhêssemos o elemento na primeira linha e na segunda coluna, teríamos volatile acidity. Se escolhêssemos o elemento na terceira linha e na segunda coluna, obteríamos 0.88.

Em uma matriz NumPy, o número de dimensões é chamado de rank, e cada dimensão é chamada de eixo. Então as linhas são o primeiro eixo, e as colunas o segundo eixo.

Agora que você entenda o básico das matrizes, vamos ver como podemos obter da nossa lista de listas para um array NumPy.

Criando um array NumPy

Podemos criar um array NumPy usando a função numpy.array. Se passarmos em uma lista de listas, ele irá criar automaticamente um array NumPy com o mesmo número de linhas e colunas. Como queremos que todos os elementos do array sejam elementos flutuantes para facilitar o cálculo, vamos deixar de fora a linha de cabeçalho, que contém strings. Uma das limitações do NumPy é que todos os elementos em um array têm que ser do mesmo tipo, então se incluirmos a linha de cabeçalho, todos os elementos do array serão lidos como strings. Como queremos ser capazes de fazer cálculos como encontrar a média quality dos vinhos, precisamos que todos os elementos sejam flutuantes.

No código abaixo, we:

• Importar o pacote numpy.
• Passar a lista de listas wines para a função array, que a converte em um array NumPy.
  • Excluir a linha de cabeçalho com corte de lista.
  • Especificar o argumento da palavra-chave dtype para ter certeza de que cada elemento é convertido em um float. Vamos mergulhar mais no que o dtype é mais tarde.

import csvwith open("winequality-red.csv", 'r') as f: wines = list(csv.reader(f, delimiter=";"))import numpy as npwines = np.array(wines, dtype=np.float)

Tente executar o código acima e ver o que acontece!

Se mostrarmos wines, vamos agora obter uma matriz NumPy:

wines

array(,,,...,,,])

Podemos verificar o número de linhas e colunas nos nossos dados usando a propriedade de forma das matrizes NumPy:

wines.shape

(1599, 12)

Métodos Alternativos de Criação de Matrizes NumPy

Existem vários métodos que você pode usar para criar matrizes NumPy. Para começar, você pode criar um array onde cada elemento é zero. O código abaixo irá criar um array com 3 linhas e 4 colunas, onde cada elemento é 0, usando numpy.zeros:

import numpy as np

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

É útil criar um array com todos os elementos zero nos casos em que você precisa de um array de tamanho fixo, mas ainda não tem nenhum valor para ele.

Você também pode criar um array onde cada elemento é um número aleatório usando numpy.random.rand. Aqui está um exemplo:

np.random.rand(3,4)

array(,,])

Criar arrays cheios de números aleatórios pode ser útil quando você quer testar rapidamente seu código com arrays.

Usando NumPy para ler em arquivos

É possível usar NumPy para ler diretamente csv ou outros arquivos em arrays. Nós podemos fazer isso usando a função numpy.genfromtxt. Podemos usá-la para ler em nossos dados iniciais sobre vinhos tintos.

No código abaixo, we:

• Utilizar a função genfromtxt para ler em winequality-red.csv file.
• Especificar o argumento da palavra-chave delimiter=";" para que os campos sejam analisados corretamente.
• Especificar o argumento da palavra-chave skip_header=1 para que a linha do cabeçalho seja pulada.

wines = np.genfromtxt("winequality-red.csv", delimiter=";", skip_header=1)

wines acabará parecendo o mesmo como se o lêssemos em uma lista e depois o convertemos em um array de flutuadores. NumPy irá automaticamente escolher um tipo de dados para os elementos em um array baseado no seu formato.

Indexando Arrays NumPy

Agora sabemos como criar arrays, mas a menos que possamos recuperar resultados deles, não há muito o que podemos fazer com NumPy. Podemos usar a indexação de array para selecionar elementos individuais, grupos de elementos, ou linhas e colunas inteiras. Uma coisa importante a ter em mente é que, assim como as listas Python, NumPy é indexado a zero, o que significa que o índice da primeira linha é 0, e o índice da primeira coluna é 0. Se quisermos trabalhar com a quarta linha, usaremos índice 3, se quisermos trabalhar com a segunda linha, usaremos índice 1, e assim por diante. Trabalharemos novamente com o índice wines array:

Vamos seleccionar o elemento na linha 3 e na coluna 4. No código abaixo, passamos no índice 2 como o índice da linha, e o índice 3 como o índice da coluna. Isto recupera o valor da quarta coluna da terceira linha:

wines

2.2999999999999998

Desde que estamos trabalhando com um array bidimensional em NumPy, nós especificamos 2 índices para recuperar um elemento. O primeiro índice é a linha, ou eixo 1, índice, e o segundo índice é a coluna, ou eixo 2, índice. Qualquer elemento em wines pode ser recuperado usando 2 indexes.

Slicing NumPy Arrays

Se quisermos selecionar os três primeiros itens da quarta coluna, podemos fazê-lo usando dois pontos (:). Um dois pontos indica que queremos selecionar todos os elementos do índice inicial até o índice final, mas sem incluir o índice final. Isto também é conhecido como uma fatia:

wines

array()

Apenas como com o corte da lista, é possível omitir o 0 para apenas recuperar todos os elementos do início até o elemento 3:

wines

array()

Podemos selecionar uma coluna inteira especificando que queremos todos os elementos, do primeiro ao último. Especificamos isto usando apenas os dois pontos (:), sem índices de início ou fim. O código abaixo irá seleccionar a quarta coluna inteira:

wines

array()

Seleccionamos uma coluna inteira acima, mas também podemos extrair uma linha inteira:

wines

array()

Se levarmos a nossa indexação ao extremo, podemos seleccionar a array inteira usando dois pontos para seleccionar todas as linhas e colunas em wines. Este é um grande truque de festa, mas não tem muitas aplicações boas:

wines

array(,,<br />,<br />...,,,<br />])

Atribuir valores a arrays NumPy

Também podemos usar indexação para atribuir valores a certos elementos em arrays. Podemos fazer isso atribuindo diretamente ao valor indexado:

wines = 10

Podemos fazer o mesmo para as fatias. Para sobrepor uma coluna inteira, podemos fazer isto:

wines = 50

O código acima escreve todos os valores da décima primeira coluna com 50.

1-Dimensional NumPy Arrays

Até agora, temos trabalhado com arrays bidimensionais, tais como wines. No entanto, NumPy é um pacote para trabalhar com arrays multidimensionais. Um dos tipos mais comuns de arrays multidimensionais é o array 1-dimensional, ou vetor. Como você deve ter notado acima, quando nós fatiamos wines, nós recuperamos um array unidimensional. Um array unidimensional só precisa de um único índice para recuperar um elemento. Cada linha e coluna em um array bidimensional é um array unidimensional. Assim como uma lista de listas é análoga a um array bidimensional, uma única lista é análoga a um array unidimensional. Se cortarmos os vinhos e apenas recuperarmos a terceira linha, obtemos um array unidimensional:

third_wine = wines

Aqui está como third_wine parece:

11.2000.2800.5601.9000.07517.00060.0000.9983.1600.5809.8006.000

Podemos recuperar elementos individuais de third_wine usando um único índice. O código abaixo exibirá o segundo item em third_wine:

third_wine

0.28000000000000003

Mais funções NumPy com as quais trabalhamos, tais como numpy.random.rand, podem ser usadas com arrays multidimensionais. Aqui está como usaríamos numpy.random.rand para gerar um vetor aleatório:

np.random.rand(3)

array()

Anteriormente, quando chamamos np.random.rand, passamos em uma forma para um array bidimensional, então o resultado foi um array bidimensional. Desta vez, nós passamos em uma forma para um array unidimensional. A forma especifica o número de dimensões, e o tamanho do array em cada dimensão. Uma forma de (10,10) será um array bidimensional com 10 linhas e 10 colunas. Uma forma de (10,) será um array unidimensional com 10 elementos.

Onde a NumPy fica mais complexa é quando começamos a lidar com arrays que têm mais de 2 dimensões.

N-Dimensional NumPy Arrays

Isso não acontece com muita frequência, mas há casos em que você vai querer lidar com arrays que têm dimensões maiores que 3. Uma maneira de pensar nisto é como uma lista de listas de listas. Digamos que queremos armazenar os ganhos mensais de uma loja, mas queremos ser capazes de rapidamente procurar os resultados por um trimestre, e por um ano. Os ganhos de um ano podem parecer assim:

A loja ganhou 0 em janeiro, 5 em fevereiro, e assim por diante. Podemos dividir estes ganhos por trimestre numa lista de listas:

year_one = , , , ]

Podemos recuperar os ganhos de Janeiro ligando para year_one. Se quisermos os resultados de um trimestre inteiro, podemos ligar para year_one ou year_one. Agora temos uma matriz bidimensional, ou matriz. Mas e se agora quisermos adicionar os resultados de outro ano? Temos que adicionar uma terceira dimensão:

earnings = , , , ], , , , ]]

Podemos recuperar os ganhos de janeiro do primeiro ano chamando earnings. Agora precisamos de três índices para recuperar um único elemento. Uma matriz tridimensional em NumPy é muito parecida. Na verdade, podemos converter earnings para um array e então obter os ganhos de janeiro do primeiro ano:

earnings = np.array(earnings)earnings

500

Também podemos encontrar o formato do array:

earnings.shape

(2, 4, 3)

Indexando e fatiando trabalhamos exatamente da mesma forma com um array tridimensional, mas agora temos um eixo extra para passar. Se quiséssemos obter os ganhos de janeiro de todos os anos, poderíamos fazer isso:

earnings

array()

Se quiséssemos obter os ganhos do primeiro trimestre de ambos os anos, poderíamos fazer isso:

earnings

array(,])

Adicionar mais dimensões pode tornar muito mais fácil a consulta dos seus dados se eles estiverem organizados de uma certa forma. Como passamos de matrizes tridimensionais para matrizes 4-dimensionais e maiores, as mesmas propriedades se aplicam, e elas podem ser indexadas e fatiadas das mesmas maneiras.

NumPy Tipos de Dados

Como mencionamos anteriormente, cada matriz NumPy pode armazenar elementos de um único tipo de dado. Por exemplo, wines contém apenas valores de flutuação. NumPy armazena valores usando seus próprios tipos de dados, que são distintos dos tipos Python como float e str. Isto porque o núcleo da NumPy é escrito em uma linguagem de programação chamada C, que armazena dados de forma diferente dos tipos de dados Python. Os tipos de dados NumPy mapeiam entre Python e C, permitindo-nos usar arrays NumPy sem nenhum acerto de conversão.

Você pode encontrar o tipo de dados de um array NumPy acessando a propriedade dtype:

wines.dtype

dtype('float64')

NumPy tem vários tipos de dados diferentes, que na maioria das vezes mapeiam os tipos de dados Python, como float, e str. Você pode encontrar uma lista completa dos tipos de dados NumPy aqui, mas aqui estão alguns importantes:

• float – dados numéricos de ponto flutuante.
• int – dados inteiros.
• string – dados de caracteres.
• object – objetos Python.

Tipos de dados terminam adicionalmente com um sufixo que indica quantos bits de memória eles ocupam. Então int32 é um tipo de dado inteiro de 32 bits, e float64 é um tipo de dado de flutuador de bits.

Converter tipos de dados

Pode usar o método numpy.ndarray.astype para converter um array para um tipo diferente. O método irá copiar o array, e retornar um novo array com o tipo de dado especificado. Por exemplo, podemos converter wines para int data type:

wines.astype(int)

array(,,,...,,,])

Como você pode ver acima, todos os itens no array resultante são inteiros. Note que usamos o tipo de dados Python int em vez de um tipo de dados NumPy quando convertemos wines. Isto porque vários tipos de dados Python, incluindo float, int, e string, podem ser usados com NumPy, e são automaticamente convertidos para NumPy tipos de dados.

Podemos verificar a propriedade do nome do dtype do array resultante para ver que tipo de dados NumPy mapeou o array resultante para:

int_wines = wines.astype(int)int_wines.dtype.name

'int64'

O array foi convertido para um tipo de dados inteiro de 64 bits. Isto permite valores inteiros muito longos, mas ocupa mais espaço na memória do que armazenar os valores como inteiros de 32 bits.

Se você quiser mais controle sobre como o array é armazenado na memória, você pode criar diretamente objetos NumPy dtype como numpy.int32:

np.int32

numpy.int32

Você pode usá-los diretamente para converter entre tipos:

wines.astype(np.int32)

array(,,,...,,,], dtype=int32)

NumPy Array Operations

NumPy torna simples a realização de operações matemáticas em arrays. Esta é uma das principais vantagens do NumPy, e torna bastante fácil fazer cálculos.

Matéria Única de Matriz

Se você fizer qualquer uma das operações matemáticas básicas (/, *, -, +, ^) com um array e um valor, ele aplicará a operação a cada um dos elementos do array.

Vamos dizer que queremos adicionar 10 pontos a cada pontuação de qualidade porque estamos bêbados e nos sentimos generosos. Eis como o faríamos:

wines + 10

array()

Note que a operação acima não irá alterar o array wines – irá retornar um novo array unidimensional onde 10 foi adicionado a cada elemento da coluna de qualidade dos vinhos.

Se em vez disso fizéssemos +=, modificaríamos o array no lugar:

wines += 10wines

array()

Todas as outras operações funcionam da mesma forma. Por exemplo, se quisermos multiplicar cada uma das pontuações de qualidade por 2, poderíamos fazê-lo assim:

wines * 2

array()

Multiple Array Math

É possível também fazer operações matemáticas entre arrays. Isto irá aplicar a operação aos pares de elementos. Por exemplo, se adicionarmos a coluna quality a si mesma, eis o que obtemos:

wines + wines

array()

Nota que isto é equivalente a wines * 2 – isto porque NumPy adiciona cada par de elementos. O primeiro elemento do primeiro array é adicionado ao primeiro elemento do segundo array, o segundo ao segundo, e assim por diante.

Também podemos usar isto para multiplicar os arrays. Digamos que queremos escolher um vinho que maximize o teor alcoólico e a qualidade (queremos ficar bêbados, mas temos classe). Multiplicaríamos alcohol por quality, e seleccionaríamos o vinho com a pontuação mais alta:

wines * wines

array()

Todas as operações comuns (/, *, -, +, ^) funcionarão entre arrays.

Broadcasting

A menos que as arrays em que está a operar sejam exactamente do mesmo tamanho, não é possível fazer operações por elementos. Em casos como este, a NumPy realiza transmissões para tentar combinar elementos. Essencialmente, a transmissão envolve alguns passos:

• A última dimensão de cada array é comparada.
  • Se os comprimentos das dimensões forem iguais, ou se uma das dimensões for de comprimento 1, então continuamos.
  • Se os comprimentos das dimensões não forem iguais, e nenhuma das dimensões tiver comprimento 1, então há um erro.
• Continuar verificando dimensões até que a menor dimensão do array esteja fora das dimensões.

Por exemplo, as duas formas seguintes são compatíveis:

A: (50,3)B (3,)

Isto é porque o comprimento da dimensão do array do trailing A é 3, e o comprimento da dimensão do array do trailing B é 3. Eles são iguais, então essa dimensão é ok. Array B está então fora dos elementos, então estamos bem, e os arrays são compatíveis para operações matemáticas.

As duas formas seguintes também são compatíveis:

A: (1,2)B (50,2)

A última dimensão corresponde, e A é de comprimento 1 na primeira dimensão.

Estas duas matrizes não combinam:

A: (50,50)B: (49,49)

Os comprimentos das dimensões não são iguais, e nenhuma das matrizes tem um comprimento de dimensão igual a 1.

Existe aqui uma explicação detalhada da transmissão, mas vamos passar por alguns exemplos para ilustrar o princípio:

wines * np.array()

------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython -input-40-821086ccaf65> in <module>()----> 1 wines * np.array()ValueError: operands could not be broadcast together with shapes (1599,12) (2,)</module></ipython>

O exemplo acima não funcionou porque as duas matrizes não têm uma dimensão de trailing correspondente. Aqui está um exemplo em que a última dimensão corresponde:

array_one = np.array( , ])array_two = np.array()array_one + array_two

array(,])

Como você pode ver, array_two foi transmitida através de cada linha de array_one. Aqui está um exemplo com o nosso wines data:

rand_array = np.random.rand(12)wines + rand_array

array(,,,...,,,])

Elementos de rand_array são transmitidos através de cada linha de wines, portanto a primeira coluna de wines tem o primeiro valor em rand_array adicionado a ele, e assim por diante.

NumPy Array Methods

Além das operações matemáticas comuns, NumPy também tem vários métodos que você pode usar para cálculos mais complexos em arrays. Um exemplo disso é o método numpy.ndarray.sum. Isto encontra a soma de todos os elementos em um array por padrão:

wines.sum()

9012.0

O total de todas as nossas classificações de qualidade é 154.1788. Podemos passar o argumento axis para o método sum para encontrar somas sobre um eixo. Se chamarmos sum através da matriz wines, e passarmos em axis=0, vamos encontrar as somas sobre o primeiro eixo da matriz. Isto nos dará a soma de todos os valores em cada coluna. Isto pode parecer ao contrário que as somas sobre o primeiro eixo nos dariam a soma de cada coluna, mas uma maneira de pensar sobre isto é que o eixo especificado é aquele que “vai embora”. Então se especificarmos axis=0, queremos que as linhas desapareçam, e queremos encontrar as somas para cada um dos eixos restantes em cada linha:

wines.sum(axis=0)

array()

Podemos verificar que fizemos a soma correctamente verificando a forma. A forma deve ser 12, correspondente ao número de colunas:

wines.sum(axis=0).shape

(12,)

Se passarmos em axis=1, encontraremos as somas sobre o segundo eixo do array. Isto nos dará a soma de cada linha:

wines.sum(axis=1)

array()

Existem vários outros métodos que se comportam como o método sum, incluindo:

• numpy.ndarray.mean – encontra a média de um array.
• numpy.ndarray.std – encontra o desvio padrão de um array.
• numpy.ndarray.min – encontra o valor mínimo em um array.
• numpy.ndarray.max – encontra o valor máximo em um array.

Você pode encontrar uma lista completa de métodos de array aqui.

NumPy Array Comparisons

NumPy torna possível testar se as linhas correspondem a certos valores usando operações de comparação matemática como <, >, >=, <=, e ==. Por exemplo, se quisermos ver quais vinhos têm uma classificação de qualidade superior a 5, podemos fazer isto:

wines > 5

array(, dtype=bool)

>

Obtemos um conjunto booleano que nos diz quais dos vinhos têm uma classificação de qualidade superior a 5. Podemos fazer algo semelhante com os outros operadores. Por exemplo, podemos ver se algum vinho tem uma classificação de qualidade igual a 10:

wines == 10

array(, dtype=bool)

Subsetting

Uma das coisas poderosas que podemos fazer com um array Booleano e um array NumPy é selecionar apenas certas linhas ou colunas no array NumPy. Por exemplo, o código abaixo apenas selecionará linhas em wines onde a qualidade é superior a 7:

high_quality = wines > 7wines

array(,,])

Selecionamos apenas as linhas onde high_quality contém um valor True, e todas as colunas. Este subconjunto torna simples filtrar arrays para certos critérios. Por exemplo, podemos procurar por vinhos com muito álcool e de alta qualidade. A fim de especificar várias condições, temos de colocar cada condição entre parênteses, e separar as condições com um sinal de ampersand (&):

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines

array(,,,,,,,,,,,,,,,])

Podemos combinar o subconjunto e a atribuição para sobrepor certos valores num array:

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines = 20

Reestruturação de Arrays NumPy

Podemos alterar a forma dos arrays, preservando todos os seus elementos. Isso muitas vezes pode facilitar o acesso aos elementos de array. A remodelação mais simples é inverter os eixos, assim as linhas tornam-se colunas, e vice-versa. Nós podemos fazer isso com a função numpy.transpose:

np.transpose(wines).shape

(12, 1599)

Nós podemos usar a função numpy.ravel para transformar um array em uma representação unidimensional. Ele irá essencialmente achatar um array em uma longa seqüência de valores:

wines.ravel()

array()

Aqui está um exemplo onde podemos ver a ordenação de numpy.ravel:

array_one = np.array( , ])array_one.ravel()

array()

Finalmente, podemos usar a função numpy.reshape para reformular um array para uma determinada forma que especificamos. O código abaixo irá transformar a segunda linha de wines em um array bidimensional com 2 linhas e 6 colunas:

wines.reshape((2,6))

array(,])

Combinando Arrays NumPy

Com NumPy, é muito comum combinar múltiplos arrays em um único array unificado. Podemos usar o numpy.vstack para empilhar verticalmente múltiplas arrays. Pense nisso como os itens da segunda arrays sendo adicionados como novas linhas ao primeiro array. Podemos ler no conjunto de dados winequality-white.csv, que contém informação sobre a qualidade dos vinhos brancos, e depois combiná-lo com o nosso conjunto de dados existente, wines, que contém informação sobre vinhos tintos.

No código abaixo, nós:

• Ler em winequality-white.csv.
• Exibir a forma de white_wines.

white_wines = np.genfromtxt("winequality-white.csv", delimiter=";", skip_header=1)white_wines.shape

(4898, 12)

Como pode ver, nós temos atributos para 4898 vinhos. Agora que temos os dados dos vinhos brancos, podemos combinar todos os dados do vinho.

No código abaixo, nós:

• Utilizar a função vstack para combinar wines e white_wines.
• Exibir a forma do resultado.

all_wines = np.vstack((wines, white_wines))all_wines.shape

(6497, 12)

Como pode ver, o resultado tem 6497 linhas, que é a soma do número de linhas em wines e o número de linhas em red_wines.

Se quisermos combinar arrays horizontalmente, onde o número de linhas permanece constante, mas as colunas estão unidas, então podemos usar a função numpy.hstack. As arrays que combinamos precisam ter o mesmo número de linhas para isso funcionar.

Finalmente, podemos usar o numpy.concatenate como uma versão de propósito geral de hstack e vstack. Se quisermos concatenar dois arrays, passamos para concatenate, então especifique o argumento axis da palavra-chave que queremos concatenar junto. A concatenação ao longo do primeiro eixo é semelhante a vstack, e a concatenação ao longo do segundo eixo é semelhante a hstack:

np.concatenate((wines, white_wines), axis=0)

array(,,,...,,,])

Free NumPy Cheat Sheet

Se você estiver interessado em aprender mais sobre NumPy, confira nosso curso interativo sobre NumPy e Pandas. Você pode se registrar e fazer as primeiras missões gratuitamente.

Você também pode querer levar suas habilidades de NumPy para o próximo nível com nossa folha de trapaças NumPy gratuita!

Outras leituras

Você agora deve ter um bom domínio de NumPy, e como aplicá-lo a um conjunto de dados.

Se você quiser mergulhar em mais profundidade, aqui estão alguns recursos que podem ser úteis:

• NumPy Quickstart – tem bons exemplos de código e cobre a maioria das funcionalidades básicas da NumPy.
• Python NumPy Tutorial – um ótimo tutorial sobre NumPy e outras bibliotecas Python.
• Introdução Visual NumPy – um guia que usa o jogo da vida para ilustrar conceitos NumPy.

Em nosso próximo tutorial, mergulharemos mais em Pandas, uma biblioteca que se baseia em NumPy e torna a análise de dados ainda mais fácil. Ela resolve dois dos maiores pontos de dor que são:

• Você não pode misturar vários tipos de dados em um array.
• Você tem que lembrar que tipo de dados cada coluna contém.