Guia para matrizes em Python

Introdução

Imagine que você tem uma playlist com suas músicas favoritas no seu celular. Esta lista de reprodução é uma lista onde cada música é colocada em uma ordem específica. Você pode tocar a primeira música, pular para a segunda, pular para a quinta e assim por diante. Esta lista de reprodução é muito parecida com um array na programação de computadores.

Arrays são uma das estruturas de dados mais fundamentais e amplamente utilizadas.

Em essência, um array é uma forma estruturada de armazenar vários itens (como números, caracteres ou até mesmo outros arrays) em uma ordem específica, e você pode acessar, modificar ou remover rapidamente qualquer item se souber sua posição (índice).

Neste guia, forneceremos uma visão geral abrangente da estrutura de dados do array. Em primeiro lugar, veremos o que são arrays e quais são suas principais características. Em seguida, faremos a transição para o mundo do Python, explorando como os arrays são implementados, manipulados e aplicados em cenários do mundo real.

Compreendendo a estrutura de dados do array

Arrays estão entre as estruturas de dados mais antigas e fundamentais usadas em ciência da computação e programação. Sua simplicidade, combinada com sua eficiência em determinadas operações, os torna um tópico básico para qualquer pessoa que se aprofunde no domínio do gerenciamento e manipulação de dados.

Um array é uma coleção de itens, normalmente do tipo mesmo tipo, armazenado em locais de memória contíguos.

Esse armazenamento contíguo permite que os arrays forneçam acesso em tempo constante a qualquer elemento, dado seu índice. Cada item de um array é chamado de elemento, e a posição de um elemento na matriz é definida por seu índice, que normalmente começa do zero.

Por exemplo, considere uma matriz de inteiros: [10, 20, 30, 40, 50]. Aqui, o elemento 20 tem um índice de 1:

Existem múltiplos vantagens de usar arrays para armazenar nossos dados. Por exemplo, devido ao seu layout de memória, os arrays permitem O (1) Complexidade de tempo (constante) ao acessar um elemento por seu índice. Isto é particularmente benéfico quando precisamos de acesso aleatório aos elementos. Além disso, as matrizes são armazenadas em locais de memória contíguos, o que pode levar a uma melhor localização do cache e melhorias gerais de desempenho em determinadas operações. Outra vantagem notável do uso de arrays é que, como os arrays têm um tamanho fixo depois de declarados, é mais fácil gerenciar a memória e evitar estouros inesperados ou erros de falta de memória.

Por outro lado, os arrays vêm com seu próprio conjunto de limitações. Uma das principais limitações dos arrays tradicionais é a sua tamanho fixo. Depois que um array é criado, seu tamanho não pode ser alterado. Isso pode levar a problemas como desperdício de memória (se o array for muito grande) ou necessidade de redimensionamento (se o array for muito pequeno). Além disso, inserir ou excluir um elemento no meio de um array requer deslocamento de elementos, levando a O (n) complexidade de tempo para essas operações.

Para resumir tudo isso, vamos ilustrar as principais características dos arrays usando o exemplo da lista de reprodução de músicas do início deste guia. Uma matriz é uma estrutura de dados que:

• Está indexado: Assim como cada música da sua playlist possui um número (1, 2, 3,…), cada elemento de um array possui um índice. Mas, na maioria das linguagens de programação, o índice começa em 0. Assim, o primeiro item está no índice 0, o segundo no índice 1 e assim por diante.

• Tem tamanho fixo: quando você cria uma lista de reprodução para, digamos, 10 músicas, não é possível adicionar uma 11ª música sem remover uma primeiro. Da mesma forma, os arrays têm um tamanho fixo. Depois de criar uma matriz de determinado tamanho, você não poderá adicionar mais itens do que sua capacidade.

• É homogêneo: todas as músicas da sua lista de reprodução são faixas musicais. Da mesma forma, todos os elementos de uma matriz são do mesmo tipo. Se você tiver uma matriz de números inteiros, não poderá armazenar repentinamente uma sequência de texto nela.

• Tem acesso direto: Se quiser ouvir a 7ª música da sua playlist, você pode pular diretamente para ela. Da mesma forma, com arrays, você pode acessar instantaneamente qualquer elemento se conhecer seu índice.

• Memória Contígua: Isso é um pouco mais técnico. Quando um array é criado na memória de um computador, ele ocupa um bloco contínuo de memória. Pense nisso como uma fileira de armários adjacentes na escola. Cada armário fica ao lado do outro, sem espaços entre eles.

Python e matrizes

