7.

Cadenas

7.1. Un tipo de datos compuesto

Hasta ahora hemos visto cinco tipos: int, float, bool, NoneType y str. Las cadenas son cualitativamente
diferentes de los otros cuatro tipos porque están hechas de piezas más pequeñas — los caracteres.

Los tipos que comprenden piezas mas pequeñas se llaman tipos de datos compuestos. Dependiendo
de lo que hagamos, podemos tratar un tipo de datos compuesto como una única cosa o podemos
acceder a sus partes. Esta ambigüedad es útil.

El operador corchete selecciona sólo un carácter de una cadena:

>>> fruta = "banana"

>>> letra = fruta[1]
>>> print letra

La expresión fruta[1] selecciona el carácter número 1 de fruta. La variable letra apunta al resultado.
Cuando mostramos letra, nos encontramos con una sorpresa:

La primera letra de "banana" no es a. A no ser que usted sea un programador. Por perversas razones,
los científicos de la computación siempre empiezan a contar desde cero. La 0-ésima letra (“cero-
ésima”) de "banana" es b. La 1-ésima (“uno- ésima”) es a, y la 2-ésima (“dos-ésima”) letra es n.

Nota del traductor: La numeración ordinal — por todos conocida — no contempla al cero
como parte de su verbalización, por lo que se considera apropiada la introducción de esta
forma de expresar la numeración de caracteres, dado el objetivo que se persigue.

Si quiere la cero-ésima letra de una cadena, simplemente pone 0, o cualquier expresión de valor 0,
entre los corchetes:

>>> letra = fruta[0]

>>> print letra
b

A la expresión entre corchetes se le llama índice. Un índice identifica a un miembro de un conjunto

ordenado, en este caso el conjunto de caracteres de la cadena. El índice indica cuál quiere usted, de ahí
el nombre. El índice puede ser cualquier expresión entera.

7.2. Longitud
La función len devuelve el número de caracteres de una cadena:

>>> fruta = "banana"

>>> len(fruta)
6

Para obtener la última letra de una cadena, puede sentirse tentado a probar algo como esto:

longitud = len(fruta)
ultima = fruta[longitud] # ¡ERROR!

Eso no funcionará. Esto provoca el error en tiempo de ejecución IndexError: string index out of
range. La razón es que no hay una seis-ésima letra en "banana". Como empezamos a contar desde cero,
las seis letras están numeradas del 0 al 5. Para obtener el último carácter tenemos que restar 1 a la
longitud:

longitud = len(fruta)
ultima = fruta[longitud-1]

Alternativamente podemos usar índices negativos, que cuentan hacia atrás desde el final de la cadena.
La expresión fruta[-1] da la última letra, fruta[-2] da la penúltima, y así sucesivamente.

7.3. Recorrido y el bucle for

Muchos cálculos implican procesar una cadena carácter por carácter. A menudo empiezan por el
principio, seleccionan cada carácter por turno, hacen algo con él y siguen hasta el final. Este patrón de
proceso se llama recorrido. Una forma de codificar un recorrido es con una sentencia while:

indice = 0
while indice < len(fruta):
letra = fruta[indice]
print letra
indice += 1

Este bucle recorre la cadena y muestra cada letra en una línea distinta. La condición del bucle es indice
&lt; len(fruta), de modo que cuando indice es igual a la longitud de la cadena, la condición es falsa y
no se ejecuta el cuerpo del bucle. El último carácter al que se accede es el que tiene el índice
len(fruta)-1, que es el último carácter de la cadena.

Usar un índice para recorrer un conjunto de valores es tan común que Python proporciona una sintaxis
alternativa más simple — el bucle for:

for carac in fruta:

print carac

Cada vez que recorremos el bucle, se asigna a la variable carac el siguiente carácter de la cadena. El
bucle continúa hasta que no quedan más caracteres.

