Listas ligadas

En las secciones anteriores se contemplaron diferentes estructuras estticas en

dnde la manipulacin de datos es a travs de posiciones localizadas
secuencialmente. Para de clarar estas estructuras se deba definir un tamao
determinado el cual no poda modificarse posteriormente. Esto puede ser un
problema en el caso de que:
no sepamos de antemano el tamao requerido para nuestra aplicacin
hay una gran cantidad de operaciones y manipulaciones de los datos
dentro de las estructuras
En estos casos es generalmente m&a acute;s conveniente utilizar estructuras
dinmicas, es decir, las cuales pueden aumentar o disminuir de tamao de
acuerdo a los requerimientos especficos del procedimiento. As se resuelve el
problema de no saber el tama&ntild e;o exacto desde un principio y las
manipulaciones de datos se pueden hacer de una manera mas rpida y eficiente.
Una lista ligada es entonces un grupo de datos organizados secuencialmente, pero
a diferencia de los arreglos, la organizacin no est dada implcitamente por su
posicin en el arreglo. En una lista ligada cada elemento es un nodo que contiene
el dato y adems una liga al siguiente dato. Estas ligas son simplemente variables
que contienen la(s) direccin(es) de los datos contiguos o relacionados.
Para manejar una lista es necesario contar con un apuntador al primer elemento
de la lista "head".
Las ventajas de las listas ligadas son que:
Permiten que sus tamaos cambien durante la ejecucin del programa
Proveen una mayor flexibilidad en el manejo de los datos.
Este principio de listas ligadas se puede aplicar a cualquiera de los conceptos de
estructura de datos vistos anteriormente: arreglos, colas y pilas. Es decir, las
operaciones de altas, bajas y cambios, as como bsquedas y ordenamientos se
tendrn que adaptar en la cuestin del manejo de localidades nicamente.

Listas ligadas sencillas

Una lista ligada sencilla es un grupo de datos en dnde cada dato contiene
adems un apuntador hacia el siguiente dato en la lista, es decir, una liga hacia el
siguiente dato.

Los siguientes algoritmos fueron tomados de "Estructuras de Datos", Cair Guardati, 2a. Ed., McGraw Hill, 2002.
Algoritmo 5.1
CREAINICIO(P)
{Este algoritmo crea una lista, agregando cada nuevo nodo al inicio de la
misma}
{ P y Q son variables de tipo puntero. P apuntar al inicio de la lista}
1.
2.
3.
4.

CREA (P) {Crea el primer nodo de la lista}

Leer P->INFORMACIN
Hacer P->LIGA=NIL
Repetir
CREA (Q)
Leer Q->INFORMACIN
Hacer Q->LIGA= P y P = Q

5.

Hasta (que ya no haya informacin)

Algoritmo 5.2
CREAFINAL(P)
{Este algoritmo crea una lista, agregando cada nuevo nodo al final de la
misma}
{P y Q son variables de tipo puntero. P apuntar al inicio de la lista}
1.
2.
3.
4.

5.

CREA (P) {Crea el primer nodo de la lista}

Leer P->INFORMACIN
Hacer P->LIGA=NIL y T=P
Repetir
CREA (Q)
Leer Q->INFORMACIN
Hacer Q->LIGA=NIL, T->LIGA=Q y T=Q
Hasta (que ya no haya informacin)

Para poder dar de alta un dato en una lista ligada sencilla es necesario recorrer la
lista nodo por nodo hasta encontrar la posicin adecuada. Se crea un nuevo nodo,
se inserta el dato y se actualizan las ligas del nodo nuevo y del anterior para
intercalar el nuevo nodo en la lista.

Algoritmo 5.3
RECORREITERATIVO(P)
{Este algoritmo recorre una lista cuyo primer nodo est apuntado por P}
{Q es una variable de tipo puntero}
1.
2.
3.

Hacer Q = P
Repetir mientras Q =! NIL
Escribir Q->INFORMACUN
Hacer Q=Q->LIGA {Apunta al siguiente nodo de la lista}
{Fin del ciclo del paso 2}

