Cadenas de caracteres – strings

Las cadenas de caracteres son uno de los elementos más utilizados en los lenguajes de programación, y en especial las cadenas de caracteres en Python. Sin embargo, es importante conocer bien su funcionamiento y sacarle el máximo.

En Python las cadenas o strings (como se denominan en inglés) están modeladas en el tipo de dato str, y son uno de los tipos de datos más extensos que existen.

Las cadenas de caracteres se emplean para poder describir en un lenguaje humano el código o la ejecución de un programa.

¿Qué es una cadena de caracteres en Python?

Los strings en Python son una concatenación de caracteres simples y pueden formarse como literales o como expresiones. Sin embargo, internamente cada carácter se guarda/representa como uno (o varios) bytes que guardan el número que ocupan en la tabla de unicode.

Además, en Python 3 todas las cadenas son del tipo unicode por defecto, lo que permite poder expresar caracteres en cualquier lenguaje humano con gran facilidad. Aunque, soporta diferentes codificaciones.

Existen diferentes tipos de cadenas de caracteres, muchos métodos disponibles y diferentes formas de crear caracteres, como se verá a continuación.

Crear cadenas de caracteres

El constructor y clase del tipo cadena es str, por lo tanto, se puede utilizar para obtener una versión de cualquier objeto en forma de cadena de caracteres (si el objeto lo soporta o implementa __str__).

>>> str('Hello world')
'Hello world'
>>> str(123415.23)
'123415.23'
>>> class Car:
...    pass
...
>>> str(Car)
"<class '__main__.Car'>"
>>> str(8j)
'8j'
>>> str(True)
'True'
>>> str(None)
'None'

Formas de crear strings literales

Se pueden crear cadenas de caracteres utilizando literales rodeando una serie de caracteres con:

• Comillas simples (‘): 'hello World'
• Comillas dobles («): "el perro ladra"
• Triples comillas simples(»’): '''El gato maulla'''
• Triples comillas dobles («»»): """El pollo pía"""

>>> 'Hello this is a sentence'
'Hello this is a sentence'
>>> "A sentence with double quotes"
'A sentence with double quotes'
>>> """This
... is
... a multi
... line
... sentence"""
'This\nis\na multi\nline\nsentence'
>>> print('''
... This is another
... multiline but using
... triple single quotes
... ''')

This is another
multiline but using
triple single quotes

>>>

El uso de triples comillas se hace principalmente para definir cadenas de caracteres en múltiples líneas, aunque, también se usan como docstring.

Creando cadenas desde otros objetos

Se pueden hacer conversiones (castings) desde otros objetos a cadenas de caracteres utilizando str.

>>> str([1, 2, 3, False, True, lambda: x])
'[1, 2, 3, False, True, <function <lambda> at 0x109cb7af0>]'
>>> str({'a': 4, 'b': 23})
"{'a': 4, 'b': 23}"
>>> str((1, 2, 3, 4, 5))
'(1, 2, 3, 4, 5)'

Para que funcione correctamente la conversión, el tipo de dato debe de implementar el método __str__.

>>> class Car:
...      def __init__(self, color, size):
...          self.color = color
...          self.size = size
...      def __str__(self):
...          return f'The Car color is: {self.color} and size of {self.size}'
...
>>> Car('Blue', 54)
<__main__.Car object at 0x109bc2670>
>>> c = Car('Blue', 54)
>>> str(c)
'The Car color is: Blue and size of 54'
>>> c = Car('Red', 8997)
>>> str(c)
'The Car color is: Red and size of 8997'

Además, se pueden crear caracteres sabiendo la posición que ocupan en la tabla unicode (ya sea con su número en hexadecimal o en base 10) utilizando la función chr.

>>> ord('A')
65
>>> chr(65)
'A'
>>> ''.join(chr(65 + x) for x in range(10))
'ABCDEFGHIJ'
>>> for x in ('24c5', '24e8', '24e3', '24d7', '24de', '24dd'):
...     print(int(x, base=16))
...     print(chr(int(x, base=16)))
...
9413
Ⓟ
9448
ⓨ
9443
ⓣ
9431
ⓗ
9438
ⓞ
9437
ⓝ
>>> ' '.join(chr(x) for x in (9413, 9448, 9443, 9431, 9438, 9437))
'Ⓟ ⓨ ⓣ ⓗ ⓞ ⓝ'
>>> ' '.join(chr(int(x, base=16)) for x in ('2660', '2665', '2666', '2663'))
'♠ ♥ ♦ ♣'