El ejemplo siguiente muestra cómo usar la concatenación y a un bucle for para generar una serie
abecedaria. “Abecedaria” se refiere a la serie o lista en la que cada uno de los elementos aparece en
orden alfabético. Por ejemplo, en el libro de Robert McCloskey Make Way for Ducklings, los nombres de
los patitos son Jack, Kack, Lack, Mack, Nack, Ouack, Pack, y Quack. Este bucle muestra esos nombres en
orden:

prefijos = "JKLMNOPQ"
sufijo = "ack"

for letra in prefijos:

print letra + sufijo

La salida de este programa es:

Jack
Kack
Lack
Mack
Nack
Oack
Pack
 Qack

Por supuesto, esto no es del todo correcto, porque “Ouack” y “Quack” no están correctamente escritos.
Usted solucionará esto en un ejercicio más adelante.

7.4. Porciones de cadenas

A la subcadena de una cadena se le llama porción. La selección de una porción es similar a la selección
un carácter:

>>> s = "Pedro, Pablo, y Mario"

>>> print s[0:5]
Pedro
>>> print s[7:12]
Pablo
>>> print s[16:21]
Mario

El operador [n:m] devuelve la parte de la cadena desde el “n-ésimo” carácter hasta el “m-ésimo”,
incluyendo el primero pero excluyendo el último. Este comportamiento contradice a nuestra intuición;
tiene más sentido si imagina los índices señalando entre los caracteres, como en el siguiente diagrama:

Si omite el primer índice (antes de los dos puntos), la porción comienza al principio de la cadena. Si
omite el segundo índice, la porción llega al final de la cadena. Así:

>>> fruta = "banana"

>>> fruta[:3]
'ban'
>>> fruta[3:]
'ana'

¿Qué cree que significa s[:]?

7.5. Comparación de cadenas

Los operadores de comparación trabajan sobre cadenas. Para ver si dos cadenas son iguales:

if palabra == "banana":
print "Sí, ¡no tenemos bananas!"

Otras operaciones de comparación son útiles para poner palabras en orden alfabético:

if palabra < "banana":

print "Su palabra," + palabra + ", va antes de banana."
elif word > "banana":
print "Su palabra," + palabra + ", va después de banana."
else:
print "Sí, ¡no tenemos bananas!"

Sin embargo, debería ser consciente de que Python no maneja las letras mayúsculas y minúsculas como
lo hace la gente. Todas las letras mayúsculas van antes de las letras minúsculas. Por lo tanto:

Su palabra, Cebra, va antes de banana.

Una forma común de abordar este problema es convertir las cadenas a un formato estándar — como
pueden ser las minúsculas— antes de realizar la comparación. Un problema mayor es hacer que el
programa se de cuenta de que las cebras no son frutas.

7.6. Las cadenas son inmutables

Es tentador usar el operador [] en el lado izquierdo de una asignación, con la intención de cambiar un
carácter en una cadena. Por ejemplo:

saludo = "¡Hola todo el mundo!"

saludo[2] = 'L' # ¡ERROR!
print saludo

Nota del traductor: De acuerdo con la codificación de caracteres en utf-8 ó latin-1 (véase la
Nota del traductor del capítulo 2) el carácter de admiración, ‘¡’, en la variable saludo ocupa
dos posiciones, de ahí que la letra ‘H’ esté localizada en el índice 2.

En lugar de presentar la salida ¡Lola todo el mundo!, este código presenta el siguiente error en tiempo
de ejecución TypeError: 'str' object does not support item assignment.

Las cadenas son inmutables, lo que significa que no puede cambiar una cadena existente. Lo más que
puede hacer es crear una nueva cadena que sea una variación de la original:

saludo = "¡Hola todo el mundo!"

nuevoSaludo = '¡' + 'L' + saludo[3:]
print nuevoSaludo

Aquí la solución es concatenar la apertura del signo de admiración y una nueva primera letra a una
porción de saludo. Esta operación no tiene efecto sobre la cadena original.

7.7. El operador in
El operador in prueba si una cadena es una subcadena de otra:

>>> 'z' in 'manzana'

True
>>> 'i' in 'manzana'
False
>>> 'nz' in 'manzana'
True
>>> 'az' in 'manzana'
False

Observe que una cadena es una subcadena de si misma:

>>> 'a' in 'a'

True
>>> 'manzana' in 'manzana'
True

Combinando el operador in con la concatenación de cadenas usando +, podemos escribir una función
que elimina todas las vocales de una cadena:

def elimina_vocales(s):
vocales = "aeiouAEIOU"
s_sin_vocales = ""
for letra in s:
if letra not in vocales:
s_sin_vocales += letra
 return s_sin_vocales

Pruebe esta función para confirmar que realiza lo que queremos que haga.

7.8. Una función encuentra

¿Qué hace la siguiente función?

def encuentra(cadena, carac):

indice = 0
while indice &lt; len(cadena):
if cadena[indice] == carac:
return indice
indice += 1
return -1

En cierto sentido, encuentra es lo contrario del operador []. En lugar de tomar un índice y extraer el
carácter correspondiente, toma un carácter y encuentra el índice donde aparece el carácter. Si el carácter
no se encuentra, la función devuelve -1.

Este es el primer ejemplo que hemos visto de una sentencia return `` dentro de un bucle. Si
``cadena[indice] == carac, la función devuelve inmediatamente el índice, escapando del bucle
prematuramente.

Si el carácter no aparece en la cadena, entonces el programa sale del bucle normalmente y devuelve -1.

Este patrón de computación se llama a veces un recorrido “eureka” porque tan pronto como
encontramos lo que buscamos, podemos gritar “¡Eureka! ” y dejar de buscar.

7.9. Iterando y contando

El siguiente programa cuenta el número de veces que aparece la letra a en una cadena, y es otro
ejemplo del patrón de conteo introducido en el Contando dígitos:

fruta = "banana"
cuenta = 0
for carac in fruta:
if carac == 'a':
cuenta += 1
print cuenta

7.10. Parámetros opcionales

Para encontrar las posiciones de la segunda o tercera ocurrencia de un carácter en una cadena,
podemos modificar la función encuentra, agregando un tercer parámetro para la posición inicial en la
cadena de búsqueda:

def encuentra2(cadena, carac, inicio):

indice = inicio
while indice < len(cadena):
if cadena[indice] == carac:
return indice
indice += 1
return -1

La llamada a encuentra2('banana', 'a', 2) ahora devuelve 3, el índice de la segunda ‘a’ en ‘banana’.

Mejor aún, podemos combinar encuentra y encuentra2 usando un parámetro opcional:

 def encuentra(cadena, carac, inicio=0):
indice = inicio
while indice < len(cadena):
if cadena[indice] == carac:
return indice
indice += 1
return -1

La llamada a encuentra('banana', 'a', 2) en esta versión de encuentra se comporta precisamente

como encuentra2, mientras que, en la llamada a encuentra('banana', 'a'), el parámetro inicio se
establecerá en el valor por defecto, esto es, 0.

Agregar otro parámetro opcional a encuentra hace que busque tanto hacia adelante como hacia atrás:

def encuentra(cadena, carac, inicio=0, paso=1):

indice = inicio
while 0 <= indice < len(cadena):
if cadena[indice] == carac:
return indice
indice += paso
return -1

Asignar un valor de -1 al paso hará que busque en dirección al inicio de la cadena en lugar de hacerlo
hacia el final. Note que, para realizar este cambio, necesitamos verificar en el bucle while el límite
inferior del índice así como el límite superior.

7.11. El módulo string

El módulo string contiene funciones útiles que manipulan cadenas. Como de costumbre, tenemos que
importar el módulo antes de que podamos usarlo:

>>> import string

Para ver lo que hay dentro de él, use la función dir con el nombre del módulo como un argumento.

>>> dir(string)

lo que devolverá la lista de objetos dentro del módulo string:

