Pesquisa de site

Aprenda a estrutura de dados da lista Python - Parte 1

Estrutura de dados é uma coleção de tipos de dados, o relacionamento entre eles e as funções ou operações que podem ser aplicadas aos dados. O tipo de dados pode ser string, Inteiro, Valor flutuante e assim por diante.

Qual é a diferença entre objeto Mutável/Imutável?
Objetos Mutáveis
  1. Objetos cujo estado pode ser alterado depois de criado, como adicionar, atualizar ou excluir elementos.
  2. Listas, Dicionário, Conjunto, bytearray são tipos de objetos mutáveis em python.
Objetos Imutáveis
  1. O estado do objeto não pode ser modificado. Uma vez criado o objeto, não podemos adicionar, remover ou atualizar elementos.
  2. String, Integer, Tuples, Frozenset são alguns dos tipos de objetos imutáveis em python.
Qual é a diferença entre estrutura de dados homogênea/heterogênea?
  1. Estrutura de dados homogênea – Os elementos de dados serão do mesmo tipo de dados (ex: Array).
  2. Estrutura de dados heterogênea – Os elementos de dados podem não ser do mesmo tipo de dados (ex: Lista, Tuplas, Conjuntos etc…).
O que são tipos de dados primitivos e não primitivos?

Antes de compreender a funcionalidade da estrutura de dados integrada, vamos ver algumas funções integradas que serão usadas com objetos de estrutura de dados.

  • dir(obj) – uma função integrada que retornará o atributo e os métodos.
  • len(obj) – Retorna o comprimento (o número de itens) de um objeto. O argumento pode ser uma sequência (como uma string, bytes, tupla, lista ou intervalo) ou uma coleção (como um dicionário, conjunto ou conjunto congelado).
  • del – Esta palavra-chave integrada é usada para excluir um objeto de um namespace ou remover itens de um objeto como uma lista, dicionário, etc.
  • type(obj) – A função type() retorna o tipo do objeto ou retorna um novo tipo de objeto com base nos argumentos passados.
  • id() – Esta função retorna a “identidade” de um objeto. Este é um número inteiro garantido como único e constante para este objeto durante sua vida útil.

Agora que você viu alguns detalhes importantes, vamos prosseguir com as estruturas de dados python.

Python vem com estruturas de dados integradas e os usuários podem definir suas próprias estruturas de dados. A estrutura de dados integrada inclui LIST, DICTIONARY, TUPLE e SET. Alguns dos exemplos de estruturas de dados definidas pelo usuário são STACK, QUEUES, TREE, HASHMAP, etc…

Pessoas vindas de outras linguagens de programação estarão muito familiarizadas com um tipo de array. Mas em python, eles não são tão comuns.

Aqui, a lista é semelhante a um array, mas a lista nos permite armazenar valores de qualquer tipo de dados (heterogêneo), enquanto o array conterá apenas dados de um tipo específico (int, float etc…). Para usar array você deve importar explicitamente o array do módulo “array”.

Nesta série de artigos sobre Python, veremos o que é uma estrutura de dados e uma estrutura de dados integrada em Python.

LISTA

Lista é uma estrutura de dados que é uma coleção de diferentes tipos de dados. O que significa “coleta de diferentes tipos de dados”? Lista pode armazenar strings, inteiros, valores de ponto flutuante, lista aninhada e assim por diante.

Os objetos Lista são “Mutáveis”, o que significa que os itens criados dentro da lista podem ser acessados, modificados ou excluídos. Indexação de suporte de lista. Cada item nas listas é atribuído a um endereço e esse endereço pode ser usado para acessar ou modificar o valor do item específico.

  • Crie uma lista
  • Lista Inserir/Acessar/Modificar
  • Excluir lista

CRIAR LISTA

A lista pode ser criada usando colchetes.