Algoritmo 5.4
RECORRECURSIVO(P)
{Este algoritmo recorre una lista recursivamente.
nodo a visitar}
1.

la lista}
2.

P es el apuntador al

Si P =! NIL entonces
Escribir P->INFORMACIN
Llamar a RECORRECURSIVO con P->LIGA
{Llamada recursiva con el apuntador al siguiente nodo de
{Fin del condicional del paso 1}

Algoritmo 5.6
INSERTAFINAL(P)
{Este algoritmo inserta un nodo al final de la lista. P es el apuntador
al primer nodo
de la lista, y DATO es la informacin que se almacenar en el nuevo nodo}
{Q y T son variables de tipo puntero}
1.
2.
3.
4.
5.

Hacer T= P
Repetir mientras T ->Liga =! NIL
{Recorre la lista hasta llegar al ltimo elemento}
Hacer T=T->LIGA
{Fin del ciclo del paso 2}
CREA (Q)
Hacer Q->INFORMACIN =DATO, Q->LIGA =NIL y T ->LIGA =Q

Algoritmo 5.7
INSERTANTES ( P, DATO, REF )
{Este algoritmo inserta un nodo dado como referencia, REF. P es el
apuntador al
primer nodo de la lista, y DATO es la informacin que se almacenar en el
nuevo nodo}
{Q, X y T son variables de tipo puntero, BAND es una variable de tipo
booleano}
1.
2.
VERDADERO)

Hacer Q= P y BAND= VERDADERO

Repetir mientras (Q->INFORMACIN =! REF) y (BAND =
2.1

3.
4.

5.

Si Q -> LIGA =! NIL

Entonces
Hacer T= Q y Q= Q-> LIGA
Si no
Hacer BAND = FALSO
2.2
{Fin del condicional del paso 2.1}
{Fin del ciclo del paso 2}
Si BAND = VERDADERO entonces
CREA(X)
Hacer X->INFORMACIN = DATO
4.1
Si P = Q {Es el primer nodo}
Entonces
Hacer X ->LIGA = P y P = X
Si no
Hacer T ->LIGA =X y X ->LIGA = Q
4.2
{Fin del condicional del paso 4.1}
{Fin del condicional del paso 4}

Algoritmo 5.9
ELIMINAPRIMERO(P)
{Este algoritmo borra el primer elemento de una lista.
al primer nodo de la lista}
{Q es una variable de tipo puntero}

P es el apuntador

1.
2.

Hacer Q = P
Si Q -> LIGA =! NIL {Verifica si la lista tiene slo un

3.
4.

Entonces
Hacer P= Q-> LIGA {Redefine el puntero al inicio}
Si no
Hacer P = NIL
{Fin del condicional del paso2}
QUITA(Q)

nodo}

Algoritmo 5.10
ELIMINALTIMO(P)
{Este algoritmo borra el ltimo elemento de una lista.
al primer nodo de la lista}
{Q y T son variables de tipo puntero}
1.
elemento}

2.

P es el apuntador

Si P -> LIGA = NIL {Verifica si la lista tiene slo un

Entonces
QUITA(P)
Hacer P = NIL
Si no
Hacer Q = P
1.1
Repetir mientras ( Q->LIGA =! NIL)
Hacer T=Q y Q = Q -> LIGA
1.2
{Fin del ciclo del paso 1.1}
Hacer T -> LIGA = NIL
QUITA(Q)
{Fin del condicional del paso 1}

Algoritmo 5.11
ELIMINAX( P, X )
{Este algoritmo elimina un nodo con informacin X de una lista. P es el
apuntador al primer nodo de la lista}
{Q y T son variables de tipo puntero. BAND es una variable de tipo
booleano}
1.
2.
VERDADERO)

Hacer Q = P y BAND= VERDADERO

Repetir mientras (Q->INFORMACIN =! X) y
2.1

3.
4.

el primero}

5.

