Fundamentos del Procesamiento de Texto

Introducción

Esta sección presenta formas de trabajar con texto.

Representando texto literal

Los literales de cadena se escriben en los programas con comillas.

## Comilla simple
a = 'Yeah but no but yeah but...'

## Comilla doble
b = "computer says no"

## Comillas triples
c = '''
Look into my eyes, look into my eyes, the eyes, the eyes, the eyes,
not around the eyes,
don't look around the eyes,
look into my eyes, you're under.
'''

Normalmente, las cadenas solo pueden abarcar una sola línea. Las comillas triples capturan todo el texto encerrado en múltiples líneas, incluyendo todo el formato.

No hay diferencia entre usar comillas simples (') y comillas dobles ("). Sin embargo, se debe usar el mismo tipo de comilla para iniciar y terminar una cadena.

Códigos de escape de cadena

Los códigos de escape se utilizan para representar caracteres de control y caracteres que no se pueden escribir fácilmente directamente desde el teclado. Aquí hay algunos códigos de escape comunes:

'\n'      Salto de línea
'\r'      Retorno de carro
'\t'      Tabulación
'\''      Comilla simple literal
'\"'      Comilla doble literal
'\\'      Barra invertida literal

Representación de cadenas

Cada carácter en una cadena se almacena internamente como un llamado "punto de código" Unicode, que es un entero. Puedes especificar un valor exacto de punto de código usando las siguientes secuencias de escape:

a = '\xf1'          ## a = 'ñ'
b = '\u2200'        ## b = '∀'
c = '\U0001D122'    ## c = '𝄢'
d = '\N{FOR ALL}'   ## d = '∀'

La Unicode Character Database es una referencia para todos los códigos de caracteres disponibles.

Indexación de cadenas

Las cadenas funcionan como un array para acceder a los caracteres individuales. Se utiliza un índice entero, comenzando en 0. Los índices negativos especifican una posición relativa al final de la cadena.

a = 'Hello world'
b = a[0]          ## 'H'
c = a[4]          ## 'o'
d = a[-1]         ## 'd' (final de la cadena)

También se puede segmentar o seleccionar subcadenas especificando un rango de índices con :.

d = a[:5]     ## 'Hello'
e = a[6:]     ## 'world'
f = a[3:8]    ## 'lo wo'
g = a[-5:]    ## 'world'

El carácter en el índice final no se incluye. Los índices faltantes asumen el principio o el final de la cadena.

Operaciones con cadenas

Concatenación, longitud, pertenencia y replicación.

## Concatenación (+)
a = 'Hello' + 'World'   ## 'HelloWorld'
b = 'Say'+ a          ## 'Say HelloWorld'

## Longitud (len)
s = 'Hello'
len(s)                  ## 5

## Prueba de pertenencia (`in`, `not in`)
t = 'e' in s            ## True
f = 'x' in s            ## False
g = 'hi' not in s       ## True

## Replicación (s * n)
rep = s * 5             ## 'HelloHelloHelloHelloHello'

Métodos de cadenas

Las cadenas tienen métodos que realizan diversas operaciones con los datos de la cadena.

Ejemplo: eliminar cualquier espacio en blanco al principio / al final.

s ='  Hello '
t = s.strip()     ## 'Hello'

Ejemplo: conversión de mayúsculas y minúsculas.

s = 'Hello'
l = s.lower()     ## 'hello'
u = s.upper()     ## 'HELLO'

Ejemplo: reemplazar texto.

s = 'Hello world'
t = s.replace('Hello', 'Hallo')   ## 'Hallo world'

Más métodos de cadenas:

Las cadenas tienen una amplia variedad de otros métodos para probar y manipular los datos de texto. Este es un pequeño ejemplo de métodos:

s.endswith(suffix)     ## Comprobar si la cadena termina con el sufijo
s.find(t)              ## Primera aparición de t en s
s.index(t)             ## Primera aparición de t en s
s.isalpha()            ## Comprobar si los caracteres son alfabéticos
s.isdigit()            ## Comprobar si los caracteres son numéricos
s.islower()            ## Comprobar si los caracteres son en minúsculas
s.isupper()            ## Comprobar si los caracteres son en mayúsculas
s.join(slist)          ## Unir una lista de cadenas usando s como delimitador
s.lower()              ## Convertir a minúsculas
s.replace(old,new)     ## Reemplazar texto
s.rfind(t)             ## Buscar t desde el final de la cadena
s.rindex(t)            ## Buscar t desde el final de la cadena
s.split([delim])       ## Dividir la cadena en una lista de subcadenas
s.startswith(prefix)   ## Comprobar si la cadena empieza con el prefijo
s.strip()              ## Quitar el espacio en blanco al principio / al final
s.upper()              ## Convertir a mayúsculas

Inmutabilidad de cadenas

Las cadenas son "inmutables" o de solo lectura. Una vez creadas, no se puede cambiar su valor.

>>> s = 'Hello World'
>>> s[1] = 'a'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError:'str' object does not support item assignment
>>>

Todas las operaciones y métodos que manipulan los datos de una cadena, siempre crean nuevas cadenas.

Conversiones de cadenas

Utilice str() para convertir cualquier valor en una cadena. El resultado es una cadena que contiene el mismo texto que se habría producido con la instrucción print().

>>> x = 42
>>> str(x)
'42'
>>>

Cadenas de bytes

Una cadena de bytes de 8 bits, comúnmente encontrada en la E/S de bajo nivel, se escribe de la siguiente manera:

data = b'Hello World\r\n'

Al poner una pequeña b antes de la primera comilla, se especifica que es una cadena de bytes en oposición a una cadena de texto.

La mayoría de las operaciones habituales de cadenas funcionan.

len(data)                         ## 13
data[0:5]                         ## b'Hello'
data.replace(b'Hello', b'Cruel')  ## b'Cruel World\r\n'

La indexación es un poco diferente porque devuelve valores de byte como enteros.

data[0]   ## 72 (código ASCII para 'H')

Conversión a/desde cadenas de texto.

text = data.decode('utf-8') ## bytes -> texto
data = text.encode('utf-8') ## texto -> bytes

El argumento 'utf-8' especifica una codificación de caracteres. Otros valores comunes incluyen 'ascii' y 'latin1'.

Cadenas sin procesar

Las cadenas sin procesar son literales de cadena con una barra invertida no interpretada. Se especifican prefijando la comilla inicial con una "r" minúscula.

>>> rs = r'c:\newdata\test' ## Sin procesar (barra invertida no interpretada)
>>> rs
'c:\\newdata\\test'

La cadena es el texto literal encerrado dentro, exactamente como se escribió. Esto es útil en situaciones donde la barra invertida tiene un significado especial. Ejemplo: nombre de archivo, expresiones regulares, etc.

Cadenas f

Una cadena con sustitución de expresión formateada.

>>> name = 'IBM'
>>> shares = 100
>>> price = 91.1
>>> a = f'{name:>10s} {shares:10d} {price:10.2f}'
>>> a
'       IBM        100      91.10'
>>> b = f'Cost = ${shares*price:0.2f}'
>>> b
'Cost = $9110.00'
>>>

Nota: Esto requiere Python 3.6 o posterior. El significado de los códigos de formato se describe más adelante.

En estos ejercicios, experimentarás con operaciones en el tipo de cadena de Python. Debes hacerlo en el prompt interactivo de Python donde puedes ver fácilmente los resultados. Nota importante:

En los ejercicios donde se supone que debes interactuar con el intérprete, >>> es el prompt del intérprete que obtienes cuando Python te pide que escribas una nueva declaración. Algunas declaraciones en el ejercicio abarcan varias líneas: para que estas declaraciones se ejecuten, es posible que tengas que presionar 'enter' varias veces. Solo un recordatorio de que NO escribes el >>> cuando trabajas estos ejemplos.

Comienza definiendo una cadena que contenga una serie de símbolos de cotización de acciones como esta:

>>> symbols = 'AAPL,IBM,MSFT,YHOO,SCO'
>>>

Ejercicio 1.13: Extracción de caracteres individuales y subcadenas

Las cadenas son arrays de caracteres. Intenta extraer algunos caracteres:

>>> symbols[0]
?
>>> symbols[1]
?
>>> symbols[2]
?
>>> symbols[-1]        ## Último carácter
?
>>> symbols[-2]        ## Los índices negativos son a partir del final de la cadena
?
>>>

En Python, las cadenas son de solo lectura.

Verifícalo intentando cambiar el primer carácter de symbols a una 'a' en minúsculas.

>>> symbols[0] = 'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>>

Ejercicio 1.14: Concatenación de cadenas

Aunque los datos de cadena son de solo lectura, siempre puedes reasignar una variable a una cadena recién creada.

Prueba la siguiente declaración que concatena un nuevo símbolo "GOOG" al final de symbols:

>>> symbols = symbols + 'GOOG'
>>> symbols
'AAPL,IBM,MSFT,YHOO,SCOGOOG'
>>>

Uy! Eso no es lo que querías. Corrige it para que la variable symbols tenga el valor 'AAPL,IBM,MSFT,YHOO,SCO,GOOG'.

>>> symbols =?
>>> symbols
'AAPL,IBM,MSFT,YHOO,SCO,GOOG'
>>>

Agrega 'HPQ' al principio de la cadena:

>>> symbols =?
>>> symbols
'HPQ,AAPL,IBM,MSFT,YHOO,SCO,GOOG'
>>>

En estos ejemplos, puede parecer que la cadena original está siendo modificada, en una aparente violación de la propiedad de solo lectura de las cadenas. No es así. Las operaciones en cadenas crean una cadena completamente nueva cada vez. Cuando la variable symbols se reasigna, apunta a la cadena recién creada. Después, la cadena vieja se destruye ya que ya no se está utilizando.

Ejercicio 1.15: Prueba de pertenencia (prueba de subcadena)

Experimenta con el operador in para comprobar subcadenas. En el prompt interactivo, prueba estas operaciones:

>>> 'IBM' in symbols
?
>>> 'AA' in symbols
True
>>> 'CAT' in symbols
?
>>>

¿Por qué la comprobación de 'AA' devolvió True?

Ejercicio 1.16: Métodos de cadena

En el prompt interactivo de Python, intenta experimentar con algunos de los métodos de cadena.

>>> symbols.lower()
?
>>> symbols
?
>>>

Recuerda, las cadenas siempre son de solo lectura. Si quieres guardar el resultado de una operación, debes ponerlo en una variable:

>>> lowersyms = symbols.lower()
>>>

Intenta algunas operaciones más:

>>> symbols.find('MSFT')
?
>>> symbols[13:17]
?
>>> symbols = symbols.replace('SCO','DOA')
>>> symbols
?
>>> name = '   IBM   \n'
>>> name = name.strip()    ## Elimina los espacios en blanco circundantes
>>> name
?
>>>

Ejercicio 1.17: cadenas f

A veces quieres crear una cadena y embeber los valores de variables en ella.

Para hacer eso, utiliza una cadena f. Por ejemplo:

>>> name = 'IBM'
>>> shares = 100
>>> price = 91.1
>>> f'{shares} acciones de {name} a ${price:0.2f}'
'100 acciones de IBM a $91.10'
>>>

Modifica el programa mortgage.py del Ejercicio 1.10 para crear su salida utilizando cadenas f. Intenta hacerlo de modo que la salida esté bien alineada.

Ejercicio 1.18: Expresiones regulares

Una limitación de las operaciones básicas de cadenas es que no admiten ningún tipo de coincidencia de patrones avanzada. Para eso, debes recurrir al módulo re de Python y a las expresiones regulares. El manejo de expresiones regulares es un tema amplio, pero aquí hay un ejemplo corto:

>>> text = 'Today is 3/27/2018. Tomorrow is 3/28/2018.'
>>> ## Encuentra todas las ocurrencias de una fecha
>>> import re
>>> re.findall(r'\d+/\d+/\d+', text)
['3/27/2018', '3/28/2018']
>>> ## Reemplaza todas las ocurrencias de una fecha con texto de reemplazo
>>> re.sub(r'(\d+)/(\d+)/(\d+)', r'\3-\1-\2', text)
'Today is 2018-3-27. Tomorrow is 2018-3-28.'
>>>

Para obtener más información sobre el módulo re, consulte la documentación oficial en https://docs.python.org/library/re.html.

Comentario

A medida que empiezas a experimentar con el intérprete, a menudo quieres saber más sobre las operaciones admitidas por diferentes objetos. Por ejemplo, ¿cómo descubres qué operaciones están disponibles en una cadena?

Dependiendo de tu entorno de Python, es posible que puedas ver una lista de los métodos disponibles a través de la finalización con tabulación. Por ejemplo, prueba a escribir esto:

>>> s = 'hello world'
>>> s.<tab key>
>>>

Si pulsar la tecla Tab no produce ningún efecto, puedes recurrir a la función integrada dir(). Por ejemplo:

>>> s = 'hello'
>>> dir(s)
['__add__', '__class__', '__contains__',..., 'find', 'format',
'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace',
'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition',
'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit',
'rstrip','split','splitlines','startswith','strip','swapcase',
'title', 'translate', 'upper', 'zfill']
>>>

dir() produce una lista de todas las operaciones que pueden aparecer después del (.). Utiliza el comando help() para obtener más información sobre una operación específica:

>>> help(s.upper)
Ayuda sobre la función integrada upper:

upper(...)
    S.upper() -> string

    Devuelve una copia de la cadena S convertida a mayúsculas.
>>>

Resumen

¡Felicitaciones! Has completado el laboratorio de cadenas. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.