Tipos de Datos en Python: Cadenas de Caracteres

El tipo de dato str representa lo que comúnmente se denomina cadenas de caracteres o strings, que en Python son secuencias inmutables de caracteres. Se emplean generalmente para representar y manipular datos textuales. Constituyen un tipo de dato muy empleado en la programación y en Python son extremadamente versátiles y flexibles.

Algunos ejemplos de literales válidos del tipo str en Python son:

Con comillas simples:

'Hola Mundo!'

'Python es increíble'

'Comillas dobles "embebidas"'

Este es el tipo de string más empleado, quizás por ser el más fácil de teclear, se emplea además, cuando queremos incluir comillas dobles en el texto que estamos procesando.

Con comillas dobles:

"Hola Mundo!"

"Python es increíble"

"Comillas simples 'embebidas'"

Esta variante es menos empleada, su aplicación más común es cuando deseamos incluir comillas simples en el texto.

Con tres comillas simples:

'''Hola Mundo!'''

'''Python es increíble'''

'''Este tipo de cadena soporta múltiples líneas

en un mismo entrecomillado.'''

Con tres comillas dobles:

"""Hola Mundo!"""

"""Python es increíble"""

"""Este tipo de cadena soporta múltiples líneas

en un mismo entrecomillado."""

Este último tipo de strings se emplea generalmente en lo que conocemos como “docstrings” o “cadenas de documentación”, muy útiles para mejorar la legibilidad y comprensión de nuestro código fuente.

Para crear una cadena de caracteres vacía se puede proceder de las maneras siguientes:

>>> empty = str()
>>> empty
''
>>> empty = ''
>>> empty
''

La variante de las comillas acepta todos los tipos de comillas válidos que hemos listado con anterioridad.

Definición del Tipo str

El tipo str se define como una clase de la forma:

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
Que retorna una versión string de object. Si no se suministra ningún valor para object, retorna una cadena vacía. Si se suministran valores para encoding o errors, entonces object debe ser un objeto de tipo byteslike, por esta razón debemos colocar una b delante de las comillas en el segundo constructor de la clase. Veamos algunos ejemplos:
>>> str('Python')
'Python'
>>> str(125)
'125'
>>> str(b'101010101')
"b'101010101'"
>>> str(b'101010101', encoding='utf-8')
'101010101'
>>> str(b'Esta es la letra \xc3\x91', encoding='utf-8')
'Esta es la letra Ñ'

Debemos hacer notar que en Python no existe un tipo de dato específico para caracteres individuales como existe en otros lenguajes, por tanto, la forma de representar un carácter individual es usando una cadena de longitud igual a uno que contenga únicamente el carácter deseado.

Algunos Métodos Comunes de la Clase str

La clase str define una serie bien amplia de métodos que nos pueden auxiliar en muchas tareas de manipulación de strings. Veamos algunos de ellos y su funcionamiento general.

str.endswith(suffix[, start[, end]])

Retorna verdadero (True) si la cadena termina con el sufijo suffix, de otro modo retorna falso (False).
>>> s = 'Python es genial'
>>> s.endswith('genial')
True

str.startswith(prefix[, start[, end]])

Retorna verdadero (True) si la cadena comienza con el prefijo prefix, de otro modo retorna falso (False).
>>> s.startswith('Py')
True

str.strip([chars])

Retorna una copia de str con los caracteres inicial y final eliminados. Si proporcionamos un valor para chars, este representará el conjunto de caracteres que serán eliminados al principio y al final de la cadena. Si no se proporciona ningún valor para chars, se asume por defecto el conjunto de caracteres de espacios en blanco, tal y como se define en string.whitespace.

>>> s = 'Texto con espacios al final '

>>> s

'Texto con espacios al final '

>>> s.strip() # Eliminamos los espacios al final del texto

'Texto con espacios al final'

>>> s = 'Texto con tabulación al final '

>>> s

'Texto con tabulación al final \t\t\t'

>>> s.strip() # Eliminamos los caracteres de tabulación

'Texto con tabulación al final'

str.split(sep=None, maxsplit=-1)

Retorna una lista de las palabras incluidas en str usando como delimitador el parámetro sep. Si suministramos un valor entero para maxsplit al menos maxsplit divisiones se realizarán.

>>> s = 'Python es genial'

>>> s

'Python es genial'

>>> s.split() # Generamos una lista con las palabras del texto

['Python', 'es', 'genial']

>>> s.split(maxsplit=1)

['Python', 'es genial'] # Solo se ejecuta una división

>>> url = 'http://pythonscouts.cubava.cu'

>>> url.split('.') # Empleamos el carácter “.” como delimitador

['http://pythonscouts', 'cubava', 'cu']

str.lower()

Retorna una copia de str con todas las letras mayúsculas convertidas en minúsculas.

>>> s = 'PyTHoN Es genial'

>>> s.lower() # Todo en minúsculas

'python es genial'

str.upper()

Retorna una copia de str con todas las letras minúsculas convertidas en mayúsculas.

>>> s = 'Python Es Genial'

>>> s.upper() # Todo en mayúsculas

'PYTHON ES GENIAL'