Métodos disponibles sobre str

A continuación se muestran los métodos disponibles para strings:

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', 
'__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', 
'__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
'__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 
'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 
'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 
'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 
'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 
'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 
'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

Operaciones sobre cadenas

A continuación, se muestran ejemplos de cómo utilizar los métodos disponibles para cadenas de caracteres en Python.

Comparar cadenas en Python

Las cadenas se pueden comparar al ser iterables con los métodos de igualdad, mayor que, o menor qué.

Estas operaciones miran el orden alfabético de las letras que contiene cada string para comparar.

>>> 'Hola' > 'Hola'
False
>>> 'Hola' == 'Hola'
True
>>> 'Hola' == 'Hola Mundo'
False
>>> '123' > '0453'
True
>>> 'Pepe' < 'Juan'
False
>>> '123' > '01234'
True
>>> len('hola mundo') < len('HOLA MUNDO')
False
>>> '123' < 123
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'

Como se puede ver en los ejemplos, la comparación de cadenas hace que el resultado de comparar cadenas que reprensenten números devuelva un valor contrario a la lógica.

>>> '123' > '0453'
True  # aunque 123 < 0453 numéricamente
>>> '1' > '05'
True
>>> int('1') > int('05')
False
>>> '1' > 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'str' and 'int'

Si se utilizan enteros para comparar, se puede ver que 1 < 5 pero en forma de cadenas '1' > '05'.

Por otro lado, cuando se mezclan números con cadenas para hacer comparaciones, se devuelve un error tipo TypeError al no soportar esta operación entre tipos distintos de datos.

Además, se pueden comparar si una cadena está en un texto, utilizando la operación in como en cualquier otro tipo de iterador.

>>> 'a' in 'alberto'
True
>>> 'alberto' in 'Los alumnos son juan, pedro y ana'
False
>>> 'juan' in 'Los alumnos son juan, pedro y ana'
True

Separar cadenas en Python – split

Para separar cadenas se utiliza split, y como argumento se pasa el carácter, o cadena de caracteres que se quiera utilizar para separar las cadenas.

>>> 'This,is,a,comma,separated,string'.split(',')
['This', 'is', 'a', 'comma', 'separated', 'string']
>>> 'butazalsoazcanazbeazusedazwithazcharacters'.split('az')
['but', 'also', 'can', 'be', 'used', 'with', 'characters']
>>> 'also can be used like this'.split(' ')
['also', 'can', 'be', 'used', 'like', 'this']

Reemplazo de caracteres en Python – replace

Para reemplazar cadenas de caracteres por otras en python, se utilizar el método replace. Como primer argumento se usa la cadena a reemplazar y como segundo argumento, la cadena que debe de usarse.

>>> 'pepe'.replace('e', 'a')
'papa'
>>> 'jezzo porld'.replace('j', 'h').replace('z', 'l').replace('p', 'w')
'hello world'
>>> 'antonio sabe nadar'.replace('antonio', 'juan')
'juan sabe nadar'

Este método permite ser concatenado múltiples veces.

Recorrer cadenas en Python

Python permite leer cadenas de caracteres utilizando sentencias de bucles como cualquier iterador. Por tanto cualquier forma en la que se utilizan los iteradores en Python es válida.

>>> idx = 0
>>> msg = 'Hola'
>>> while idx < len(msg):
...     print(msg[idx])
...     idx += 1
...
H
o
l
a
>>> for idx in range(len(msg)):
...     print(msg[idx])
...
H
o
l
a
>>> for x in msg:
...     print(x)
...
H
o
l
a

Leer cadenas en Python – substring o slicing

Como en cualquier otro tipo de iteradores, se pueden utilizar las operaciones de slicing para acceder a determinados elementos y seleccionar solo una porción de la cadena principal.

>>> 'abcd-efg-hij'[1]
'b'
>>> 'abcd-efg-hij'[1:]
'bcd-efg-hij'
>>> 'abcd-efg-hij'[1:5]
'bcd-'
>>> 'abcd-efg-hij'[:5]
'abcd-'
>>> 'abcd-efg-hij'[6:7]
'f'
>>> 'abcd-efg-hij'[6:10:2]
'f-'
>>> 'abcd-efg-hij'[1:10:3]
'b-g'
>>> 'abcd-efg-hij'[-1]
'j'
>>> 'abcd-efg-hij'[:-1]
'abcd-efg-hi'
>>> 'abcd-efg-hij'[4:-1:-4]
''
>>> 'abcd-efg-hij'[4:10:-4]
''
>>> 'abcd-efg-hij'[10:0:-2]
'i-f-c'

