LENGUAJES. Python

ITERACION

Función enumerate()

El bucle for permite iterar colecciones recorriendo cada uno de sus elementos, pero hay veces en que, además, necesitamos acceder al índice del elemento. En estos casos o bien usamos una estructura que incluya el contador dentro del bucle, o bien recurrimos a la función enumerate().

lista = ["A", "B", "C"]

# Bucle for simple -------------------------------------------------------
'''
for recorre aquí el iterable lista y devuelve (print()) 
la lista de sus elementos
'''
for l in lista:
    print(l)

'''
Salida:
A
B
C
'''

# Iteración más índice. Estructura compleja
'''
Para obtener la iteración asociada a su índice necesitamos 
inicilizar el índice e incluirlo dentro del ciclo
'''

indice = 0
for l in lista:
    print(indice, l)
    indice += 1

'''
Salida:
0 A
1 B
2 C
'''

# Uso de enumerate()
'''
Empleando enumerate() nos ahorramos especificar el contador. 
Éste y el iterador se esciben tras for y separados por una coma.
La salida es la misma de antes
'''
for indice, l in enumerate(lista):
    print(indice, l)

Pero también podemos utilizar numerate() sobre colecciones, generando una lista de tuplas. En cada una de ellas se obtiene el índice y el elemento de la colección.

# Numerate también en listas

en = list(enumerate(lista))
print(en)

'''
Salida:
[(0, 'A'), (1, 'B'), (2, 'C')]
'''

Otro uso posible de numerate() es cadenas, que, como sabemos, también se entienden en Python como iterables.

cadena = "ejemplo" 
for x in enumerate(cadena): 
    print(x)

'''
Salida:
(0, 'e') 
(1, 'j') 
(2, 'e') 
(3, 'm') 
(4, 'p') 
(5, 'l') 
(6, 'o')
'''

Aunque podemos usar nmerate() con un único parámetro (el iterable) (for indice, l in enumerate(lista):), también podemos utilizar un segundo parámetro (for x in enumerate(cadena,1)) , que hace que la numerción del índice empeice por el valor numérico que se usa como segundo parámetro, de modo que, por ejemplo, en el script anterior, la numetación de las letras de la cadena comiencen por 1 ((0,'e') -> pasa a ser (1,'e')).

NOTA: Este contenido se basa en ellibrodepython.com y en www.ionos.es.

LENGUAJES. Python.

Listas. Manejo básico

Colecciones de datos

Las listas son las colecciones nativas de datos más simples y flexibles con las que cuenta Python lo que hace que sean usadas con mucha frecuencia.

Como dije en su presentación, una lista es una colección ordenada y mutables de datos. Además los datos pueden ser de diferentes tipos (caracteres, cadenas, enteros, reales, booleanos) y pueden estar repetidos. Esto, junto con las operaciones permitidas sobre ella, la convierten en un recurso muy flexible.

En este cuaderno te explico cómo trabajar con listas.

LENGUAJES. Python.

Lista como iterable

Colecciones de datos

Ya hemos tenido ocasión de comprobar la utilidad que tiene el uso de un array como iterable en la automatización de procedimientos cuando trabajamos con OOo Basic. Uno de esos iterables en Python son las listas, de ahí el interés por saber iterar por ellas. De hecho la iteración se presenta en Python más sencilla y a la vez más variada en cuanto procedimiento. Y también más potente. Trataremos en esta entrada sobre las diferentes formar de iterar por una lista... y algo más.

Partiendo de la estructura for, la forma más sencilla de iterar es tomar como referente el elemento y como iterable la lista. Así, dada una lista, vg. los curso de E. Primaria cursos = ['P1','P2','P3','P4','P5','P6'] podemos recorrer la lista del siguiente modo:

for curso in cursos:
    print(curso)

Otra forma de iterar es obtener el número de elementos de la lista mediante la función >len() y usar la variable asociada (o la misma expresión) como límite superior del recorrido a realizar (1):

n = len(cursos)

for i in range (n):
    print(cursos[i])

En ocasiones nos puede venir bien recuperar a la vez el dato y el índice que, como elemento, ocupa en la lista. Para estos casos disponemos de un método específico:

for index, curso in enumerate (cursos):
    print(index, curso)

Otra situación especial, que no podemos contemplar como específica en OOo Basic aunque podemos simularla de otro modo, es cuando disponemos de dos o más listas y deseamos iterar por ambas, simultaneándolas:

cursos = ['P1','P2','P3','P4','P5','P6']
intervalos = ['2000/2001','2001/2002','2002/2003','2003/2004','2005/2006','2006/2007']

for curso, intervalo in zip(cursos, intervalos):
    print(intervalo, curso)

Finalmente también podemos iterar secuencialmente (2) por dos o más listas. Para ello primero importamos el módulo itertools y después usamos el método itertools.chain(), como vemos en este ejemplo:

import itertools

for item in itertools.chain(cursos, intervalos):
    print(item)

NOTAS
¹ Obsérvese el modo diferente en que construimos la expresión de escritura en los dos métodos anteriores: en el primero es el referente (contador, si se prefiere, aunque en este caso no es esa su función principal) el que usamos como contenedor del dato print(curso) pero en el segundo identificamos directamente el elemento de la lista mediante su índice, siendo éste el valor actual del contador print(cursos[i]). Como recordarás, este segundo método se asemeja más al modo en que trabajamos en OOo Basic
² Secuencialmente se opone aquí a simultaneo, lo que implica que zip() se opone a itertools.chain(). zip() es una de las funciones built-in que puedes consultar en esta entrada.

LENGUAJES. Python.

Modificar una lista

Colecciones de datos

Trataremos en esta entrada cómo modificar los elementos que componen una lista mediante diferentes funciones y procedimientos, completando lo visto en entradas anteriores, especialmente en esta para terminar con esta temática.

Una vez declarada una lista vacía lista_1 = [] (1) contamos con dos funciones para añadir elementos:

• Para añadirlos al final append() - lista_1.append('Rosa')
• Para añadirlos en una posición intermedia insert(indice,elemento) - lista_1.insert(1,'Cecilia')