Python, conhecido por sua flexibilidade e facilidade de uso, oferece diversas maneiras de trabalhar com arrays. Embora Python não tenha uma estrutura de dados de array nativa como algumas outras linguagens, ele fornece alternativas poderosas que podem funcionar de forma semelhante e até mesmo oferecer recursos estendidos.

À primeira vista, Lista de Python pode parecer sinônimo de array, mas há diferenças e nuances sutis a serem consideradas:

Lista	Ordem
Uma estrutura de dados Python integrada	Não são nativos em Python – eles vêm do módulo `array`
Tamanho dinâmico	Tamanho fixo (predefinido)
Pode conter itens de diferentes tipos de dados	Guarde itens do mesmo tipo
Fornece uma variedade de métodos integrados para manipulação	Precisa importar módulos externos
O(1) complexidade de tempo para operações de acesso	O(1) complexidade de tempo para operações de acesso
Consumir mais memória	Mais eficiência de memória

Olhando para esta tabela, é natural perguntar – “Quando usar qual?”. Bem, se você precisa de uma coleção que possa aumentar ou diminuir dinamicamente e que possa conter tipos de dados mistos, a lista do Python é a melhor opção. No entanto, para cenários que exigem uma coleção mais eficiente em termos de memória com elementos do mesmo tipo, você pode considerar usar o Python array módulo ou bibliotecas externas como NumPy.

A ordem Módulo em Python

Quando a maioria dos desenvolvedores pensa em arrays em Python, eles geralmente pensam em listas. No entanto, Python oferece uma estrutura de array mais especializada por meio de seu recurso integrado array módulo. Este módulo fornece um armazenamento com uso eficiente de espaço de tipos de dados básicos de estilo C em Python.

Embora as listas Python sejam incrivelmente versáteis e possam armazenar qualquer tipo de objeto, às vezes elas podem ser um exagero, especialmente quando você só precisa armazenar uma coleção de tipos de dados básicos, como inteiros ou flutuantes. O array O módulo fornece uma maneira de criar matrizes que são mais eficientes em termos de memória do que listas para tipos de dados específicos.

Criando uma matriz

Para usar o array módulo, primeiro você precisa importá-lo:

from array import array

Depois de importado, você pode criar um array usando o array() construtor:

arr = array('i', [1, 2, 3, 4, 5])
print(arr)

Aqui o 'i' argumento indica que a matriz armazenará sinais inteiros. Existem vários outros códigos de tipo disponíveis, como 'f' para carros alegóricos e 'd' para duplas.

Acessando e Modificando Elementos

Você pode acessar e modificar elementos em um array da mesma forma que faria com uma lista:

print(arr[2]) 

E agora, vamos modificar o elemento alterando seu valor para 6:

arr[2] = 6
print(arr) 

Métodos Array

A array O módulo fornece vários métodos para manipular arrays:

• append() – Adiciona um elemento ao final do array:

  arr.append(7)
  print(arr) 

• extend() – Acrescenta elementos iteráveis ​​ao final:

  arr.extend([8, 9])
  print(arr) 

• pop() – Remove e retorna o elemento na posição dada:

  arr.pop(2)
  print(arr) 

• remove(): Remove a primeira ocorrência do valor especificado:

  arr.remove(2)
  print(arr) 

• reverse(): Inverte a ordem da matriz:

  arr.reverse()
  print(arr) 

Enquanto o array oferece uma maneira mais eficiente de armazenar tipos de dados básicos, é essencial lembrar sua limitações. Ao contrário das listas, os arrays são homogêneo. Isso significa que todos os elementos da matriz devem ser do mesmo tipo. Além disso, você só pode armazenar tipos de dados básicos de estilo C em matrizes. Se precisar armazenar objetos personalizados ou outros tipos de Python, você precisará usar uma lista ou outra estrutura de dados.

Matrizes NumPy

NumPy, abreviação de Numerical Python, é um pacote fundamental para cálculos numéricos em Python. Uma de suas principais características é seu poderoso Objeto de matriz N-dimensional, que oferece operações rápidas em arrays, incluindo manipulação matemática, lógica, de formas e muito mais.

Matrizes NumPy são mais versáteis que as matrizes integradas do Python array módulo e são essenciais em projetos de ciência de dados e aprendizado de máquina.

Por que usar matrizes NumPy?

A primeira coisa que vem à mente é atuação. Os arrays NumPy são implementados em C e permitem armazenamento de memória eficiente e operações mais rápidas devido a algoritmos otimizados e aos benefícios do armazenamento de memória contíguo.