Estos dos métodos anteriores vienen a mano cuando estamos procesando datos suministrados por el usuario en sistemas sensibles a las mayúsculas y minúsculas (case-sensitive), para, de alguna forma, homogeneizar los datos a procesar y validar.

str.join(iterable)

Retorna la cadena que resulta de la concatenación de str con los elementos de iterable, empleando como separador la propia cadena que suministra el método.

>>> l = ['Yo', 'prefiero', 'Python', '3']

>>> l

['Yo', 'prefiero', 'Python', '3']

>>> ' '.join(l) # Concatenamos usando el caracteres de espacio

'Yo prefiero Python 3'

Aquí debemos tener en cuenta que el Intérprete levantará una excepción del tipo TypeError si alguno de los elementos de iterable no es de tipo string.

Cada vez que queramos concatenar cadenas de caracteres en tiempo de ejecución es recomendable usar el método join() en lugar del operador más (+), que aunque hace la misma función, resulta un poco menos eficiente (al menos en versiones anteriores de Python, pues esto ha sido mejorado en versiones más recientes).

str.format(*args, **kwargs)

Ejecuta operaciones de formateo de cadenas.

>>> 'La suma de 3 + 2 es {0}'.format(3 + 2)

'La suma de 3 + 2 es 5'

>>> 'Este es el Blog {bname}'.format(bname='Python Scouts')

'Este es el Blog Python Scouts'

El método format() puede tomar argumentos posicionales y/o keyword. {0} será reemplazado por el primer argumento, {1}, por el segundo y así sucesivamente. Si usamos argumentos keyword, como por ejemplo {bname}, entonces la llamada de format() deberá usar keyword, como en el ejemplo anterior.

Es importante hacer notar que todos estos métodos tienen un valor de retorno específico, que en muchos casos consistente en una copia de la cadena original a la que se le han aplicado las modificaciones que define el método. Esto se debe a que, como ya hemos dicho, las cadenas (strings) pertenecen a los tipos de datos inmutables y por tanto no pueden ser modificadas en el lugar, como es el casos de las listas o los diccionarios.

>>> id('La suma de 3 + 2 es {0}')

139750136940992

>>> id('La suma de 3 + 2 es {0}'.format(3 + 2))

139750136941064

Cadenas Formateadas f-strings

Para los que prefieren mantenerse a la cabeza del desarrollo de Python y usar la versión 3.6, recomendamos el empleo de las Cadenas Formateadas o f-strings, que no son más que cadenas de caracteres definidas con el prefijo “f” y que funcionan en forma muy parecida al método format(), pero que aportan una sintaxis más compacta y eficiente.

Python 3.6.2 (default, Aug 13 2017, 12:42:31)

[GCC 5.4.0 20160609] on linux

Type "help", "copyright", "credits" or "license" for more information.

>>> bname = 'Python Scouts'

>>> 'Este es el Blog {bname}'

'Este es el Blog Python Scouts'

Acceso a caracteres individuales de una cadena

Las cadenas de caracteres forman parte de lo que llamamos secuencias. Una de las operaciones que comúnmente realizamos sobre las secuencias es el acceso a elementos individuales de estas a través de sus índices, lo cual se logra con el operador []. Por ejemplo:

>>> s = 'Python es genial'

>>> s[0] # Primer elemento de la secuencia

'P'

>>> s[1] # Segundo elemento

'y'

>>> s[2] # Tercer elemento...

't'

Los índices, como en toda secuencia, comienzan en 0, que da acceso al primer elemento, 1, al segundo y así sucesivamente. Podemos emplear índices negativos, para lo cual -1 dará acceso al último elemento de la secuencia, -2, al penúltimo, -3, al antepenúltimo, etc.

>>> s[-1] # Último elemento de la secuencia

'l'

>>> s[-2] # Penúltimo elemento

'a'

>>> s[-3] # Antepenúltimo elemento...

'i'

Finalmente, como las cadenas son inmutables, no está permitida la modificación de elementos individuales de la forma:

>>> s[0] = 'J'

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'str' object does not support item assignment

Es por eso que somos recompensados con la excepción correspondiente, tal y como podemos apreciar en el ejemplo anterior.

El Módulo string

Si hurgamos un poco en la librería estándar encontraremos el módulo string que no es más que una colección de contantes de cadenas, tal y como resume el docstring del propio módulo. Entra estas constantes podemos encontrar:

>>> import string

>>> string.whitespace

' \t\n\r\x0b\x0c'

>>> string.digits

'0123456789'

>>> string.punctuation

'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

Entre otras que nos pueden ayudar en determinadas situaciones.

Lecturas Recomendadas

Para profundizar en el estudio y conocimiento del tipo de datos str recomendamos la lectura de la documentación oficial de Python en su acápite 4.7. Text Sequence Type — str. Recomendamos además, la lectura del Capítulo 4 “Strings” del libro “Dive Into Python 3” de Mark Pilgrim.

Bien, esto es todo por ahora, si este artículo te resultó interesante y/o útil, compártelo para que otros también puedan acceder a él. Déjanos tus comentarios y podremos mejorar nuestros contenidos.

Gracias de antemano,

lpozo