Búsqueda de sitios web

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

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.

¿Cuál es la diferencia entre objeto mutable/inmutable?
Objetos mutables
  1. Objetos cuyo estado se puede cambiar una vez creado, como agregar, actualizar o eliminar elementos.
  2. Listas, diccionarios, conjuntos y bytearray son tipos de objetos mutables en Python.
Objetos inmutables
  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.
¿Cuál es la diferencia entre estructura de datos homogénea/heterogénea?
  1. Estructura de datos homogénea: los elementos de datos serán del mismo tipo de datos (por ejemplo, matriz).
  2. Estructura de datos heterogénea: los elementos de datos pueden no ser del mismo tipo de datos (por ejemplo, lista, tuplas, conjuntos, etc.).
¿Qué son los tipos de datos primitivos y no primitivos?

Antes de comprender la funcionalidad de la estructura de datos integrada, veamos algunas funciones integradas 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, un conjunto o un 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, un diccionario, etc.
  • tipo(obj): la función tipo() devuelve el tipo de objeto o devuelve un nuevo tipo de objeto según los argumentos pasados.
  • id(): esta función devuelve la "identidad" de un objeto. Se trata de un número entero que se garantiza que será único y constante para este objeto durante su vida.

Ahora que ha visto algunos detalles importantes, continúemos 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 integrada incluye LISTA, DICCIONARIO, 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 contendrá datos de un tipo particular únicamente (int, float, etc.). Para usar una matriz, debe importar la matriz explícitamente desde el módulo "matriz".

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

LISTA

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”? Lista puede almacenar cadenas, números enteros, valores de punto flotante, listas anidadas, etc.

Los objetos Lista son “mutables”, lo que significa que se puede acceder a los elementos creados dentro de la lista, modificarlos o eliminarlos. Lista de indexación de soporte. Cada elemento de las listas está asignado a una dirección y esa dirección se puede utilizar para acceder o modificar el valor del elemento en particular.

  • Crear una lista
  • Insertar/Acceder/Modificar lista
  • Eliminar lista

CREAR LISTA

La lista se puede crear usando 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 list 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']

INSERTAR/ACCEDER/MODIFICAR LISTA

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 indicó, 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 utilizar el corte 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 apariciones de 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 determinado utilizando 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']

BORRAR LISTA

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 que una lista esté vacía asignando el nombre de la lista entre 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 vaciar la lista 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 segmento.

>>> 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. Se trata de un número entero que se garantiza que será único y constante para este objeto durante su vida.

>>> 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)
Resumen

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 comprensión de listas en Python, que proporciona una forma más concisa y legible de crear una lista.