Embora as listas e arrays integrados do Python sejam unidimensionais, os arrays NumPy podem ser multidimensional, tornando-os ideais para representar matrizes ou tensores.

Finalmente, NumPy fornece um vasta gama de funções para operar nessas matrizes, desde aritmética básica até operações matemáticas avançadas, remodelação, divisão e muito mais.

Criando uma matriz NumPy

Para usar o NumPy, primeiro você precisa instalá-lo (pip install numpy) e depois importe-o:

import numpy as np

Depois de importado, você pode criar um array NumPy usando o array() função:

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

Você também pode criar matrizes multidimensionais:

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

Isso nos dará:

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

Além dessas maneiras básicas de criar arrays, NumPy nos fornece outras maneiras inteligentes de criar arrays. Um deles é o arange() método. Ele cria matrizes com valores incrementais regularmente:

arr = np.arange(10)
print(arr) 

Outro é o linspace() método, que cria matrizes com um número especificado de elementos, espaçados igualmente entre valores iniciais e finais especificados:

even_space = np.linspace(0, 1, 5)
print(even_space) 

Acessando e Modificando Elementos

Acessar e modificar elementos em um array NumPy é intuitivo:

print(arr[2]) arr[2] = 6
print(arr) 

Fazendo praticamente o mesmo para matrizes multidimensionais:

print(matrix[1, 2]) matrix[1, 2] = 10
print(matrix)

Irá alterar o valor do elemento na segunda linha (índice 1) e a terceira coluna (índice 2):

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

Alterando a forma de um array

NumPy oferece muitas funções e métodos para manipular e operar arrays. Por exemplo, você pode usar o reshape() método para alterar a forma de uma matriz. Digamos que temos um array simples:

import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
print("Original Array:")
print(arr) 

E queremos remodelá-la para uma matriz 3×4. Tudo que você precisa fazer é usar o reshape() método com as dimensões desejadas passadas como argumentos:

reshaped_arr = arr.reshape(3, 4)
print("Reshaped Array (3x4):")
print(reshaped_arr)

Isso resultará em:

Reshaped Array (3x4):
[[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]]

Multiplicação da matriz

A numpy.dot() método é usado para multiplicação da matriz. Ele retorna o produto escalar de duas matrizes. Para matrizes unidimensionais, é o produto Interno das matrizes. Para matrizes bidimensionais, é equivalente a multiplicação da matriz, e para ND, é um soma do produto sobre o último eixo da primeira matriz e o penúltimo da segunda matriz.

Vamos ver como isso funciona. Primeiro, vamos calcular o produto escalar de duas matrizes 1-D (o produto interno dos vetores):

import numpy as np vec1 = np.array([1, 2, 3])
vec2 = np.array([4, 5, 6])
dot_product_1d = np.dot(vec1, vec2) print("Dot product of two 1-D arrays:")
print(dot_product_1d) 

Isso resultará em:

Dot product of two 1-D arrays:
32

32 é, na verdade, o produto interno das duas matrizes – (14 2 +5 + 3*6). A seguir, podemos realizar a multiplicação de matrizes de duas matrizes 2-D:

mat1 = np.array([[1, 2], [3, 4]])
mat2 = np.array([[2, 0], [1, 3]])
matrix_product = np.dot(mat1, mat2) print("Matrix multiplication of two 2-D arrays:")
print(matrix_product) 

O que nos dará:

Matrix multiplication of two 2-D arrays:
[[ 4 6] [10 12]]

Os arrays NumPy são um avanço significativo em relação às listas integradas do Python e ao array módulo, especialmente para cálculos científicos e matemáticos. Sua eficiência, combinada com a rica funcionalidade fornecida pela biblioteca NumPy, torna-os uma ferramenta indispensável para quem deseja realizar operações numéricas em Python.

Conclusão

Os arrays, uma pedra angular da ciência da computação e da programação, provaram seu valor repetidas vezes em vários aplicativos e domínios. Em Python, esta estrutura de dados fundamental, através de suas várias encarnações como listas, o array O módulo e os poderosos arrays NumPy oferecem aos desenvolvedores uma combinação de eficiência, versatilidade e simplicidade.

Ao longo deste guia, viajamos desde os conceitos básicos de arrays até suas aplicações práticas em Python. Vimos como os arrays, com sua natureza contígua à memória, fornecem tempos de acesso rápidos e como as listas dinâmicas do Python trazem uma camada adicional de flexibilidade. Também nos aprofundamos no mundo especializado do NumPy, onde arrays se transformam em ferramentas poderosas para computação numérica.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://stackabuse.com/guide-to-arrays-in-python/