Cadenas de caracteres – strings

Strings en python

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']
MétodoDescripciónEjemplo
capitalizeDevuelve la forma capitalizada de la cadena. Con el primer carácter en mayúscula.str.capitalize()
casefoldDevuelve una versión de la cadena para comparar de forma segura.str.casefold()
centerDevuelve una cadena centrada con una longitud definida como argumento.str.center(50)
countDevuelve el número de ocurrencias donde una cadena aparece en la principal.str.count(str2)
encodePermite añadir la codificación de la cadena.str.encode('latin-1')
endswithDevuelve True si la cadena principal termina con una cadena como argumento.str.endswith(str2)
expandtabsDevuelve una cadena donde los caracteres tabulador se expanden usando espacios.str.expandtabs()
findDevuelve la posición de una cadena sobre la cadena principal. Si no la encuentra devuelve -1.str.find(str2)
formatPermite formatear una cadena con argumentos. Desde Python 3 se suelen usar f-strings en vez de format cuando es posible.str.format(color='Red')
format_mapPermite crear un mapeo para ser usado en la función format.str.format_map({'color': 'red'})
indexDevuelve la posición exacta de una sub-cadena sobre la principal. Si no la encuentra devuelve un error.str.index('pepe')
isalnumDevuelve si la cadena es alfanumérica.str.isalnum()
isalphaDevuelve si la cadena es alfa.str.isalpha()
isasciiDevuelve True si todos los caracteres están en el rango unicode U+0000-U+007F.str.isascii()
isdecimalDevuelve True si todos los caracteres son decimales.str.isdecimal()
isdigitDevuelve True si todos los caracteres son dígitos.str.isdigit()
isidentifierDevuelve True si la cadena es un identificador reservado.str.isidentifier()
islowerDevuelve True si todos los caracteres de la cadena estén en su forma minúscula.str.islower()
isnumericDevuelve True si todos los caracteres son numéricos.str.isnumeric()
isprintableDevuelve True si todos los caracteres de la cadena son imprimibles.str.isprintable()
isspaceDevuelve True si todos los caracteres de la cadena son espacios.str.isspace()
istitleDevuelve True si la cadena está en formato de título.str.istitle()
isupperDevuelve True si todos los caracteres de la cadena estén en su forma mayúscula..str.isupper()
joinUne todos los caracteres pasados como argumentos usando la cadena como carácter de unión.str.join('hola')
ljustDevuelve una cadena justificada a la izquierda.str.ljust(50)
lowerReturn a copy of the string converted to lowercase.str.lower(5)
lstripDevuelve una cadena sin espacios a la izquierda.str.lstrip()
maketransDevuelve una tabla para mapear caracteres.str.maketrans({45: 'a', 43: 'b'})
partitionDevuelve 3 cadenas separando la principal con un carácter pasado como argumento.str.partition(',')
removeprefixDevuelve una nueva cadena con el prefijo como argumento eliminado (si existe).str.removeprefix('hello')
removesuffixDevuelve una nueva cadena con el sufijo como argumento eliminado (si existe).str.removesuffix('world')
replaceDevuelve una nueva cadena con los caracteres reemplazados.str.replace('a', 'b')
rfindDevuelve el índice donde aparece una sub-cadena en la cadena principal o -1.str.rfind(5)
rindexDevuelve el índice donde aparece una sub-cadena en la cadena principal o eleva un error.str.rindex(5)
rjustDevuelve una cadena justificada a la derecha.str.rjust(50)
rpartitionSimilar a partition pero comenzando desde la derecha.str.rpartition(',')
rsplitSimilar a split pero comenzando desde la derecha.str.rsplit(',')
rstripSimilar a strip pero comenzando desde la derecha.str.rstrip()
splitSepara la cadena original en sub-cadenas donde se encuentre el separador pasado como argumento. Devuelve una lista.str.split(',')
splitlinesDevuelve una lista de cadenas separando la original por sus saltos de línea.str.splitlines()
startswithDevuelve True si la cadena principal comienza con la que se pasa como argumento.str.startswith(str2)
stripDevuelve una copia de la cadena original con los espacios al comienzo y final eliminados.str.strip()
swapcaseCambia el tamaño de todos los caracteres de la cadena principal.str.swapcase()
titleDevuelve una versión de la cadena principal en formato titulo.str.title()
translateReemplaza la cadena principal con una tabla de conversión.str.translate({1: None, 10: None, 99: 145})
upperDevuelve una copia de la cadena principal con todos los caracteres en mayúsculas.str.upper(5)
zfillRellena la cadena con ceros a la izquierda.str.zfill(50)

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:

Compartir

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Información básica sobre protección de datos Ver más

  • Responsable Oscar Ramirez.
  • Finalidad Moderar los comentarios. Responder las consultas.
  • Legitimación Su consentimiento.
  • Destinatarios  ionos.
  • Derechos Acceder, rectificar y suprimir los datos.

Publicar un comentario