Concatenar cadenas en Python – join

Se pueden concatenar cadenas usando el método join, que a partir de un iterador de elementos (una lista por ejemplo), concatena todos los elementos uniendolos con la cadena a la que se llame el método creando una cadena final de elementos concatenados.

>>> ''.join(['a', 'b', 'c'])
'abc'
>>> '-'.join(['a', 'b', 'c'])
'a-b-c'
>>> ';'.join(['a', 'b', 'c'])
'a;b;c'
>>> ' ; '.join(['a', 'b', 'c'])
'a ; b ; c'
>>> ' || '.join(['a', 'b', 'c'])
'a || b || c'

Además, se pueden concatenar cadenas usando el operador de suma

>>> 'abc' + 'def'
'abcdef'
>>> 'Hola' + 'Mundo'
'HolaMundo'
>>> 'Hola' + ' Mundo'
'Hola Mundo'
>>> 'Hola' + ' Mundo' * 4
'Hola Mundo Mundo Mundo Mundo'

Invertir cadenas en Python

Para invertir cadenas en Python se puede hacer de múltiples formas. Dado que se pueden acceder a cada elemento, si se itera sobre la cadena con números negativos hasta llegar al 0, se obtienen los elemento en orden inverso.

>>> idx = -1
>>> while idx >= -len(msg):
...     print(f'msg[{idx}] -> {msg[idx]}')
...     idx -= 1
...
msg[-1] -> a
msg[-2] -> l
msg[-3] -> o
msg[-4] -> H

También se podría optar por generar una lista, invertir la lista y concatenar los elementos, aunque esta opción es muy poco eficiente.

>>> lst_msg = list(msg)
>>> print(lst_msg)
['H', 'o', 'l', 'a']
>>> lst_msg.reverse()
>>> print(lst_msg)
['a', 'l', 'o', 'H']
>>> print(''.join(lst_msg))
aloH

Sin embargo, la forma más simple y eficiente es utilizar la inversión de iteradores por medio de slicing en python como sigue:

>>> inv_msg = msg[::-1]
>>> print(msg, inv_msg)
Hola aloH

Limpieza de cadenas en Python – strip

En multitud de casos se pretende «limpiar» las cadenas de caracteres eliminando los espacios alrededor de la misma. En Python se utiliza el método strip para ello.

>>> '\n\t     Hello        World   \t'
'\n\t     Hello        World   \t'
>>> print('\n\t     Hello        World   \t')

	     Hello        World
>>> print('\n\t     Hello        World   \t'.strip())
Hello        World
>>> '\n\t     Hello        World   \t'.strip()
'Hello        World'

Cambiar tamaño de cadenas en Python – lowercase, uppercase, title, capitalize, …

El lenguaje dispone de múltiples formas para transformar los tamaños de cada caracter.

>>> 'En un LuGaR de La ManchA'.lower()
'en un lugar de la mancha'
>>> 'En un LuGaR de La ManchA'.upper()
'EN UN LUGAR DE LA MANCHA'
>>> 'En un LuGaR de La ManchA'.swapcase()
'eN UN lUgAr DE lA mANCHa'
>>> 'En un LuGaR de La ManchA'.capitalize()
'En un lugar de la mancha'
>>> 'En un LuGaR de La ManchA'.title()
'En Un Lugar De La Mancha'

Libros recomendados para aprender Python

Estos son los libros que pueden ayudarte a aprender Python, aprender a programar, tipos de datos, algoritmia y mucho más.

Disponible en: Marcombo Amazon

Ver en Kindle Amazon

Ver en Kindle Amazon

Ver en Kindle Amazon

Ver en Kindle Amazon

---

Rangos y enumerados en Python – range y enumerate

Rangos y enumerados en Python – range y enumerate

Diccionarios en Python (Mapas) – dicts

Diccionarios en Python (Mapas) – dicts

Tipos numéricos y bool – int, float, complex y bool

Tipos numéricos y bool – int, float, complex y bool

Conjuntos en Python – set

Conjuntos en Python – set

Tuplas en Python – tuple

Tuplas en Python – tuple

Listas y matrices en Python – list

Listas y matrices en Python – list

Variables en Python

Variables en Python