Lenguajes. Python.

Listas y tuplas

Lista como iterable

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 como instrucción básica para la iteración, 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)

A partir de aquí ya podemos utilizar las listas para automatizar procedimiento al mismo nivel que hacemos en OOo Basic, sólo de con mayor facilidad y potencia. 

NOTAS 

(1) 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.
(2) Secuencialmente se opone aquí a simultáneamente, 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.

Listas y tuplas

Modificar el contenido de una lista

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] cerrando una temática que lleva abierta desde hace tiempo.

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

Añadir elementos  al final (append())

lista_1.append('Rosa')

Añadir elementos 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'])

En realidad lo que añadimos es una lista a la lista anterior, motivo por el cual situamos los elementos entre corchete. De no hacerlo obtendremos error o un resultado inesperado (2)

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

(1) También podría tratarse de una lista con un cierto número de elementos
(2) 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ódulos básicos. 

Módulos de tiempo (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 de 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 y datetime, 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 básicamente dos opciones:

• Importar el módulo al completo (import datetime)
• O importar cada uno de sus componentes de forma específica (from datetime import date, time, datetime)

Esta segunda forma es la más recomendable, 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 una fecha dada como cadena a datetime.

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

Supongamos entonces la siguiente situación:

• Pido la fecha mediante input(), indicando el formato deseado:

fecha = input("Dime la fecha (dd/mm/aaa)")

•  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 que he pedido en input()

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 los siguientes instrucciones:

año = fecha_date.year
mes = fecha_date.month
dia = fecha_date.day 
 

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 recurrir a introducirla por teclado. Para ello haremos uso de algunas funciones disponibles en datetime (3).

hoy = date.today()

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.

NOTAS

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

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

(3) 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)