Aprenda la estructura de datos de la lista de Python - Parte 1


La estructura de datos es una colección de tipos de datos, la relación entre ellos y las funciones u operaciones que se pueden aplicar a los datos. El tipo de datos puede ser cadena, entero, valor flotante, etc.

  1. Objetos cuyo estado se puede cambiar una vez creado, como agregar, actualizar o eliminar elementos.
  2. Lists, Dictionary, Set, bytearray son tipos de objetos mutables en Python.

  1. El estado del objeto no se puede modificar. Una vez creado el objeto, no podemos agregar, eliminar ni actualizar elementos.
  2. String, Integer, Tuples, Frozenset son algunos de los tipos de objetos inmutables en Python.

  1. Estructura de datos homogénea: los elementos de datos serán del mismo tipo de datos (p. ej., matriz).
  2. Estructura de datos heterogénea: los elementos de datos pueden no ser del mismo tipo de datos (p. ej., lista, tuplas, conjuntos, etc.).

Antes de comprender la funcionalidad de la estructura de datos incorporada, veamos algunas funciones incorporadas que se utilizarán con objetos de estructura de datos.

  • dir (obj): una función incorporada que devolverá el atributo y los métodos.
  • len (obj): devuelve la longitud (el número de elementos) de un objeto. El argumento puede ser una secuencia (como una cadena, bytes, tupla, lista o rango) o una colección (como un diccionario, conjunto o conjunto congelado).
  • del: esta palabra clave incorporada se utiliza para eliminar un objeto de un espacio de nombres o eliminar elementos de un objeto como una lista, diccionario, etc.
  • type (obj): la función type() devuelve el tipo del objeto o devuelve un nuevo tipo de objeto en función de los argumentos pasados.
  • id(): esta función devuelve la "identidad" de un objeto. Este es un número entero que se garantiza que será único y constante para este objeto durante su vida útil.

Ahora, como ha visto algunos detalles importantes, continuemos con las estructuras de datos de Python.

Python viene con estructuras de datos integradas y los usuarios pueden definir sus propias estructuras de datos. La estructura de datos incorporada incluye LIST, DICTIONARY, TUPLE y SET. Algunos de los ejemplos de estructuras de datos definidas por el usuario son STACK, QUEUES, TREE, HASHMAP, etc.

Las personas que provienen de otros lenguajes de programación estarán muy familiarizadas con un tipo de matriz. Pero en Python, no son tan comunes.

Aquí la lista es algo similar a una matriz, pero la lista nos permite almacenar valores de cualquier tipo de datos (heterogéneos) mientras que la matriz solo contendrá datos de un tipo particular (int, float, etc.). Para usar la matriz, debe importar la matriz desde el módulo "matriz" explícitamente.

En esta serie de artículos de Python, veremos qué es una estructura de datos y una estructura de datos incorporada en Python.

La lista es una estructura de datos que es una colección de diferentes tipos de datos. ¿Qué significa "recopilación de diferentes tipos de datos"? La lista puede almacenar cadenas, números enteros, valores de punto flotante, lista anidada, etc.

Los objetos de la lista son "Mutables", lo que significa que se puede acceder, modificar o eliminar los elementos creados dentro de la lista. Lista de indexación de soporte. Cada artículo de las listas se asigna a una dirección y esa dirección se puede utilizar para acceder o modificar el valor del artículo en particular.

  • Cree una lista
  • Insertar/acceder/modificar lista
  • Eliminar lista

La lista se puede crear utilizando corchetes.

>>> 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 la función incorporada type() para verificar el tipo de objeto.

>>> type(name)

Podemos acceder a los métodos y atributos de la instancia de la lista usando la función 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 averiguar el número total de elementos en la lista usando el método len() .

>>> len(name)

Podemos crear una nueva lista a partir de una lista existente usando el método list.copy() .

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

Podemos insertar un elemento en una lista en cualquier posición usando el 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 el método list.append (x) para agregar un solo elemento a la lista. Esto insertará el elemento al final de la lista.

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

Podemos usar el método list.extend() para agregar varios elementos a la lista.

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

También podemos usar el operador + para combinar dos listas. Ambas listas pueden ser de diferentes tipos de datos.

>>> 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 ya se ha dicho, los objetos de las listas son mutables. Un elemento de la lista se puede modificar haciendo referencia a la posición del índice y asignándole un valor.

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

La lista admite indexación tanto positiva como negativa.

La indexación comienza desde 0 y la indexación negativa comienza desde -1.

Podemos acceder al elemento de la lista usando su posición de í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'

También podemos usar la división para acceder a los elementos de la lista. El corte nos permite acceder a una variedad de elementos definiendo los parámetros de paso inicial y final.

# 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 el número de ocurrencias para un valor dado usando el método list.count (x) .

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

Podemos encontrar la posición del índice de un elemento dado usando el 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 el método list.reverse() para invertir los elementos de la lista.

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

Podemos usar el método list.pop (x) para eliminar un elemento de una lista en la posición x . Esta función eliminará el elemento de la lista y mostrará el elemento eliminado. Si no se especifica x , el método pop() devolverá el último elemento de la 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'

También podemos usar el método list.remove (x) para eliminar el elemento de la lista. Aquí x toma el valor del elemento y arroja un ValueError si x no está en la 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 hacer una lista vacía asignando el nombre de la lista a corchetes o usando el 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
[]

En lugar de usar métodos de lista para hacer que la lista esté vacía o eliminar un elemento de la lista, podemos usar la palabra clave incorporada del para realizar estas acciones. La palabra clave "del" puede eliminar un objeto de lista de la memoria o eliminar un elemento de una lista o eliminar un elemento de un sector.

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

La función id() incorporada devuelve la "identidad" de un objeto. Este es un número entero que se garantiza que es único y constante para este objeto durante su 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: hemos eliminado la variable de lista de la memoria usando del() , por lo que arroja un error de nombre.

help() funtion:

La ayuda integrada function() es muy útil para obtener detalles sobre un objeto en particular o los métodos de ese objeto.

help(object)
help(object.method)

Hasta ahora en este artículo, hemos visto cómo podemos usar una estructura de datos de lista para almacenar, acceder, modificar y eliminar objetos de lista utilizando los métodos de lista. También hemos visto algunas funciones integradas como id(), dir(), type(), help() que son funciones muy efectivas. También tenemos la comprensión de listas en Python, que proporciona una forma más concisa y legible de crear una lista.