['Template', '_TemplateMetaclass', '__builtins__', '__doc__', '__file__', '__name__',

'_float', '_idmap', '_idmapL', '_int', '_long', '_multimap', '_re', 'ascii_letters',
'ascii_lowercase', 'ascii_uppercase', 'atof', 'atof_error', 'atoi', 'atoi_error', 'atol',
'atol_error', 'capitalize', 'capwords', 'center', 'count', 'digits', 'expandtabs', 'find',
'hexdigits', 'index', 'index_error', 'join', 'joinfields', 'letters', 'ljust', 'lower',
'lowercase', 'lstrip', 'maketrans', 'octdigits', 'printable', 'punctuation', 'replace',
'rfind', 'rindex', 'rjust', 'rsplit', 'rstrip', 'split', 'splitfields', 'strip', 'swapcase',
'translate', 'upper', 'uppercase', 'whitespace', 'zfill']

Para averiguar más sobre un objeto de la lista, podemos usar el comando type. Necesitamos especificar
el nombre del módulo seguido por el objeto usando la notación punto.

>>> type(string.digits)
<type 'str'>
>>> type(string.find)
<type 'function'>

Puesto que string.digits es una cadena, podemos mostrarla para ver qué contiene:
 >>> print string.digits
0123456789

No es de extrañar, contiene cada uno de los dígitos decimales.

string.find es una función que hace más o menos lo mismo que la función que escribimos
antes,``encuentra``. Para saber más sobre ella, podemos mostrar la documentación del módulo
string, __doc__, que contiene la documentación de la función:

>>> print string.find.__doc__

find(s, sub [,start [,end]]) -> in

Return the lowest index in s where substring sub is found,

such that sub is contained within s[start,end]. Optional
arguments start and end are interpreted as in slice notation.

Return -1 on failure.

Los parámetros en corchetes cuadrados son opcionales. Podemos usar la función string.find de la
misma forma que nuestra función encuentra:

>>> fruta = "banana"

>>> indice = string.find(fruta, "a")
>>> print indice
1

Este ejemplo demuestra uno de los beneficios de los módulos — ayudan a evitar colisiones entre los
nombres de las funciones de biblioteca y las funciones definidas por el usuario. Mediante el uso de la
notación punto podemos especificar cuál versión de find/encuentra queremos.

En realidad string.find es más general que nuestra versión; string.find puede encontrar subcadenas,
no sólo caracteres:

>>> string.find("banana", "na")

2

Así como la nuestra, toma un argumento adicional que especifica el índice en el cual debería empezar:

>>> string.find("banana", "na", 3)

4

A diferencia de la nuestra, su segundo parámetro opcional especifica el índice en el cual la búsqueda

debería terminar.

>>> string.find("bob", "b", 1, 2)

-1

En este ejemplo, la búsqueda falla porque la letra b no aparece en en el rango de índices de 1 a 2 (no se
incluye 2).

7.12. Clasificación de caracteres

Con frecuencia es útil examinar un carácter y comprobar si está en mayúsculas o en minúsculas, o si es
un carácter o un dígito. El módulo string proporciona varias constantes que son útiles para lograr estos
objetivos. Una de ellas, que ya hemos visto, es `` string.digits``.

La cadena string.lowercase contiene todas las letras que el sistema considera como minúsculas. De
forma similar, `` string.uppercase`` contiene todas las letras mayúsculas. Intente lo siguiente y vea que
obtiene:

print string.lowercase
print string.uppercase
print string.digits

Podemos usar estas constantes y find para clasificar los caracteres. Por ejemplo, si find(lowercase,
carac) devuelve un valor distinto de -1, entonces carac debe ser una letra minúscula:

def es_minuscula(carac):
return string.find(string.lowercase, carac) != -1

Alternativamente, podemos aprovechar el operador in:

def es_minuscula(carac):
return carac in string.lowercase

Como una alternativa más, podemos usar el operador de comparación:

def es_minuscula(carac):
return 'a' <= carac <= 'z'

Si carac está entre a y z, debe ser una letra minúscula.

Otra constante definida en el módulo string puede sorprenderlo cuando la muestre:

>>> print string.whitespace

Los caracteres de whitespace mueven el cursor sin mostrar nada. Crean los espacios en blanco entre los
caracteres visibles (al menos sobre el papel). La constante string.whitespace contiene todos los
caracteres de espacio en blanco, incluidos espacio, tabulador (\t), y salto de línea (\n).

Hay otras funciones útiles en el módulo string, pero este libro no pretende ser un manual de referencia.
Por otra parte, la Python Library Reference - Biblioteca de Referencia de Python sí lo es, que, junto con
un cúmulo de documentación adicional, está disponible en el sitio web de Python,
http://www.python.org, (Documentación adicional en español, limitada, se puede encontrar aquí
<http://wiki.python.org/moin/Languages/Spanish?highlight=(CategoryLanguage)>.

7.13. Formateo de cadenas

La forma más concisa y poderosa de dar formato a una cadena en Python es usar el operador de
formateo de cadenas, %, junto con las operaciones de formateo de cadenas de Python. Para observar
cómo funciona, empecemos con algunos ejemplos:

>>> "Su nombre es %s." % "Arturo"

'Su nombre es Arturo.'
>>> nombre = "Alicia"
>>> edad = 10
>>> "Soy %s y tengo %d años de edad." % (nombre, edad)
'Soy Alicia y tengo 10 años de edad.'
>>> n1 = 4
>>> n2 = 5
>>> "2**10 = %d y %d * %d = %f" % (2**10, n1, n2, n1 * n2)
'2**10 = 1024 y 4 * 5 = 20.000000'
>>>
La sintaxis para las operaciones de formateo de cadenas luce así:

"<FORMATO>" % (<VALORES>)

Ésta comienza con un formato que contiene una secuencia de caracteres y especificaciones de
conversión. Las especificaciones de conversión inician con el operador %. Tras el formato de cadena está
un solo % y después una secuencia de valores, uno por especificación de conversión, separados por
comas y encerrados entre paréntesis. Los paréntesis son opcionales si hay solamente un valor.

En el primero de los anteriores ejemplos, hay una única especificación de conversión, %s, que indica una
cadena. El único valor, "Arturo", le corresponde a la especificación de conversión, y no está entre
paréntesis.

En el segundo ejemplo, nombre tiene el valor de cadena, "Alicia", y edad tiene el valor entero, 10. Estos
corresponden a las especificaciones de conversión %s `` y ``%d. La d en la segunda especificación de
conversión indica que el valor es un entero decimal.

En el tercer ejemplo las variables n1 y n2 tienen los valores enteros 4 y 5 respectivamente. Hay cuatro
especificaciones de conversión en el formato de la cadena: tres con %d y una con %f. La f indica que el
valor debe ser representado como un número de punto flotante. Los cuatro valores que corresponden a
las cuatro especificaciones de conversión son: 2**10, n1, n2, y n1 * n2.

s, d, y f son todos los tipos de conversión que necesitaremos en este libro. Para ver la lista completa,
vaya a la sección String Formatting Operations <http://docs.python.org/lib/typesseq-
strings.html>, de la Python Library Reference, ó en español a la sección Operaciones de formato de
las cadenas <http://pyspanishdoc.sourceforge.net/lib/typesseq-strings.html> de la Biblioteca de
Referencia de Python.

El siguiente ejemplo ilustra la verdadera utilidad del formateo de cadenas:

i = 1
print "i\ti**2\ti**3\ti**5\ti**10\ti**20"
while i <= 10:
print i, '\t', i**2, '\t', i**3, '\t', i**5, '\t', i**10, '\t', i**20
i += 1

