Python — Estructura de datos: Listas, Tuplas

Que son las listas y como usarlas

Una lista en Python es una estructura de datos formada por una secuencia ordenada de objetos y pueden accederse mediante su índice, siendo 0 el índice del primer elemento. Estas son:

heterogéneas: pueden estar conformadas por elementos de distintos tipo, incluidos otras listas.

mutables: sus elementos pueden modificarse.

Ejemplo:

>>> factura = ['pan', 'huevos', 100, 1234]
>>> factura
['pan', 'huevos', 100, 1234]
>>> factura[0]
'pan'
>>> factura[3]
1234

Usando la funcion len()

>>> len(factura)
4
>>> len(factura) - 1
3
>>> factura[-len(factura)]
'pan'

¿Cuáles son las diferencias y similitudes entre strings y listas?

A modo de repaso, recordemos que ambas estructuras son secuencias ordenadas de elementos. Sin embargo, las listas son mutables mientras que las cadenas de texto no. Esto significa que en las listas se puede cambiar, mediante una simple asignación, el elemento que ocupa una cierta posición. Como veremos a continuación, esto no es posible en los strings.

¿Cuáles son los métodos de listas más comunes y cómo usarlos?

append(): Añade un ítem al final de la lista:

>>> lista = [1,2,3,4,5] 
>>> lista.append(6) 
>>> lista
[1, 2, 3, 4, 5, 6]

clear(): Vacía todos los ítems de una lista:

>>> lista.clear() 
>>> lista
[]

extend(): Une una lista a otra:

>>> l1 = [1,2,3] 
>>> l2 = [4,5,6] 
>>> l1.extend(l2) 
>>> l1
[1, 2, 3, 4, 5, 6]

count():Cuenta el número de veces que aparece un ítem:

>>> ["Hola", "mundo", "mundo"].count("Hola")
1

index(): Devuelve el índice en el que aparece un ítem (error si no aparece):

>>> ["Hola", "mundo", "mundo"].index("mundo")
1

insert(): Agrega un ítem a la lista en un índice específico:

>>> l = [1,2,3] 
>>> l.insert(0,0)
>>> l
[0, 1, 2, 3]

pop(): Extrae un ítem de la lista y lo borra:

>>> l = [10,20,30,40,50] 
>>> print(l.pop()) 
>>> print(l)
50
[10, 20, 30, 40]

remove(): Borra el primer ítem de la lista cuyo valor concuerde con el que indicamos:

>>> l = [20,30,30,30,40] 
>>> l.remove(30) 
>>> print(l)
[20, 30, 30, 40]

reverse(): Le da la vuelta a la lista actual:

>>> l.reverse() 
>>> print(l)
[1, 2, 3, 4, 5, 6]

sort(): Ordena automáticamente los ítems de una lista por su valor de menor a mayor:

>>> lista = [5,-10,35,0,-65,100] 
>>> lista.sort() 
>>> lista
[-65, -10, 0, 5, 35, 100]
>>> lista.sort(reverse=True) 
>>> lista
[100, 35, 5, 0, -10, -65]

Cómo usar listas como pilas y colas

PILAS: es un método de estructuración datosusando la forma LIFO (último en entrar, primero en salir), que permite almacenar y recuperar datos. Las operaciones que se pueden realizar con una pila son:

• PUSH (pila, elemento): Introduce un elemento en la pila. También se le conoce como poner o meter.
• POP (pila): Elimina un elemento de la pila. También se le conoce como sacar o quitar.
• VACIA(pila): Función booleana que indica si la pila esta vacía o no.

COLAS: Es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.

Tipos de Colas

• Cola Simple: Estructura lineal donde los elementos salen en el mismo orden en que llegan.
• Cola Circular : Representación lógica de una cola simple en un arreglo.
• Cola de Prioridades: Estructura lineal en la cual los elementos se insertan en cualquier posición de la cola y se remueven solamente por el frente.
• Cola Doble (Bicola) : Estructura lineal en la que los elementos se pueden añadir o quitar por cualquier extremo de la cola (Cola bidireccional).

Operaciones básicas en Colas Simples

• Insertar.- Almacena al final de la cola el elemento que se recibe como parámetro.
• Eliminar.- Saca de la cola el elemento que se encuentra al frente.
• Vacía.- Regresa un valor booleano indicando si la cola tiene o no elementos (true — si la cola esta vacía, false — si la cola tiene al menos un elemento).
• Llena.- Regresa un valor booleano indicando si la cola tiene espacio disponible para insertar nuevos elementos ( true — si esta llena y false si existen espacios disponibles).

¿Qué son las listas por comprensión y cómo usarlas?

Una lista enlazada es una de las estructuras de datos fundamentales, y puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias (punteros) al nodo anterior o posterior. El principal beneficio de las listas enlazadas respecto a los array convencionales es que el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento. Es un tipo de dato auto- referenciado porque contienen un puntero o link a otro dato del mismo tipo. Las listas enlazadas permiten inserciones y eliminación de nodos en cualquier punto de la lista en tiempo constante (suponiendo que dicho punto está previamente identificado o localizado), pero no permiten un acceso aleatorio. Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas Enlazadas Circulares y Listas Enlazadas Doblemente Circulares.

Que son las tuplas y como usarlas

Es una secuencia de valores agrupados, sirve para agrupar, como si fueran un único valor, varios valores que, por su naturaleza, deben ir juntos. El tipo de datos que representa a las tuplas se llama tuple. El tipo tuple es inmutable: una tupla no puede ser modificada una vez que ha sido creada.

>>> persona = ('Perico', 'Los Palotes')
>>> persona
('Perico', 'Los Palotes')

Cuándo usar tuplas versus listas

La diferencia es que las listas presentan una serie de funciones adicionales que permiten un amplio manejo de los valores que contienen. Basándonos en esta definición, puede decirse que las listas son dinámicas, mientras que las tuplas son estáticas.

>>> a = []      # Sí.
>>> b = list()  # No.
>>> a == b      
True

Desempaquetado de tuplas

>>> nombre, apellido = persona
>>> nombre
'Perico'
>>> persona[1]
'Los Palotes'

Comparación de tuplas

>>> (1, 2) == (3 / 2, 1 + 1)
True
>>> (6, 1) == (6, 2)
False
>>> (6, 1) == (6, 1, 0)
False
>>> (1, 4, 7) < (2, 0, 0, 1)
True
>>> (1, 9, 10) < (0, 5)
False

Las tuplas se usan siempre que es necesario agrupar valores. Generalmente, conceptos del mundo real son representados como tuplas que agrupan información sobre ellos.

partido1 = ('Milan', 'Bayern')
def distancia(p1, p2):
    x1, y1 = p1
    x2, y2 = p2
    dx = x2 - x1
    dy = y2 - y1
    return (dx ** 2 + dy ** 2) ** 0.5
>>> a = (2, 3)
>>> b = (7, 15)
>>> distancia(a, b)
13.0
>>> hoy = (2011, 4, 19)
>>> ayer = (2011, 4, 18)
>>> navidad = (2011, 12, 25)
>>> anno_nuevo = (2012, 1, 1)
>>> hoy < ayer
False
>>> hoy < navidad < anno_nuevo
True

Que es una secuencia

Listas y tuplas en Python son objetos que contienen listas de datos a los que se accede mediante un índice, de forma similar a los arreglos (vectores o matrices) de otros lenguajes. Pertenecen a un tipo de datos que Python llama secuencias y que incluyen también a las cadenas de texto.