7. Manejo de String
Complementando con lo que se definió en los tipos de datos de texto
En Python, nos referimos a un "string" o "texto" cuando el tipo de
dato de un elemento (variable o constante) es de tipo str. Esto es
fácil de identificar, ya que un "string" es un valor que se representa
utilizando comillas simples (' '), comillas dobles (" "), e incluso
triples comillas (''' ''') para párrafos o fragmentos largos.
Es importante destacar que los dos primeros casos son exactamente iguales, no hay ninguna diferencia visual o práctica en su uso. Podemos utilizar indistintamente cualquiera de ellos o elegir uno u otro según haya comillas simples o dobles dentro de nuestra cadena.
variable = "Hola Mundo"
print(type(variable))
# La salida será > <class 'str'>
# Ahora con comilla simple
variable = 'Hola Mundo'
print(type(variable))
# La salida será > <class 'str'>
Para ambas salidas el tipo de dato será str y el tratamiento es
igual.
Es posible que dentro de nuestro "string" existan comillas simples. Para evitar conflictos, podemos delimitar la cadena utilizando comillas dobles. De esta manera, Python entenderá que las comillas simples dentro del "string" forman parte del contenido y no como delimitadores del "string" en sí.
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto1 = "Hola ' Mundo"
texto2 = 'Otro " Hola Mundo '
texto3 = """En un lugar '
de la mancha"
de cuyo nombre
no quiero acordarme"""
print(texto)
print(texto2)
print(texto3)
La salida esperada para el ejemplo anterior es la siguiente:
Hola ' Mundo
Otro " Hola Mundo
En un lugar '
de la mancha"
de cuyo nombre
no quiero acordarme
Al analizar las variables, podemos observar que "texto1" y "texto2" contienen comillas simples y dobles entre las cadenas definidas, lo que permite que sean visualizadas en la salida. Esto significa que si necesitamos mostrar comillas simples o dobles en la salida, podemos incluirlas dentro de la cadena de la forma mencionada.
Por otro lado, la variable "texto3" ha sido declarada utilizando triple comillas, lo cual nos permite mostrar en pantalla textos más extensos, como párrafos.
7.1. Secuencia de escape
En Python, al igual que en otros lenguajes de programación, existen caracteres especiales que se interpretan dentro de una cadena de texto cuando están precedidos por un "backslash" (). Estos caracteres con "backslash" se conocen como secuencias de escape y permiten realizar formateo o mostrar caracteres especiales en la salida del "string".
Algunos ejemplos comunes de secuencias de escape en Python son:
| -----------------------------------
| Secuencia | |
| Escape | Resultado |
-----------------------------------
| \n | Salto de linea |
-----------------------------------
| \t | Tabulado horizontal |
-----------------------------------
| \v | tabulado vertical |
-----------------------------------
| \b | Borra un espacio |
-----------------------------------
| \f | Formfeed |
-----------------------------------
| \r | Retorna al margen |
-----------------------------------
Ejemplo
a = "Hola \n Mundo"
print(a)
La salida esperada es la siguiente en donde podemos observar el salto de linea en la salida:
Hola
Mundo
Existen numerosos caracteres especiales para el manejo de cadenas de texto en Python. Una lista completa de estos caracteres y las secuencias de escape correspondientes se puede consultar en la siguiente URL: https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals.
7.2. Mayúsculas, Minúsculas y Capital
En Python, es importante tener en cuenta que una 'A' y una 'a' son caracteres distintos. Por lo tanto, en muchas ocasiones es necesario 'normalizar' los textos que manejamos para evitar problemas. Un ejemplo de esto es al realizar búsquedas cuando no conocemos el estilo del texto en su forma original. En estos casos, una opción útil es transformar el texto a mayúsculas, minúsculas o utilizar letras en formato capital (capitalizarlas). Esto nos permite asegurar que las comparaciones y búsquedas sean consistentes y no se vean afectadas por diferencias en las letras mayúsculas y minúsculas.
Existen funciones que logran realizar la transformación del texto:
upper()para convertir a mayúsculaslower()para minúsculascapitalize()para letra capital o mayúscula inicial.
Estás funciones son propias de toda definición de tipo str.
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto = "Hola mundo"
print(texto.upper())
print(texto.lower())
print(texto.capitalize())
La forma de utilizar consiste en llamar a la función que se desea instanciar utilizando un punto seguido del nombre de la función. A continuación, se muestra la salida del ejemplo:
HOLA MUNDO
hola mundo
Hola mundo
7.3. Formateo y completado con variables
El formateo y la concatenación de cadenas son operaciones comunes en Python como en cualquier lenguaje de programación para combinar valores y texto de manera efectiva. Python ofrece varias opciones para lograr esto. Una forma común de formatear cadenas es mediante el método .format(), donde se pueden insertar variables y valores utilizando marcadores de posición dentro de la cadena. Por ejemplo, podemos utilizar {} en la cadena y luego usar el método .format() para proporcionar los valores correspondientes. Otra opción es utilizar f-strings que permiten la interpolación directa de variables y expresiones dentro de una cadena precedida por f. Además, para concatenar cadenas, se puede utilizar el operador + para unir dos cadenas o el operador += para agregar contenido a una cadena existente. Estas opciones ofrecen flexibilidad y claridad al trabajar con cadenas en Python, permitiendo crear resultados más dinámicos y personalizados.
7.3.1. Operador %
El operador "%" es una forma conocida y tradicional de complementar o concatenar cadenas de texto con otras variables. Es una forma comúnmente utilizada en muchos lenguajes de programación para llevar a cabo esta acción.
Sintaxis
variable = 'string %[formato]' %variable
Es importante destacar que después del signo '%' se coloca una letra que representa el formato de la variable que se utilizará. En el ejemplo proporcionado, se utilizaron las letras 'd', 'f' y 's' para representar diferentes formatos. Es crucial tener en cuenta que Python ofrece una variedad de formatos disponibles, que también son aplicables en otros lenguajes de programación. A continuación, se muestra una tabla que enumera todos los formatos disponibles en Python y su uso correspondiente.
----------------------------------------------------------------
| %c | un char (caracter) |
----------------------------------------------------------------
| %d | un entero con signo en notación de base decimal |
----------------------------------------------------------------
| %i | un entero con signo |
----------------------------------------------------------------
| %e | reales((pseudoreales como double)) en notación científica |
| indicando el exponente con "e" |
----------------------------------------------------------------
| %E | reales((pseudoreales como double)) en notación científica |
| indicando el exponente con "E" |
----------------------------------------------------------------
| %f | formato de punto flotante |
----------------------------------------------------------------
| %g | la opción más corta entre "%e" y "%f" |
----------------------------------------------------------------
| %G | la opción más corta entre "%E" y "%F" |
----------------------------------------------------------------
| %o | un entero sin signo en notación de base octal |
----------------------------------------------------------------
| %s | una cadena de caracteres |
----------------------------------------------------------------
| %u | un entero sin signo |
----------------------------------------------------------------
| %x | un entero sin signo en notación de base hexadecimal, |
| usando minúsculas para los dígitos extendidos |
----------------------------------------------------------------
| %X | un entero sin signo en notación de base hexadecimal, |
| usando mayúsculas para los dígitos extendidos |
----------------------------------------------------------------
Ejemplo:
print("El valor es %d" %11)
print("Los valores son %d y %d" %(11, 33))
print("Muestro un entero de 5 cifras por delante %5d" %11)
print("Muestro un numero real (float) con dos decimales %.2f" %10.2313242)
print("Mi nombre es %s " %"pepito")
La salida es la siguiente:
El valor es 11
Los valores son 11 y 33
Muestro un entero de 5 cifras por delante 11
Muestro un numero real (float) con dos decimales 10.23
Mi nombre es pepito
7.3.2. Método format()
El método format() es una función que nos permite controlar las cadenas de texto de manera más precisa. Su forma consiste en utilizar llaves {} dentro del texto para indicar los lugares donde deseamos insertar los valores de variables que pasamos como parámetros a la función.
Sintaxis
texto = "texto {}".format(variable)
En el lugar de las {} irá el valor de la variable que ha sido pasada como parámetro al método "format()".
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
print("El valor es {}".format (11))
print("El valor es {}".format (11.3456))
print("Los valores son {}, {} y {}".format(1 ,2 ,3))
print("Los valores son {2}, {1} y {0}".format(1 ,2 ,3))
print("{maria} y {juan}".format(juan=11, maria=200))
print("Valor formateado {:10.2f}".format(77.6438))
La salida linea a linea es la siguiente
El valor es 11
El valor es 11.3456
Los valores son 1, 2 y 3
Los valores son 3, 2 y 1
200 y 11
Valor formateado 77.64
Hay varias consideraciones importantes con respecto al ejemplo. En primer lugar, el método format() no se ve afectado por el tipo de datos de las variables que se pasan como parámetros. Independientemente de si son datos numéricos u otros tipos, format() intentará concatenarlos y los convertirá automáticamente a texto.
En segundo lugar, la posición de las variables es crucial. Si observamos la cuarta línea del ejemplo, las llaves están numeradas. Estos números indican la posición de los parámetros que se han pasado al método format(). En este caso, se incluye el parámetro en la posición 2, luego en la posición 1, y finalmente se completa la cadena de caracteres utilizando el parámetro en la posición 0.
Por último, en la quinta línea del ejemplo, se utilizan variables dentro de las llaves (maria y juan). Estos valores corresponden a los valores de los parámetros que han sido declarados para el método format()
7.3.3. F-String
El "F-string" o 'string literal format' es una poderosa característica en Python que permite crear cadenas de texto dinámicas y legibles. Se trata de un "string" precedido por la letra f, que indica que se utilizará formateo de variables dentro del texto. En un "F-string", podemos incluir variables entre llaves {} y serán reemplazadas automáticamente por los valores de las variables que hayan sido declaradas previamente en el código.
Sintaxis
texto = f"texto {variable}"
Ejemplo:
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
valor = 132.456
print(f"El valor es {valor}")
print(f"El valor es: {valor: 10.2f}")
La salida es:
El valor es 132.456
El valor es: 132.46
Al igual que el método format(), en el "F-string" también es indiferente el tipo de datos que tenga la variable. Python intentará automáticamente convertir la variable a una representación de texto para concatenarla en el "string". Esto significa que no importa si la variable es de tipo numérico u otro tipo, el "F-string" se encargará de convertirla adecuadamente
7.3.4. Método join()
El método join() proporciona una forma flexible de crear cadenas a partir de elementos iterables, como listas, cadenas o tuplas.
La forma de utilizar este método es uniendo cada elemento como si se tratara de una lista, cadena o tupla, mediante un separador específico. Al llamar al método join() en un elemento de tipo cadena, el resultado es la concatenación de los elementos con el separador especificado.
Sintaxis
string.join(iterable)
Los parámetros de la función join es una lista y sería similar a declarar lo siguiente
variables = [variable1, variable2, variableN]
texto = "".join(variables)
Ejemplo
texto = " ".join(["Hola", "Mundo", "Python"])
print(texto)
La salida del ejemplo es la siguiente
Hola Mundo Python
Es importante tener en cuenta que el texto inicial en el ejemplo es un espacio en blanco. Esto permite que los elementos 'Hola' y 'Mundo' se separen por un espacio en la cadena resultante, creando un espacio de separación entre las palabras
numeros = ['1', '2', '3', '4']
texto = ', '
print(texto.join(numeros))
La salida del ejemplo es la siguiente
1, 2, 3, 4
Acá el separador no es solo un espacio, si no que también se incluye una coma (,).
7.4. Recorrer Strings
Los strings son un tipo de dato iterable, lo que significa que se comportan como un conjunto, lista o una cadena de caracteres. Según la teoría, podemos recorrer cualquier cadena de texto (o lista) utilizando cualquier ciclo y acceder a cada uno de los caracteres que la componen.
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto = "Hola Mundo"
# Recorre utilizando for
for letra in texto:
print(letra)
# Recorre utilizando while
letra = 0
while letra < len(texto):
print(texto[letra])
letra = letra + 1
Además, al tratarse de un elemento iterable, también podemos acceder directamente al carácter deseado utilizando la posición del elemento, empezando desde el valor cero."
texto = "Hola Mundo"
print(texto[2])
print(texto[6])
print(texto[-1])
La salida esperada es: l, M y o
7.5. Obtener el largo de un texto
Una operación común al trabajar con cadenas de texto es determinar su longitud. Para obtener el número de caracteres en una cadena de texto, podemos utilizar la función len(). Al llamar a len() y pasarle la cadena como argumento, nos devolverá el tamaño o longitud de la cadena. Esta información es útil para realizar diversas operaciones y análisis de texto, como verificar la validez de una entrada o manipular la cadena de acuerdo con su longitud.
Ejemplo
texto = "Hola Mundo"
print(len(texto))
La salida esperada es 10
7.6. Substring
En la manipulación de cadenas de texto, a menudo necesitamos extraer una porción específica de un "string". A esta porción se le conoce como "substring". Un "substring" es un nuevo "string" que se obtiene a partir de otro "string", y representa un fragmento o "pedazo" del texto original. Para crear un "substring", podemos establecer los rangos necesarios indicando el inicio y el final del fragmento deseado dentro del "string" original. Es importante recordar que en Python, al trabajar con índices, el primer elemento del "string" tiene un índice de cero.
Sintaxis
subcadena = texto[indice_inicial:indice_final]
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto = "Hola Mundo"
print("1:", texto[1:3])
print("2:", texto[:3])
print("3:", texto[4:])
print("4:", texto[-4: -2])
print("5:", texto[-4:])
print("6:", texto[:-2])
La salida espera para el ejemplo es la siguiente:
1: ol
2: Hol
3: Mundo
4: un
5: undo
6: Hola Mun
En relación al ejemplo proporcionado, hay algunas apreciaciones importantes a considerar. En la línea 2, donde no se especifica un 'índice inicial' y solo se presenta un 'índice final', Python lo interpreta como la posición inicial, que es equivalente a declarar '[0:3]'. En otras palabras, representa un rango que comienza desde el inicio del string hasta la posición final deseada.
Por otro lado, en la línea 3 del ejemplo, se omite el 'índice final'. En este caso, Python asume que el rango se extiende hasta el final del string. Por ejemplo, '[4:len(texto)]' sería equivalente a '[4:]', lo cual significa que el rango comienza en el elemento 4 y se extiende hasta el final del texto.
Además, es importante destacar las líneas del ejemplo que contienen índices negativos. Estos índices indican que el texto debe ser leído de derecha a izquierda. Por ejemplo, 'texto[-4:]' implica que se tomarán los últimos cuatro elementos del texto, comenzando desde la posición 4 contando desde la derecha y extendiéndose hasta el inicio del texto.
7.7. Búsqueda dentro de strings
La naturaleza iterable de las cadenas de texto nos brinda la capacidad de realizar búsquedas y encontrar coincidencias dentro de los strings. Esta característica es extremadamente útil cuando necesitamos buscar palabras, frases o patrones específicos dentro de un texto. Al utilizar métodos de búsqueda y comparación, podemos identificar y extraer las ocurrencias deseadas, lo que nos permite analizar y procesar eficientemente la información contenida en los strings. Esta capacidad de búsqueda y coincidencia en las cadenas de texto amplía las posibilidades de manipulación y análisis de datos en diferentes escenarios y aplicaciones.
7.7.1. in
En Python, una forma común de realizar búsquedas en cadenas de texto
es mediante el uso del operador in. Este operador nos devuelve un
valor booleano, es decir, True o False. Si el elemento buscado se
encuentra en el string, el resultado será True, mientras que si no hay
coincidencia, el resultado será False. El operador in nos permite
verificar de manera rápida y sencilla si un elemento específico está
presente en una cadena de texto. Esto resulta útil en diversas
situaciones, como la validación de datos, la búsqueda de palabras
clave o la comprobación de la existencia de ciertos caracteres o
subcadenas dentro de un texto
Sintaxis
criterio in texto
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto = " Hola Mundo "
# Verdaderos
print("o" in texto)
print("Hola" in texto)
# Falsos
print("p" in "Hola Mundo" )
print("ll" in "Hola Mundo" )
En cuanto a los ejemplos dados, las dos primeras instancias son evaluadas como verdaderas, ya que los caracteres 'o' y 'Hola' se encuentran presentes en la cadena de texto. Por otro lado, las siguientes dos instancias son falsas, ya que los caracteres 'p' y 'll' no existen en la cadena.
El operador in es altamente versátil y se puede utilizar en conjunto
con una estructura de condición, como un bloque if. Esto nos permite
realizar acciones específicas según el resultado de la búsqueda. Por
ejemplo, si el caracter buscado se encuentra en la cadena, podemos
ejecutar un bloque de código particular, y si no se encuentra, podemos
realizar otra acción. De esta manera, el operador in nos brinda una
poderosa herramienta para la toma de decisiones basada en la presencia
o ausencia de ciertos caracteres en una cadena de texto.
Ejemplo
if "la" in texto :
print ("Ok existe la")
7.7.2. find()
Además del operador in, otra forma de realizar búsquedas en una cadena
de texto es utilizando la función find(). A diferencia del operador
in, que devuelve un valor booleano, la función find() nos proporciona
el índice en el cual se encuentra la primera coincidencia del elemento
buscado dentro del string. Si se encuentra la coincidencia, la función
find() devuelve el índice correspondiente, mientras que si no se
encuentra, retorna el valor -1.
Esta función resulta útil cuando necesitamos conocer la posición
exacta de una coincidencia dentro de un texto. Podemos utilizar el
valor devuelto por find() para realizar diferentes acciones, como
extraer una subcadena, reemplazar caracteres o realizar operaciones
más complejas. Es importante tener en cuenta que find() devuelve
únicamente la posición de la primera aparición del elemento
buscado. Si deseamos encontrar todas las ocurrencias, podemos combinar
la función find() con un bucle para recorrer el string en busca de
todas las coincidencias
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto = "Hola Mundo"
print(texto.find("Hola"))
print(texto.find("Mundo"))
En relación a los resultados esperados, podemos observar que para la primera salida, se espera un valor de 0. Esto se debe a que la coincidencia comienza en la posición cero (0) del texto. De manera similar, para la segunda línea, se espera una salida de 5, ya que la coincidencia también comienza en el quinto carácter del texto.
Es posible entregar rangos de búsqueda al interior de una cadena de texto.
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto = "Hola Mundo"
# Comienza la búsqueda a partir de la posición 3
print(texto.find("Hola", 3))
print(texto.find("Mundo", 3))
En el caso del segundo parámetro de la función find(), se trata de un
entero que nos permite fraccionar el texto y posicionar el cursor de
búsqueda en la posición declarada (en este caso, el número 3).
En la primera salida de la función find(), se obtendrá un valor de -1,
lo cual indica que no se ha encontrado ninguna coincidencia. Esto se
debe a que al iniciar la búsqueda en la posición tres (3), el texto ha
sido fraccionado y en lugar de buscar en el texto completo "Hola
Mundo", se realiza la búsqueda en un fragmento de texto que comienza
con el valor " Mundo". En cambio, en la segunda salida, sí se
encuentra una coincidencia y el resultado devuelto es el número
5. Esto indica que la coincidencia buscada se encuentra en la posición
cinco (5) del texto original.
Si deseamos limitar aún más nuestra búsqueda en una cadena de texto,
podemos agregar un tercer parámetro a la función find(), el cual nos
permitirá definir un rango entre dos posiciones específica
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto = "Hola Mundo"
# Comienza la búsqueda es entre la posición 0 y 5
print(texto.find("Hola", 0, 5))
print(texto.find("Mundo", 0, 5))
En este caso, el string "Hola Mundo" se reduce a solo cinco elementos y se evalúa como "Hola ". En la primera salida, se encuentra una coincidencia en la posición 0, ya que la letra 'H' coincide con el carácter buscado. Por lo tanto, el resultado es 0. En la segunda salida, no se encuentra ninguna coincidencia, por lo que el resultado es -1.
Cuando nos enfrentamos a múltiples coincidencias de elementos repetidos en una cadena, puede surgir un problema y será necesario abordar estrategias para manejar esta situación. Dependiendo de los requisitos específicos, podríamos utilizar métodos adicionales, como iterar sobre la cadena y almacenar las posiciones de todas las coincidencias, o utilizar expresiones regulares para realizar búsquedas más complejas y flexibles.
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto = "a la una, a las dos y a las tres"
print (texto.find("la"))
print (texto.rfind("la"))
Utilizar solo la función find() puede resultar insuficiente en
algunos casos. En situaciones donde se necesite buscar coincidencias
de forma inversa, es posible utilizar la función rfind(). Esta
función se utiliza de manera similar a find(), pero realiza la
búsqueda de derecha a izquierda en la cadena de texto.
En el ejemplo proporcionado, se espera obtener como resultado 2 y 24
utilizando rfind(). Sin embargo, estos valores no son suficientes,
ya que existen tres ocurrencias del patrón de búsqueda en la cadena.
Una estrategia adicional para abordar este problema es utilizar la
función count(). Esta función permite determinar cuántas veces se
repite un determinado patrón en la cadena de texto. Su uso es similar
a find(), y proporciona información sobre la cantidad de ocurrencias
encontradas.
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto = "a la una, a las dos y a las tres"
print(texto.count("la"))
# evalúe desde el caracter 10
print(texto.count("la", 10))
# solo evalúa entre el caracter 1 y 6
print(texto.count("la", 1, 6))
La salida espera es 3, 2, 1
7.7.3. startswith y endswith
Una última forma de buscar o analizar texto es utilizando las
funciones startswith y endswith. Estas funciones son más sencillas
y tienen una funcionalidad limitada, ya que solo analizan el principio
y el final de una cadena de caracteres.
El método startswith se utiliza para verificar si el string
comienza con un patrón específico. En caso de encontrar una
coincidencia, devuelve el valor True; de lo contrario, devuelve
False. Por otro lado, el método endswith realiza la misma tarea,
pero analiza si el string termina con un patrón específico. Si
encuentra una coincidencia, devuelve True; de lo contrario, devuelve
False.
Estas funciones son útiles cuando se necesita verificar rápidamente si una cadena de texto cumple con un patrón específico al inicio o al final. Sin embargo, es importante tener en cuenta que solo analizan esas posiciones específicas y no realizan una búsqueda más exhaustiva dentro del texto.
Ejemplo
texto = "Hola Mundo"
a = texto.startwith("Ho")
print(a)
a = texto.startwith("m")
print(a)
La salida del ejemplo anterior nos muestra un valor de retorno True
en el primer caso, ya que la cadena comienza con los caracteres 'Ho',
lo cual coincide con el patrón buscado. En cambio, en el segundo caso,
el valor de retorno es False, indicando que la cadena no termina con
el patrón especificado.
7.8. Reemplazo
La función replace() es utilizada para realizar reemplazos de
valores en una cadena de texto. Al llamar a esta función, se obtiene
una copia del string original donde se aplicará el reemplazo
especificado.
Al igual que en la función find(), replace() también recibe tres
parámetros, siendo los dos primeros obligatorios. El primer parámetro
corresponde al texto que se desea buscar y reemplazar, mientras que el
segundo parámetro indica el texto que se utilizará como reemplazo.
Por ejemplo, si queremos reemplazar todas las ocurrencias del texto
"Python" por "Rust" en una cadena llamada "texto", podemos utilizar la
siguiente sintaxis: texto.replace('Python', 'Rust'). Esto creará una
nueva variable con el resultado del reemplazo.
Es importante destacar que la función replace() realiza el reemplazo
de manera global, es decir, reemplazará todas las apariciones del
texto buscado en la cadena original.
Sintaxis
texto.replace("valor a buscar", "valor para reemplazar")
Ejemplo
#!/usr/bin/env python3
# -*- coding:utf-8 *-*
texto = "a la una, a las dos y a las tres"
nuevo_texto = texto.replace ("la", "XXX")
print(texto)
print(nuevo_texto)
La salida espera al ejemplo anterior es:
a la una, a las dos y a las tres
a XXX una, a XXXs dos y a XXXs tres