>>> name_empty = []			# Empty list
>>> name = ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']	# list with string data type
>>> name_int = [1,2,3]			# list with Integer data type
>>> name_mixed = [name_int,name,1,2,3.14]	# list with nested list items.
>>> name_mixed
[[1, 2, 3], ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'], 1, 2, 3.14]
>>> name_int
[1, 2, 3]

Podemos usar a função type() embutida para verificar o tipo de objeto.

>>> type(name)

Podemos acessar os métodos e atributos da instância list usando a função dir().

>>> dir(name)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Podemos descobrir o número total de itens na lista usando o método len().

>>> len(name)

Podemos criar uma nova lista a partir de uma lista existente usando o método list.copy().

>>> name_new = name.copy()
>>> name_new
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']

INSERINDO/ACESSANDO/MODIFICANDO LISTA

Podemos inserir um item em uma lista em qualquer posição usando o método list.insert(i, x).

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> name
['Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.insert(0,'Tom')	# Insert method takes 2 arguments (Index position, Item)
>>> name
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']	# Tom is inserted at the 0th position.

Podemos usar o método list.append(x) para anexar um único item à lista. Isso irá inserir o item no final da lista.

>>> name = []
>>> len(name)
0
>>> name.append('Leo')
>>> name.append('Matt')
>>> name.append('Kane')
>>> print(name)
['Leo', 'Matt', 'Kane']

Podemos usar o método list.extend() para adicionar vários itens à lista.

>>> new_name = ['Gowtham','Martin','Luis']
>>> name.extend(new_name)
>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']

Também podemos usar o operador '+' para combinar duas listas. Ambas as listas podem ser de diferentes tipos de dados.

>>> a = [1,2,3]
>>> b = [2,3,3]
>>> c = a + b
>>> c
[1, 2, 3, 2, 3, 3]
>>> d = ['karthi','kenny']
>>> e = a + d
>>> e
[1, 2, 3, 'karthi', 'kenny']

Como já foi dito, os objetos das listas são mutáveis. Um item da lista pode ser modificado referenciando a posição do índice e atribuindo valor a ele.

>>> name									# Before modified
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name[0] = 'Karthi'
>>> name									# After Modified
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']

A lista suporta indexação positiva e negativa.

A indexação começa em 0 e a indexação negativa começa em -1.

Podemos acessar o item da lista usando sua posição no índice.

>>> name[0]			# Accessing the List item at index 0
'Leo'
>>> name[1]
'Matt'
>>> name[4]
'Petter'
>>> name[5]
'Will'
>>> name[-1]			# Accessing the list item with negative indexing
'Will'
>>> name[-6]
'Leo'

Também podemos usar o fatiamento para acessar os itens da lista. O fatiamento nos permite acessar uma variedade de itens definindo os parâmetros inicial e final da etapa.

SYNTAX: list[starting position, ending position, Step]

>>> name[0:3]
['Tom', 'Leo', 'Matt']
>>> name[:]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name[:4]
['Tom', 'Leo', 'Matt', 'Kane']
>>> name[:-2]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott']
>>> name[:-1]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter']
>>> name[:-1:2]
['Tom', 'Matt', 'Scott']

Podemos encontrar o número de ocorrências para um determinado valor usando o método list.count(x).

>>> name_int = [1,1,2,3,1]
>>> name_int.count(1)
3

Podemos encontrar a posição do índice de um determinado item usando o método list.index(x[, start[, end]]).

>>> name			# Inserted ‘Will’ at the end of the list. Now we have 2 name ‘Will’.
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will']
>>> name.index('Will)	# Returns the index position of first occurence of x.
0
>>> name.index('Will',2)	# Starting index positon’2’ is given.
7
>>> name.index('Will',2,4)	# Starting and Ending Index position is given. Since there is no 					occurence of ‘Will’ within the given search position it will throw 					Value Error.
Traceback (most recent call last):
File "<stdin>", line 1, in 
ValueError: 'Will' is not in list

Podemos usar o método list.reverse() para reverter os itens da lista.

>>> name
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.reverse()
>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi']

EXCLUIR LISTA

Podemos usar o método list.pop(x) para remover um item de uma lista na posição x. Esta função removerá o item da lista e exibirá o item removido. Se x não for especificado, o método pop() retornará o último item da lista.

>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']
>>> name.pop(0)
'Will'
>>> name
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']
>>> name.pop()
'Luis'

Também podemos usar o método list.remove (x) para remover o item da lista. Aqui x pega o valor do item e lança um ValueError se x não estiver na lista.

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> name.remove('Leo')
>>> name
['Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.remove('Leo')
Traceback (most recent call last):
  File "", line 1, in 
ValueError: list.remove(x): x not in list

Podemos esvaziar uma lista atribuindo o nome da lista entre colchetes ou usando o método list.clear().

>>> name1 = name.copy()
>>> name1
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin']
>>> name
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin']
>>> name = []			
>>> name
[]
>>> name1.clear()		
>>> name1
[]

Em vez de usar métodos de lista para esvaziar a lista ou remover um item da lista, podemos usar a palavra-chave incorporada del para executar essas ações. A palavra-chave “del” pode excluir um objeto de lista da memória ou excluir um item de uma lista ou excluir um item de uma fatia.

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> del name[0]
>>> name
['Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> del name[-3:]
>>> name
['Matt', 'Kane']
>>> del name[:]
>>> name
[]

A função id() integrada retorna a “identidade” de um objeto. Este é um número inteiro garantido como único e constante para este objeto durante sua vida útil.

>>> id(name)
139979929658824
>>> del name
>>> id(name)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'name' is not defined

Nota: removemos a variável de lista da memória usando del(), portanto gera erro de nome.

help() funtion:

A ajuda integrada function() é muito útil para obter detalhes sobre um objeto específico ou métodos desse objeto.

help(object)
help(object.method)
Resumo

Até agora neste artigo, vimos como podemos usar uma estrutura de dados de lista para armazenar, acessar, modificar e excluir objetos de lista usando os métodos de lista. Também vimos algumas funções integradas como id(), dir(), type(), help()< que são funções muito eficazes. Também temos compreensão de lista em python, que fornece uma maneira mais concisa e legível de criar uma lista.