Este programa muestra una tabla de varias potencias de los números del 1 al 10. En su forma actual, la
tabla depende del carácter de tabulación (\t) para alinear las columnas de valores, pero esto se
distorsiona cuando los valores en la tabla son más largos que el ancho de 8 del carácter de tabulación:

i i**2 i**3 i**5 i**10 i**20

1 1 1 1 1 1
2 4 8 32 1024 1048576
3 9 27 243 59049 3486784401
4 16 64 1024 1048576 1099511627776
5 25 125 3125 9765625 95367431640625
6 36 216 7776 60466176 3656158440062976
7 49 343 16807 282475249 79792266297612001
8 64 512 32768 1073741824 1152921504606846976
9 81 729 59049 3486784401 12157665459056928801
10 100 1000 100000 10000000000 100000000000000000000

Una posible solución sería cambiar el ancho del carácter de tabulación, pero la primera columna ya tiene
más espacio del que necesita. La mejor solución es sería establecer el ancho de cada columna
independientemente. Como probablemente ya ha adivinado, el formateo de cadenas proporciona la
solución:

i = 1
 print "%-4s%-5s%-6s%-8s%-13s%-15s" % \
('i', 'i**2', 'i**3', 'i**5', 'i**10', 'i**20')
while i <= 10:
print "%-4d%-5d%-6d%-8d%-13d%-15d" % (i, i**2, i**3, i**5, i**10, i**20)
i += 1

La ejecución de esta versión produce la siguiente salida:

i i**2 i**3 i**5 i**10 i**20

1 1 1 1 1 1
2 4 8 32 1024 1048576
3 9 27 243 59049 3486784401
4 16 64 1024 1048576 1099511627776
5 25 125 3125 9765625 95367431640625
6 36 216 7776 60466176 3656158440062976
7 49 343 16807 282475249 79792266297612001
8 64 512 32768 1073741824 1152921504606846976
9 81 729 59049 3486784401 12157665459056928801
10 100 1000 100000 10000000000 100000000000000000000

El - después de cada % en la especificación de conversión indica justificación a la izquierda. Los valores

numéricos especifican la longitud mínima, así que %-13d es un número justificado a la izquierda de por
lo menos 13 caracteres de ancho.

7.14. Glosario
tipo de datos compuesto:
Un tipo de datos en el que los valores están hechos de componentes o elementos que son a su vez
valores.

índice:
Una variable o valor usado para seleccionar un miembro de un conjunto ordenado, como puede ser
un carácter de una cadena.

recorrido:
Iterar sobre los elementos de un conjunto, realizando una operación similar en cada uno de ellos.

porción:
Una parte de una cadena (subcadena) especificada mediante un rango de índices. Más ampliamente,
una subsecuencia de cualquier tipo de secuencia en Python puede ser creada usando el operador
porción (secuencia[inicio:fin]).

inmutable:
Tipos de datos compuestos a cuyos elementos no se les puede asignar nuevos valores.

parámetro opcional:
Parámetro escrito en un encabezado de una función con una asignación de un valor por defecto, el
cual será recibido por la llamada a función si no se le da el correspondiente argumento.

valor por defecto:

Valor dado a un parámetro opcional si no se le da un argumento en la llamada a función.

notación punto:
Uso el operador punto, ., para acceder funciones dentro de un módulo.

documentación del módulo string:

Una cadena constante en la primera línea de una definición de función o módulo (y como veremos
más adelante, también en las definiciones de clases y métodos). La documentación del módulo
 string proporciona una forma conveniente de asociar la documentación con el código. La
documentación del módulo string es también usada por el módulo doctest para pruebas unitarias
automatizadas.

whitespace:
Cualquiera de los caracteres que mueven el cursor sin mostrar caracteres visibles. La constante
string.whitespace contiene todos los caracteres de espacio en blanco.

7.15. Ejercicios
1. Modifique:

prefijos = "JKLMNOPQ"
sufijo = "ack"

for letra in prefijos:

print letra + sufijo

tal que Ouack y Quack se muestren correctamente.

2. Encapsule