(BAND =

Si Q ->LIGA =! NIL
Entonces
Hacer T = Q y Q = Q -> LIGA
Si no
Hacer BAND = FALSO
2.2
{Fin del condicional del paso 2.1}
{Fin del ciclo del paso 2}
Si BAND = FALSO
Entonces
Escribir El elemento no fue encontrado
Si no
4.1
SI P = Q {Verifica si el elemento a eliminar es
Entonces
Hacer P = Q->LIGA
Si no
Hacer T -> LIGA=Q-> LIGA
4.2
{Fin del condicional del paso 4.1}
QUITA(Q)
{Fin del condicional del paso 4}

Algoritmo 5.15
BUSCARRECURSIVO(P,X)
{Este algoritmo busca recursivamente al elemento con informacin X en una
lista que se encuentra desordenada. P es el apuntador del nodo a
visitar}
1.

Si ( P =! NIL)
Entonces
1.1
Si ( P ->INFORMACIN = X )
Entonces
Escribir El elemento se encuentra en la

lista

Si no
1.2

lista

2.

Llamar a BUSCARRECURSIVO con P -> LIGA y X

{Fin del condicional del paso 1.1}
Si no
Escribir El elemento no se encuentra en la

{Fin del condicional del paso 1}

index

next |
previous |

Cmo Pensar como un Informtico: El aprender con Python vEd 2

documentation
Ad by unisales | Close

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 estn hechas de piezas
ms pequeas loscaracteres.
Los tipos que comprenden piezas mas pequeas 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 ambigedad
es til.
El operador corchete selecciona slo un carcter de una cadena:
>>> fruta = "banana"
>>> letra = fruta[1]
>>> print letra

La expresin fruta[1] selecciona el carcter nmero 1 de fruta. La

variable letra apunta al resultado. Cuando mostramos letra, nos encontramos con
una sorpresa:
a

La primera letra de "banana" no es a. A no ser que usted sea un programador. Por

perversas razones, los cientficos de la computacin siempre empiezan a contar
desde cero. La 0-sima letra (cero- sima) de "banana" es b. La 1-sima (unosima) es a, y la 2-sima (dos-sima) letra es n.
Nota del traductor: La numeracin ordinal por todos conocida no contempla al
cero como parte de su verbalizacin, por lo que se considera apropiada la
introduccin de esta forma de expresar la numeracin de caracteres, dado el
objetivo que se persigue.
Si quiere la cero-sima letra de una cadena, simplemente pone 0, o cualquier
expresin de valor 0, entre los corchetes:

>>> letra = fruta[0]

>>> print letra
b

A la expresin 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 cul quiere usted, de ah el nombre. El ndice puede ser cualquier
expresin entera.

7.2. Longitud
La funcin len devuelve el nmero 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

ejecucin IndexError: string index out of range. La razn es que no hay una seissima letra en "banana". Como empezamos a contar desde cero, las seis letras
estn numeradas del 0 al 5. Para obtener el ltimo carcter tenemos que restar 1 a
la longitud:
longitud = len(fruta)
ultima = fruta[longitud-1]

Alternativamente podemos usar ndices negativos, que cuentan hacia atrs desde el
final de la cadena. La expresin fruta[-1] da la ltima letra, fruta[-2] da la penltima,
y as sucesivamente.

7.3. Recorrido y el bucle for

Muchos clculos implican procesar una cadena carcter por carcter. A menudo
empiezan por el principio, seleccionan cada carcter por turno, hacen algo con l y
siguen hasta el final. Este patrn 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 lnea distinta. La condicin
del bucle es indice &lt; len(fruta), de modo que cuando indice es igual a la longitud
de la cadena, la condicin es falsa y no se ejecuta el cuerpo del bucle. El ltimo
carcter al que se accede es el que tiene el ndice len(fruta)-1, que es el ltimo
carcter de la cadena.
Usar un ndice para recorrer un conjunto de valores es tan comn que Python
proporciona una sintaxis alternativa ms simple el bucle for:
for carac in fruta:
print carac

Cada vez que recorremos el bucle, se asigna a la variable carac el siguiente carcter
de la cadena. El bucle contina hasta que no quedan ms caracteres.
El ejemplo siguiente muestra cmo usar la concatenacin 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 alfabtico. 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:

Ad by unisales | Close

Jack
Kack
Lack
Mack
Nack
Oack
Pack
Qack

Por supuesto, esto no es del todo correcto, porque Ouack y Quack no estn
correctamente escritos. Usted solucionar esto en un ejercicio ms adelante.

7.4. Porciones de cadenas

A la subcadena de una cadena se le llama porcin. La seleccin de una porcin es
similar a la seleccin un carcter:
>>> 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 carcter hasta

el m-simo, incluyendo el primero pero excluyendo el ltimo. Este comportamiento
contradice a nuestra intuicin; tiene ms sentido si imagina los ndices
sealando entre los caracteres, como en el siguiente diagrama:

Si omite el primer ndice (antes de los dos puntos), la porcin comienza al principio
de la cadena. Si omite el segundo ndice, la porcin llega al final de la cadena. As:
>>> fruta = "banana"
>>> fruta[:3]
'ban'
>>> fruta[3:]
'ana'

Qu cree que significa s[:]?

7.5. Comparacin de cadenas

Los operadores de comparacin trabajan sobre cadenas. Para ver si dos cadenas son
iguales:
if palabra == "banana":
print "S, no tenemos bananas!"

Otras operaciones de comparacin son tiles para poner palabras en orden

alfabtico:
if palabra < "banana":
print "Su palabra," + palabra + ", va antes de banana."
elif word > "banana":
print "Su palabra," + palabra + ", va despus de banana."

else:
print "S, no tenemos bananas!"

Sin embargo, debera ser consciente de que Python no maneja las letras maysculas
y minsculas como lo hace la gente. Todas las letras maysculas van antes de las
letras minsculas. Por lo tanto:
Su palabra, Cebra, va antes de banana.

Una forma comn de abordar este problema es convertir las cadenas a un formato
estndar como pueden ser las minsculas antes de realizar la comparacin. 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 asignacin, con la
intencin de cambiar un carcter en una cadena. Por ejemplo:
saludo = "Hola todo el mundo!"
saludo[2] = 'L'
# ERROR!
print saludo

Nota del traductor: De acuerdo con la codificacin de caracteres en utf-8 latin-1

(vase la Nota del traductor del captulo 2) el carcter de admiracin, , 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 cdigo presenta el
siguiente error en tiempo de
ejecucin TypeError: 'str' object does not support item assignment.
Las cadenas son inmutables, lo que significa que no puede cambiar una cadena
existente. Lo ms que puede hacer es crear una nueva cadena que sea una
variacin de la original:
saludo = "Hola todo el mundo!"
nuevoSaludo = '' + 'L' + saludo[3:]
print nuevoSaludo

Aqu la solucin es concatenar la apertura del signo de admiracin y una nueva

primera letra a una porcin de saludo. Esta operacin no tiene efecto sobre la
cadena original.

7.7. El operador in

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

Ad by unisales | Close

>>>
True
>>>
False
>>>
True
>>>
False

'z' in 'manzana'
'i' in 'manzana'
'nz' in 'manzana'
'az' in 'manzana'

Observe que una cadena es una subcadena de si misma:

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

Combinando el operador in con la concatenacin de cadenas usando +, podemos

escribir una funcin 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 funcin para confirmar que realiza lo que queremos que haga.

7.8. Una funcin encuentra

Qu hace la siguiente funcin?
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 carcter correspondiente, toma un carcter y encuentra el ndice
donde aparece el carcter. Si el carcter no se encuentra, la funcin devuelve -1.

Este es el primer ejemplo que hemos visto de una

sentencia return `` dentro de un bucle. Si ``cadena[indice] == carac, la funcin
devuelve inmediatamente el ndice, escapando del bucle prematuramente.
Si el carcter no aparece en la cadena, entonces el programa sale del bucle
normalmente y devuelve -1.
Este patrn de computacin 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 nmero de veces que aparece la letra a en una
cadena, y es otro ejemplo del patrn de conteo introducido en el Contando dgitos:
fruta = "banana"
cuenta = 0
for carac in fruta:
if carac == 'a':
cuenta += 1
print cuenta

7.10. Parmetros opcionales

Para encontrar las posiciones de la segunda o tercera ocurrencia de un carcter en
una cadena, podemos modificar la funcin encuentra, agregando un tercer
parmetro para la posicin inicial en la cadena de bsqueda:
Ad by unisales | Close

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 an, podemos combinar encuentra y encuentra2 usando un parmetro
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 versin de encuentra se comporta

precisamente como encuentra2, mientras que, en la llamada
a encuentra('banana', 'a'), el parmetroinicio se establecer en el valor por
defecto, esto es, 0.
Agregar otro parmetro opcional a encuentra hace que busque tanto hacia adelante
como hacia atrs:
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 direccin 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 lmite inferior del ndice as como el lmite superior.

7.11. El mdulo string

El mdulo string contiene funciones tiles que manipulan cadenas. Como de
costumbre, tenemos que importar el mdulo antes de que podamos usarlo:
>>> import string

Para ver lo que hay dentro de l, use la funcin dir con el nombre del mdulo como
un argumento.
>>> dir(string)

lo que devolver la lista de objetos dentro del mdulo 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', 'c
apwords', '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', 'splitfiel

ds', 'strip', 'swapcase', 'translate', 'upper', 'uppercase', 'whitespace', 'zfill']

Para averiguar ms sobre un objeto de la lista, podemos usar el comando type.

Necesitamos especificar el nombre del mdulo seguido por el objeto usando
la notacin 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 extraar, contiene cada uno de los dgitos decimales.

string.find es una funcin que hace ms o menos lo mismo que la funcin que

escribimos antes,``encuentra``. Para saber ms sobre ella, podemos mostrar

la documentacin del mdulo string, __doc__, que contiene la documentacin de
la funcin:
Ad by unisales | Close

>>> 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 parmetros en corchetes cuadrados son opcionales. Podemos usar la

funcin string.find de la misma forma que nuestra funcin encuentra:
>>> fruta = "banana"
>>> indice = string.find(fruta, "a")
>>> print indice
1

Este ejemplo demuestra uno de los beneficios de los mdulos ayudan a evitar
colisiones entre los nombres de las funciones de biblioteca y las funciones definidas
por el usuario. Mediante el uso de la notacin punto podemos especificar cul
versin de find/encuentra queremos.

En realidad string.find es ms general que nuestra versin; string.find puede

encontrar subcadenas, no slo caracteres:
>>> string.find("banana", "na")
2

As como la nuestra, toma un argumento adicional que especifica el ndice en el cual

debera empezar:
>>> string.find("banana", "na", 3)
4

A diferencia de la nuestra, su segundo parmetro opcional especifica el ndice en el

cual la bsqueda debera terminar.
>>> string.find("bob", "b", 1, 2)
-1

En este ejemplo, la bsqueda falla porque la letra b no aparece en en el rango de

ndices de 1 a 2 (no se incluye 2).

7.12. Clasificacin de caracteres

Con frecuencia es til examinar un carcter y comprobar si est en maysculas o en
minsculas, o si es un carcter o un dgito. El mdulo 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
minsculas. De forma similar, `` string.uppercase`` contiene todas las letras
maysculas. 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 minscula:
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 ms, podemos usar el operador de comparacin:

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

Si carac est entre a y z, debe ser una letra minscula.

Otra constante definida en el mdulo 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 lnea (\n).
Hay otras funciones tiles en el mdulo 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 cmulo de documentacin adicional,
est disponible en el sitio web de Python, http://www.python.org, (Documentacin
adicional en espaol, limitada, se puede encontrar aqu
<http://wiki.python.org/moin/Languages/Spanish?highlight=(CategoryLanguage)> .

7.13. Formateo de cadenas

La forma ms 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 cmo funciona, empecemos con algunos
ejemplos:
Ad by unisales | Close

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

'Su nombre es Arturo.'
>>> nombre = "Alicia"
>>> edad = 10
>>> "Soy %s y tengo %d aos de edad." % (nombre, edad)
'Soy Alicia y tengo 10 aos 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 conversin. Las especificaciones de conversin inician con el
operador %. Tras el formato de cadena est un solo % y despus una secuencia de
valores, uno por especificacin de conversin, separados por comas y encerrados
entre parntesis. Los parntesis son opcionales si hay solamente un valor.
En el primero de los anteriores ejemplos, hay una nica especificacin de
conversin, %s, que indica una cadena. El nico valor, "Arturo", le corresponde a la
especificacin de conversin, y no est entre parntesis.
En el segundo ejemplo, nombre tiene el valor de cadena, "Alicia", y edad tiene el
valor entero, 10. Estos corresponden a las especificaciones de conversin %s `` y ``
%d. La d en la segunda especificacin de conversin 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 conversin en el
formato de la cadena: tres con %d y una con %f. La findica que el valor debe ser
representado como un nmero de punto flotante. Los cuatro valores que
corresponden a las cuatro especificaciones de conversin son: 2**10, n1, n2,
y n1 * n2.
s, d, y f son todos los tipos de conversin que necesitaremos en este libro. Para ver

la lista completa, vaya a la seccin String Formatting Operations

<http://docs.python.org/lib/typesseq-strings.html> , de la Python Library Reference,
en espaol a la seccin 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 nmeros del 1 al 10. En
su forma actual, la tabla depende del carcter de tabulacin (\t) para alinear las

columnas de valores, pero esto se distorsiona cuando los valores en la tabla son ms
largos que el ancho de 8 del carcter de tabulacin:
i
1
2
3
4
5
6
7
8
9
10

i**2
1
4
9
16
25
36
49
64
81
100

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

1
1
1
1
8
32
1024 1048576
27
243
59049 3486784401
64
1024 1048576
1099511627776
125
3125 9765625
95367431640625
216
7776 60466176
3656158440062976
343
16807 282475249
79792266297612001
512
32768 1073741824
1152921504606846976
729
59049 3486784401
12157665459056928801
1000 100000 10000000000
100000000000000000000

Una posible solucin sera cambiar el ancho del carcter de tabulacin, pero la
primera columna ya tiene ms espacio del que necesita. La mejor solucin es sera
establecer el ancho de cada columna independientemente. Como probablemente ya
ha adivinado, el formateo de cadenas proporciona la solucin:
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 ejecucin de esta versin 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 - despus de cada % en la especificacin de conversin indica justificacin a la

izquierda. Los valores numricos especifican la longitud mnima, as que %-13d es un
nmero 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 estn 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 carcter de una cadena.

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

porcin:
Una parte de una cadena (subcadena) especificada mediante un rango de
ndices. Ms ampliamente, una subsecuencia de cualquier tipo de secuencia
en Python puede ser creada usando el operador porcin
(secuencia[inicio:fin] ).

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

parmetro opcional:
Parmetro escrito en un encabezado de una funcin con una asignacin de un
valor por defecto, el cual ser recibido por la llamada a funcin si no se le da
el correspondiente argumento.

valor por defecto:

Valor dado a un parmetro opcional si no se le da un argumento en la llamada
a funcin.

notacin punto:
Uso el operador punto, ., para acceder funciones dentro de un mdulo.

documentacin del mdulo string:

Una cadena constante en la primera lnea de una definicin de funcin o
mdulo (y como veremos ms adelante, tambin en las definiciones de clases
y mtodos). La documentacin del mdulo string proporciona una forma
conveniente de asociar la documentacin con el cdigo. La documentacin
del mdulo string es tambin usada por el mdulo 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:
2. prefijos = "JKLMNOPQ"
3. sufijo = "ack"
4.
5. for letra in prefijos:
6.
print letra + sufijo

tal que Ouack y Quack se

muestren correctamente.
7. Encapsule
8. fruta = "banana"
9. cuenta = 0
10. for carac in fruta:
11.
if carac == 'a':
12.
cuenta += 1
13. print cuenta

en una funcin que se

llame cuenta_letras , y generalzela
para que acepte la cadena y la
letra como argumentos.
14. Ahora, reescriba la
funcin cuenta_letras para que en
lugar de recorrer la cadena, llame
repetidamente a encuentra (la
versin de la seccin 7.10), con el
tercer parmetro opcional para
localizar las nuevas ocurrencias de
la letra que est siendo contada.
15. Cual versin
de es_minuscula cree que ser
ms rpida? Se le ocurren otras

razones aparte de la velocidad

para preferir una u otra versin?
16. Cree un archivo
llamado herramientasdecadenas.p
y y escriba lo siguiente en l:
17. def invertir(s):
18.
"""
19.
>>> invertir('feliz')
20.
'zilef'
21.
>>> invertir('Python')
22.
'nohtyP'
23.
>>> invertir("")
24.
''
25.
>>> invertir("P")
26.
'P'
27.
"""
28.
29. if __name__ == '__main__':
30.
import doctest
31.
doctest.testmod()

Agregue un cuerpo a la
funcin invertir que haga que
pase la prueba unitaria.
32. Agregue reflejar a herramientasde
cadenas.py.
33. def reflejar(s):
34.
"""
35.
>>> reflejar("bien")
36.
'bienneib'
37.
>>> reflejar("s")
38.
'ss'
39.
>>> reflejar('Python')
40.
'PythonnohtyP'
41.
>>> reflejar("")
42.
''
43.
>>> reflejar("a")
44.
'aa'
45.
"""

Escriba un cuerpo para la funcin

de forma que haga que pase la
prueba unitaria.

46. Incluya elimina_letra en herramien

tasdecadenas.py .
47. def elimina_letra(letra, cadena):
48.
"""
49.
>>> elimina_letra('a',
'manzana')
50.
'mnzn'
51.
>>> elimina_letra('a',
'banana')
52.
'bnn'
53.
>>> elimina_letra('z',
'banana')
54.
'banana'
55.
>>> elimina_letra('i',
'Mississippi')
56.
'Msssspp'
57.
"""

Escriba un cuerpo para la funcin

de forma que haga que pase la
prueba unitaria.
58. Finalmente, agregue cuerpos a
cada una de las siguientes
funciones, una a la vez
59. def es_palindromo(s):
60.
"""
61.
>>> es_palindromo('abba')
62.
True
63.
>>> es_palindromo('abab')
64.
False
65.
>>> es_palindromo('tenet')
66.
True
67.
>>> es_palindromo('banana')
68.
False
69.
>>> es_palindromo('zorra
arroz')
70.
True
71.
"""
72.
73. def cuenta(sub, s):
74.
"""
75.
>>> cuenta('is', 'Mississippi')
76.
2
77.
>>> cuenta('an', 'banana')
78.
2
79.
>>> cuenta('ana', 'banana')
80.
2

81.
82.
83.

>>> cuenta('nana', 'banana')

1
>>> cuenta('nanan',
'banana')
84.
0
85.
"""
86.
87. def elimina(sub, s):
88.
"""
89.
>>> elimina('an', 'banana')
90.
'bana'
91.
>>> elimina('cic', 'bicicleta')
92.
'bileta'
93.
>>> elimina('iss',
'Mississippi')
94.
'Missippi'
95.
>>> elimina('huevo',
'bicicleta')
96.
'bicicleta'
97.
"""
98.
99. def elimina_todo(sub, s):
100.
"""
101.
>>> elimina_todo('an',
'banana')
102.
'ba'
103.
>>> elimina_todo('cic',
'bicicleta')
104.
'bileta'
105.
>>> elimina_todo('iss',
'Mississippi')
106.
'Mippi'
107.
>>>
elimina_todo('huevos', 'bicicleta')
108.
'bicicleta'
109.
"""

hasta que todas pasen la prueba

unitaria.
110.

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)
111.

Las siguientes cadenas con

formato tienen errores. Arrglelos:

1. %s %s %s %s % (esto,
eso, algo)
2. %s %s %s % (s, no,
arriba, abajo)
3. %d %f %f % (3, 3, tres)

index

next |
previous |

Cmo Pensar como un Informtico: El

aprender con Python vEd 2
documentation
Copyright 2009, Jeffrey Elkner, Allen B.
Downey, Chris Meyers y Gregorio Inda.
Created using Sphinx 0.6.1.