Observa que para añadir elementos en una posición determinada debemos indicar como primer parámetro el índice (o posición) que deseemos que ocupe el elemento. Si lo que deseamos es añadir un conjunto de elementos a la lista, todos a la vez, usaremos la función extend([] - lista_1.extend(['Maria','Celia']) que en realidad añade una lista a la lista anterior, motivo por el cual situamos los elementos entre corchete. De no hacerlo obtendremos error o un resultado inesperado.

También contamos con funciones para borrar o eliminar elementos de la lista:

• Eliminamos el elemento identificado de la lista mediante remove() - lista_1.remove('Rosa')
• El método pop() elimina por defecto el último elemento de la lista lista_1-pop() pero si le pasamos como parámetro un índice válido de la lista elimina el elemento que ocupe esa posición lista_1.pop(2)
• Pero el método más simple para borrar un elemento es usar la instrucción del - del lista_1[0]

NOTAS
¹ También podría tratarse de una lista con un cierto número de elementos.
² Lo segundo si añadimos una palabra ('Maria'). En este caso nos devolverá cada letra como elemento de la lista.

Lenguajes. Python.

Funciones built-in en Python

Al igual que en OOo Basic, también Python dispone de una colección de funciones incorporadas en el propio lenguaje (funciones built-in). Te las presento en esta entrada.

Puedes encontrar un listado y la explicación de su funcionamiento [en esta página]

A continuación te presento el listado de contenidos para facilitarte el acceso a la explicación de aquella que te interese especialmente (1).

abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

NOTA (1) Listado ordenado alfabéticamente en columnas copiado de la referencia indicada.

Lenguajes. Python.

Módulo datetime

Mediante datetime podemos manejar fechas (date) y horas (time) de forma sencilla y eficiente. No es el único módulo que trabaja con este tipo de datos, pero posiblemente sí sea el más conocido y empleado.

Podríamos decir mucho de datetime, ya que es mucho lo que este módulo contiene, pero nos vamos a limitar a tratar sobre lo fundamental y de aquello que posiblemente más usemos en nuestros script. Puedes consultar esta página para más detalle (1). Este módulo incorpora tres componentes principales: time, date ydatetime, cuyas principales utilidades son:

• Facilitar el acceso a los diferentes componentes de la referencia temporal (año, día, mes, hora, minuto, segundo, milisegundo)
• Convertir cadenas con formato de fecha a los tipos referidos
• Realizar el proceso inverso, esto es, convertir expresiones de los tipos time, date y datetime en cadenas formateadas
• Realizar comparaciones y cálculos con fechas, como sumar o restar fechas

Voy a plantear, en lo que resta de entrada y a modo de ejemplos, algunas aplicaciones de datetime que me parecen de especial e inmediato interés para aplicar en la creación de script. Empezaré por el modo de importar el módulo y seguiré por algunas cuestiones que considero más comunes.

Para importar datetime tengo dos opciones:

• Importar el módulo al completo import datetime
• O importar cada componente de forma específica from datetime import date, time, datetime

La segunda es la forma más recomendable de proceder ya que nos permite diferenciar cada uno de los componentes de la clase con el que deseemos trabajar, incluyendo otros que ahora no mostramos.

Caso 1. Transformar a datetime una fecha dada como cadena.

Cuando usamos input() para la entrada de una fecha, lo que hacemos es proporcionar una cadena de texto, y en Python, al contrario que en otros lenguajes (2), no existe una función de conversión directa a unidad de tiempo, al margen de módulos como datetime, de ahí el interés por aprender a realizar este tipo de transformaciones.

Supongamos entonces que pido la fecha mediante input(), indicando el formato deseado: fecha = input("Dime la fecha (dd/mm/aaa)"). Depues la transformo en un objeto date mediante la función strptime() (fecha_date= datetime.strptime(fecha,'%d/%m/%Y')) Observa que en el parámetro formato utilizo el mismo fomrato que he pedido en la entrada.

Caso 2. Acceder a los componentes de la fecha.

Este acceso es la base para realizar manipulaciones y cálculos de diferente tipo. Partiendo de la trasformación anterior (variable fecha_date) es suficiente con aplicar las instrucciones año = fecha_date.year, mes = fecha_date.month y dia = fecha_date.day para obtener los datos que deseamos.

Caso 3. Conocer el día y la hora actuales.

Con frecuencia nos interesa conocer la fecha y hora actuales del sistema sin tener que introducirla por teclado. Para ello haremos uso de algunas funciones disponibles en datetime (3): hoy = date.today() y ahora = datetime.now()

Faltan muchas instrucciones por explicar, ya que datetime es una clase muy extensa, así que posiblemente tengamos que realizar alguna que otra entrada más sobre este módulo, o sobre otros que también trabajan con unidades temporales, como time o calendar.

Nota:

¹En ella, entre otras muchas cosas, encontrarás enlaces a otros módulos Python que también trabajan con unidades temporales, como time y calendar, que son los más conocidos. Otra referencia de interés, en este caso directamente orientada a la práctica, es página de Alf. Muy recomendable.

²Como es el caso de OOo Basic (CDate())

³Mientras que today() pertenece al objeto date, now() pertenece al objeto datetime.

Lenguajes. Python.

Funciones de cadena en Python: división y unión de elementos

Para separar y unir los elementos que componen una cadena de texto Python dispone de algunas funciones específicas que facilitan esta tarea. Dedicaremos entra entrada a experimentar con esas funciones que tanta utilidad van a tener en la automatización del trabajo con textos.

Vamos a empezar por la segmentación de una cadena, proceso en el que empleamos la función split(). Esta función nos permite dividir una cadena en segmentos en función de un separador (el que nosotros decidamos), que en caso de no especificar ninguno será directamente el espacio que separa las palabras. Un ejemplo.

Supongamos el siguiente texto asignado a la variable:

texto = "Una narración breve en prosa es un texto corto que cuenta una historia usando el lenguaje no métrico o rítmico, y que puede ser un cuento, un microrrelato o una fábula\n. Estas formas literarias se caracterizan por su concisión y la condensación de eventos en un formato limitado, buscando captar la atención del lector mediante la intensidad de la historia, un final inesperado o una enseñanza moral." 

Tomando este texto como objetivo, vamos a analizarlo en términos de posible segmentación. 

• En primer lugar, podemos dividirlo en función de las palabras (lista1); para ello emplearemos split() sin determinar separador (lista1 = texto.split())
• La segunda división puede ser dividirlo en función del punto (lista2), para lo que explicitaremos el elemento divisor (lista2 = texto.split('.'))
• En tercer lugar, podemos dividir el texto en función del salto de línea (\n), que equivale a los párrafos que componen el texto. En este caso tenemos dos opciones (el resultado es el mismo):
• Mediante la identificación directa del separador (lista3 = texto.split('\n'))
• O mediante el uso de la función splitlines() (lista4 = texto.splitlines())

Podemos obtener un resultado confirmatorio de la ejecución de las diferentes instrucciones obteniendo el número de elementos de las distintas listas (v.g. n_pal = len(lista1) o n_seg = len(lista2)) y mostrar a continuación el resultado de len() por pantalla (v.g. print (f'Número de elementos de la lista 1 ->  {n_pal}')), o también puedes hacerlo mostrando directamente los diferentes segmentos de las distintas listas mediante un bucle que las recorre:

i = 0

for i in range(n_pal):

    print(lista1[i])

Pasemos ahora a explicar el proceso inverso, consistente en unir lo que hemos separado previamente. Para ello disponemos de dos procedimiento que explico a continuación.

La primera forma consiste en utilizar un bucle cuya expresión más simple (pero no la única) es la siguiente, que incluye declaración de variables y escritura del resultado por pantalla:

i = 0

texto_1 = ""

for i in range(n_pal):

    texto_1 = texto_1 + lista1[i] + ' '

print(texto_1)

El núcleo de este procedimiento es la asignación recursiva del contenido de la lista sobre la variable contenedora (texto_1 = texto_1 + lista1[i] + ' ')

La segunda fórmula se basa en el uso de la función join()  que  nos ahorra el bucle y cuya sintaxis es la siguiente...

variable_de_asignación_de_cadena =  "separador".join(lista)

... que traducido a un caso concreto se muestra como sigue (incluyendo declaración de variable contenedora e instrucción de escritura por pantalla:

texto1 = ""
texto1 = " | ".join(lista1)
print(texto1)

Datos. Python.

Módulo ezodf (Calc)

Para trabajan con documentos Excel disponemos de la biblioteca Openpyxl y para trabajar con Calc del módulo ezodf (1). Este módulo está menos desarrollado que el anterior, pero nos sirve para un manejo básico de archivos sencillos.

Igual que sucede con Openpyxl, también deberemos instalar el módulo ezodf mediante el instalador pip (pip install ezodf) y después importarlo en nuestro script (import ezodf).

Con este módulo podemos hacer unas cuantas cosas, algunas de las cuales son accesibles en forma de ejemplos desde GitHub (2), pero no me voy a detener demasiado en esto ya que la utilidad inmediata que le veo a este paquete, igual que a otros de tipo ofimático, es facilitar la automatización de tareas, y escribir en Calc desde Python no me resulta especialmente atractivo.

Me limitaré entonces a mostrar como acceder a un archivo Calc y leer datos de sus celdas. Es una tarea muy simple pero muy interesante, ya que nos va a permitir acceder a nuestros documentos Calc y a los datos que contienen para trabajar con ellos de diferentes maneras (3)

Veamos a continuación un pequeño script Python:

import ezodf

# Lectura del archivo ODS

documento = ezodf.opendoc('AlumLS.ods')

#Acceso a la hoja Datos 1 (la segunda, en este caso)

hoja_datos = documento.sheets[1]

#Acceso a la celda A1

celdaA1 = hoja_datos['A1'].value

#Mostrar contenido de la celda

print(celdaA1)

Como podemos ver este script no tiene ningún misterio y no es muy diferente del que podemos crear con la misma función mediante Openpyxl. De hecho la función clave opendoc() es muy simple e intuitiva y el resto del procedimiento tampoco se puede considerar novedoso: vamos descendiendo desde el documento hasta la celda y una vez en este nivel, nos apropiamos de su contenido (4) para asociarlo a una variable que después podemos manipular en función del objetivo que persigamos.

No corresponde ahora realizar este tipo de desarrollos, pero en entradas posteriores mostraré alguna de estas posibilidades.

NOTAS

(1) Muy recomendable consultar la [página del proyecto]

(2) Especialmente ver [documentación y ejemplos]

(3) En concreto estoy pensando en el acceso masivo a datos y la creación de procedimientos de análisis mediante bibliotecas especializadas de Python; pero también en cuestiones más simples, como la automatización de la creación de documentos Excel a partir de documentos Calc. Hasta donde yo se, no existe una biblioteca que convierta directamente un tipo de documento en el otro y por desgracia, los módulos Python tanto de acceso a datos como de manipulación y análisis de los mismos están diseñados para trabajar con formatos Excel.

(4) Importante observar que debemos especificar que accedemos al valor o dato almacenado en la celda. Para ello añadimos al identificador de la celda el atributo value (hoja_datos['A1'].value)

LENGUAJES . Python

Listas y tuplas. Operadores

Colecciones de datos

Los operadores son, como ya sabemos, componentes de todo lenguaje de programación que permiten manipular los datos referenciados en las variables de diferentes maneras, según el tipo de dato y de operador de que se trate. También las colecciones de datos admiten la acción de operadores. Las listas y las tuplas comparten los mismos.

Los operadores disponibles en listas y tuplas son los siguientes:

• : Permite obtener segmentos del contenido de ambas colecciones.
• + y * Permiten realizar las operaciones sobre listas y tuplas. Veremos cuáles.
• in / not in Permiten verificar la presencia / no presencia de determinado dato dentro del conjunto.
• Los operadores relacionales <, <=, >, >= y !=, cuyas funciones describiremos en su momento.

Aunque figure en primer lugar, no trataré el operador : en esta entrada, dada la relación que mantiene con el acceso a los datos. Por este motivo desplazo su análisis a la entrada correspondiente.

Inicio este análisis con los operadores + y *, los cuales cumplen funciones específicas con listas y tuplas, diferentes de las que permiten ejecutar en variables.

• El operador + permite la unión o concatenación de los elementos de varias listas. Como cabe suponer por lo que sabemos de los operaciones aritméticos, nos permiten realizar operaciones de suma y multiplicación con listas y tuplas.

lista1 = list([1,2,3,4])
lista2 = list([5,6,7,8])
print(lista1 + lista2) 

-> devuelve [1,2,3,4,5,6,7,8]

• Este mismo operador, aplicado a tuplas funciona exactamente igual, aunque lógicamente devuelve una tupla (1,2,3,4,5,6,7,8)
• La operación * tiene como efecto la repetición de la lista o la tupla sujeta a tal operación, siendo indiferente que el operador se sitúe antes o después de la lista o tupla. Así que print(3 * lista1) devuelve [1,2,3,4,1,2,3,4,1,2,3,4] y print(tupla1 * 2) devuelve (1,2,3,4,1,2,3,4). En ambos casos el número debe ser entero (ni 3.1 ni 2.4 se admiten como "multiplicadores")
• Ambos operadores tienen el mismo efecto con independencia de la naturaleza de los elementos de la lista o de la tupla.
• En ambos casos no está permitido el trabajo con listas y tuplas simultáneamente. No es posible ni lista + tupla, ni tupla * lista, ni ninguna otra combinación o permutación de elementos.

• Los operadores in / not in permiten identificar si un dato forma parte o no de una lista o de una tupla. Ambos devuelven True o False según el resultado de la operación. Ejemplos para lista1 y tupla1 anteriores:

print(5 in lista1) #devuelve False
print(1 in lista1) #devuelve False

print(5 not in lista1) #devuelve True
print(1 not in lista1) #devuelve True

print(5 in tupla1) #devuelve False
print(1 in tupla1) #devuelve False

print(5 not in tupla1) #devuelve True
print(1 not in tupla1) #devuelve True

Los operadores relacionales permiten comparar dos listas entre sí, elemento a elemento y según criterios específicos en función del tipo de elemento. También devuelven True o False, según el resultado de la comparación. Veamos algunas comparaciones, tomando como referencia las listas y las tuplas creadas antes. Dada la multiplicidad de opciones me limitaré a unos pocos ejemplos, aunque los resultados se pueden hacer extensibles al resto de los operadores:

#Operadores relacionales con listas

print(lista1 == lista1) #Devuelve True

print(lista1 != lista2) #Devuelve True

#Operadores relacionales con tuplas

print(tupla1 == tupla1) #Devuelve True

print(tupla1 != tupla2) #Devuelve True

#Operadores relacionales con listas y tuplas

print('Operadores relacionales con listas y tuplas')

print(lista1 == tupla1) #Devuelve False por ser una lista y la otra tupla, aunque el contenido es el mismo

LENGUAJES. Python

Listas y tuplas. Automatizar contenido

Colecciones de datos

Aunque la forma más frecuente de crear colecciones de datos es introducirlos directamente mediante teclado o acceder a documentos en los que estos se encuentren disponibles, en ocasiones es necesario crear colecciones de datos numéricos más o menos amplias cuyos elementos mantienen entre sí una relación, lo que hace que sea posible automatizar su creación. Para estos casos es muy útil conocer procedimientos de creación automática de colecciones de datos. Y existen, tanto para listas y como para tuplas.

El primer procedimiento para crear listas (y tuplas) automáticamente es el que utiliza la función range(). Esta función precisa tres parámetros: el valor de inicio, el valor final y el incremento. Un ejemplo: range(2,12,2 nos permite crear una colección de datos que inicia en el número 2 y finaliza en el 10 (el 12 no está incluido), incrementándose el valor inicial de 2 en 2 (2 - 4 - 6...).

Utilizamos el constructor de listas y creamos automáticamente una que cumple esos criterios. Si la lista es pequeña podemos hacerlo manualmente, pero si contiene muchos elementos es más funcional usar la función range() que acabo de explicar:

• lista_1 = list(range(2,100,2)) crea una lista con todos los números pares comprendidos entre 2 y 100 (100 no incluido).
• tupla_1 = tuple(range(2,100,2)) tiene el mismo efecto práctico, aunque en este caso se trata de una tupla, con todo lo que esto implica respecto a inmutabilidad.

Existen otros procedimientos que además de permitirnos crear colecciones de datos numéricos más complejas que también es necesario conocer si nos encontramos con script que utilicen estas expresiones. Me estoy refiriendo a la creación de listas o tuplas mediante operadores, bucles y condicionales. Veamos algunos ejemplos:

• lista_3 = [x * 2 for x in lista_1] es una lista de valores numéricos que utiliza lista_1 (recuerda: números pares comprendidos entre 2 y 98) multiplicando por 2 cada uno de ellos. Mediante for x in lista_1 recorre esa lista.
• La tupla_2 =tuple([x * 2 for x in tupla_1]) hace lo mismos pero creando una tupla y usando una tupla como base. Observa que ahora necesitamos usar el constructor y una combinación de ([])
• La lista_4 = [x**2 for x in lista_1 if x > 8] hace los mismo que lista_2, pero ahora añadimos como condición para la creación de la colección de datos que el valor original de lista_1 sea superior a 8 if x > 8)
• Finalmente, en lista_6 = [x * 3 for x in range(2,32,2) if x >10] utilizamos directamente la función range() para crear automáticamente la colección de datos de base for x in range(2,32,2) y mantenemos una condición: que los valores resultantes sean superiores a 10 if x >10

Digo finalmente para no prolongar esta casuística más de lo necesario, porque aun caben otras combinaciones, incluyendo la de listas y tuplas y el uso de doble bucle en función de una doble variable lista_5 = [x + y for x in lista_1 for y in lista_2]

Documento. En este enlace te dejo acceso a un script con ejemplos, incluidos los explicados en esta entrada.

LENGUAJES. Python

Acceso a listas y a tuplas

Colecciones de datos

Aunque listas y tuplas son colecciones de datos diferentes, ya dijimos que comparten muchas características y comportamientos; entre estos últimos están su posible contenido y el modo en que podemos acceder a él.

El acceso a los elementos de las listas y las tuplas es un procedimiento de uso muy frecuente y de mucha utilidad práctica, por lo que interesa conocer cómo realizarlo. Ya sabemos cómo es el procedimiento básico por haberlo visto al hablar de ambas colecciones de datos (v.g. print(mi_tupla_a[0] nos devuelve en pantalla el primer elemento de la tupla), pero esto nos sirve cuando la tupla o la lista contienen elementos simples (vg mi_lista_a = [12,23,43,56]), pero, ¿ cómo accedemos a los elementos complejos, a las listas o tuplas anidadas dentro de la lista o tupla principal?.

Un ejemplo de ello podría ser el siguiente: una lista que contiene "registros" que se contienen a su vez una lista (1):

• mi_lista_b = [['Lucía','Martínez Alonso','P4'],['Mario','Carcedo Suárez','P3'],['Carlota','Álvarez López','P2']]

Veamos mediante código distintas posibilidades de acceso al contenido de esta lista. Denominaré registro a cada una de las tres sublistas y dato a cada uno de los elementos de cada uno de los registros (dato -> nombre, dato -> apellidos, dato -> curso)

#Acceso a la lista completa

print(mi_lista_b)

#Captura del primer registro

reg1 = mi_lista_b[0]

#Acceso al primer registro de la lista

print(mi_lista_b[0])

#Acceso al primer registro que pasamos previamente a reg1

print(reg1)

#Acceso al primer dato (dato -> nombre) de cada uno de los registros de la lista

reg_nombres = [[mi_lista_b[0][0]], [mi_lista_b[1][0]],[mi_lista_b[2][0]]]

print(reg_nombres)


#Acceso al primer dato del nueva lista reg_nombres

print(reg_nombres[0])

#Otro modo de acceso (ahora reg_nombres_b es una lista de elementos imples

reg_nombres_b = [mi_lista_b[0][0], mi_lista_b[1][0],mi_lista_b[2][0]]

print(reg_nombres_b)

En este script estamos jugando con diferentes formas de acceder al contenidos de una lista compleja (lista de listas). Podemos diferenciar el modo de acceder al conjunto de la lista print(mi_lista_b) y a su primer elemento print(mi_lista_b[0]). En el primer caso nos devuelve todos los registros de la lista (la lista con sus sublistas...

• [['Lucía', 'Martínez Alonso', 'P4'], ['Mario', 'Carcedo Suárez', 'P3'], ['Carlota', 'Álvarez López', 'P2']]

... y en el segundo sólo el primer registro (la primera sublista)

• ['Lucía', 'Martínez Alonso', 'P4']

Si lo que queremos es acceder al primer dato de la primera sublista, deberemos expresarlo como sigue:

• [mi_lista_b[0][0]]) - nos devuelve Lucia

Observa que empleamos una pareja de corchetes para identificar el primer registro de la lista principal (que aquí ni se nombra) reg_nombres_b y que se concreta como mi_lista_b[] y a continuación una segunda pareja de corchetes para identificar el dato que deseamos (también el primero [0][0])

Haciendo extensible este procedimiento, podemos crear una lista de listas que contienen como único registro el nombre de cada alumno...

• reg_nombres = [[mi_lista_b[0][0]], [mi_lista_b[1][0]],[mi_lista_b[2][0]]]

... o, como alternativa, una lista de elementos simples con el mismo contenido

• reg_nombres_b = [mi_lista_b[0][0], mi_lista_b[1][0],mi_lista_b[2][0]]

La diferencia es sutil pero fundamental: en el primer caso delimitamos doblemente con corchetes cada elemento, en el segundo no. Con el primer procedimiento obtenemos una lista de listas simples (de un sólo elemento o dato cada una)...

• [['Lucía'], ['Mario'], ['Carlota']]

... y con el segundo una lista simple de tres elementos (2)

• ['Lucía', 'Mario', 'Carlota']

Además de acceder a elementos concretos de la lista o de la tupla, también podemos hacerlo a un subconjunto de datos mediante el operador :. De este operador ya hablamos en esta entrada, pero dejamos aplazado su tratamiento para relacionarlo con los procedimientos de acceso al contenido, motivo por el que corresponde ahora tratarlo.

Este operador presenta una formulación básica de uso lista/tupla[inicio:fin] en la que se indica la posibilidad de delimitar el inicio del subconjunto y su final (mejor dicho, el elemento previo a su final). Por ejemplo, para lista0 = [1,2,3,4,5,6,7,8,9], print(lista0[0:3]) nos devuelve [1,2,3], dado que se cuentan los elementos empezando por 0 y el elemento posición 3 es 4, por lo que el anterior (elemento 2 -> 3).

Ahora podemos omitir tanto el elemento inicio como el elemento fin. En el primer caso (vg. lista0[:3]) el resultado será el mismo que antes ([1,2,3]) ya que la ausencia del delimitador inicio implica partir del primer elemento de la lista (o de la tupla). Si omitimos el elemento final (vg lista0[2:]) implícitamente se supone que deseamos ir desde el elemento inicio (posición 2 -> 3) hasta el final de la lista. En consecuencia, para lista0 -> [3,4,5,6,7,8,9].

Otra forma de acceder a segmentos del contenido de listas o tuplas es empleando índices negativos...

print(lista0[-5:-3]) 

#-> devuelve [5,6]

print(tupla0[-2:]) 

#-> Para tupla0, igual resultado que para lista0: devuelve (8,9)

... debido a que los valores negativos remiten al orden inverso en el acceso al contenido de listas y tuplas.

NOTAS
¹ El mismo ejemplo podríamos plantear mediante una tupla de tuplas, una lista de tuplas o una tupla de listas.
² Podríamos hacer exactamente lo mismo con una tupla y obtendríamos los mismos resultados