fruta = "banana"
cuenta = 0
for carac in fruta:
if carac == 'a':
cuenta += 1
print cuenta

en una función que se llame cuenta_letras, y generalízela para que acepte la cadena y la letra
como argumentos.

3. Ahora, reescriba la función cuenta_letras para que en lugar de recorrer la cadena, llame
repetidamente a encuentra (la versión de la sección 7.10), con el tercer parámetro opcional para
localizar las nuevas ocurrencias de la letra que está siendo contada.

4. ¿Cual versión de es_minuscula cree que será más rápida? ¿Se le ocurren otras razones aparte de la
velocidad para preferir una u otra versión?

5. Cree un archivo llamado herramientasdecadenas.py y escriba lo siguiente en él:

def invertir(s):
"""
>>> invertir('feliz')
'zilef'
>>> invertir('Python')
'nohtyP'
>>> invertir("")
''
>>> invertir("P")
'P'
"""

if __name__ == '__main__':
import doctest
doctest.testmod()

Agregue un cuerpo a la función invertir que haga que pase la prueba unitaria.

6. Agregue reflejar a herramientasdecadenas.py.

 def reflejar(s):
"""
>>> reflejar("bien")
'bienneib'
>>> reflejar("sí")
'síís'
>>> reflejar('Python')
'PythonnohtyP'
>>> reflejar("")
''
>>> reflejar("a")
'aa'
"""

Escriba un cuerpo para la función de forma que haga que pase la prueba unitaria.

7. Incluya elimina_letra en herramientasdecadenas.py .

def elimina_letra(letra, cadena):

"""
>>> elimina_letra('a', 'manzana')
'mnzn'
>>> elimina_letra('a', 'banana')
'bnn'
>>> elimina_letra('z', 'banana')
'banana'
>>> elimina_letra('i', 'Mississippi')
'Msssspp'
"""

Escriba un cuerpo para la función de forma que haga que pase la prueba unitaria.

8. Finalmente, agregue cuerpos a cada una de las siguientes funciones, una a la vez

def es_palindromo(s):
"""
>>> es_palindromo('abba')
True
>>> es_palindromo('abab')
False
>>> es_palindromo('tenet')
True
>>> es_palindromo('banana')
False
>>> es_palindromo('zorra arroz')
True
"""

def cuenta(sub, s):

"""
>>> cuenta('is', 'Mississippi')
2
>>> cuenta('an', 'banana')
2
>>> cuenta('ana', 'banana')
2
>>> cuenta('nana', 'banana')
1
>>> cuenta('nanan', 'banana')
0
"""

def elimina(sub, s):

"""
>>> elimina('an', 'banana')
 'bana'
>>> elimina('cic', 'bicicleta')
'bileta'
>>> elimina('iss', 'Mississippi')
'Missippi'
>>> elimina('huevo', 'bicicleta')
'bicicleta'
"""

def elimina_todo(sub, s):

"""
>>> elimina_todo('an', 'banana')
'ba'
>>> elimina_todo('cic', 'bicicleta')
'bileta'
>>> elimina_todo('iss', 'Mississippi')
'Mippi'
>>> elimina_todo('huevos', 'bicicleta')
'bicicleta'
"""

hasta que todas pasen la prueba unitaria.

9. Intente cada una de las siguientes operaciones de formato de cadenas en la terminal de Python y
guarde los resultados:

1. “%s %d %f” % (5, 5, 5)

2. “%-.2f” % 3
3. “%-10.2f%-10.2f” % (7, 1.0/2)
4. print ” $%5.2fn $%5.2fn $%5.2f” % (3, 4.5, 11.2)
10. Las siguientes cadenas con formato tienen errores. Arréglelos:

1. “%s %s %s %s” % (‘esto’, ‘eso’, ‘algo’)

2. “%s %s %s” % (‘sí’, ‘no’, ‘arriba’, ‘abajo’)
3. “%d %f %f” % (3, 3, ‘tres’)