Tutorial

Python 2.
5
Os ar Zarate Villegas
6 de septiembre de 2010
Tutorial de
Tutorial de Python
por Os ar Zarate Villegas
Este tutorial esta es rito bajo la li en ia Creative Commons Re ono imiento 2.5 Mexi o.
Usted es libre de:
opiar, distribuir y omuni ar publi amente esta obra.
ha er obras derivadas y/o omplementarias.

Bajo las ondi iones siguientes:
Re ono imiento. Debes re ono er y dar redito al autor original.
No puedes utilizar esta obra on nes de lu ro.
ndi e general
1. Introdu on.
1.0.1. Programa, Algoritmo, Lenguaje de Programa in !!!! . . . . . . . .
2. Qu es Python?.
2.0.2.
2.0.3.
2.0.4.
2.0.5.
El Interprete de Python. . . . . . . . .
Los Operadores Aritmti os. . . . . .
Operadores Lgi os y de Compara in.
Tipos Bsi os de Datos. . . . . . . . .
2.0.5.1. Nmeros . . . . . . . . . . . .
2.0.5.2. Cadenas. . . . . . . . . . . .
2.0.5.3. Booleanos. . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3. Mi Primer Programa en Python.
8
9
10
12
12
13
14
15
3.1. Hola mundo en Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3.2. Comentarios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3. Entrada/Salida de Datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4. Estru turas de Control
4.0.1. La Senten ia Condi ional if.

4.0.1.1. If ... else. . . . . .
4.0.2. Bu les o Ci los. . . . . . . .
4.0.2.1. while. . . . . . . .
4.0.2.2. for-in. . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
18
18
19
20
20
22
5. Cole iones.
23
6. Fun iones.
33
5.1. Listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.2. Tuplas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.3. Di ionarios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
6.1. Fun iones Predenidas. . . . . . .

6.2. Fun iones Predenidas en Mdulos.
6.3. Deni in de Fun iones. . . . . . .
6.3.1. Mdulos. . . . . . . . . . .
7. Ar hivos.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
33
34
35
40
46
7.0.2. Opera iones on Ar hivos: Abrir, Leer, Es ribir y Cerrar. . . . . . 46
ndi e general
8. Programa in Orientada a Objetos.
8.1. Introdu in a la Programa in Orientada a Objetos.

8.2. Con eptos Bsi os. . . . . . . . . . . . . . . . . . . .
8.2.1. Clases . . . . . . . . . . . . . . . . . . . . . .
8.2.2. Nombres y objetos . . . . . . . . . . . . . . .
8.2.3. Al an es y espa ions de nombres en Python .
8.2.4. Primer vistaso a las Clases . . . . . . . . . . .
8.2.4.1. Objeto Clase . . . . . . . . . . . . .
8.2.5. Objeto Instan ia . . . . . . . . . . . . . . . .
8.2.6. Objetos Mtodo . . . . . . . . . . . . . . . .
8.2.7. Algunas Observa iones . . . . . . . . . . . . .
8.2.8. Heren ia . . . . . . . . . . . . . . . . . . . . .
8.2.8.1. Heren ia Multiple . . . . . . . . . .
8.2.9. Variables privadas . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9. Re ursividad
51
51
53
53
54
54
56
57
58
59
59
61
62
63
64
9.1. Qu es la Re ursividad? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
10.Metodos de Ordenamiento y Busqueda

10.0.1.
10.0.2.
10.0.3.
10.0.4.
10.0.5.
Burbuja . . . . . . .
Sele in . . . . . .
Inser in . . . . . . .
Bsqueda Se uen ial
Bsqueda Binaria . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
11.Un Po o de Gra a in
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
67
67
70
72
73
74
76
11.1. Instala in . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
11.2. Matplotlib on Ejemplos. . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
1 Introdu on.
El objetivo de este do umento es ha er una gua de la programa in en Python, el
ual es un lenguaje inteligible de entender. Es un lenguaje e iente de alto nivel, on una
elegante sintaxis y una me anografa dinmi a. Una de las ventajas de utilizar Python
es que totalmente gratuito y el digo es abierto, lo puedes obtener del sitio Web o ial
de Python http://www.Python.org/ para diferentes tipos de plataformas (Linux, Unix,
Windows, et .).
1.0.1.
Programa, Algoritmo, Lenguaje de Programa in !!!!
Antes de omenzar a involu rarnos on Python es ne esario saber algunas osas importantes, para poder entender on mayor laridad los temas que vamos a tratar.
Que es un Programa?.
Un programa informti o es un onjunto de instru iones que una vez eje utadas realizarn una o varias tareas en una omputadora. Sin programas, estas mquinas no
pueden fun ionar orre tamente. Al onjunto general de programas, se lo denomina software y as, se reere al equipamiento lgi o o soporte lgi o de una omputadora digital.
En omputa in, se los denomina omnmente binarios, (propio en sistemas Unix,
donde debido a la estru tura de este ltimo, los heros no ne esitan ha er uso de extensiones. Posteriormente, los presentaron omo heros eje utables, on extensin .exe,
en los sistemas operativos de la familia Windows) debido a que una vez que han pasado
por el pro eso de ompila in por el interprete y han sido reados, las instru iones
que se es ribieron en un lenguaje de programa in que los humanos usan para es ribirlos
on mayor fa ilidad, se han tradu ido al ni o idioma que la mquina omprende, ombina iones de eros y unos llamada digo mquina. El mismo trmino, puede referirse
tanto a un programa eje utable, omo a su digo fuente, el ual es transformado en un
binario uando es ompilado interpretado.
Generalmente el digo fuente lo es riben profesionales ono idos omo programadores.
Se es ribe en un lenguaje que sigue uno de los siguientes dos paradigmas: imperativo o
de larativo y que posteriormente puede ser onvertido en una imagen eje utable por
un ompilador, o algn interprete. Cuando se pide que el programa sea eje utado, el
pro esador eje uta instru in por instru in.
Una vez es ritos, pueden ser eje utados de diversas formas:
Mediante un programa que va adaptando las instru iones onforme son en ontradas. A este pro eso se lo llama interpretar y a los programas que lo ha en se los
ono e omo intrpretes. Ejemplos de esto son bash, lsi o en esta iones Unix y
1 Introdu on.
que fue es rito para el proye to GNU o Python, uya pe uliaridad adems de ser
multipropsito, est en su fa ilidad de uso y produ tividad y de he ho, es usado en
parte de los proye tos Google y Youtube.
Tradu iendo el digo es rito del programa (lo que se denomina digo fuente),
a su equivalente en lenguaje mquina. A este pro eso se le llama ompilar y al
programa tradu tor se le denomina ompilador. Ejemplos de esto son: El lenguaje
C, que ombina en su sintaxis ara tersti as de medio y bajo nivel y el ompilador
g usado en el proye to GNU.
Que es un Algoritmo?.
Un algoritmo es un onjunto prees rito de instru iones o reglas bien denidas, ordenadas y nitas que permite realizar una a tividad mediante pasos su esivos que no
generen dudas a quien lo eje ute. Dados un estado ini ial y una entrada, siguiendo los
pasos su esivos se llega a un estado nal y se obtiene una solu in. Los algoritmos son
objeto de estudio de la algoritmia.
En la vida otidiana se emplean algoritmos en multitud de o asiones para resolver
problemas. Algunos ejemplos son los manuales de usuario, que muestran algoritmos para
usar un aparato, o las instru iones que re ibe un trabajador por parte de su patrn.
Algunos ejemplos en matemti as son el algoritmo de la divisin para al ular el o iente
de dos nmeros, el algoritmo de Eu lides para obtener el mximo omn divisor de dos
enteros positivos, o el mtodo de Gauss para resolver un sistema lineal de e ua iones.
Existen diferentes formas de expresar un algoritmo, algunas de ellas son:
Diagrama de Flujo: Los diagramas de ujo son des rip iones gr as de algoritmos;
usan smbolos one tados on e has para indi ar la se uen ia de instru iones y
estn regidos por ISO. Los diagramas de ujo son usados para representar algoritmos pequeos, ya que abar an mu ho espa io y su onstru in es laboriosa. Por
su fa ilidad de le tura son usados omo introdu in a los algoritmos, des rip in
de un lenguaje y des rip in de pro esos a personas ajenas a la omputa in.
Pseudo digo: Pseudo digo es la des rip in de un algoritmo que asemeja a un
lenguaje de programa in pero on algunas onven iones del lenguaje natural (de
ah que tenga el prejo pseudo, que signi a falso). Tiene varias ventajas on respe to a los diagramas de ujo, entre las que se desta a el po o espa io que se
requiere para representar instru iones omplejas. El pseudo digo no est regido
por ningn estndar.
Que es un Lenguaje de Programa in?

Un lenguaje de programa in es un idioma arti ial diseado para expresar omputa iones que pueden ser llevadas a abo por mquinas omo las omputadoras. Pueden
usarse para rear programas que ontrolen el omportamiento fsi o y lgi o de una
mquina, para expresar algoritmos on pre isin, o omo modo de omuni a in humana. Est formado de un onjunto de smbolos y reglas sint ti as y semnti as que
1 Introdu on.
denen su estru tura y el signi ado de sus elementos y expresiones. Al pro eso por el
ual se es ribe, se prueba, se depura, se ompila y se mantiene el digo fuente de un
programa informti o se le llama programa in.
2 Qu es Python?.
Python es un lenguaje de programa in interpretado1 reado por Guido van Rossum
en el ao de 1991. Se ompara habitualmente on T l, Perl, S heme y Ruby. En la
a tualidad Python se desarrolla omo un proye to de software libre2 , al ser un lenguaje
interpretado ahorra un tiempo onsiderable en el desarrollo del programa, pues no es
ne esario ompilar y enlazar.
Es un lenguaje muy expresivo, es de ir los programas son muy ompa tos, tambin es
muy legible, la sintaxis es muy elegante y permite la es ritura de programas uya le tura
resulta relativamente mas f il que si utilizramos otro lenguaje de programa in.
La poten ia base de Python, se puede extender on mdulos es ritos en C o C++. En
la mayora de los sistemas di hos mdulos se pueden argar dinmi amente. Python se
puede adaptar tambin omo lenguaje de extensin (ma ros3 ) de apli a iones existentes.
Ahora que estas emo ionado on el Python, querrs examinarlo on mas detalle. Como
la mejor manera de aprender un lenguaje es omenzar a utilizarlo. Para ha er nuestros
programas en Python, vamos a utilizar el interprete de Python y posteriormente el editor
de texto vim, el ual puedes en ontrar en ualquier distribu in de linux.
Tambin men ionaremos algunas libreras que son tiles para el desarrollo de programas visuales, l ulos e interfa es, para poder tener un mejor ono imiento de nuestro
lenguaje de programa in.
2.0.2.
El Interprete de Python.
En Linux podemos ini iar una sesin de trabajo es ribiendo Python en la lnea de
ordenes. El sistema nos responder dando un mensaje informativo sobre la versin de
Python que estamos utilizando y a ontinua in nos mostrara el prompt. El prompt es
una serie de ara teres > > > que pare e en la ltima lnea que indi a a Python que
esta listo para que nosotros introduz amos una orden utilizando el te lado.
Para salir del intrprete de Python ah que te lear un ar ter de n de hero (ControlD) puedes salir del intrprete te leando las siguientes ordenes: import sys; sys.exit()
quit().
El interprete fun iona omo una simple al uladora tu te leas una expresin y l muestra el resultado. La sintaxis de las expresiones es bastante intuitiva, es ribiremos una
1
Un interprete lee un programa es rito en lenguaje de alto nivel instru in a instru in y, para ada
una de ellas, efe ta una tradu in a las instru iones de digo de maquina equivalentes y las
eje uta inmediatamente.
2
Es el trmino on el que se ono e al software distribuido y desarrollado libremente.
3
Es una serie de datos que se alma enan para que se puedan eje utar de forma se uen ial mediante una
sola llamada u orden de eje u in.
2 Qu es Python?.
expresin aritmti a, por ejemplo 2+2 y pulsaremos la te la intro. Python evala la
expresin (es de ir obtiene el resultado) y responde mostrando el resultado en pantalla.
1 >>> 2+2
2 4
3 >>>
La ltima lnea es nuevamente la del prompt: Python a ab de eje utar la ltima linea
ordenada y nos pide que introduz amos una nueva orden.
2.0.3.
Los Operadores Aritmti os.
Los operadores aritmti os en Python nos permiten, bsi amente, ha er ualquier opera in aritmti a, que ne esitamos (ejemplo: suma, resta, multipli a ion, et .). En la
siguiente tabla se muestra los operadores de los que disponemos:
Opera in
Operador
Aridad
Ejemplo
Exponen ia in
**
Binario
x=2**6 resultado 64
Identidad
Unario
x=+2 resultado +2
Cambio de Signo
Unario
x=-2 resultado -2
Multipli a in
Binario
x=2*6 resultado 12
Divisin
Binario
x=3.5/2 resultado 1.75
Divisin Entera
//
Binario
x=3.5//2 resultado 1.0
Binario
x=7 %2 resultado 1
Mdulo
Suma
Binario
x=5+5 resultado 10
Resta
Binario
x=15-5 resultado 10
Vamos a estudiar rpidamente los operadores aritmti os. El operador binario de exponen ial que se denota on dos asteris os juntos, no separados por ningn espa io en
blan o: **. Si tenemos la nota in matemti a onven ional 26 en Python se la expresamos omo 2 ** 6.
1 >>> 2 6
2 64
3 >>>
Los operadores unario de identidad y ambio de signo (+ y -) nos sirven para denir
si utilizamos un nmero positivo o negativo.
1 Identidad
2 >>>+2
2 Qu es Python?.
3
4
5
6
7
8
2
>>>
Cambio de s i g n o
>>>2
2
>>>
La multipli a in * es un operador binario, la nota in matemti a es 2

interprete de Python nos quedara omo 2*6.
1
2
3
4
5
6
7
x 6
en nuestro
>>>26
12
>>>
>>>85
40
>>>
La diferen ia entre divisin y divisin entera, es omo lo indi a su nombre, en la divisin

nos da omo resultado un nmero real, por ejemplo 3.5/2 devuelve 1.75, mientras que si
dividimos el mismo nmero omo divisin entera 3.5//2 nos devuelve 1.0.
1 Divisin
2 >>>3.5/2
3 1.75
4 >>>
5 D i v i s i n Entera
6 >>>3.5//2
7 1.0
8 >>>
El operador modulo que se denota por el operador de por entaje %, el ual devuelve
el resto de la divisin entre dos operandos.
1 >>>7 %2
2 1
3 >>>
Las opera iones de suma y resta se representan por los smbolos + y - respe tivamente
y operan sobre valores numri os.
1 >>>5+5
2 10
3 >>>155
4 10
5 >>>
2.0.4.
Operadores Lgi os y de Compara in.
Los operadores lgi os en Python son: y lgi o and ( onjun in), el o lgi o
or (disyun in), y el no lgi o not (nega in). El omportamiento de un operador
lgi o suele denirse mediante su orrespondiente tabla de verdad4 , en ella se muestra
4
Se emplean para determinar los posibles valores de una expresin o proposi in.
10
2 Qu es Python?.
el resultado que produ e la apli a in de un determinado operador a uno o dos valores
lgi os.
Operador n-ario AND ( onjun in): Es verdadero, si y solo si los operandos son verdaderos, enton es devuelve verdadero, si hay alguno que sea falso enton es devuelve falso.
p
p AND q
Operador n-ario OR (disyun in): Apli ado a 2 o mas operadores, si todos son falsos
devuelve falso en aso ontrario devuelve verdadero.
Operador
vi eversa.
unario NOT
p OR q
(nega in): Cambia el valor de verdad de verdadero a falso y

p
NOT p
Un operador de ompara in omo su nombre lo indi a ompara sus operandos y

devuelve un valor lgi o basado en si la ompara in es verdadera o no. Los operandos
pueden ser numri os o adenas.
Operador
Opera in
<
Menor que
==
Igual que
!=
Distinto que
<=
Menor o igual que
>
Mayor que
11
2 Qu es Python?.
2.0.5.
Operador
Opera in
<
Menor que
>=
Mayor o igual que
Tipos Bsi os de Datos.
En Python existen tres tipos bsi os de datos:

Nmeros
Cadenas
Valores booleanos
2.0.5.1. Nmeros .
Enteros.
Los nmeros enteros son aquellos nmeros positivos o negativos que no tiene de imales.
En Python se pueden representar mediante el tipo int (de integer, entero). o el tipo long
(largo). La ni a diferen ia es que el tipo long permite alma enar nmeros ms grandes.
Es re omendable no utilizar el tipo long a menos que sea ne esario para no malgastar la
memoria.
El tipo int de Python se implementa a bajo nivel mediante un tipo long de C. Y dado
que Python utiliza C por debajo, el rango de los valores que puede representar depende
de la plataforma. En la mayor parte de las maquinas el long de C se representa utilizando
32 bits, es de ir, una variable tipo int en Python puede alma enar nmeros de 231 a
231 1, el tipo long en Python permite alma enar nmeros de ualquier pre isin, estando
limitados solo por la memoria disponible en la mquina.
Al asignar un nmero a una variable esta pasar a tener tipo int, a menos que el
nmero sea tan grande omo para requerir el uso del tipo long.
Reales.
Los nmeros reales son los que tienen de imales. En Python se expresan mediante
el tipo oat. Python implementa un tipo oat a bajo nivel mediante una variable de
tipo double en C, es de ir utilizando 64 bits, luego en Python siempre se utiliza doble
pre isin, y en on reto se sigue el estndar IEEE 754 5 , 1 bit para el signo, 11 para los
exponente y 52 para la mantisa. Esta signi a que los valores que podemos representar
van desde 2, 2250738585072020 10308 hasta 1, 7976931348623157 10308 .
Tambin se puede utilizar nota in ient a, y aadir una e (de exponente) para
indi ar un exponente en base 10. Por ejemplo:
5
Es el estndar ms extendido para las omputa iones en punto otante, y es seguido por mu has de
las mejoras de CPU y FPU.
12
2 Qu es Python?.
r e a l = 0 . 1 e 3
sera equivalente a 0,1 103 .

Complejos.
Los nmeros omplejos son una extensin de los nmeros reales, estos representan todas
las ra es de los polinomios, a diferen ia de los reales. Enton es los nmeros omplejos son
aquellos que tienen una parte imaginaria, una ara tersti a de Python es que podemos
trabajar on nmeros omplejos, ya que la gran mayora de los lenguajes de programa in
are en de estos.
Un nmero omplejo naliza siempre on la letra j, que representa el valor de la raz
uadrada negativa, un nmero omplejo on parte real se expresa sumando la parte real
a un nmero omplejo puro.
Ejemplo:
1 4j
2 1+2 j
3 2.0+3 j
ahora en Python
1
2
3
4
5
6
>>> 1 j
1j
>>> 1 j 1 j
(1+0 j )
>>>1j omplex ( 0 , 1 )
(1+0 j )
En on reto se alma ena en una estru tura de C, ompuesta por dos variables de
tipo double, sirviendo una de ellas para alma enar la parte real y la otra para la parte
imaginaria.
2.0.5.2. Cadenas.
Las adenas no son ms que texto en errado entre omillas simples (' adena') o omillas
dobles ( adena), dentro de las omillas se puede aadir ara teres espe iales omo, \n,
el ar ter de nueva linea, o \t, el de tabula in, et .
Tambin es posible en errar una adena entre triples omillas ( simples o dobles),
de esta forma podemos es ribir el texto en varias lineas y al imprimir la adena, se
representarn los saltos de linea que se introdujeron sin tener que re urrir al ar ter \n,
as omo las omillas sin tener que ponerlas omo ar ter espe ial.
1 >>> t r i p l e =" " " p r i m e r a l i n e a
2 . . . segunda l i n e a " " "
3 >>> print t r i p l e
4 primera l i n e a
5 segundalinea
13
2 Qu es Python?.
Las adenas tambin admiten operadores omo +, que fun iona realizando una on atena in de las adenas utilizadas omo operadores y *, en la que se repite la adena
tantas ve es omo lo indique el nmero utilizado omo segundo plano.
1
2
3
4
5
6
7
>>> a = "uno"
>>> b = " dos "
>>> = a+b
>>> print
unodos
>>>print a 2
unouno
2.0.5.3. Booleanos.
Una variable de tipo booleano slo puede tener dos valores: True ( ierto) o false (falso),
estos valores son espe ialmente importantes para las expresiones ondi ionales y los i los,
adems los valores booleanos son el resultado de expresiones que utilizan operadores
rela ionales ( ompara in entre valores).
Ejemplo:
1 >>> r = 5 == 3
2 >>> print r
3 False
4 >>>
14
3 Mi Primer Programa en Python.

3.1. Hola mundo en Python.
En Python existen dos formas de eje utar digo Python, en una sesin intera tiva
en el interprete, omo vimos en el aptulo anterior y omo es habitual, es ribiendo el
digo fuente en un ar hivo y eje utndolo. El primer programa que vamos a es ribir en
Python es el lsi o Hola mundo.
Vamos a abrir un editor de texto para rear un ar hivo, el ual llamaremos hola.py1 y
es ribiremos el siguiente digo:
1
2
#! / u s r / b i n / e n v
python
print " Hola mundo"
ahora guardamos los ambios, eje utar este programa es muy sen illo omo indi arle
el nombre del ar hivo a eje utar al intrprete de Python.
python h o l a . py
La primera linea se le ono e omo shebang o hashbang 2 , enseguida ponemos la dire in de donde se en uentra nuestro intrprete y la op in env (de environment, entorno)
para preguntar al sistema por la ruta al intrprete de Python, de modo que no tengamos
ningn problema si se diera el aso de que el programa no estuviera instalado en di ha
ruta. La segunda linea es una palabra reservada la ual nos manda a imprimir la adena
Hola mundo.
Otra forma de de eje utar nuestro programa, es dndole permisos de eje u in, esto lo
ha emos on
hmod +x h o l a . py
y desde la onsola omo si se tratara de un eje utable ualquiera:

. / h o l a . py
3.2. Comentarios.
La legibilidad de los programas es lave para ha erlos pr ti os, uando omenzamos a
es ribir programas de mayor tamao es ms dif il omprender lo que estamos ha iendo
para otros programadores o in luso llegar a re ordar lo que hi imos nosotros mismos
uando queremos revisar algn programa. Una manera de solu ionar esto es onsiste en
1
2
La extensin de los heros de Python

Es el nombre que re ibe el par de ara teres #! que indi a el ini io de un ar hivo en el que justo a
ontinua in se en uentra la ruta ompleta al intrprete.
15

inter alar omentarios que expliquen su nalidad. Cuando el intrprete de Python ve un
omentario no ha e nada on el, lo omite. Cuando le indi amos al intrprete que ierto
texto es un omentario?. Los omentarios en Python se indi an on el smbolo #(que
se lee almohadilla), todo texto despus de la almohadilla hasta el nal de la linea se
onsidera omentario y, en onse uen ia es omitido por Python.
Ejemplo:
1
2
3
4
5
#Mi
primer
programa
#! / u s r / b i n / e n v
#E s t o
es
un
en
Python
python
omentario
print " h o l a mundo"
en
Python
#I m p r i m e
en
pantalla
Es buena pra ti a que omentes tus programas, observa que podemos olo ar omentarios en ualquier lugar donde reamos onveniente.
3.3. Entrada/Salida de Datos.

Entrada.
La forma ms sen illa de obtener informa in por parte del usuario es mediante la
fun in raw_input(entrada en bruto), esta fun in ha e lo siguiente: detiene la eje u in
del programa y espera a que el usuario es riba un texto y pulse la te la enter, en ese
momento prosigue la eje u in.
Ejemplo
1
2
3
4
5
#! / u s r / b i n / e n v
#O b t e n e r
nombre
#I m p r i m e
lo
python
nombre = raw_input ( ' E s r i b e tu nombre ' )

te leado
por
el
usuario
print " Bienvenido a Python , " + nombre
Si ne esitamos un entero en lugar de una adena, podemos utilizar la fun in int. La

fun in int re ibir omo argumento la adena que devuelve raw_input y propor ionara
un nmero entero, tambin existe una fun in oat para uando ne esites, un nmero de
tipo otante.
Ejemplo:
1
2
3
4
5
6
7
#! / u s r / b i n / e n v
#O b t e n e r
nombre
#O b t i e n e
nmero
python

en
entero
edad = i n t ( raw_input ( ' Cual e s tu edad ' ) )

print "Tu nombre e s : " + nombre
print "Tu edad e s : " + edad
Si queremos utilizar la fun in oat

1 #! / u s r / b i n / e n v p y t h o n
2 from math import p i
3 r a d i o = f l o a t ( raw_input ( ' I n t r o d u e r a d i o : ' ) )
4 p e r i m e t r o = 2 p i r a d i o
5 print p e r i m e t r o
16

Salida.
En los ejemplos que hemos visto utilizamos las adenas que pueden usarse tambin
para mostrar textos por pantalla en ualquier momento a travs de la fun in print. Si
queremos mostrar el ontenido de una variable basta on suprimir las omillas para que
muestre el ontenido de di ha adena.
Una senten ia print puede mostrar ms de un resultado en una misma linea, basta
on separar on omas todos los valores que deseamos mostrar, ada una de las omas
se tradu e en un espa io de separa in.
1
2
3
4
#! / u s r / b i n / e n v
python
#i m p r i m i m o s
todo
en
un
solo
print
print ' G r a i a s ' , nombre ' ' por u t i l i z a r Python '
Con la senten ia print podemos ontrolar un po o la aparien ia de la salida, para esto

vamos a utilizar el operador %, esto seria un formato similar al estilo C.
Ejemplo:
1
2
print " Hola %s " % "mundo"

print " %d %f " % ( 5 , 5 . 0 )
Lo que ha emos en la primera linea es introdu ir el valor despus de % que es la

adena mundo en la posi in indi ada, por el espe i ador %s. En la segunda linea lo
que ha emos es pasar mas de un valor al espe i ador.
Los espe i adores mas sen illos estn formados por el smbolo % seguido de una letra
que indi a el tipo on el que formatea el valor.
%x
Hexade imal
Espe i ador
Formato
%s
Cadena
%d
Entero
%o
O tal
%f
Real
Podemos introdu ir un nmero entre el % y el ar ter que indi a el tipo de formato,

indi ando el nmero mnimo de ara teres que queremos que o upe la adena. En aso
de los reales es posible indi ar la pre isin a utilizar pre ediendo la f un punto seguido
por el nmero de de imales que queremos mostrar
Ejemplo:
1
print " %.5 f " 5.123456 7 8 9
Esto mismo lo podemos apli ar en adenas para mostrar el nmero de ara teres de la
adena que ne esitemos mostrar.
17
4 Estru turas de Control

Si un programa no fuera ms que una lista de rdenes a eje utar de forma se uen ial, una por una, no tendra mu ha utilidad, los ondi ionales nos permiten omprobar
ondi iones y ha er que nuestro programa se omporte de una forma u otra, que eje ute
un fragmento de digo u otro, dependiendo de la ondi in o de lo que ne esitemos
nosotros.
Aqu es donde vemos la importan ia de los operadores booleanos, lgi os y de rela in
en Python.
4.0.1.
La Senten ia Condi ional if.
La primera senten ia ondi ional es un if (del ingls si) seguido por la ondi in que
se va a evaluar, dos puntos (:) y en la siguiente linea e identado, el digo a eje utar si
es que la ondi in se umple.
2 a=i n t ( raw_input ( ' I n t r o d u e v a l o r de a : ' ) )
3 b=i n t ( raw_input ( ' I n t r o d u e v a l o r de b : ' ) )
4 i f b!=0:
#O b s e r v a l o s d o s p u n t o s , q u e i n d i a
5
#e l f i n d e l a s e n t e n i a
if
6
x=a/b
#La i d e n t a i n e s muy i m p o r t a n t e e n P y t h o n
7
print ' S o l u i n : ' , x
# por que a s i d i s t i n g u e l o que s e va a
8
#e j e u t a r d e n t r o d e l i f .
Asegurate de que la identa in esta omo en el ejemplo, ya que es la forma en que

Python sabe que es nuestra inten in que se eje uten las dos instru iones siguientes, si
y solo si se umple la ondi in del if.
Veamos que on el if podemos mejorar un po o nuestro ejemplo anterior.
1 ! / u s r / bin / env python
4 i f b!=0:
#O b s e r v a l o s d o s p u n t o s ,
5
#q u e i n d i a e l f i n d e l a s e n t e n i a
if
6
x=a/b
#La i d e n t a i n e s muy i m p o r t a n t e e n P y t h o n
7
#p o r q u e a s i d i s t i n g u e l o q u e s e v a a
8
#e j e u t a r d e n t r o d e l i f .
9 i f b==0:
10
print 'No puedo d i v i d i r por 0 '
Ahora nuestro programa nos indi a que tenemos una divisin por 0 y que no la puede
realizar.
18
4.0.1.1. If ... else.

Vamos a ver un ondi ional ms ompli ado, en nuestro ejemplo anterior, Como lo
realizariamos sin la ne esidad de utilizar dos if?. Para esto el ondi ional if tiene una
segunda forma de utilizarse que es muy til.
Ejemplo:
1 ! / u s r / bin / env python
4 i f b!=0:
#O b s e r v a l o s d o s p u n t o s , q u e i n d i a
5
#e l f i n d e l a s e n t e n i a
if
6
x=a/b
#La i d e n t a i n e s muy i m p o r t a n t e e n P y t h o n .
7
# por que a s i d i s t i n g u e l o que s e va
8
#a e j e u t a r d e n t r o d e l
if .
9 else :
#U t i l i z a n d o un e l s e p a r a s u p r i m i r un i f .
10
print 'No puedo d i v i d i r por 0 '
Nuestra sintaxis para utilizar esta ondi ional es:

i f ( ondi in ) :
.....
.....
else :
.....
.....
i f ( Condi in ) :
.....
.....
else :
.....
Como podemos observar es muy importante la identa in, por que as Python va a
saber que es lo que tiene que eje utar si se umple la ondi in if, o en aso ontrario de
que no se umpla que ah que realizar.
Existe una ontra in del else ... if ... que es elif:
2 numero=i n t ( raw_input ( 'Da un nmero ' ) )
3 i f numero < 0 :
4
print ' Nmero n e g a t i v o '
5 e l i f numero > 0 :
6
print ' Nmero p o s i t i v o '
7 else :
8
print ' Cero '
Es de ir el elif s i se umple la ondi in del elif se eje uta se eje uta su digo, si no
se umple se eje uta el digo que umple el else.
Ejemplo de lo visto:
1
2
3
#! / u s r / b i n / e n v
python
from
math
import
a=f l o a t ( raw_input ( ' V alor de a : ' ) )

b=f l o a t ( raw_input ( ' V alor de b : ' ) )
sqrt
19

4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
=f l o a t ( raw_input ( ' V alor de : ' ) )

i f a !=0:
i f b 2 4 a >=0:
x1=(b+s q r t ( b 2 4 a ) ) /( 2 a )
x2=(b s q r t ( b 2 4 a ) ) /( 2 a )
print ' S o l u i o n e s de l a e u a i o n : x1= %4.3 f y x2= %4.2 f ' % ( x1 , x2 )
else :
print 'No hay s a l u i o n e s r e a l e s . ' else :
i f b!=0:
x= /b
print ' S o l u i o n de l a e u a i o n : x= %4.3 f ' % x
e l i f !=0:
print ' La e u a i o n no t i e n e s o l u i o n e s '
else :
print ' La e u a i o n t i e n e i n f i n i t a s s o l u i o n e s '
4.0.2.
Bu les o Ci los.
Mientras que los ondi ionales nos permiten eje utar distintos fragmentos de digo,
los bu les o i los nos permiten eje utar un mismo fragmento un numero determinado
de ve es, mientras que se umpla alguna ondi in.
4.0.2.1. while.
El bu le i lo while (mientras) eje uta un fragmento del digo mientras se umpla
la ondi in. La sintaxis seria la siguiente:
while ondi in :
a in
......
......
......
Ejemplo:
1
2
3
4
5
6
#! / u s r / b i n / e n v
python
i =0
while i <10:
print i
i+=1
print ' Rermina i l o '
Como podemos ver, nuestro bu le nos imprime hasta que se umpla la ondi in, mientras i sea menor a 10, imprime el valor de i, uando la ondi in no se umpla termina
el i lo y ontinua on el siguiente fragmento de digo. Ah que tener en uenta que si
no se umple la ondi in de paro, nuestro bu le puede no tener n nun a, a esto se le
ono e omo bu le innito.
Veamos algunos ejemplos mas tiles.
Supongamos que ne esitamos al ular la suma de los primeros 1000 nmeros, es de ir,
un programa que al ule:
20

1000
X
i=0
o, lo que es lo mismo, el resultado de 1+2+3+....+1000.

Podramos es ribir un programa es ribiendo una variable y es ribir todos los nmeros
sumados de el 1 hasta el mil, y mandar a imprimir nuestra variable.
numero=1+2+3+4+5+6+7+8+....+1000
p r i n t numero
Esto no es fun ional, es muy problemti o tener que es ribir los nmeros del 1 al 1000,
mejor utilizaremos nuestro bu le while, as no tendremos que es ribir mu ho.
1
2
3
4
5
6
7
#! / u s r / b i n / e n v
python
i =1
sumatoria=0
while i <=1000:
sumatoria+=i
i+=1
print sumatoria
Como podemos observar on unas uantas lineas somos apa es de ahorrarnos todo el
trabajo de es ribir todos los nmeros on nuestro bu le while.
Ahora que pasara si queremos que al ule la suma de ualquier nmero, adems que
el usuario pueda de idir uando el programa termine su eje u in. Para esto vamos a
utilizar nuevamente nuestro bu le while.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#! / u s r / b i n / e n v
python
op ion= ' '

while op ion != ' d ' : #C i l o d e v a l i d a i n p a r a o p i o n e s .
print ' C a l u l a r Sumatoria S '#I m p r i m e n u e s t r o men .
print ' S a l i r d '
i f op ion==' s ' :
#V a l i d a i n
numero=i n t ( raw_input ( ' Dar un nmero : ' ) )
i =1
sumatoria=0
while i<=numero :
sumatoria+=i
i+=1
print sumatoria
e l i f op ion != ' d ' :
print ' Op in no v a l i d a '
print ' f i n '
Como podemos observar on esta pequea modi a in podemos al ular ualquier

sumatoria, sin ne esidad de modi ar nuestro programa, ada vez que ne esitemos al ular una sumatoria nueva y podemos salir de el uando lo ne esitemos. Adems podemos
ver que tan tiles son nuestras senten ias de ontrol, las uales nos ayudan a validar la
a in que el usuario desea realizar.
21
4.0.2.2. for-in.
Hay otro tipo de bu le en Python, el bu le for-in, que se puede interpretar omo para
todo elemento de una serie, ha er .... y omo tal intenta fa ilitar su uso en este n.
f o r v a r i a b l e i n s e r i e de v a l o r e s :
a in
a in
.....
Veamos un pequeo ejemplo para entender mejor el fun ionamiento de nuestro bu le.
1
2
3
4
#! / u s r / b i n / e n v
python
s e u e n i a =[" pepe " , " ana" , " juan "

for elemento in s e u e n i a :
print elemento
Primero tenemos una rela in de nombres en errada entre or hetes y ada nombre es
separado por una oma, se trata de una lista, la ual estudiaremos ms adelante. Lo que
ha e el bu le es, para ada elemento que tengamos en se uen ia, eje uta las siguientes
lineas de digo. La abe era del bu le es obtener el siguiente elemento de la se uen ia
y lo alma ena en la variable, de esta manera, la variable elemento, en nuestra primera
itera in valdr pepe, en la segunda ana y en la ter era juan.
Ahora supongamos que queremos imprimir los nmeros de el 1 al 100, esto seria muy
laborioso, por que on lo que hemos aprendido hasta ahora tendiramos que utilizar un
i lo for, on una lista [1,2,3,.....,100, adems de que es un programa po o elegante, en
su lugar utilizaremos la fun in predenida range() de Python que expli aremos ms
adelante para podernos ahorrar todo este trabajo extra.
1
2
3
#! / u s r / b i n / e n v
python
for i in range ( 1 , 1 0 1 ) :
print i
22
5 Cole iones.
Como hemos visto anteriormente tenemos algunos tipos de datos bsi os, omo nmeros,
las adenas de texto y los booleanos, Python nos propor iona ole iones de datos estru turas avanzadas omo: listas, tuplas y di ionarios, los que serian equivalentes en
otros lenguajes a ve tores, arrays y matri es.
5.1. Listas.
Las listas son un tipo de ole in ordenada. Seria equivalente a un ve tor, estas pueden
ontener ualquier tipo de dato: nmeros, adenas, booleanos e in luso tambin listas. La
estru tura para rear una lista es, indi ar entre or hetes los elementos que ne esitamos,
separados por omas ada uno de ellos:
l i s t a =[ elem1 , elem2 , . . . , elem n
Podemos a eder a ada uno de los elementos de la lista es ribiendo el nombre de la

lista e indi ando el ndi e del elemento entre or hetes. Ah que tener en uenta que que
el primer elemento de la lista es el 0 y no 1:
Ejemplo:
1
2
3
4
#! / u s r / b i n / e n v
python
l = [ 1 , 2 , 3 , 4 , 5 , " Pedro " , "Mary" , [ 6 , 7

i n d i e=l [ 0 #e s i g u a l a 1
print i n d i e
Si queremos a eder a un elemento de una lista dentro de otra lista, tendremos que
utilizar dos ve es el operador, primero para indi ar a que posi in de la lista externa
queremos a eder y el segundo para sele ionar el elemento de la lista interior.
Ejemplo:
1
2
3
4
#! / u s r / b i n / e n v
python
l = [ 1 , 2 , 3 , 4 , 5 , " Pedro " , "Mary" , [ 6 , 7

i n d i e=l [ 7 [ 0 #p r i m e r o i n d i a m o s l a p o s i i n
print i n d i e
#y e n s e g u i d a e l e l e m e n t o d e l a
del
la
lista
lista
externa
interna .
Tambin podemos utilizar este operador para modi ar un elemento de la lista si lo

olo amos en la parte izquierda de una asigna in:
1
2
3
4
#! / u s r / b i n / e n v
python
l = [ 1 , 2 , 3 , 4 , 5 , " Pedro " , "Mary" , [ 6 , 7

l [ 6 = " Diana " #Cambia e l v a l o r Mary
print l [ 6
Diana
El uso de or hetes para a eder y modi ar los elementos de una lista es omn en
mu hos lenguajes, pero Python nos guarda mu has sorpresas agradables.
23
5 Cole iones.
Una uriosidad sobre el operador [ de Python es que podemos utilizar tambin nmero
negativos. Si se utiliza un nmero negativo omo ndi e, esto se tradu e en que el ndi e
empieza a ontar desde el nal, ha ia la izquierda es de ir, on [-1 a ederamos al ltimo
elemento de la lista, on [-2 al penltimo, on [-3 al antepenltimo y as su esivamente.
Ejemplo:
1
2
3
#! / u s r / b i n / e n v
python
l = [ 1 , 2 , 3 , 4 , 5 , " Pedro " , "Mary" , [ 6 , 7

print l [ 2 #I m p r i m e e l a n t e p e n l t i m o
Otra osa importante en Python es lo que se ono e omo sli ing o parti ionado, que
onsiste en ampliar este me anismo para permitir sele ionar por iones de la lista. Si
en lugar de un nmero es ribimos dos nmeros ini io y n separados por dos puntos
(ini io:n) Python interpretar que queremos una lista que vaya des la posi in ini io
a la posi in n, sin in luir este ltimo. Si es ribimos tres nmeros (ini io:n:salto) en
lugar de dos, el ter ero se utiliza para determinar ada uantas posi iones aadir un
nuevo elemento a la lista.
Ejemplo:
1
2
3
4
5
6
#! / u s r / b i n / e n v
python
l = [ 1 , 2 , 3 , 4 , 5 , " Pedro " , "Mary" , [ 6 , 7

l n=l [ 0 : 5 #Toma l a l i s t a d e l e l e m e n t o 0 a l 4
print l n
l n=l [ 0 : 7 : 4 #I n d i a a d a u a n t a s p o s i i o n e s
print l n
#a a d i r un n u e v e e l e m e n t o .
Los nmero negativos tambin se pueden utilizar en un sli ing, on el mismo omportamiento. Hay que men ionar que no es ne esario indi ar el prin ipio y el nal del sli ing,
sino que, si estos se omiten, se usara por defe to las posi iones de ini io y n de la lista:
Ejemplo:
1
2
3
4
#! / u s r / b i n / e n v
python
l = [ 1 , 2 , 3 , 4 , 5 , " Pedro " , "Mary" , [ 6 , 7

l n=l [ 2 :
print l n
Tambin podemos utilizar este me anismo para modi ar las listas, in luso modi ar
el tamao de la lista, si la lista de la parte dere ha de la asigna in tiene un tamao
menor o mayor que el de la sele in de la parte izquierda de la asigna in.
Hasta el momento hemos aprendido a onstruir y modi ar listas de diferentes modos,
pero nos falta, mo leer listas desde el te lado. Podemos utilizar nuestra fun in que ya
ono emos raw_input on el parmetro list.
1
2
3
#! / u s r / b i n / e n v
python
l i s t a = l i s t ( raw_input ( "Dame una l i s t a : " ) )

print l i s t a
La fun in list devuelve una lista a partir de una adena, pero ada elemento de la
lista es un ar ter de una adena, esto quiere de ir que el nmero 2 se interpreta omo
un ar ter y no omo un entero.
24
5 Cole iones.
Para leer listas, lo que ne esitamos ha er es ir leyendo la lista elemento a elemento y
onstruir la lista paso a paso, esto lo podemos ha er utilizando un i lo y una fun in
predeterminada llamada range que expli aremos mas adelante.
1
2
3
4
5
6
#! / u s r / b i n / e n v
python
l i s t a =[
for i in range ( 5 ) :
elemento = i n t ( raw_input ( "Dame un elemento : " ) )
l i s t a =l i s t a +[ elemento
print l i s t a
Tambin existe la fun in append, que evita que ada on atena in genera una lista
nueva opiando los valores de la antigua y aadiendo el elemento re in ledo.
1
2
3
4
5
6
#! / u s r / b i n / e n v
python
l i s t a =[
for i in range ( 5 ) :
elemento = i n t ( raw_input ( "Dame un elemento : " ) )
l i s t a . append ( elemento )
print l i s t a
Otra fun in importante es la de borrado de un elemento de una lista, para esto

utilizamos la senten ia del, debes indi ar que elemento deseas eliminar inmediatamente
despus de la palabra del.
1
2
a =[1 ,2 ,3 ,4 ,5
del a [ 1
La senten ia del no produ e una opia de la lista sin la elda borrada, sino que modi a
dire tamente dire tamente sobre la lista que opera, tambin ah que tener en uenta que
el borrado de elementos de una lista es peligroso uando se mez la on el re orrido de
las mismas.
1
2
3
4
5
6
7
8
9
#! / u s r / b i n / e n v
python
a = [1 ,2 , 1 , 4 ,5 , 2
i =0
while i < l e n ( a ) :
i f a [ i <0:
del a [ i
else :
i+=1
print a
Otra fun in importante de las listas es que podemos rear listas de listas, Para que
nos sirve rear listas de listas?. Supongamos que ne esitamos representar una matriz, la
ual en nota in matemti a seria:
1 1 4 2
1
0 3 1 5 2
M =
3 2 3 3 1
1 1 2 2 3
2 1 2 1 4
25
5 Cole iones.
Con una lista de nmeros no se puede representar una matriz pero, si on una lista de
lista:
>>M= [ [ 1 , 2 , [ 3 , 4
.
.
.
.
.
.
n
En la nota in matemti a el elemento que o upa, la la i-sima y la olumna i-esima

de una matriz M se representa on Mi,j . Por ejemplo, el elemento de una matriz que
o upa la elda de la la 1 y la olumna 2 se denota on Mij . Pero si deseamos a eder
a ese elemento en la matriz Python M , hemos de tener en uenta que Python siempre
uenta desde ero, as que la la tendr ndi e 0 y la olumna tendr ndi e 1:
>>M[ 0 [ 1
>>2
Si deseamos leer una matriz de tamao determinado, podemos rear una matriz y
rellenar ada uno de sus omponentes:
2
3 #P e d i m o s l a d i m e n s i n d e l a m a t r i z
4 m=i n t ( raw_input ( "Dame e l numero de l a s f i l a s : " ) )
5 n=i n t ( raw_input ( "Dame e l numero de l a s olumnas : " ) )
6 #Creamos l a m a t r i z n u l a
7 M= [
6 for i in range (m) :
8
M. append ( [ 0 n )
9
26
5 Cole iones.
10
11
12
13
14
#L l e n a m o s
los
elementos
de
la
matriz .
for i in range (m) :

for j in range ( n ) :
M[ i [ j = i n t ( raw_input ( "Dame e l omponente ( %d, %d ) : " %(i , j
)))
print M
Desarrollemos un programa que nos ayude a ha er opera iones on matri es, lo primero
que ne esitamos saber es omo se realizan las opera iones on matri es:
Para realizar la suma y resta ne esitamos dos matri es de la misma dimensin, A = aij
y B = bij , y se dene la suma de matri es omo A+ B = aij + bij . Es de ir aquella matriz
uyos elementos se obtienen sumando los elementos de las dos matri es que o upan la
misma posi in.

1 2
Sea A =
3 4
y
B=
2 5
6 7
La suma de A + B :
A+B =
1+2 2+5
3+6 4+7
esto es igual a
3 7
9 11
Del mismo modo la resta se ha e omponente a omponente A B

12 25
1 3
AB =
esto es igual a
36 47
3 3
Empe emos en disear un programa que nos sume dos matri es, ah que re ordar que
las matri es tienen que ser de la misma dimensin.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#! / u s r / b i n / e n v
#P e d i m o s
los
python
datos
de
la
matriz
m=i n t ( raw_input ( "Dame e l numero de f i l a s : " ) )

n=i n t ( raw_input ( "Dame e l numero de olumnas : " ) )
#I n i i a l i z a m o s
la
matriz
A omo
matriz
B omo
matiz
nula
A= [
A. append ( [ 0 n )
la
matriz
nula
B= [
27
5 Cole iones.
17
B . append ( [ 0 n )
18
19 #P e d i m o s l o s d a t o s d e l a m a t r i z A
20
21 print " Datos de l a matriz A: "
23
24
A[ i [ j = i n t ( raw_input ( "Dame e l omponente ( %d, %d ) : " %(i , j ) ) )
25
26 #P e d i m o s l o s d a t o s d e l a m a t r i z B
27
28 print " Datos de l a matriz B: "
30
31
B [ i [ j = i n t ( raw_input ( "Dame e l omponente ( %d, %d ) : " %(i , j ) ) )
32
33 #I n i i a l i z a m o s l a m a t r i z C omo n u l a
34 #En d o n d e vamos a g u a r d a n u e s t r o s r e s u l t a d o s
35
36 C= [
38
C. append ( [ 0 n )
39
40 #Ha emos l a suma d e l a s m a t r i e s A y B
41
43
44
C[ i [ j =A[ i [ j +B[ i [ j
45
46 #M o s t r a m o s e l r e s u l t a d o
47 print "Suma : "
49
50
print C[ i [ j
51
print
Ahora para realizar la resta de matri es lo ni o que tenemos que modi ar son nuestras
lineas donde ha emos las opera iones:
1
2
3
4
5
6
7
#A q u i
ha emos
#p r o g r a m a
#l a s
el
ambio
anterior
matri es
para
de
signo
de
nuestro
restar
A y B.

C[ i [ j =A[ i [ j B[ i [ j
La siguiente opera in a realizar es la multipli a in de matri es, la ual es ms ompli ado, primero veamos las reglas para multipli ar matri es.
El produ to de matri es slo se puede denir si el nmero de olumnas de la matriz A
es el mismo nmero de las de la matriz B, esto quiere de ir que si las matri es son Amn
y Bnp enton es el produ to matri ial de AB es una matriz resultante C de la forma
Cmp , donde ada elemento de C esta denido por :
28
5 Cole iones.
Cij =
n
P
air brj
r=1
Sea:
A=
1 0 2
1 3 1
3 1
B= 2 1
1 0
enton es,
AB =
(1 3 + 0 2 + 2 1)
(1 1 + 0 1 + 2 0)
(1 3 + 3 2 + 1 1) (1 1 + 3 1 + 1 0)
5 1
4 2
Ahora que ya sabemos omo se realiza una multipli a in de matri es, vamos ha er
nuestro programa para automatizar este algoritmo.
Lo primero es pedir el nmero de las y olumnas de la primera matriz y slo el nmero
de olumnas de la segunda
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#! / u s r / b i n / e n v
python
p=i n t ( raw_input ( "Dime e l numero de l a s f i a l s de A: " ) )

q=i n t ( raw_input ( "Dime e l numero de olumnas de A ( y f i l a s de B) : " ) )
r=i n t ( raw_input ( "Dime e l numero de olumnas de B : " ) )
#Creamos
matri es
nulas
A= [
for i in range ( p ) :
A. append ( [ 0 q )
B= [
for i in range ( q ) :
B . append ( [ 0 r )
#L l e n a m o s
las
matri es
for j in range ( q ) :
A[ i [ j = i n t ( raw_input ( "Dame e l omponente ( %d , %d ) : " %(i , j ) ) )
for j in range ( r ) :
B [ i [ j = i n t ( raw_input ( "Dame e l omponente ( %d , %d ) : " %(i , j ) ) )
#Creamos
la
matriz
resultante
29
5 Cole iones.
29 C= [
30 for i in range ( p ) :
31
C. append ( [ 0 r )
32
33 #E f e t u a m o s l o s a l u l o s
34
36
37
for k in range ( q ) :
38
C[ i [ j +=A[ i [ k B[ k [ j
39
40 #M o s t r a m o s e l r e s u l t a d o
41
42 print " M u l t i p l i a i o n : "
44
45
print C[ i [ j
46
print
Por ultimo vamos ha er la traspuesta de una matriz.

Sea A una matriz on m las y n olumnas, la matriz traspuesta, denotada por At esta
dada por:

At ij = Aji , 1 i n, 1 j m
A=
1 2
3 4
At
1 3
2 4
Como podemos observar, lo ni o que tenemos que ha er es modi ar el orden de

nuestros subndi es:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#! / u s r / b i n / e n v
#P e d i m o s
la
python
matriz
m=i n t ( raw_input ( "Dame e l numero de l a s f i l a s : " ) )

n=i n t ( raw_input ( "Dame e l numero de l a s olumnas : " ) )
las
matri es
M= [
M. append ( [ 0 n )
T= [
for i in range ( n ) :
T. append ( [ 0 m)
#L l e n a m o s
la
matriz
30
5 Cole iones.
23
24
25
26
27
28
29
30
31
32
33
34
M[ i [ j = i n t ( raw_input ( "Dame e l omponenete ( %d , %d ) : " %(i , j ) ) )
#Ha emos
los
ambios
en
la
matriz .
for j in range (m) :
T[ i [ j =(M[ j [ i )
#I m p r i m i m o s
la
Matriz
print T
5.2. Tuplas.
Todo lo que hemos expli ado sobre las listas apli a tambin a las tuplas, on la ex ep in de la forma de denirlas, por lo que se utilizan parntesis en lugar de or hetes.
1 t u p l a =(1 ,2 ,3 , " python" )
Es importante poner las omas, por que la oma es el onstru tor de la tupla, esto
quiere de ir que si queremos denir una tupla de un solo elemento tenemos que ponerle
una oma al nal, para diferen iarlo de un elemento entre parntesis.
t u p l a =("un e l e m e n t o " , )
[
1
2
3
4
Para referirnos a los elementos de una tupla, omo en una lista, se utiliza el operador
#! / u s r / b i n / e n v
python
t u p l a = ( 1 , 2 , 3 , 4 , " python" )
t=t u p l a [ 1
print t
Podemos utilizar el operador [, debido a que las tuplas, al igual que las listas forman,
parte de un tipo de objeto llamado se uen ia.
Su diferen ia on las listas esta en que las listas es que son inmutables, es de ir, su
valor valor no puede modi arse una vez reada y tienen un tamao jo. A ambio de
estas limita iones las tuplas, son mas ligeras, que las listas por lo que si el uso que le
vamos a dar a una ole in es muy bsi o, puede utilizarse en lugar de una lista y as
podemos ahorrar memoria.
5.3. Di ionarios.
Los di ionarios tambin llamados matri es aso iativas, deben su nombre a que son
ole iones que rela ionan una lave y un valor. Por ejemplo:
d={" Love A t u a l l y " : " Ri hard C u r t i s " ,
" K i l l B i l l " : " Tarantino " ,
" Amelie " : " Jean P i e r r e r Jenuet "}
31
5 Cole iones.
El primer valor se trata de la lave y el segundo valor aso iado a la lave. Como lave
podemos utilizar ualquier valor inmutable: podramos usar nmeros, adenas, booleanas,
tuplas, pero no listas o di ionarios, por que son mutables. Esto es as por que las di ionarios se implementan omo una tabla hash1 y a la hora de introdu ir un nuevo par
lave-valor en el di ionario se al ula el hash de la lave para despus poder en ontrar
la entrada que le orresponde rpidamente.
Los di ionarios no tienen on epto alguno de orden entre sus elementos. Es in orre to
de ir que los elementos estn desordenados; simplemente no hay orden. Esta distin in
es importante, y le estorbar uando intente a eder a los elementos de un di ionario
en un orden espe o y repetible ( omo el orden alfabti o de las laves). Hay formas
de ha er esto, slo que no forman parte de los di ionarios.
Es una estru tura de datos que aso ia llaves o laves on valores.
32
6 Fun iones.
Una fun in es un onjunto de lneas de digo que realizan una tarea espe a y
puede retornar un valor. Las fun iones pueden tomar parmetros que modiquen su
fun ionamiento. Las fun iones son utilizadas para des omponer grandes problemas en
tareas simples y para implementar opera iones que son omnmente utilizadas durante
un programa y de esta manera redu ir la antidad de digo. Cuando una fun in es
invo ada se le pasa el ontrol a la misma, una vez que esta naliz on su tarea el ontrol
es devuelto al punto desde el ual la fun in fue llamada.
FUNCIONES
Programa Principal
Proceso A
Proceso B
Procesos
Procesos
Proceso A
Proceso B
Fin
Fin
Fin
Python nos propor iona dos tipos de fun iones a utilizar, las fun iones predenidas las
uales ya estn in luidas en Python y estn listas para usarse o tambin podemos rear
nuestras propias fun iones para ade uarlas a los requerimientos de nuestros problemas.
6.1. Fun iones Predenidas.

Existen mu has fun iones predenidas en Python, ya hemos utilizado algunas para
resolver algunos problemas anteriores, omo por ejemplo la fun in predenida range(),
omo vimos anteriormente se utiliza on dos argumentos: valor ini ial y valor nal.
1 >>>range ( 2 , 1 0 )
33
6 Fun iones.
2 [2 ,3 ,4 ,5 ,6 ,7 ,8 ,9
3 >>>
Observa que la lista devuelta ontiene todos los enteros omprendidos entre los argumentos de la fun in, in luyendo al primero, pero no el ultimo.
Podemos utilizar la fun in range() on uno, dos o tres argumentos. Si utilizamos
range() on un argumento estaremos espe i ando ni amente el ultimo valor de la serie,
pues el primero vale por defe to 0.
1 >>>range ( 5 )
2 [0 ,1 ,2 ,3 ,4
3 >>>
Si usamos tres argumentos, el ter ero permite utilizar un in remento para la serie de
valores:
1 >>>range ( 2 , 1 0 , 2 )
2 [2 ,4 ,6 ,8
3 >>>range ( 2 , 1 0 , 3 )
4 [2 ,5 ,8
5 >>>
Otra fun in predenida que podemos utilizar es abs(), esta nos ayuda a sa ar el valor
absoluto de un nmero:
1 >>>abs ( 3)
2 3
3 >>>
Observa que el argumento 3 se a onvertido en un nmero positivo.

La fun in round (redondeo), puede utilizarse on uno o dos argumentos, si se utiliza
on uno solo redondea el nmero al otante mas er a uya parte de imal sea nula.
1 >>>round ( 2 . 1 )
2 2.0
3 >>>round ( 2 . 9 )
4 3.0
Si round re ibe dos argumentos, estos deben ir separados por omas y el segundo indi a
el nmero de de imales que deseamos onservar en el redondeo.
1 >>>round ( 2 . 1 4 1 5 , 2 )
2 2.14
3 >>>round ( 2 . 1 4 1 5 , 3 )
4 2.141
5 >>>
Existen mu has ms fun iones predeterminadas que podemos utilizar, ya hemos men ionado algunas, puedes onsultar mu has mas en la gua de referen ia de Python.
6.2. Fun iones Predenidas en Mdulos.

Python propor iona fun iones para ha er l ulos matemti os, para intera tuar on
el sistema operativo, fun iones de hora y fe ha, et . Pero antes de utilizarlas ne esitamos
34
6 Fun iones.
indi arle a Python que vamos a ne esitarlas. Para ello, es ne esario importar ada fun in
de un modulo.
Para importar un modulo lo ni o que ne esitamos saber es el nombre del modulo y
la fun in o fun iones que ne esitamos utilizar:
2 from math import s i n #I m p o r t a m o s e l m o d u l o math y l a f u n i o n
3
4 n=i n t ( raw_input ( "Dame un numero para a l u l a r e l seno : " ) )
5
6 print s i n ( n )
sin
Cuando importamos una fun in, Python aprende su deni in y nos permite utilizarla.
Si queremos utilizar alguna otro fun in de nuestro modulo math, ne esitamos indi arle
a Python ual es por que en este momento solo ono e la fun in sin.
En una misma lineas podemos importar varios mdulos:
from math import s i n , o s
aunque puede resultar ompli ado importar un gran nmero de fun iones y mdulos,
as que Python nos ofre e la op in de importar todos los elementos de un modulo si
utilizamos un asteris o. Por ejemplo si queremos ver importar todo lo que tiene nuestro
modulo math :
from math import
Podemos importar y utilizar ualquiera otro modulo de la misma manera que lo hi imos
on math, tanto originales de Python omo otros que hayas bajado de internet o in luso
alguno que hagamos nosotros mismos.
6.3. Deni in de Fun iones.

Vamos a aprender a denir nuestras propias fun iones, para poder ir personalizando
nuestros programas a nuestras ne esidades, es ne esario utilizar una palabra reservada
para denir una fun in. La palabra def es la abreviatura de dene la ual nos ayuda
a denir ual va a ser el nombre de nuestra fun in, a esto se le llama abe era, de
la fun in despus vamos a denir que es lo que ne esitamos que haga, a esto se le
denomina uerpo de la fun in. El valor que pasamos a una fun in uando la invo amos
se denomina parmetro o argumento, el uerpo de una fun in solo se eje utara si se
produ e la orrespondiente llamada.
35
6 Fun iones.
Cabecera
def cuadrado(x):
Parametro
Cuerpo de la funcion
return x**2
cuadrado(x)
print
Invocar o llamar a la funcion
Argumento
Las reglas para dar nombre a nuestras fun iones y a sus parmetros son: slo se pueden
usar letras, dgitos y el guin bajo, la primera letra del nombre no puede ser nmero y
no se pueden utilizar palabras reservadas. Cada nombre debe identi ar laramente un
ni o elemento: una variable o una fun in.
Veamos un pequeo ejemplo de la deni in de una fun in:
1
2
3
4
5
6
7
8
#! / u s r / b i n / e n v
python
#D e f i n i i o n
la
de
def uadrado ( x ) :
return x 2
#Llamado
la
fun ion
#C u e r p o
de
la
fun in
fu in
print uadrado ( 2 )
Dentro del uerpo de una fun in podemos utilizar estru turas de ontrol senten ias
ondi ionales, i los, et . Una forma usual de devolver valores es atreves de la fun in
return, en la ual podemos regresar valores enteros, otantes, booleanos et . In luso
dentro de nuestras fun in podemos ha er el llamado a otra fun in ya sea predenida o
que nosotros la denamos.
1
2
3
4
5
6
#! / u s r / b i n / e n v
python
def xseno ( x ) :
return s i n ( x )
#Llamado
fun ion
predefinida .
print xseno ( 1 )
No todas las fun iones tienen un slo parmetro, podemos denir fun iones que re iban
varios parmetros, por ejemplo supongamos que ne esitamos un programa que nos de el
rea de un re tngulo y le pedimos al usuario que nos de su altura y su an ho:
36
6 Fun iones.
2
3 def a r e a ( a l t u r a , an hura ) :
4
return a l t u r a an hura
5
6 a=f l o a t ( raw_input ( "Dame e l a l t o : " ) )
7 w=f l o a t ( raw_input ( "Dame e l an ho" ) )
8
9 print " El a r e a e s : " a r e a ( a ,w)
Los programas se dividen en tres partes, importa in de mdulos, deni in de fun iones y nuestro programa prin ipal, los uales puedes olo ar, o mandar a llamar en
ualquier parte del programa, pero esto resultara muy dif il para saber on laridad que
es lo que llega ha er el programa, lo mas re omendable adems de ser un buen habito para
futuras orre iones o si algn otro programador que esta interesado en analizar nuestro
digo, es poner primero las importa iones, a ontinua in las fun iones y por ultimo
nuestro programa prin ipal, adems olo ar nuestros omentarios orrespondientes, para
ha erlos mas legibles y amigables para a tualizar.
Dentro del uerpo de la fun in es posible denir y usar variables. Existen algunas
propiedades de las variables denidas dentro del uerpo de la fun in y que se diferen ian
de las variables que denimos fuera de ualquier fun in, es de ir, en nuestro programa
prin ipal.
Ejemplo:
Denamos una fun in que dado los tres lados del tringulo, devuelvan el valor de su
rea:
p
s(s a)(s b)(s c)
donde s = (a + b + c)/2
El programa quedara:
2 from math import s q r t
3
4 def a r e a _ t r i a n g u l o ( a , b , ) :
5
s =(a+b+ ) /2
6
return s q r t ( s ( s a ) ( s b ) ( s ) )
7
8 print a r e a _ t r i a n g u l o ( 1 , 3 , 2 )
En el uerpo de nuestra fun in se dene la variable s, la ual slo existe para nuestra
fun in area_triangulo, fuera de di ha fun in s no esta denida. Las variables que slo
existe en el uerpo de la fun in se denominan variables lo ales y las variables que se
en uentras en ontraposi in. se les llama variables globales. Tambin los parmetros
formales de una fun in se onsideran variables lo ales, as que no es posible a eder a
ellos fuera del uerpo de la fun in.
Otra ara tersti a importante de las fun iones, es que las variables y onstantes lo ales que ontiene el uerpo de la fun in, slo existen dentro de la fun in, por lo ual
37
6 Fun iones.
podramos tener las mismas variables lo ales en otra fun in y esto no nos provo ara
ningn problema, por que al terminar de eje utarse la fun in, las variables lo ales dejan
de existir, para el dems uerpo de nuestro programa prin ipal. Imaginemos que queremos un programa que nos ayude a al ular el rea de un triangulo de los lados a, b, y
y en el al ulo del ngulo (en grados) opuesto al lado a.
El ngulo se al ula por la formula:
180
arcsin
2s
bc
donde s es el rea del triangulo y ar sin es la fun in ar o-seno, las fun iones arcsin
y estn denida en nuestro modulo math on el identi ador asin y pi .
2 from math import s q r t , a s i n , p i
3
4 def a r e a _ t r i a n g u l o ( a , b , ) :
5
s =(a+b+ )/2
#s e s una v a r i b l e l o a l
6
return s q r t ( s ( s a ) ( s b ) ( s ) )
7
8 def a n g u l o _ a l f a ( a , b , ) :
9
s=a r e a _ t r i a n g u l o ( a , b , )
#s e s una v a r i a b l e l o a l
10
return 180/ p i a s i n ( 2 . 0 s /( b ) )
11
12 def menu ( ) :
13
op ion =0
14
while op ion !=1 and op ion ! = 2 :
15
print " 1) C a l u l a r e l a r e a de t r i a n g u l o "
16
print " 2) C a l u l a r angulo opuesto a l primer l a d o "
17
op ion=i n t ( raw_input ( " Es oge una op ion : " ) )
18
return op ion
19
20 l a d o 1=f l o a t ( raw_input ( "Dar e l l a d o a : " ) )
21 l a d o 2=f l o a t ( raw_input ( "Dar e l l a d o b : " ) )
22 l a d o 3=f l o a t ( raw_input ( "Dar e l l a d o : " ) )
23
24 s=menu ( )# s e s una v a r i a b l e g l o b l a
25
26 i f s ==1:
27
r e s u l t a d o=a r e a _ t r i a n g u l o ( lado1 , lado2 , l a d o 3 )
28 e l s e :
29
r e s u l t a d o=a n g u l o _ a l f a ( lado1 , lado2 , l a d o 3 )
30
31 print " E s o g i s t e l a op ion " , s
32 print " El r e s u l t a d o e s : " , r e s u l t a d o
Observa que en el uerpo de nuestras fun iones, tenemos de larada dos variables s y
que ada una de ellas tienen variables diferentes. Si a edemos a s desde area_triangulo
a edemos a s lo al a area_triangulo, mientras que las dems variables s de las otras
fun iones son ignoradas. Si a edemos a s desde fuera de ualquier fun in, a edemos a
s de la variable global.
38
6 Fun iones.
Puede que te parez a absurdo que Python distinga entre variables lo ales y variables
globales, pero lo ierto es que disponer de estos dos tipos de variable es de gran ayuda.
Piensa en que o urrira si la variable s de la primera fun in fuese global: al a abar la
eje u in de rea_triangulo, s re ordara el valor 6.0 y habra olvidado el valor 1. El
texto impreso seria errneo, pues se leera as ((Es ogiste la op in 6.0000)). Disponer
de variables lo ales permite asegurarse de que las llamadas a fun in no modi aran
a identalmente nuestras variables globales, aunque se llamen igual.
Las variables lo ales tambin pueden ontener valores se uen iales. Estudiemos un
ejemplo de fun in on una variable lo al de tipo se uen ial: una fun in que re ibe una
lista y devuelve o otra uyos elementos son los de la primera, pero sin repetir ninguno;
es de ir, si la fun in re ibe la lista [1, 2, 1, 3, 2, devolver la lista [1, 2, 3. Empe emos
por denir el uerpo de la fun in:
1
2
3
4
5
6
7
8
9
10
11
#! / u s r / b i n / e n v
def
python
sin_repetir ( l i s t a ) :
resultado =[
for e le me nt o in l i s t a :
i f e le me nt o not in r e s u l t a d o :
r e s u l t a d o . append ( e le me nt o )
return r e s u l t a d o
u n a _ l i s t a=s i n _ r e p e t i r ( [ 1 , 2 , 1 , 3 , 2 )
una_lista
print
Una buena idea onsiste en disponer de una nueva lista auxiliar (una variable lo al)
ini ialmente va a en la que iremos insertando los elementos de la lista resultante. Podemos re orrer la lista original elemento a elemento y preguntar a ada uno de ellos si ya
se en uentra en la lista auxiliar. Si la respuesta es negativa, lo aadiremos a la lista.
La variable resultado es lo al, as que su tiempo de vida se limita al de la eje u in del
uerpo de la fun in uando sta sea invo ada. El ontenido de resultado se devuelve on
la senten ia return, as que ser a esible desde fuera.
Como hemos visto hasta el momento, las variables lo ales de una fun in slo pueden
ser a esibles desde adentro del uerpo de nuestra fun in, pero existe una forma, donde
tambin puedes onsultar y modi ar variables globales, pero antes de poder ha er esto
tenemos que de irle a Python que ne esitamos de una variable global, para esto vamos
ha er uso de la palabra reservada global, veamos un ejemplo rpido.
1
2
3
4
5
6
7
8
9
10
11
12
13
#! / u s r / b i n / e n v
python
var1 =20
var2 =40
var3 =60
def m o d i f i a _ v a r i a b l e ( )
global var1 , var2 , var3
var1=var1+var2
print " Estado i n i i a l de l a s v a r i a b l e s : "
print var1
print var2
39
6 Fun iones.
14
15
16
17
18
19
20
21
print var3
modifi ar_variable ()
i f var1==var3 :
print " l a v a r i a b l e 1 y l a v a r i a b l e 2 son i g u a l e s "
print " V a r i a b l e 1=" , var1
print " V a r i a b l e 3= " , var3
Hemos visto que desde una fun in podemos llamar a otra fun in. Desde esta ultima
fun in podramos llamar a otra, y desde sta a otra. . . Cada vez que se produ e una
llamada, la eje u in del programa prin ipal o de la fun in ((a tual)) queda suspendida
a la espera de que nali e la llamada realizada y prosigue uando sta naliza. Por otra
parte, hemos visto que si una variable lo al en una fun in tiene el mismo nombre o que
una variable global, durante la eje u in de la fun in la variable lo al o ulta a la global
y su valor es ina esible. Cmo es posible que al nalizar la eje u in Python re uerde
todo esto?
Python utiliza internamente una estru tura espe ial de memoria para re ordar la informa in aso iada a ada invo a in de fun in: la pila de llamadas a fun in. Una pila
es una serie de elementos a la que slo podemos aadir y eliminar omponentes por uno
de sus dos extremos, el que denominamos la ima. Esto es muy importante por que as
estamos seguros de que no perderemos ninguno de nuestros datos y seguirn un orden.
6.3.1.
Mdulos.
Para fa ilitar el mantenimiento y la le tura de los programas demasiado largos los

podemos dividir en mdulos, agrupando elementos rela ionados. Los mdulos son ole iones de fun iones que puedes utilizar desde tus programas. Python ofre e gran nmero
de mdulos predenidos, pero podemos rear nuestros propios mdulos que se ajusten a
nuestras ne esidades.
Vamos a rear nuestro primer mdulo, reando un ar hivo pequeo modulo.py on el
siguiente ontenido:
1
2
3
4
5
6
7
8
9
10
11
def min ( a , b ) :
i f a<b :
return a
else :
return b
def max( a , b ) :
i f a>b
return a
else :
return b
Ahora en ualquier programa donde ne esitemos utilizar nuestras fun iones de min
y max lo ni o que ne esitamos ha er es es in luir en nuestro programa prin ipal la
siguiente linea:
1 from modulo import min , max
40
6 Fun iones.
Con esta ya tenemos denido nuestras fun iones en mdulos las uales vamos a poder
utilizar en ualquier programa que ne esitemos.
Aunque se onsidera una mala pra ti a tambin es posible importar todos los nombres
de los mdulos al espa io de nombres a tual usando el *.
1 from modulo import
Cuando importas por primera vez el modulo modulo.py en Python, este reara automti amente un hero llamado modulo.py . Este hero ontiene una versin de tu
mdulo ms f il de argar en memoria de Python, pero absolutamente ilegible para las
personas, esta odi ado en lo que llamamos formato binario. Con esto Python pretende
a elerar as la arga de este mdulos que utilizaras en tus programas, pero sin obligarte
a ti a gestionar los heros .py .
Si borras el ar hivo modulo.py no pasa nada grave, Python volver a rear hero
uando argues nuevamente el modulo modulo.py desde un programa ualquiera. Si modi amos el ontenido de muestro mdulo, Python regenera automti amente el hero
modulo.py para que siempre este on los nuevos ambios que hemos realizado.
Veamos un ultimo ejemplo, rearemos un modulo on nuestros programas que realizamos anteriormente de opera iones on matri es. Primero vamos a rear un ar hivo
llamado matri es.py on lo siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#D e f i n i m o s
#F u n i o n
nuestras
de
sumar
fun iones
matri es
def suma ( ) :
la
matriz
A omo
matriz
nula
A= [
A. append ( [ 0 n )
la
matriz
B omo
matiz
matriz
nula
B= [
#P e d i m o s
los
datos
de
la
print " Datos de l a matriz A: "

#P e d i m o s
los
datos
de
la
matriz
print " Datos de l a matriz B : "
41
6 Fun iones.
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

B[ i [ j = i n t ( raw_input ( "Dame e l omponente ( %d, %d ) : " %(i , j ) ) )
#En
donde
la
matriz
C omo
guarda
nuestros
vamos
nula
resultados
C= [
C. append ( [ 0 n )
#Ha emos
la
suma
de
las
matri es
A y B

C[ i [ j =A[ i [ j +B[ i [ j
#M o s t r a m o s
el
resultado
print "Suma : "

print C[ i [ j
print
#F u n i o n
de
restar
matri es
def r e s t a ( ) :
la
matriz
A omo
matriz
B omo
matiz
matriz
nula
A= [
A. append ( [ 0 n )
la
matriz
nula
B= [
#P e d i m o s
los
datos
de
la
print " Datos de l a matriz A: "

#P e d i m o s
los
datos
de
la
matriz
print " Datos de l a matriz B : "

B[ i [ j = i n t ( raw_input ( "Dame e l omponente ( %d, %d ) : " %(i , j ) ) )
42
6 Fun iones.
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
#En
donde
la
matriz
C omo
guarda
nuestros
vamos
nula
resultados
C= [
C. append ( [ 0 n )
#Ha emos
la
suma
de
las
matri es
A y B

C[ i [ j =A[ i [ j B[ i [ j
#M o s t r a m o s
el
resultado
print
"Suma :
"

print C[ i [ j
print
#F u n i o n
de
multipli ar
matri es
def m u l t i p l i a i o n ( ) :
p=i n t ( raw_input ( "Dime e l numero de l a s f i a l s de A: " ) )
q=i n t ( raw_input ( "Dime e l numero de olumnas de A ( y f i l a s de B) : " ) )
r=i n t ( raw_input ( "Dime e l numero de olumnas de B : " ) )
#Creamos
matri es
nulas
A= [
A. append ( [ 0 q )
B= [
B . append ( [ 0 r )
#L l e n a m o s
las
matri es
for j in range ( q ) :
A[ i [ j = i n t ( raw_input ( "Dame e l omponente ( %d , %d ) : " %(i , j ) ) )
B[ i [ j = i n t ( raw_input ( "Dame e l omponente ( %d , %d ) : " %(i , j ) ) )
#Creamos
la
matriz
resultante
C= [
C. append ( [ 0 r )
43
6 Fun iones.
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
#E f e t u a m o s
los
al ulos
for k in range ( q ) :
C [ i [ j +=A[ i [ k B [ k [ j
#M o s t r a m o s
el
resultado
print " M u l t i p l i a i o n : "

print C[ i [ j
print
#F u n i o n
traspues
de
matri es
def t r a s p u e s t a ( ) :
#P e d i m o s
la
matriz
m=i n t ( raw_input ( "Dame e l numero de l a s f i l a s : " ) )

n=i n t ( raw_input ( "Dame e l numero de l a s olumnas : " ) )
las
matri es
M= [
M. append ( [ 0 n )
T= [
T. append ( [ 0 m)
#L l e n a m o s
la
matriz

M[ i [ j = i n t ( raw_input ( "Dame e l omponenete ( %d , %d ) : " %(i , j ) ) )
#Ha emos
los
ambios
en
la
matriz .
for j in range (m) :
T[ i [ j =(M[ j [ i )
#I m p r i m i m o s
la
Matriz
print T
Ahora vamos a rear nuestro programa prin ipal el ual va a utilizar nuestro modulo
matri es.py . En el ual solo vamos a llamar a nuestras fun iones, este lo llamaremos
opera iones.py
44
6 Fun iones.
2
3 #D e f i n i m o s n u e s t r o m o d u l o
4
5 from m a t r i e s import
6
7 #Creamos un p e q u e o menu
8 x= ' '
9 while x != ' q ' :
10
print " Opera iones "
11
print "Suma s "
12
print " Resta r "
13
print " M u l t i p l i a i o n m"
14
print " Traspuesta t "
15
print " s a l i r q"
16
x=raw_input ( "Que q u i e r e s ha er : " )
17
i f x != [ ' s ' , ' r ' , 'm' , ' q ' :
18
print " Op ion no v a l i d a "
19
20
#Llamamos a n u e s t r a s f u n i o n e s d e n u e s t r o
21
22
i f x== ' s ' :
23
suma ( )
24
25
i f x== ' r ' :
26
resta ()
27
28
i f x== 'm' :
29
multipli a ion ()
30
31
i f x== ' t ' :
32
traspuesta ()
33
34 print "Anta pronto . . . . "
modulo
Como podemos observar ya se reo tambin nuestro ar hivo matri es.py , el ual omo
ya omentamos anteriormente nos ayuda que nuestro programa orra un po o mas rpido.
45
7 Ar hivos.
Un ar hivo o hero es un onjunto de bits alma enado en un dispositivo perifri o.
Un ar hivo es identi ado por un nombre y la des rip in de la arpeta o dire torio
que lo ontiene. Los ar hivos se llaman as porque son los equivalentes digitales de los
ar hivos en tarjetas, papel o mi ro has del entorno de o ina tradi ional. Los ar hivos
informti os fa ilitan una manera de organizar los re ursos usados para alma enar datos
en un sistema informti o.
7.0.2.
Opera iones on Ar hivos: Abrir, Leer, Es ribir y Cerrar.
Existen diferentes tipos de opera iones que podemos realizar en un ar hivo, pero para
poder realizar esto, ne esitamos seguir siempre unas pequeas reglas:
1. Lo primero es abrir el ar hivo indi ando su ruta relativa1 o absoluta2 y el modo de
trabajo. Existen diferentes tipos de modos de trabajo:
Le tura: es posible leer informa in del ar hivo, pero no modi arla ni aadir
nueva informa in
Es ritura: slo es posible es ribir informa in en el hero. Al abrir un ar hivo
en modo es ritura borra todo el ontenido previo del mismo.
Le tura/es ritura: permite leer y es ribir informa in del hero.
Adi in: permite aadir nueva informa in, al ar hivo sin modi ar la ya existente.
2. Leer o es ribir la informa in
3. Cerrar el hero
Uno de los errores mas omunes es que olvides errar el ar hivo, esto es algo preo upante,
por que Python no dete tar esta omo un error del programa. Cerrar el programa es
muy importante una vez que hayas terminado de trabajar on el, espe ialmente si lo has
modi ado, si no ierras el ar hivo, es posible que los ambios que hayas realizado en el
se pierdan o, peor an que el hero se orrompa.
Vamos ha er un ejemplo:
Crearemos un ar hivo al que lo llamaremos ar hivo.txt, y dentro de el es ribiremos
1
Las rutas relativas sealan la ubi a in de un ar hivo o dire torio a partir de la posi in a tual del
sistema operativo en el sistema de ar hivos.
2
Las rutas absolutas sealan la ubi a in de un ar hivo o dire torio desde el dire torio raz del sistema
de ar hivos.
46
7 Ar hivos.
1 Mi p r i m e r a l e t u r a de un a r h i v o
2 Python e s muy f a i l de u t i l i z a r
3 Con Python aprendo a programar
y lo guardamos. Nos aseguramos de que este en mismo dire torio donde vamos a rear
nuestro programa.
Figura 7.1: Ar hivo.txt

Ahora omo lo indi amos en los pasos anteriores tenemos que omenzar por abrir un
ar hivo indi ando el modo de trabajo, el ual puede re ibir ualquiera de los siguientes
parmetros:
'r'
Le tura
'w'
Es ritura
'a'
Adi in
'b'
Binario
'+'
Le tura/es ritura simultneas
Cuadro 7.2: Modos de Trabajo

En este aso vamos a darle el parmetro 'r', slo nos interesa leer el ontenido de
nuestro ar hivo. Nuestro digo quedara de la siguiente manera
1
#! / u s r / b i n / e n v
python
47
7 Ar hivos.
2
3
4
5
6
7
8
9
10
11
#A b r i m o s
nuestro
ar hivo
a r h i v o=open ( ' a r h i v o . t x t ' , ' r ' )
#L e e r
los
datos
del
ar hivo
for l i e n a in a r h i v o :
print l i n e a
#C e r r a r
el
ar hivo
ar hivo . lose ()
Como podemos observar nuestra salida tiene espa ios de ms, esto se debe a que las
lineas nalizadas en el hero ontiene un salto de linea, adems ah que agregarle el
espa io de salto de linea propio del print, por lo ual tenemos dos saltos de linea a la
hora de ver el ontenido de nuestro ar hivo.
Si queremos eliminar estos saltos de linea debemos modi ar nuestro programa:
1
2
3
4
5
6
7
8
9
10
11
12
13
#! / u s r / b i n / e n v
#A b r i m o s
python
nuestro
ar hivo
#L e e r
los
datos
del
ar hivo
for l i e n a in a r h i v o :
i f l i n e a [ 1== ' \n ' :
l i n e a=l i n e a [ : 1
print l i n e a
#C e r r a r
el
ar hivo
ar hivo . lose ()
Con esto quitamos nuestros saltos de linea extras, pero no modi amos en absoluto el
ontenido de nuestro ar hivo. Una vez que lees un ar hivo, trabajas on una opia en la
memoria de la informa in, y no dire tamete en el hero.
Tambin es posible leer los ar hivos ar ter por ar ter:
1
2
3
4
5
6
7
8
9
10
11
12
13
#/ u s r / b i n / e n v
python
a r h i v o=open ( ' a r h i v o . t x t ' , r ' )

ontador =0
while 1:
a r a e t e r = a r h i v o . read ( 1 )
i f a r a t e r ==' ' :
break
ontador +=1
ar hivo . lose ()
p r i n t ontador
El mtodo read a ta sobre el hero abierto y re ibe omo argumento el nmero de

ara teres que deseamos leer. El resultado es una adena on, a lo sumo, ese nmero de
ara teres. Cuando se ha llegado al nal del hero y no hoy mas texto que leer, read
devuelve la adena va a.
48
7 Ar hivos.
Otra forma de leer linea a linea, es utilizando el mtodo
leer una sola linea de un ar hivo de texto:
1
2
3
4
5
6
7
8
9
#! / u s r / b i n / e n v
readline
on el ual podemos
python

while 1 :
linea = ar hivo . readline ()
i f l i n e a ==' ' :
break
print l i n e a . r s t r i p ( )
ar hivo . lose ()
o podemos ha erlo un po o mas abreviado

1
2
3
4
5
6
#! / u s r / b i n / e n v
python
a r h i v o=open ( ' ejemplo . t x t ' , ' r ' )

for l i n e a in a r h i v o :
print l i n e a . r s t r i p ( )
f . lose ()
Como podemos observar este otro mtodo es mu ho menos ompli ado.

Otra fun in que podemos ha er on los ar hivos adems de leerlos, tambin podemos,
es ribir nuestro propias ar hivos, esto seria muy til, supongamos que queremos ha er
una tabla que ontenga los nmeros del 0 al 100. Para esto vamos a utilizar un nuevo
mtodo llamado write. Este mtodo solo trabaja on adenas, no on nmeros, as que
tenemos que mandarle adenas on el parmetro str, otro aspe to importante, es ambiar
el parmetro de open el ual va a ser 'w' para poder es ribir en nuestro ar hivo.
1
2
3
4
5
6
7
8
#! / u s r / b i n / e n v
python
a r h i v o = open ( ' numeros . t x t ' , 'w ' )

for numero in range (100+1) :
a r h i v o . w r i t e ( s t r ( numero) + ' \n ' )
ar hivo . lose ()
Podemos observar que es ne esario dar un salto de linea '\n' por ada nmero que se
va a es ribir en nuestro ar hivo.
Otra op in es es ribir las adenas formadas a partir de nmeros, on el operador de
formato:
1
2
3
4
5
6
7
8
#! / u s r / b i n / e n v
python
a r h i v o = open ( ' numero . t x t ' 'w ' )

for numero in range (100+1) :
a r h i v o . w r i t e ( ' %d\n ' % ( numero) )
ar hivo . lose ()
Como podemos observar el mtodo de es ritura, borra nuestro ar hivo original, Qu

pasa si no queremos que no se borre el ontenido de nuestro ar hivo, si no agregarle ms
49
7 Ar hivos.
ontenido?
Para esto vamos a utilizar nuestro mtodo open pero vamos a darle omo segundo
parmetro 'a', on esto vamos a aadir ualquier es ritura al nal del ar hivo.
Vamos a tomar nuestro ar hivo que generamos llamado numero.txt y vamos agregarle
un omentario al nal.
1
2
3
4
5
6
#! / u s r / b i n / e n v
python
omentario = raw_input ( ' Comentario : ' )

a r h i v o = open ( ' numero . t x t ' , ' a ' )
f . w r i t e ( omentario + ' \n ' )
f . lose ()
Con ada eje u in de nuestro programa vamos a agregar una nueva linea a numero.txt,
esto quiere de ir que nuestro ar hivo esta re iendo.
Todo lo que hemos he ho hasta el momento, es un tipo de programa in estru tural,
esto es una manera de es ribir programas de manera lara y f il. Pero hoy en da las
apli a iones son mu ho mas ambi iosas, que las ne esidades de programa in existentes
en los aos de 1960, prin ipalmente debido a las apli a iones gr as, por lo que las t ni as de programa in estru turada no son su iente. Esto a llevado a desarrollar nuevas
t ni as, tales omo la programa in orientada a objetos y el desarrollo de entornos de
programa in que fa iliten la implementa in de programar apli a iones ms grandes.
50
8 Programa in Orientada a Objetos.

8.1. Introdu in a la Programa in Orientada a Objetos.
Aunque ya han pasado algunos aos la Orienta in a Objetos sigue siendo un trmino
de moda. En 1967 fue desarrollado SIMULA, un lenguaje para apli a iones de simula in, onsiderado por mu hos el pre ursor en la introdu in del on epto de objeto.
Lamentablemente este na imiento en Noruega pas inadvertido para gran parte de la
familia de los programadores. Resulta que ahora tenemos un nio de ms de 25 aos
que mu hos se apuran en querer rebautizar.
Por aquel enton es se hablaba de la risis del software que provo ara el surgimiento
de la Programa in Estru turada. Las grandes brigadas de programadores que programaban los grandes sistemas para las grandes mquinas enfrentaban serios problemas de organiza in y produ tividad. La respuesta fue una metodologa que promova
una solu in jerrqui a, dis iplinada, organizada y plani ada! para desarrollar el software. Algunas mejoras fueron introdu idas en los lenguajes de programa in para fa ilitar
esto: mejores estru turas de ontrol para obviar el goto, algunos re ursos de modularidad
y de organiza in de bibliote as de programas.
Esto pare i ser su iente durante los 70's. No obstante, po os sistemas lograban terminarse, po os se terminaban umpliendo los requerimientos ini iales y no todos los que
se terminaban umpliendo los requisitos ini iales se usaban segn lo plani ado. El problema (mal llamado de mantenimiento) onsista en mo adaptar el software a nuevos
requerimientos imposibles de haber sido plani ados ini ialmente. La estru tura in
fa ilitaba en todo aso la zambullida de los programadores de mantenimiento en los
mares de lneas de programa fuente, pero no la impeda.
Este alto grado de plani a in y previsin es ontrario a la propia realidad. El hombre
aprende y rea a travs de la experimenta in, no la plani a in. Se ne esitan medios
que fa iliten la experimenta in y no que exijan que tenga que ser plani ado un proye to entero antes de poder es ribir una lnea de programa para que luego este proye to se
onvierta en una amisa de fuerza en el desarrollo y evolu in del sistema. El desarrollo
de SMALLTALK a nales de los 70's fue una respuesta a este problema.
El desarrollo t ni o del hardware, su disminu ion de pre ios y la explosion de las
omputadoras personales fueron el detonante nal.
La Programa in Orientada a Objetos (P00), que por todo lo anterior algunos han
dado en la Programa in Estru turada de los 90s, en uentra aqu un terreno frtil. Es
la POO un mejor paradigma que otros? En ierto sentido s lo es. Es una ura de todos
nuestros problemas? No lo es. Signi a que la arriba men ionada risis del software
51

desapare er? Probablemente no. Pero enton es, qu es lo grande de la Programa in
Orientada a Objetos?.
En lugar de tratar de modelar un problema en algo familiar a la omputadora se trata
ahora de a er ar la omputadora al problema. Es de ir, modelar la realidad del problema a travs de entidades independientes pero que intera tan entre s y uyas fronteras
no estn determinadas por su instrumenta in omputa ional sino por la naturaleza del
problema. Estas entidades sern denominadas objetos, por analoga on el on epto de
objeto en el mundo real.
Resolver problemas onsiste en denir objetos y sus a iones y enton es invo ar las
a iones enviando mensajes a los objetos que o ultan las ara tersti as internas d omo
llevan a abo estas a iones. Esta forma de resolver problemas lu e familiar y lgi a y
ha sido utilizada por otras dis iplinas ient as ya que en nuestra experien ia diaria
nosotros manipulamos objetos.
Programar en un lenguaje de programa in orientado a objetos es denir lases (nuevos
tipos de datos) que expresan una determinada fun ionalidad la ual es omn a todos
los individuos de una lase. A travs de esta fun ionalidad los objetos o instan ias on retas de una lase dan respuesta a las soli itudes (mensajes) que les envan otros objetos.
Las lases deben ser lo su ientemente CERRADAS omo para que ada objeto pueda
o ultar la informa in (datos) que lo ara teriza omo individuo. Es un problema interno
del objeto mo llevar a abo la fun ionalidad des rita en la lase.
Visto en la pti a de las arquite turas onven ionales de omputadoras, en la POO los
datos no ir ulan abiertamente por todo el sistema omo en la programa in tradi ional.
Los programas no se dividen en de lara iones pasivas de estru turas de datos y fun iones
(que tal vez a ten sobre algunas de las estru turas de datos). Los datos estn ahora
en errados dentro de ada objeto y ste es quien de ide internamente mo trabajar on
ellos para dar respuesta a una soli itud de otro objeto.
Por otra parte estas lases deben ser lo su ientemente ABIERTAS para permitir la
reutiliza in, adapta in y extensin de las mismas a nuevas fun ionalidades, sin orrer
el riesgo de afe tar el fun ionamiento de lo que ya est orre to.
Esta aparente ontradi in, de lo que se ono e omo prin ipio ABIERTO CERRADO, es la piedra angular de la POO.
En ausen ia de una deni in formal de qu es la POO, algunos preeren identi arla por sus objetivos. Tres objetivos fundamentales persigue la POO para fa ilitar la
experimenta in:
La robustez de las partes que garanti en su integridad y fun ionamiento propio
(lo ual a su vez fa ilita arrin onar las fallas). Esto se fa ilita en los lenguajes
orientado a La robustez de las partes que garanti en su integridad y fun ionamiento
propio (lo ual a su vez fa ilita arrin onar las fallas). Esto se fa ilita en los
lenguajes orientado a objetos (LOO) a travs de re ursos omo el en apsulamiento
y el manejo de ex ep iones.
52

La reusabilidad y la extensibilidad. Que se pueda derivar (ms que redenir) nuevas
lases de objetos a partir de las ya existentes, fa ilitandole on ello al programador el
desarrollo de prototipos y una rapida explora in en las nuevas ideas. Esto se fa ilita
en los LOO mediante la redeni in de operadores y fun iones, la generalidad, la
heren ia y el polimorsmo.
Esta bsqueda de la omunidad, de aprove har lo existente, es una de las ara tersti as
bsi as de la POO. Algunos de estos re ursos omo el polimorsmo y la jerarqua de
lases a travs de la heren ia nos dotan de re ursos para lasi ar lgi amente a los
objetos, evitando las redundan ias y obviando restri iones que otros paradigmas de
programa in nos imponen.
POO es un importante onjunto de t ni as que se pueden utilizar para ha er el desarrollo de programas ms e iente mientras se mejora la abilidad de los programas
resultantes. En esen ia, POO es un nuevo, medio de enfo ar el trabajo de programa in.
Python es un lenguaje multiparadigma en el se puede trabajar on programa in estru turada on programa in orientada a objetos o programa in estru turada. Para
entender la POO en Python ne esitamos ono er algunos on eptos basi o, omo la
heren ia, objeto, lase et .
8.2. Con eptos Bsi os.
8.2.1.
Clases
El me anismo de lases de Python agrega lases al lenguaje on un mnimo de nuevas

sintaxis y semnti as. Es una mez la de los me anismos de lase en ontrados en C++ y
53

Modula-3. Como es ierto para los mdulos, las lases en Python no ponen una barrera
absoluta entre la deni in y el usuario, sino que ms bien se apoya en la ortesa del
usuario de no "forzar la deni in". Sin embargo, se mantiene el poder ompleto de
las ara tersti as ms importantes de las lases: el me anismo de la heren ia de lases
permite mltiples lases base, una lase derivada puede sobrees ribir ualquier mtodo
de su(s) lase(s) base, y un mtodo puede llamar al mtodo de la lase base on el mismo
nombre. Los objetos pueden tener una antidad arbitraria de datos. En terminologa de
C++, todos los miembros de las lases (in luyendo los miembros de datos), son pbli os,
y todas las fun iones miembro son virtuales. Como en Modula-3, no hay atajos para ha er
referen ia a los miembros del objeto desde sus mtodos: la fun in mtodo se de lara on
un primer argumento expl ito que representa al objeto, el ual se provee impl itamente
por la llamada. Como en Smalltalk, las lases mismas son objetos. Esto provee una
semnti a para importar y renombrar. A diferen ia de C++ y Modula-3, los tipos de datos
integrados pueden usarse omo lases base para que el usuario los extienda. Tambin,
omo en C++ pero a diferen ia de Modula-3, la mayora de los operadores integrados on
sintaxis espe ial (operadores aritmti os, de subndi e, et .) pueden ser redenidos por
instan ias de la lase. (Sin haber una terminologa universalmente a eptada sobre lases,
har uso o asional de trminos de Smalltalk y C++. Usara trminos de Modula-3, ya
que su semnti a orientada a objetos es ms er ana a Python que C++, pero no espero
que mu hos le tores hayan es u hado hablar de l).
8.2.2.
Nombres y objetos
Los objetos tienen individualidad, y mltiples nombres (en mu hos mbitos) pueden
vin ularse al mismo objeto. Esto se ono e omo aliasing en otros lenguajes. Normalmente
no se apre ia esto a primera vista en Python, y puede ignorarse sin problemas uando se
maneja tipos bsi os inmutables (nmeros, adenas, tuplas). Sin embargo, el aliasing, o
renombrado, tiene un efe to posiblemente sorpresivo sobre la semnti a de digo Python
que involu ra objetos mutables omo listas, di ionarios, y la mayora de otros tipos.
Esto se usa normalmente para bene io del programa, ya que los renombres fun ionan
omo punteros en algunos aspe tos. Por ejemplo, pasar un objeto es barato ya que la
implementa in solamente pasa el puntero; y si una fun in modi a el objeto que fue
pasado, el que la llama ver el ambio; esto elimina la ne esidad de tener dos formas
diferentes de pasar argumentos, omo en Pas al.
8.2.3.
Al an es y espa ions de nombres en Python
Antes de ver lases, primero debo de irte algo a er a de las reglas de al an e de Python.
Las deni iones de lases ha en unos lindos tru os on los espa ios de nombres, y ne esits saber mo fun ionan los al an es y espa ios de nombres para entender por ompleto mo es la osa. De paso, los ono imientos en este tema son tiles para ualquier
programador Python avanzado.
Comen emos on unas deni iones.
54

Un espa io de nombres es una rela in de nombres a objetos. Mu hos espa ios de nombres estn implementados en este momento omo di ionarios de Python, pero eso no se
nota para nada (ex epto por el desempeo), y puede ambiar en el futuro. Como ejemplos de espa ios de nombres tenemos: el onjunto de nombres in luidos (fun iones omo
abs(), y los nombres de ex ep iones integradas); los nombres globales en un mdulo; y
los nombres lo ales en la invo a in a una fun in. Lo que es importante saber de los
espa ios de nombres es que no hay rela in en absoluto entre los nombres de espa ios
de nombres distintos; por ejemplo, dos mdulos diferentes pueden tener denidos los dos
una fun in maximizar sin onfusin; los usuarios de los mdulos deben usar el nombre
del mdulo omo prejo.
Por ierto, yo uso la palabra atributo para ualquier osa despus de un punto; por
ejemplo, en la expresin z.real, real es un atributo del objeto z. Estri tamente hablando,
las referen ias a nombres en mdulos son referen ias a atributos: en la expresin modulo.fun ion, modulo es un objeto mdulo y fun ion es un atributo de ste. En este aso
hay una rela in dire ta entre los atributos del mdulo y los nombres globales denidos
en el mdulo: estn ompartiendo el mismo espa io de nombres!
Los atributos pueden ser de slo le tura, o de es ritura. En el ltimo aso es posible la
asigna in a atributos. Los atributos de mdulo pueden es ribirse: modulo.la_respuesta
= 42. Los atributos de es ritura se pueden borrar tambin on la instru in del. Por
ejemplo, del modulo.la_respuesta va a eliminar el atributo la_respuesta del objeto on
nombre modulo. Los espa ios de nombres se rean en diferentes momentos y on diferentes tiempos de vida. El espa io de nombres que ontiene los nombres in luidos se rea
uando se ini ia el intrprete, y nun a se borra. El espa io de nombres global de un
mdulo se rea uando se lee la deni in de un mdulo; normalmente, los espa ios de
nombres de mdulos tambin duran hasta que el intrprete naliza. Las instru iones
eje utadas en el nivel de llamadas superior del intrprete, ya sea desde un s ript o intera tivamente, se onsideran parte del mdulo llamado __main__, por lo tanto tienen su
propio espa io de nombres global. (Los nombres in luidos en realidad tambin viven en
un mdulo; este se llama __builtin__.)
El espa io de nombres lo al a una fun in se rea uando la fun in es llamada, y se
elimina uando la fun in retorna o lanza una ex ep in que no se maneje dentro de la
fun in. (Podramos de ir que lo que pasa en realidad es que ese espa io de nombres se
"olvida".) Por supuesto, las llamadas re ursivas tienen ada una su propio espa io de
nombres lo al.
Un al an e es una regin textual de un programa en Python donde un espa io de
nombres es a esible dire tamente. "A esible dire tamente" signi a que una referen ia
sin ali ar a un nombre intenta en ontrar di ho nombre dentro del espa io de nombres.
Aunque los al an es se determinan estti amente, se usan dinmi amente. En ualquier
momento durante la eje u in hay por lo menos uatro al an es anidados uyos espa ios
de nombres son dire tamente a esibles:
el mbito interno, donde se bus a primero, ontiene los nombres lo ales
55

los espa ios de nombres de las fun iones anexas, en las uales se bus a empezando
por el al an e adjunto ms er ano, ontiene los nombres no lo ales pero tambin
los no globales 80
el mbito anteltimo ontiene los nombres globales del mdulo a tual
el al an e exterior (donde se bus a al nal) es el espa io de nombres que ontiene
los nombres in luidos
Si un nombre se de lara omo global, enton es todas las referen ias y asigna iones al
mismo van dire to al al an e intermedio que ontiene los nombres globales del mdulo.
De otra manera, todas las variables que se en uentren fuera del al an e interno son de
slo le tura (un intento de es ribir a esas variables simplemente rea una nueva variable
en el al an e interno, dejando inta ta la variable externa del mismo nombre).
Habitualmente, el al an e lo al referen ia los nombres lo ales de la fun in a tual.
Fuera de una fun in, el al an e lo al referen ia al mismo espa io de nombres que el
al an e global: el espa io de nombres del mdulo. Las deni iones de lases rean un
espa io de nombres ms en el al an e lo al.
Es importante notar que los al an es se determinan textualmente: el al an e global de
una fun in denida en un mdulo es el espa io de nombres de ese mdulo, no importa
desde dnde o on qu alias se llame a la fun in. Por otro lado, la bsqueda de nombres se
ha e dinmi amente, en tiempo de eje u in; sin embargo, la deni in del lenguaje est
evolu ionando a ha er resolu in de nombres estti amente, en tiempo de " ompila in",
as que no te onfes de la resolu in de nombres dinmi a! (De he ho, las variables lo ales
ya se determinan estti amente.)
Una pe uliaridad espe ial de Python es que, si no hay una de lara in global o nonlo al
en efe to, las asigna iones a nombres siempre van al al an e interno. Las asigna iones
no opian datos, solamente aso ian nombres a objetos. Lo mismo uando se borra: la
instru in del x quita la aso ia in de x del espa io de nombres referen iado por el
al an e lo al. De he ho, todas las opera iones que introdu en nuevos nombres usan el
al an e lo al: en parti ular, las instru iones import y las deni iones de fun iones aso ian
el mdulo o nombre de la fun in al espa io de nombres en el al an e lo al. (La instru in
global puede usarse para indi ar que iertas variables viven en el al an e global.)
8.2.4.
Primer vistaso a las Clases
Las lases introdu en un poquito de sintaxis nueva, tres nuevos tipos de objetos y algo
de semnti a nueva.
La forma ms sen illa de deni in de una lase se ve as:
1
2
3
4
5
6
C l a s s Clase :
<d e l a r a i o n 1>
.
.
.
.
56

7
<d e l a r a i o n n>
Las deni iones de lases, al igual que las deni iones de fun iones (instru iones def)
deben eje utarse antes de que tengan efe to alguno. (Es on ebible poner una deni in de lase dentro de una rama de un if, o dentro de una fun in.) En la pr ti a, las
de lara iones dentro de una lase son deni iones de fun iones, pero otras de lara iones
son permitidas, y a ve es resultan tiles; veremos esto ms adelante.
Las deni iones de fun iones dentro de una lase normalmente tienen una lista de argumentos pe uliar, di tada por las onven iones de invo a in de mtodos; a esto tambin
lo veremos ms adelante. Cuando se ingresa una deni in de lase, se rea un nuevo
espa io de nombres, el ual se usa omo al an e lo al; por lo tanto, todas las asigna iones
a variables lo ales van a este nuevo espa io de nombres.
En parti ular, las deni iones de fun iones aso ian el nombre de las fun iones nuevas
all. Cuando una deni in de lase se naliza normalmente se rea un objeto lase.
Bsi amente, este objeto envuelve los ontenidos del espa io de nombres reado por la
deni in de la lase; aprenderemos ms a er a de los objetos lase en la se in siguiente.
El al an e lo al original (el que tena efe to justo antes de que ingrese la deni in de la
lase) es restable ido, y el objeto lase se aso ia all al nombre que se le puso a la lase
en el en abezado de su deni in (Clase en el ejemplo).
8.2.4.1. Objeto Clase

Los objetos lase soportan dos tipos de opera iones: ha er referen ia a atributos e
instan ia in. Para ha er referen ia a atributos se usa la sintaxis estndar de todas las
referen ias a atributos en Python: objeto.nombre. Los nombres de atributo vlidos son
todos los nombres que estaban en el espa io de nombres de la lase uando sta se re.
Por lo tanto, si la deni in de la lase es as:
1
2
3
4
5
l a s s MiClase :
""" Simple l a s e de ejemplo """
i = 12345
def f ( s e l f ) :
return ' h o l a mundo '
...enton es MiClase.i y MiClase.f son referen ias de atributos vlidas, que devuelven un
entero y un objeto fun in respe tivamente. Los atributos de lase tambin pueden ser
asignados, o sea que pods ambiar el valor de MiClase.i mediante asigna in. __do __
tambin es un atributo vlido, que devuelve la do umenta in aso iada a la lase: "Simple
lase de ejemplo". La instan ia in de lases usa la nota in de fun iones. Ha de uenta
que el objeto de lase es una fun in sin parmetros que devuelve una nueva instan ia
de la lase. Por ejemplo (para la lase de ms arriba):
x = MiClase ( )
... rea una nueva instan ia de la lase y asigna este objeto a la variable lo al x. La
opera in de instan ia in ("llamar" a un objeto lase) rea un objeto va o. Mu has
57

lases ne esitan rear objetos on instan ias en un estado ini ial parti ular. Por lo tanto
una lase puede denir un mtodo espe ial llamado __init__(), de esta forma:
def __init__( s e l f ) :
s e l f . datos = [
Cuando una lase dene un mtodo __init__(), la instan ia in de la lase automti amente invo a a __init__() para la instan ia re in reada. Enton es, en este ejemplo,
una instan ia nueva e ini ializada se puede obtener ha iendo:
x = MiClase ( )
Por supuesto, el mtodo __init__() puede tener argumentos para mayor exibilidad.
En ese aso, los argumentos que se pasen al operador de instan ia in de la lase van a
parar al mtodo __init__(). Por ejemplo,
1 >>> l a s s Complejo :
2 ...
def __init__( s e l f , p a r t e r e a l , p a r t e i m a g i n a r i a ) :
3 ...
sel f . r = partereal
4 ...
s e l f . i = parteimaginaria
5 ...
6 >>> x = Complejo ( 3 . 0 , 4.5)
7 >>> x . r , x . i ( 3 . 0 , 4.5)
8.2.5.
Objeto Instan ia
Ahora, Qu podemos ha er on los objetos instan ia? La ni a opera in que es

entendida por los objetos instan ia es la referen ia de atributos. Hay dos tipos de nombres
de atributos vlidos, atributos de datos y mtodos. Los atributos de datos se orresponden
on las "variables de instan ia" en Smalltalk, y on las "variables miembro" en C++. Los
atributos de datos no ne esitan ser de larados; tal omo las variables lo ales son reados
la primera vez que se les asigna algo. Por ejemplo, si x es la instan ia de MiClase reada
ms arriba, el siguiente pedazo de digo va a imprimir el valor 16, sin dejar ningn
rastro:
1 x . ontador = 1
2 while x . ontador < 1 0 :
3
x . ontador = x . ontador 2
4 print x . ontador
5 del x . ontador
El otro tipo de atributo de instan ia es el mtodo. Un mtodo es una fun in que

"pertene e a" un objeto. En Python, el trmino mtodo no est limitado a instan ias
de lase: otros tipos de objetos pueden tener mtodos tambin. Por ejemplo, los objetos
lista tienen mtodos llamados append, insert, remove, sort, y as su esivamente. Pero,
en la siguiente expli a in, usaremos el trmino mtodo para referirnos ex lusivamente
a mtodos de objetos instan ia de lase, a menos que se espe ique expl itamente lo
ontrario.
58

Los nombres vlidos de mtodos de un objeto instan ia dependen de su lase. Por
deni in, todos los atributos de lase que son objetos fun iones denen mtodos orrespondientes de sus instan ias. Enton es, en nuestro ejemplo, x.f es una referen ia a un
mtodo vlido, dado que MiClase.f es una fun in, pero x.i no lo es, dado que MiClase.i
no lo es. Pero x.f no es la misma osa que MiClase.f; es un objeto mtodo, no un objeto
fun in.
8.2.6.
Objetos Mtodo
Generalmente, un mtodo es llamado luego de ser vin ulado:

x . f ()
En el ejemplo MiClase, esto devuelve la adena 'hola mundo'. Pero no es ne esario
llamar al mtodo justo en ese momento: x.f es un objeto mtodo, y puede ser guardado
y llamado ms tarde. Por ejemplo:
1 xf = x . f
2 while True :
3
print x f ( )
... ontinuar imprimiendo hola mundo hasta el n de los das.
Qu su ede exa tamente uando un mtodo es llamado? Debs haber notado que x.f()
fue llamado ms arriba sin ningn argumento, a pesar de que la deni in de fun in
de f() espe i aba un argumento. Qu pas on ese argumento? Seguramente Python
levanta una ex ep in uando una fun in que requiere un argumento es llamada sin
ninguno, an si el argumento no es utilizado...
De he ho, tal vez hayas adivinado la respuesta: lo que tienen de espe ial los mtodos es
que el objeto es pasado omo el primer argumento de la fun in. En nuestro ejemplo, la
llamada x.f() es exa tamente equivalente a MiClase.f(x). En general, llamar a un mtodo
on una lista de n argumentos es equivalente a llamar a la fun in orrespondiente on
una lista de argumentos que es reada insertando el objeto del mtodo antes del primer
argumento.
Si an no omprends omo fun ionan los mtodos, un vistazo a la implementa in
puede ayudar a lari ar este tema. Cuando se ha e referen ia un atributo de instan ia y
no es un atributo de datos, se bus a dentro de su lase. Si el nombre denota un atributo
de lase vlido que es un objeto fun in, un mtodo objeto es reado, juntando (punteros
a) el objeto instan ia y el objeto fun in que ha sido en ontrado. Este objeto abstra to
reado de esta unin es el objeto mtodo. Cuando el objeto mtodo es llamado on una
lista de argumentos, es nuevamente desempaquetado, una lista de argumentos nueva es
onstruida a partir del objeto instan ia y la lista de argumentos original, y el objeto
fun in es llamado on esta nueva lista de argumentos.
8.2.7.
Algunas Observa iones
Los atributos de datos tienen preferen ia sobre los mtodos on el mismo nombre; para
evitar oni tos de nombre a identales, que pueden ausar errores dif iles de en ontrar
59

en programas grandes, es prudente usar algn tipo de onven in que minimi e las posibilidades de di hos oni tos. Algunas onven iones pueden ser poner los nombres de
mtodos on mays ulas, prejar los nombres de atributos de datos on una pequea adena ni a (a lo mejor slo un guin bajo), o usar verbos para los mtodos y sustantivos
para los atributos.
A los atributos de datos los pueden ha er referen ia tanto los mtodos omo los usuarios
(" lientes") ordinarios de un objeto. En otras palabras, las lases no se usan para implementar tipos de datos abstra tos puros. De he ho, en Python no hay nada que haga
umplir el o ultar datos; todo se basa en onven in. (Por otro lado, la implementa in
de Python, es rita en C, puede o ultar por ompleto detalles de implementa in y el
ontrol de a eso a un objeto si es ne esario; esto se puede usar en extensiones a Python
es ritas en C.)
Los lientes deben usar los atributos de datos on uidado; stos pueden romper invariantes que mantienen los mtodos si pisan los atributos de datos. Observ que los lientes
pueden aadir sus propios atributos de datos a una instan ia sin afe tar la validez de sus
mtodos, siempre y uando se eviten oni tos de nombres; de nuevo, una onven in de
nombres puede ahorrar un montn de dolores de abeza.
No hay un atajo para ha er referen ia a atributos de datos (u otros mtodos!) desde
dentro de un mtodo. A mi pare er, esto en realidad aumenta la legibilidad de los mtodos: no existe posibilidad alguna de onfundir variables lo ales on variables de instan ia
uando repasamos un mtodo.
A menudo, el primer argumento de un mtodo se llama self (uno mismo). Esto no es
nada ms que una onven in: el nombre self no signi a nada en espe ial para Python.
Observ que, sin embargo, si no segus la onven in tu digo puede resultar menos legible a otros programadores de Python, y puede llegar a pasar que un programa navegador
de lases pueda es ribirse de una manera que dependa de di ha onven in.
Cualquier objeto fun in que es un atributo de lase dene un mtodo para instan ias
de esa lase. No es ne esario que el la deni in de la fun in est textualmente dentro
de la deni in de la lase: asignando un objeto fun in a una variable lo al en la lase
tambin est bien.
Por ejemplo:
1
2
3
4
5
6
7
8
#F u n i n
definida
fuera
de
def f 1 ( s e l f , x , y ) :
return min ( x , x+y )
l a s s C:
f = f1
def g ( s e l f ) :
return ' h o l a mundo '
h = g
la
lase
Ahora f, g y h son todos atributos de la lase C que ha en referen ia a objetos fun in,
y onse uentemente son todos mtodos de las instan ias de C; h siendo exa tamente
equivalente a g. Fijate que esta pr ti a normalmente slo sirve para onfundir al que
60

lea un programa.
Los mtodos pueden llamar a otros mtodos de la instan ia usando el argumento self:
1
2
3
4
5
6
7
8
l a s s Bolsa :
def __init__( s e l f ) :
s e l f . datos = [
def a g r e g a r ( s e l f , x ) :
s e l f . datos . append ( x )
def d o b l e a g r e g a r ( s e l f , x ) :
s e l f . agregar (x)
s e l f . agregar (x)
Los mtodos pueden ha er referen ia a nombres globales de la misma manera que

lo ha en las fun iones omunes. El al an e global aso iado a un mtodo es el mdulo
que ontiene la deni in de la lase. (La lase misma nun a se usa omo un al an e
global.) Si bien es raro en ontrar una buena razn para usar datos globales en un mtodo,
hay mu hos usos legtimos del al an e global: por lo menos, las fun iones y mdulos
importados en el al an e global pueden usarse por los mtodos, al igual que las fun iones
y lases denidas en l. Habitualmente, la lase que ontiene el mtodo est denida en
este al an e global, y en la siguiente se in veremos algunas buenas razones por las que
un mtodo querra ha er referen ia a su propia lase.
Todo valor es un objeto, y por lo tanto tiene una lase (tambin llamado su tipo). sta
se alma ena omo objeto.__ lass__.
8.2.8.
Heren ia
Por supuesto, una ara tersti a del lenguaje no sera digna del nombre " lase" si no
soportara heren ia. La sintaxis para una deni in de lase derivada se ve as:
1
2
3
4
5
6
l a s s ClaseDerivada ( ClaseBase ) :
<d e l a r a i n 1>
.
.
.
<d e l a r a i n N>
El nombre ClaseBase debe estar denido en un al an e que ontenga a la deni in de

la lase derivada. En el lugar del nombre de la lase base se permiten otras expresiones
arbitrarias. Esto puede ser til, por ejemplo, uando la lase base est denida en otro
mdulo:
l a s s ClaseDerivada ( modulo . ClaseBase ) :
La eje u in de una deni in de lase derivada pro ede de la misma forma que una
lase base. Cuando el objeto lase se onstruye, se tiene en uenta a la lase base. Esto
se usa para resolver referen ias a atributos: si un atributo soli itado no se en uentra en
la lase, la bsqueda ontina por la lase base. Esta regla se apli a re ursivamente si la
lase base misma deriva de alguna otra lase.
No hay nada en espe ial en la instan ia in de lases derivadas: ClaseDerivada() rea
una nueva instan ia de la lase. Las referen ias a mtodos se resuelven de la siguiente
61

manera: se bus a el atributo de lase orrespondiente, des endiendo por la adena de
lases base si es ne esario, y la referen ia al mtodo es vlida si se entrega un objeto
fun in.
Las lases derivadas pueden redenir mtodos de su lase base. Como los mtodos
no tienen privilegios espe iales uando llaman a otros mtodos del mismo objeto, un
mtodo de la lase base que llame a otro mtodo denido en la misma lase base puede
terminar llamando a un mtodo de la lase derivada que lo haya redenido. (Para los
programadores de C++: en Python todos los mtodos son en efe to virtuales.)
Un mtodo redenido en una lase derivada puede de he ho querer extender en vez
de simplemente reemplazar al mtodo de la lase base on el mismo nombre. Hay una
manera simple de llamar al mtodo de la lase base dire tamente: simplemente llams a
ClaseBase.metodo(self, argumentos). En o asiones esto es til para los lientes tambin.
(Observ que esto slo fun iona si la lase base es a esible omo CalseBase en el al an e
global.)
Python tiene dos fun iones integradas que fun ionan on heren ia:
Us isinstan e() para veri ar el tipo de una instan ia: isinstan e(obj, int) devuelve
True solo si obj.__ lass__ es int o alguna lase derivada de int.
Us issub lass() para omprobar heren ia de lase: issub lass(bool, int) da True
ya que bool es una sub lase de int. Sin embargo, issub lass(uni ode, str) devuelve
False porque uni ode no es una sub lase de str (solamente tienen un an estro en
omn, basestring).
8.2.8.1. Heren ia Multiple

Python tambin soporta una forma limitada de heren ia mltiple. Una deni in de
lase on mltiples lases base se ve as:
1
2
3
4
5
6
l a s s ClaseDerivada ( Base1 , Base2 , Base3 ) :

<d e l a r a i n 1>
.
.
.
<d e l a r a i n N>
Para lases de estilo viejo la ni a regla es bus ar en profundidad, de izquierda a

dere ha. Por lo tanto, si un atributo no se en uentra en ClaseDerivada, se bus a en
Base1, luego (re ursivamente) en las lases base de Base1, y slo si no se en uentra all
se lo bus a en Base2, y as su esivamente.
(A algunos la bsqueda en an hura, o sea, bus ar en Base2 y Base3 antes que en las
lases base de Base1, les pare e ms natural. Sin embargo, para esto hara falta que sepas
si un atributo en parti ular de Base1 est de he ho denido en Base1 o en alguna de sus
lases base antes de que puedas entender las onse uen ias de un oni to de nombres
on un atributo de Base2. La regla de bus ar primero en profundidad no ha e diferen ias
entre atributos dire tos o heredados de Base1.)
62

Para las lases de estilo nuevo, el mtodo de resolu in de orden ambia dinmi amente para soportar llamadas ooperativas a super(). Este enfoque es ono ido en otros
lenguajes on heren ia mltiple omo "llmese al siguiente mtodo" y es ms poderoso
que la llamada al superior que se en uentra en lenguajes on slo heren ia simple.
Con las lases de estilo nuevo, se ne esita el orden dinmi o porque todos los asos de
heren ia mltiple exhiben una o ms rela iones en diamante ( uando se puede llegar al
menos a una de las lases base por distintos aminos desde la lase de ms abajo). Por
ejemplo, todas las lases de nuevo estilo heredan de obje t, por lo tanto ualquier aso
de heren ia mltiple provee ms de un amino para llegar a obje t. Para que las lases
base no sean a edidas ms de una vez, el algoritmo dinmi o ha e lineal el orden de
bsqueda de manera que se preserve el orden de izquierda a dere ha espe i ado en ada
lase, que se llame a ada lase base slo una vez, y que sea montona (lo ual signi a
que una lase puede tener lases derivadas sin afe tar el orden de pre eden ia de sus
lases bases). En onjunto, estas propiedades ha en posible disear lases onables y
extensibles on heren ia mltiple.
8.2.9.
Variables privadas
Las variables "privadas" de instan ia que no pueden a ederse ex epto desde dentro
de un objeto, no existen en Python. Sin embargo, hay una onven in que se sigue en la
mayora del digo Python: un nombre prejado on un guin bajo (por ejemplo, _spam)
debera tratarse omo una parte no pbli a de la API (ms all de que sea una fun in,
un mtodo, o un dato). Debera onsiderarse un detalle de implementa in y que est
sujeto a ambios sin aviso.
Ya que hay un aso de uso vlido para los identi adores privados de lase (a saber:
olisin de nombres on nombres denidos en las sub lases), hay un soporte limitado para
este me anismo. Cualquier identi ador on la forma __spam (al menos dos guiones bajos al prin ipio, omo mu ho un guin bajo al nal) es textualmente reemplazado por
_nombrede lase__spam, donde nombrede lase es el nombre de lase a tual al que se
le sa an guiones bajos del omienzo (si los tuviera). Se modi a el nombre del identi ador sin importar su posi in sint ti a, as que puede ser usado para denir instan ias
y variables de lase privadas, mtodos, variables guardadas en globales, y an variables
guardadas en instan ias privadas de esta lase en instan ias de otras lases. Puede o urrir
que se trunque si el nombre modi ado queda on ms de 255 ara teres. Fuera de las
lases, o uando el nombre de lase onsiste solo en guiones bajos, no se modi an los
nombres de identi adores.
Hay que a larar que las reglas de modi a in de nombres estn diseadas prin ipalmente para evitar a identes; es posible a eder o modi ar una variable que es onsiderada omo privada. Esto hasta puede resultar til en ir unstan ias espe iales, tales omo
en el depurador.
63
9 Re ursividad
9.1. Qu es la Re ursividad?
La re ursividad es una t ni a en la que una fun in se ha e llamadas as misma en el
pro eso de la realiza in de sus tareas.
La re ursividad da al programador una herramienta potente para resolver iertos tipos
de problemas redu iendo omplejidad u o ultando los detalles del problema.
Una fun in re ursiva es una fun in que se llama asi misma, ya sea dire ta o indireta,
la re ursividad dire ta, que es uando una fun in se llama as misma la ual onsidera
dos elementos: el Caso Base (n de la re ursin) y el Caso General (Parte puramente
re ursiva).
Caso base: Es el ao ms simple de una fun in re ursiva, y simplemente devuelve
un resultado. ( el aso base se puede onsiderar omo una salida no re ursiva)
Caso general: Rela iona el resultado del algoritmo on resultados de asos ms
simples. Dado que ada aso de problema aparenta o se ve similar al problema
original, la fun in llama una opia nueva de si misma, para que empie e a trabajar
sobre el problema mas pequeo y esto se ono e omo una llamada re ursiva y
tambien se llama el paso de re ursin.
La re ursin se puede denir mejor mediante el lsi o ejemplo de la fun in fa torial.
Ejemplo:
0! = 1, 1! = 1 Caso Base
Sea, n! = n (n 1) (n 2) 1, si n > 0 Caso General
Supongamos que bus amos el valor de 4! omo 4 > 0 enton es utilizamos la segunda
parte de la deni in:
4! = 4 3 2 1 = 24
Vamos a ver las fun iones en modo iterativo y re ursivo
1
2
3
4
5
6
7
8
#Modo
Iterativo
#! / u s r / b i n / e n v
python
def f a t o r i a l ( n ) :
f =1
for i in range ( 1 , n +1):
f=i f
return f
64
9 Re ursividad
1
2
3
4
5
6
7
8
9
#Modo
Re ursivo
#! / u s r / b i n / e n v
python
def f a t o r i a l ( n ) :
i f n==0 or n==1:
resultado = 1
e l i f n>1:
r e s u l t a d o=n f a t o r i a l ( n 1)
Como podemos observar en nuestra fun in re ursiva no utlizamos ninguna estru tura
de repeti in (for , while, et .).
El al ulo re ursivo del fa torial de un nmero natural, el ual parte de la siguiente
deni in matemti a, valida para valores positivos de n:
1,
n = 0, n = 1
n! =
n(n 1), n > 1
Para es ribr una fun in re ursiva, ahi un metodo que nos ayuda a formular nuestras
fun iones re ursivas:
1. Primero, ahi que obtener una deni in exa ta del problema a resolver. (Esto, por
supuesto, es el primer paso en la resolu in de ualquier problema de programa in)
2. A ontinua in, determinar el tamaa del problema ompleto que hoy que resolver.
Este tamao determinar los valores de los parmetros en la llamada ini ial a la
fun in.
3. Ter ero, resolver el aso base en el que el problema puede expresar no re ursivamente. Por. ltimo, resolver el aso general mas pequeo del mismo problema, una
llamada re ursiva.
Ah que tener uidado on la ele in inapropiada de los asos base, por que esto puede
ondu ir a una re ursin que no se detiene jams. Es lo que se ono e omo una regresin
innita y es anloga a los i los innitos.
Otro ejemplo muy utilizado es el l ulo de los nmeros de Fibona i, eson son una
se uendia de nmeros.
Los dos primeros nmeros de la se uen ia valen 1 y ada nmero a partir del ter ero se
obtiene sumando los dos anteriores. Podemos expresar esta deni in matemti amente
as:
(
1,
n=1n=2
Fn
Fn1 + Fn2 , n > 2
La transforma in de esta deni in de una fun in de Python es:
65
9 Re ursividad
1
2
3
4
5
6
def f i b o n a i ( n ) :
i f n==1 or n==2:
r e s u l t a d o =1
e l i f n>2:
r e s u l t a d o = f i b o n a i ( n1)+ f i b o n a i ( n 2)
Como podemos observar es muy fa l es ribir nuestro aso re ursivo, en una fun in
para as poderla llamar. La importan ia de este aso re ursivo, es denir nuestros asos
bases, los uales son uando n = 1 y n = 2.
Existen varios fa tores a onsiderar en la de isin de usar o no una solu in re ursiva
a un problema. Las prin ipales uestiones son la laridad y la e ien ia de la solu in.
En general una solu in no re ursiva es ms e iente en trminos de tiempo y espa io de omputadora. La solu ion re ursiva puede requerir gastos onsiderables, y deben
guardarse opias de variables lo ales y temporales. Aunque el gasto de una llamada a
una fun in re ursiva no es peor, esta llamada original puede o ultar mu has apas de
llamadas re ursivas internas. El sistema puede no tener su iente espa io para eje utar
una solu in re ursiva de algunos problemas.
Una solu in re ursiva parti ular puede tener una ine iendia inherente. Tal ine ien ia no es debida a la ele in de la implementa in del algoritmo, ms bien, es un defe to
del algoritmo en si mismo.
Un problema inherente es que algunos valores son al ulados una y otra vez ausando
que la apasidad de la omputadora se ex eda antes de obtener una respuesta.
La uestin de laridad en la solu in es, no obstante, un fa tor importante. En algunos
problemas una solu in re ursiva es ms simple y ms natural de es ribir omo vimos en
los ejemplos anteriores.
66
10 Metodos de Ordenamiento y
Busqueda
Mu has a tividades humanas requieren que en ellas las diferentes ole iones de elementos utilizados se oloquen en un orden espe o. Las o inas de orreo y las empresas
de mensajera ardenan el orreo y los paquetes por digos postales on el objeto de onseguir una entrega e iente, los anuarios o listas telefoni as, ordenan sus lientes por
orden alfabti o de apellido on el n ltimo de en ontrar f ilmente el nmero de telfono deseado, los estudiantes de una lase en la universidad se ordenan por apellidos o
por nmero de expediente, et . Por tal ir unstan ia una de las tareas que realizan ms
fre uentemente las omputadoras en el pro esamiento de datos es la ordena in.
El estudio de diferentes metodos de ordena in es una tarea intrnse amente interasante
desde el punto de vista teri o y naturalemente, pra ti o. Vamos a ver algunos algorimos
y te ni as de ordenamiento ms usuales.
Existen diferentes algoritmos de ordena in elementales o bsi os:
Burbuja
Sele in
Inser in
Estos metodos, son algunos de los mu hos que existen, pero estos son los lasi os por lo
ual debemos de ono er su t ni a.
10.0.1.
Burbuja
El mtodo de burbuja es el ms ono ido y popular entre estudiantes y aprendi es

de programa in por su fa ilidad de omprensin y programa in, por el ontrario, es el
menos e iente y por ello, normalemente se aprende su t ni a pero no se utiliza mu ho.
La t ni a utilizada se dnomina ordena in por burbuja debido a que los valores ms
pequeos gradualmente suben ha ia la ima o parte superior de una lista de modo similar
a omo suben las burbujas en el agua, mientras los valores mayores se hunden a la parte
inferio de la lista.
La t ni a onsite en ha er varias pasadas a travs de la lista, en asa pasada se omparan
parejas su e ivas de elementos. Si una pareja est en orden re iente o los valores son
identi os, se dejan omo estn, si una pareja est en orden de re iente, sus valores se
inter ambian.
El ejemplo ilustra el fun ionamiento del algoritmo de la burbuja on una lista de 5
elementos L=50,20,40,80,30.
67
10 Metodos de Ordenamiento y Busqueda

Pasada 0:
50
20
20
50
20
80
40
40
40
20
40
20
40
30
50
80
50
80
50
30
80
30
30
30
80
Intercambia 50 y20
Intercambia 50 y 40
50 y 80 ordenados
Intercambia 80 y 30
El elemento mayor es 80
Pasada 1:
20
40
20
40
20
20
50
30
50
40
40
80
80
30
50
30
30
50
20 y 40 ordenados
40 y 50 ordenados
80
Intercambia 50 y 30
80
Elementos mayores ordenados
Pasada 2:
20
40
20
30
30
40
50
50
80
80
Pasada 3:
68
20 y 40 ordenados
Intercambia 40 y30

20
30
20
30
40
40
50
50
80
80
20 y 30 ordenados
Lista ordenada
En la pasada 3, se ha e una ni a ompara in de 20 y 30, y no se produ e inter ambio.

Vamos a implemetar el algoritmo de burbuja en Python, para esto vamos a rear un
modulo que nos va ayudar a rear una lista de nmeros aleatorios, para que no tengamos
que ponerlos manualmente.
Implementa in modulo arrayh.py:
1 # Modulo p a r a r e a i o n y o p e r a i o n e s
2 # sobre a r r e g l o s .
3
4 import random
5 # C r e a un a r r e g l o d e n e l e m e l e m e n t o s
6 # a l a z a r q u e s e e n o n t r a r a n en e l
7 # rango de i l a s l
8
9 def r e a t e _ a r r a y ( i l , s l , nelem ) :
10
arra =[
11
for i in range ( nelem ) :
12
a r r a . append ( random . r a n d i n t ( i l , s l ) )
13
return a r r a
14
15 # I n t e r a m b i a d o s e l e m e n t o s d e un a r r e g l o d a d a s
16 # s u s p o s i i o n e s .
17
18 def swap_values ( arra , index1 , index2 ) :
19
temp=a r r a [ index1
20
a r r a [ index1 = a r r a [ index2
21
a r r a [ index2 = temp
Ahora vamos a implemetar un modulo para nuestro mtodo burbuja, el ual llamaremos
bsort.py:
1 # Ordenamiento b u r b u j a
2 import arrayh
3
4 def s o r t ( a r r a ) :
5
nelem = l e n ( a r r a )
6
for i in range ( nelem ) :
7
for j in range ( nelem 1) :
8
i f ( a r r a [ j > a r r a [ j +1) :
9
arrayh . swap_values ( arra , j , j +1)
Y por ultimo nuestro programa prin ipal, ordenador.py:

1 #Cargamos n u e s t r o s
2 #b u r b u j a y a r r a y h
3
4 import b s o r t
modulos
69

5 import arrayh
6
7 #Creamos n u e s t r a l i s t a d e e l e m e n t o s a l a z a r
8 #d e 0 a 1 0 0 o n tamao 1 0
9
10 array_nuevo = arrayh . r e a t e _ a r r a y ( 0 , 1 0 0 , 1 0 )
11
12 print array_nuevo #i m p r i m e a r r e g l o l l e n o
13 print ' \n '
#d e s o r d e n a d o
14
15 #Mandamos a o r d e n a r
16 b s o r t . s o r t ( array_nuevo )
17
18 #mandamos a i m p r i m i r n u e s t r o
19 #a r r e g l o o r d e n a d o
20 print array_nuevo
10.0.2.
Sele in
Cosidrese el algoritmo para ordenar una lista A de enteros en orden as endente, es

de ir, del nmero ms pequeo al mayor. Es de ir, si la lista A tiene n elemntos, se trata
de ordenar los valores de la lista de modo que el dato onteni o en A[0 sea el valor ms
pequeo, el valor alma enado en A[1 el siguiente ms pequeo, y asi hasta A[n-1, que ha
de ontener el elemento de mayor valor. En resumen se bus a el elemento ms pequeo
de la lista y se inter ambia on A[0, primer elemento de la lista.
A[0, A[1, A[2,...A[n-1
Despus de terminar esta primera pasada, el frente de la lista est ordenado y el resto
de la lista A[1, A[2,...A[n-1 permane en desordenados. La siguiente pasada bus a en
esta lista desordenada y sele iona el elemento ms pequeo, que se alma ena enton es
en la posi in A[1. De este modo los elementos A[0 y A[1 estan ordenados y la sublista
A[2, A[3,...A[n-1 desordenada enton es, se sele iona el elemento mas pqueo y se inter ambia on A[2. El pro eso ontinua n-1 pasadas y en ese momento la lista desrdenada
se redu e a un elemento, el mayor de la lista, y on esto queda ompletamente ordenado.
Un ejemplo pr ti o ayudaria a la ompren ion del algoritmo, onsideremos una lista A
on 5 valores enteros 51, 21, 39, 80, 36.
70

A[0]
A[1]
A[2]
A[3]
A[4]
51
21
39
80
36
Seleccionar 21
Intercambiar
21 y A[0]
36
Seleccionar 36
Intercambiar
36 y A[2]
51
Seleccionar 39
Intercambiar
39 y A[2]
Pasada 0
21
51
39
80
Pasada 1
21
39
36
80
Pasada 2
21
36
39
80
51
Seleccionar 51
Intercambiar
51 y A[3]
Pasada 3
21
36
39
51
80
Lista ordenada
Los pasos del algoritmo son:

1. Sele ionar el elemento ms pequeo de la lista A inter ambiarlo on el primer
elemnto A[0. Ahora la entrada ms pequea est en la primera posi ion del ve tor.
2. Considerar las posi iones de la lista A[1, A[2, A[3, . . ., sele ionar el elemento
mpas pequeo e inter ambiarlo on A[1. Ahora las dor primeras entradas de A
estn en orden.
3. Continuar este pro eso en ontrando o sele ionando el elemento ms pequeo de
los restantes elementos de la lista, inter ambindolos ade uadamente.
Vamos a utlizar nuevamente nuestro modulo, arrayh.py que reamos anteriormente, para
llenar nuestra lista on nmeros aleatorios automati amente. Y tambien vamos a rear
un modulo para nuestro algoritmo de sele in el ual llamaremos sesort.py.
1 #S e l e i o n
2 import arrayh
3
4 def s o r t ( a r r a y ) :
5
for i in range ( 0 , l e n ( a r r a y ) 1) :
6
indi eMenor=i
7
for j in range ( i +1, l e n ( a r r a y ) ) :
8
i f a r r a y [ j < a r r a y [ indi eMenor :
9
indi eMenor=j
10
i f i != indi eMenor :
11
a r r a y [ i , a r r a y [ indi eMenor = a r r a y [ indi eMenor , a r r a y [ i
Y tambien tenemos que modi ar nuestro programa prin ipal, para in luir el modulo
y poderlo utilizar.
71

1 import s e s o r t
2 import arrayh
3 array_nuevo = arrayh . r e a t e _ a r r a y ( 0 , 1 0 0 , 1 0 )
4 print array_nuevo
5 print ' \n '
6 s e s o r t . s o r t ( array_nuevo ) print array_nuevo
10.0.3.
Inser in
El mtodo de ordena in por inser in es similar al pro eso tipi o de ordenar tarjetas
de nombres ( artas de una baraja) por orden alfabeti o, que onsiste en insertar un
nombre en su posi in orrenta dentro de una lista o ar hivo que ya est ordenado. As
el pro eso en el aso de la lista de enteros A=50, 20, 40, 80, 30.
50
Comienzo con 50
Inserta 20 en la posicion 0
50 se mueve a posicion 1
Procesar 20
20
50
Procesar 40
20
40
50
Procesar 80
20
40
50
Procesar 30
20
30
40
Inserta 40 en la posicion 1
50 se mueve a posicion 2
80
50
80 esta bien ordenado
80
Inserta 30 en posicion 1
Se desplaza a la derecha
la sublista
El algoritmo orrespondiente a la ordena in por inser in ontempla los siguientes

pasos:
El primer elemto A[0 se onsidera ordenado, es de ir, la lista ini ial onsta de un
elemento.
Se inserta A[1 en la posi in orre ta, delante o detrs de A[0, dependiendo de
que sea menor o mayor.
Por ada i lo i se explora la sublista A[i-1..A[0 bus ando la posi in orre ta de
inser in, a la vez se mueve ha ia abajo una posi in todos los elementos mayores
que el elemento a insertar A[i, para dejar va a esa posi in.
Inserta el elemento a la posi in orre ta.
Ahora rearemos nuestro modulo llamado insort.py.
1
2
3
4
# Inser ion
# La
# a
fun ion
sort ()
insert
no
se
usa ,
llamar
dire tamente .
72

5 import arrayh
6
7 def i n s e r t ( arra , length , v a l ) :
8
i = length 1
9
while ( i >=0 and a r r a [ i > v a l ) :
10
a r r a [ i +1 = a r r a [ i
11
i =1
12
a r r a [ i +1 = v a l
13 def s o r t ( a r r a ) :
14
i = 1
15
nelem = l e n ( a r r a )
16
while ( i < nelem ) :
17
i n s e r t ( arra , i , a r r a [ i )
18
i+=1
Con mu ha fe uen ia los programadores trabajan on grandes antidades de datos alma enados en listas y registros, por ello ser ne esario determinar si una lista ontiene
un valor que oin ida on un ierto valor lave. El pro eso de en ontrar un elemento espe o de una lista se denomina bsqueda. Vamos a examinar dos t ni as de bsqueda:
bsquda lineal o se uen ial, y la t ni a ms sen illa, y bsqueda binario, la te ni a ms
e iente.
10.0.4.
Bsqueda Se uen ial
La bsqueda se uen ial bus a un elemento de una lista utilizando un valor destino
llamado lave. En una bsqueda se ue ial, los elementos de una lista se exploran en
se uen ia, uno despus del otro. La bsqueda se uen ial es ne esaria, por ejemplo, si
se desea en ontrar la persona uyo nmero de telfono es 222-214565 en un dire torio
telefoni o de su iudad. Los dire torios de telfonos estn organizados alfabti amente
por el nombre del propietario en lugar de por nmeros de telfono, de modo que deben
explorarse todos los nmeros, uno despues de otro, esperando en ontrar el nmero 222214565.
El algoritmo de bsqueda se uen ial ompara asa elemento de la lista on la lave de
bsqueda. Dado que la lista no est en un orden prejado, es probable que el elemento a
bus ar pueda ser el primer elemento, el ltimo elemento o ualquier otro.
Crearemos nuestro modulo bseq.py
1
2
3
4
5
6
7
8
9
10
11
# Busqueda
# Fun ion
Se uen ial
de
Busqueda
# Argumentos :
#
>
( arreglo ,
elemento
bus ar )
def s e a r h ( arra , elem ) :

for i in range ( l e n ( a r r a ) ) :
i f elem == a r r a [ i :
return i
i f ( i == l e n ( a r r a ) 1) :
return 1
Ahora vamos a rear el programa prin ipal, donde vamos a mandar una lista de nmeros
enteros, y el elemento a bus ar.
73

1 #Programa P r i n i p a l
2 #Modulo B . S e u e n i a l
3 import bseq
4
5 array_nuevo = [ 0 , 2 , 6 , 4 , 7 , 3 , 5 , 8 , 9 , 1
6 p o s i i o n=bseq . s e a r h ( array_nuevo , 5 )
7 print array_nuevo
8 print ' El elemento a bus ar e s t a en l a p o s i i o n : ' , p o s i i o n
Para este aso nadamas utilizamos una lista de 10 elementos, on los uales podemos
darnos uenta, que nos indi a la posi ion de donde se en uentra el elemento que bus amos.
10.0.5.
Bsqueda Binaria
La bsqueda se uen ial se apli a a ualquier lista. Si la lista est ordenada, la bsqueda
binaria propor iona una t ni a de bsqueda mejorada. Una bsqueda binaria tpi a es
la bsqueda de una palabra en un di ionario. Dada la palabra, se abre el libro er a
del prin ipio, del entro o del nal dependiendo de la primera letra del primer apellido
o de la palabra que bus a. Se puede tener suerte y a ertar on la pgina orre ta; pero,
normalmente, no ser as y se mueve el le tor a la pgina anterior o posterior del libro.
Por ejemplo, si la palabra omienza on J y se est en la L se mueve uno ha ia atrs.
El pro eso ontina hasta que se en uentra la pgina bus ada o hasta que se des ubre
que la palabra no est en la lista. Una idea similar se apli a en la bsqueda en una lista
ordenada. Se sita la le tura en el entro de la lista y se omprueba si la lave oin ide
on el valor del elemento entral. Si no se en uentra el valor de la lave, se sigue la
bsqueda uno en la mitad inferior o superior del elemento entral de la lista. En general,
si los datos de la lista estn ordenados se puede utilizar esa informa in para a ortar el
tiempo de bsqueda.
Vamos a rear el modulo bbin.py en donde implementaremos el algoritmo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# Busqueda
Binaria
# Argumentos :
#
>
# Valor
#
#
>
( dondebus ar ,
de
que ,
de_donde ,
a_donde )
retorno
posi ion
del
se
si
no
elemento
bus ado ,
en ontro .
def s e a r h ( arra , elem , lo , up ) :

middle = ( l o+up )/2
i f a r r a [ middle == elem :
return middle
i f l o == up :
return 1
i f elem > a r r a [ middle :
pos = s e a r h ( arra , elem , middle +1, up )
i f elem < a r r a [ middle :
pos = s e a r h ( arra , elem , lo , middle 1)
return pos
Programa prin ipal, para llamar a nuestro modulo bbin.py:
74

1 #B u s q u e d a B i n a r i a
2
3 import bbin
4
5 array_nuevo = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 1 0 , 1 1 , 1 2 , 1 3 , 1 4 , 1 5 , 1 6 , 1 7 , 1 8 , 1 9 , 2 0
6 p o s i i o n=bbin . s e a r h ( array_nuevo , 1 0 , 1 , 2 0 )
7 print array_nuevo
8 print ' El elemento e s t a en l a p o s i i o n : ' , p o s i i o n
La bsqueda se uen ial se apli a para lo alizar una lave en un ve tor no ordenado.
Para apli ar el algoritmo de bsqueda binaria la lista, o ve tor, donde se bus a debe de
estar ordenado. Estos fueron algunos de los algoritmos, pero existen mu hos ms.
75
11 Un Po o de Gra a in
matplotlib est diseado on la losofa que debe ser apaz de rear tramas sen illas
on slo unos po os omandos, o slo uno!. Aunque tiene sus origenes en la emula ion
de Matlab, en omandos gr os es independiente totalmete de Matlab. Esta bibliote a
aunque esta es rita prin ipalmente en Python puro, que ha e uso intensivo de NumPy,
para propor ionar un buen rendimiento in luso para grandes onjuntos.
El digo matplotlib es on eptualmente dividido en tres partes: la interfaz pylab, es
un onjunto de fun iones que ofre e matplotlib.pylab que permiten al usuario rear fun iones on digo muy similar a Matlab generar digo gura. La interfaz matplotlib o
matplotlib API es el onjunto de lases que ha en el trabajo pesado, la rea ion y gestion
de datos, texto, lineas, et .
Esta es una interfaz abstra ta que no sabe nada a er a de la salida. Los motores,
son dependientes del dispositivo de extra in del dispositivo, que transforma la representa in de interfaz de papel o un dispositivo de pantalla, por ejemplo para rear un
PS (PostS rip), PNG de salida on alta alidad et .
matplotlib es utilizado por mu has personas en mu hos ontextos diferentes, algunas
personas quieren generar automati amente ar hivos PostS ript para enviar a una impresora o editores, otros implementar en un servidor de apli a in web para generar PNG
de salida para su in lusin en paginas web generadas dinmi amente et .
11.1. Instala in
Vamos ha erlo de la manera mas fa il. En primer lugar, tendra que averiguar si ya
tienes instalado Python en tu maquina, si no debes de instalarlo.
Una vez que Python este instalado y fun ionando, tendra que instalar numpy. numpy
propor iona un alto rendimiento de datos de matri es estru turas y fun iones matemti as y es un requisito para matplotlib.
Ahora solo ne esitamos ha er:
>apt g e t i n s t a l l python m a t p l o t l i b
Esto es para distribu iones debian o ubuntu.
Ya on esto tenemos instalado matplotlib, ahora solo nos restra trabajar.
11.2. Matplotlib on Ejemplos.

Vamos a rear la gr a ms simple que se puede ontruir on matplotlib. Para este
ejemplo solo vamos a importar las fun iones que ne esitamos. El omando plot() que
re ibe dos listas, on oordenadas (x,y) y la instru ion show() que despliegua la gr a.
76
Aadamos un po o ms de di ultad. El omando plot puede re ibir ms parametros,

en esta o a in aadiremos ro para de irle olor rojo y simbolo ir ulo. El omando
saveg permite guardar la gr a generada en diversos formatos. La instru in axis
ontrola los limites de los ejes.
2
3 from m a t p l o t l i b . pylab import p l o t , a x i s , s a v e f i g , show
4
5 #G r a f i a m o s u n o s p u n t o s
6 #E l p a r a m e t r o ' r o ' = ( o l o r=r o j o s i m b o l o=o )
7 p l o t ( [ 1 , 2 , 3 , 4 , [ 1 , 4 , 9 , 1 6 , ' ro ' )
8 #E l d e f a u l t e s ' b '=( o l o r=a z u l s i m b o l o= l i n e a )
9
10 #m o d i f i a m o s l o e e j e s
11 a x i s ( [ 0 , 6 , 0 , 2 0 )
12 #L o s p r i m e r o s d o s e l e m e n t o s o n t r o l a n e l e j e x
13 #l o s u l t i m o s d o s e l e j e y
14 #[ xmin , xmax , ymin , ymax
15
16 #Guarda l a f i g u r a a a r h i v o
17 s a v e f i g ( ' g r a f . png ' )
18 s a v e f i g ( ' g r a f . ps ' )
19 s a v e f i g ( ' g r a f . pdf ' )
20 s a v e f i g ( ' g r a f . eps ' )
21
22 show ( )
77
Matplotlib importa automati amente gran parte de numpy. Lo ual es muy util pues el
omando plot tambien admite arreglos omo el generado abajo usando arange. Un mismo
omando de plot puede servir para gra ar multiples onjuntos de datos omo abajo.
2
3 from pylab import arange , p l o t , show
4
5 #Creamos un r a n g o d e 0 a 5 . 2 e n p a s o s d e
6 t=arange ( 0 . 0 , 5 . 2 , 0 . 2 )
7
8 #Combinamos t r e s g r a f i a s
9 #r =( o l o r=r o j o s i m b o l o=g u i o n )
10 #b s =( o l o r=a z u l s i m b o l o= u a d r o )
11 #g ^=( o l o r=v e r d e s i m b o l o= t r i a n g u l o )
12 p l o t ( t , t , ' r ' , t , t 2 , ' bs ' , t , t 3 , ' g^ ' )
13
14 show ( )
78
0.2
Podemos ontrolar la mayor parte de las op iones de la gra a, vamos a mostrar

algunas de las propiedades de las lineas y simbolos. Para ver todas las ara teristi as
de las lineas, desde el interprete on pylab importando from matplotlib.pylab import *,
podemos pedir ayuda sobre lines help(matplotlib.lines). La instru ion legend genera un
uadro de leyenda
2
3 from m a t p l o t l a b . pylab import arange , p l o t , show , l e g e n d
4
5 t=arange ( 0 . 0 , 0 . 5 , 0 . 2 )
6
7 #P y t h o n o n p a r a m e t r o s y s u v a l o r
8 p l o t ( t , t , ' r ' , l i n e w i d t h =3.0 , a n t i a l i a s e d =False , l a b e l= ' datos ' )
9
10 #E l omando l o n o s p e r m i t e p o s i i o n a r l a l e y e n d a
11 #t a m b i e n p o d e m o s u s a r t u p l a p a r a o l o a r l a
12 #Shadow a g r a g a s o m b r a
13 l e g e n d ( l o = ' upper l e f t ' , shadow=True )
14
15 show ( )
79
Otras propiedades ontrolables son:

markeredgewidth
An ho de la linea del mar ador en puntos
Propiedad
Efe to
alpha
Valor de transparen ia alpha entre 0 y 1
olor
Argumento de olor: 'b' o bien hexade imal rgb:'#FF000'
data_ lipping
Usar numeri para ha er lip a los datos
label
Una adena para usar de leyenda
linestyle
Estilo de la linea omo o -
linewidth
An ho de la linea en puntos(otante)
marker
Mar ador para los puntos omo +,o
markeredge olor
Color de la linea del mar ador en puntos
markerfa e olor
Color de relleno del mar ador en puntos
markersize
Tamaa del mar ador
markeredgewidth
An ho de la linea del mar ador en puntos
Existen diferentes formas de manipular una gr a, veamos algunos ejemplos:

2
3 #P r o p i e d a d e s d e l n e a ( y s m b o l o s )
4 from pylab import arange , p l o t , show , l e g e n d
5
6 t = arange ( 0 . 0 , 5 . 2 , 0 . 2 )
80
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
1
2
3
#La
segunda
es
#E l
omando
plot
#A q u
line
es
on
mtodos
regresa
el
el
de
una
an ho
de
linea
l i ne . set_linewidth (2.0)
#Por
ejemplo
podemos
desa tivar
l i n e . set_antialiased ( False )
#E t i q u e t a
de
la
modifi an
lista
nombre
l i n e , = p l o t ( t , t , ' r ' )
#I n r e m e n t e m o s
que
una
de
variable
el
del
linea
mar ador
l i n e . set_markersize (7)
#T i p o
de
mar ador
( diamante )
l i n e . set_marker ( ' d ' )
#C o l o r
del
mar ador
l i ne . set_markerfa e olor( ' g ' )

l i n e . set_markeredge olor( ' r ' )
l e g e n d ( shadow=True )
show ( )
#! / u s r / b i n / e n v
#P r o p i e d a d e s
de
python
lnea
(y
grfi a
no
la
un
antialising
l i n e . s e t _ l a b e l ( " datos " )
#Tamao
la
lneas
smbolos )
81
ual
a tiva
se
omando !
puede
usar
4
5 from pylab import arange , p l o t , show , setp , l e g e n d
6
7 t = arange ( 0 . 0 , 5 . 2 , 0 . 2 )
8
9 #F i n a l m e n t e h a y omandos s i m i l a r e s a l o s d e m a t l a b
10 l i n e s = p l o t ( t , t , t , t 2)
11 s e t p ( l i n e s , l i n e w i d t h =2.0)
12 s e t p ( l i n e s [ 0 , o l o r= ' r ' , l a b e l=" datos1 " )
13 s e t p ( l i n e s [ 1 , o l o r= ' k ' , l a b e l=" datos2 " )
14
15 l e g e n d ( )
16
17 show ( )
18 #O aun ms s i m i l a r e s a m a t l a b u s a n d o a d e n a s
19 #s e t p ( l i n e s , ' o l o r ' , ' r ' , ' l i n e w i d t h ' , 2 . 0 )
para
modifi ar
propiedades
Qu su ederia si queremos gra ar ms de una gra a en una ventana, para esto

utilizaremos el omando subplot.
2
3 #M u l t i p l e s g r f i a s
4 from m a t p l o t l i b . pylab import
5 from f u n i o n e s import f
6
7 #Generamos d o s a r r a y s
8 t1 = arange ( 0 . 0 , 5 . 0 , 0 . 1 )
9 t2 = arange ( 0 . 0 , 5 . 0 , 0 . 0 2 )
10
11 #Creamos una f i g u r a ( o p i o n a l s u b p l o t l o h a e a u t o m t i o )
12 #Creamos una " e l d a " p a r a e l s u b p l o t a l a m a t l a b
82
f i g u r e (1)
13
14
15
16
17
18
19
20
#E s t o
signifi a
#Es
igual
#E l
otro
a:
filas ,
subplot (2 ,1 ,1)
olumna ,
>
1 era
permite
p l o t ( t1 , f ( t1 ) , ' bo ' , t2 , f ( t2 ) )
sub
plot
grfi a
ms
s u b p l o t (211)
numeros
s u b p l o t (212)
p l o t ( t2 , o s (2 p i t2 ) , ' r ' )
show ( )
Como podemos darnos uenta ne esitamos rear un modulo llamado fun iones:
2
3 from m a t p l o t l i b . pylab import os , exp , multiply , p i
4
5 def f ( t ) :
6
s1= o s (2 p i t )
7
e1=exp( t )
8
return m u l t i p l y ( s1 , e1 )
A ve es en lugar de dos gra as en la misma ventana, lo que queremos son dos gra as
independientes, matplotlib nos permite rear tantas ventanas on gra as omo ne esitemos.
2
3 #M u l t i p l e s f i g u r a s
5
6 #Creamos una f i g u r a f i g u r e ( 1 )
7 plot ( [ 1 , 2 , 3 )
8
9 #Creamos una ms f i g u r e ( 2 )
83
10
11
12
13
14
15
16
plot ( [ 4 , 5 , 6 )
#Le
ponemos
ttulo
la
figura
figure (1)
t i t l e ( ' Titulo : figura 1 ' )
show ( )
Mu as ve es nos interesa olo ar titulos y etiquetas a los ejes en nuestra gra a, vamos
aadir y ontrolar algunas propiedades del texto.
2
3 #E t i q u e t a s y t e x t o
5
6 plot ( [ 1 , 2 , 3 )
7
8 #P o n i e n d o e t i q u e t a s a l a g r f i a
9 x l a b e l ( ' tiempo ' , o l o r= ' r ' , f o n t w e i g h t = ' bold ' )
10 y l a b e l ( ' v o l t s ' , o l o r= ' b ' , fontname= ' C o u r i e r ' )
11 t i t l e ( u ' Una g r f i a ' , o l o r= ' g ' , alpha =0.5)
12
13 #Tambin e s v l i d o
14 #t = x l a b e l ( ' t i e m p o ' )
15 #s e t p ( t , o l o r = ' r ' , f o n t w e i g h t = ' b o l d ' )
16
17 show ( )
84
Otras propiedades de texto disponibles son:

rotation
horizontal,verti al
Propiedades
Valores
alpha
Valor de transparen ia otante en el rango 0-1
olor
Argumento de olor: 'b' o bien hexade imal rgb:'#FF000'
fontangle
itali ,normal,oblique
fontname
Sans,Helveti a,Courier,Times,Others
fontsize
Tamao de la fuente en putnos
fontweight
normal, bold, light
horizontalalignmen
left, enter,right
verti alalignment
bottom enter top
Cuando las propiedades del texto que queremos son repetitivas podemos generar un
di ionario on las propiedades que queremos y pasar el di ionario omo parametro,
las propiedades que el di ionario dena se apli aran al texto. La instru ion text nos
permite aadir texto dentro de una gra a.
2
3 #C o n t r o l a n d o e l t e x t o o n d i i o n a r i o
5
6 #Podemos armar un d i i o n a r i o o n l a s
7 #y p a s a r l o omo a r g u m e n t o a l p l o t
ara tersti as
85
deseadas
8
9
10
11
12
13
14
15
16
17
18
19
20
21
f o n t = { ' fontname '

:
' olor '
:
' fontweight ' :
' fontsize '
:
' Courier ' ,

'r ' ,
' bold ' ,
11}
plot ( [ 1 , 2 , 3 )
t i t l e ( ' La g r a f i a ' , font , f o n t s i z e =12)
#E l
omando
texto
agrega
texto
en
la
posi in
t e x t ( 0 . 5 , 2 . 0 , ' l a l i n e a ' , font , o l o r= ' k ' )
x,y
x l a b e l ( ' tiempo ( s ) ' , f o n t )

y l a b e l ( ' v o l t a g e (mV) ' , f o n t )
show ( )
Es posible utilizar latex dentro de ualquier elemento de texto en matplotlib. Es importante re ordar que las adenas deben de llevar la 'r' antes de las omillas. Esto le di e
al interprete que la adena es 'raw' es de ir que no interprete ara teres espe iales omo
son '\n' o '\t'.
2
3 #Usando l a t e x d e s d e m a t p l o l i b
5
6 t = arange ( 0 . 0 , 2 . 0 , 0 . 0 1 ) s = s i n (2 p i t )
7 plot ( t , s )
8
9 #Un t t u l o q u e i n o r p o r a l a t e x , no o l v i d a r l a
10 t i t l e ( r ' $ \ alpha_i > \ beta_i$ ' , f o n t s i z e =20)
11
12 #T e x t o s d e n t r o d e l a g r f i a o n l a t e x
86
antes
del
texto !
13
14
15
16
17
18
19
20
21
22
t e x t ( 1 , 0.6 , r ' $\sum_{ i =0}^\ i n f t y x_i$ ' , f o n t s i z e =20)

t e x t ( 0 . 6 , 0 . 6 , r ' $\ a l {A}\rm{ s i n }(2 \omega t ) $ ' , f o n t s i z e =20)
#E t i q u e t a s
x l a b e l ( ' tiempo ( s ) ' )

y l a b e l ( ' v o l t s (mV) ' )
#G u a r d a l a ,
si
no
espe ifi as
formato
s a v e f i g ( ' mathtext_tut ' , dpi =50)

show ( )
el
default
es
png
En algunas o a iones queremos dos gra as, pero en lugar de una junto a la otra, la
ne esitamos una dentro de otra.
2
3 #S u b g r f i a i n t e r n a
5
6 #Creamos d a t o s
7 #Tamao d e l p a s o
8 dt =0.001
9 t=arange ( 0 . 0 , 1 0 . 0 , dt )
10
11 #R e s p u e s t a d e l i m p u l s o
12 r=exp( t [ : 1 0 0 0 / 0 . 0 5 )
13
14 #R u i d o o l o r r o j o
15 x=randn ( l e n ( t ) )
16 s= o n v o l v e ( x , r , mode = 2 ) [ : l e n ( x ) dt
17
18 #La g r f i a p r i n i p a l
87
19 p l o t ( t , s )
20
21 #A j u s t a l o s e j e s p a r a q u e h a y a e s p a i o
22 a x i s ( [ 0 , 1 , 1 . 1 min( s ) , 2 max( s ) )
23 x l a b e l ( ' tiempo ( s ) ' )
24 t i t l e ( ' Ruido Gausiano ' )
25
26 #S u b g r f i a d e n t r o d e l a p r i m e r a
27 a=axes ( [ 0 . 2 , 0 . 6 5 , 0 . 6 , 0 . 2 , a x i s b g= ' y ' )
28 n , bins , p a t h e s=h i s t ( s , 4 0 0 , normed=1)
29 t i t l e ( ' P r o b a b i l i d a d ' )
30 s e t p ( a , x t i k s = [ , y t i k s = [ )
31 show ( )
Cuando es ne esario intera tuar on la gr a matplotlib nos permite apturar una
serie de eventos, ono son los li ks de mouse o presinar una te la.
2
3 #C a p t u r a n d o e v e n t o s
5
6 #Una g r f i a u a l q u i e r a
7 p l o t ( arange ( 1 0 ) )
8
9 #La f u n i n a e j e u t a r o n e l e v e n t o
10 def on_ li k ( event ) :
11
#g e t t h e x and y p i x e l o o r d s
12
x , y = event . x , event . y
13
i f event . i n a x e s :
14
print ' Coordenadas : ' , event . xdata , event . ydata
15
#P i n a l o s p u n t o s n u e v o s
88
16
17
18
19
20
21
22
23
p l o t ( [ event . xdata , [ event . ydata , ' o ' )

#A t u a l i z a
draw ( )
#C o n e t a
los
eventos
on
la
las
grfi a
fun iones
# o n n e t ( ' m o t i o n _ n o t i f y _ e v e n t ' ,
on_ li k )
onne t ( ' button_press_event ' , on_ li k )

show ( )
Esta es la gr a ini ial.
Despues de dar varios li ks en la gr a obtenemos:
89
Los objetos, eventos tiene ms propiedades:
button
Botn que esta presionado
Propiedades
Uso
Posi in en x
Posi in en y
inaxes
Un boleano que di e si estamos o no dentro de los ejes
xdata
Posi in en x en los datos
ydata
Posi in en y en los datos
name
Nombre del evento
anvas
Canvas donde o urrio el evento
key
Te la presionada
En algunas o a iones nuestro eje x onsiste de fe has, matplotlib, nos permite gra ar
valores de fe has f ilmente, el omando datatime.date() genera un objeto on la fe ha
espe i ada. La instru in datetime.delta genera una diferen ia entre dias y nalmente
la instru in drange genera un rango de fe has desde la primera fe ha, hasta la segunda
separada por el delta espe i ado.
#!/ u s r / b i n / env python
from m a t p l o t l i b . p yl a b import import d a t e t i m e
#Dos f e h a s para r e a r un rango
date1
= datetime . date ( 1997 , 1 , 1 )
date2
= d a t e t i m e . d a t e ( 2 0 0 7 , 4 , 12 )
#Un d e l t a de tiempo ( d i f e r e n i a e n t r e dos f e h a s )
delta
= d a t e t i m e . t i m e d e l t a ( days =50)
#Un rango , a l e s t i l o a r a n g e > drange
dates
= drange ( date1 , date2 , d e l t a )
#Un par de v a l o r e s a l e a t o r i o s
s = rand ( l e n ( d a t e s ) )
#La g r f i a de f e h a s
plot_date ( dates , s )
show ( )
90
Cuando los datos ya estn guardados en un ar hivo podemos simplemente argarlos

para gra arlos desde matplotlib. Para este ejemplo el programa re ibe op iones desde
lnea de omandos. Por eso lo primero que est en el s ript es el manejador de argumentos. Despus si el argumento fue "-e" generamos una serie de datos y los es ribimos a
un ar hivo llamado "data.dat". Si la op in de lnea de omandos fue "-l" leemos los
datos del ar hivo "data.dat" y lo gra amos. Para realizar estas a iones matplotlib nos
propor iona omandos "save" y "load".
2
3 #C a r g a d o d a t o s d e s d e a r h i v o
4 from s y s import argv , e x i t
5
6 i f l e n ( argv )!= 2 or ( argv [ 1 ! = ' l ' and argv [ 1 ! = 'e ' ) :
7
print " Error de argumentos"
8
print "Uso : "
9
print "\ t " , argv [ 0 , "[ l | e "
10
print "\ t l \ t l e e r "
11
print "\ t e \ t e s r i b i r "
12
e x i t ( 1)
13 i f argv [1== 'e ' :
14
#G e n e r a un a r h i v o d e d a t o s
15
from pylab import arange , s i n , z e r o s , save , pi , rand , f l o a t
16
#Creamos l o s d a t o s
17
t=arange ( 0 . 0 , 1 . 0 , 0 . 0 0 5 )
18
s=s i n (2 p i t )+0.5 rand ( l e n ( t ) )
19
#Creamos un a r r e g l o p a r a g u a r d a r l o s d a t o s
20
data=z e r o s ( ( l e n ( t ) , 2 ) , f l o a t )
21
#La p r i m e r a o l u m n a e s t
22
data [ : , 0 = t
23
#La s e g u n d a o l u m n a e s s
24
data [ : , 1 = s
91
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#Ahora
try :
ex ept :
else :
guardalos ,
pero
uidado
por
si
falla
save ( ' data . dat ' , data )

print " Error a l guardar datos "
e x i t ( 3)
from pylab import load , p l o t , show

#C a r g a r
try :
ex ept :
datos
data=l o a d ( ' data . dat ' )

print " Error a l l e e r l o s datos "
e x i t ( 2)
#P r i m e r a
olumna
#S e g u n d a
olumna
#G r a f i a
los
t=data [ : , 0
s=data [ : , 1
datos
plot ( t , s , 'o ' )

show ( )
Matplotlib permite realizar gr as en oordenadas polares de forma muy sen illa.
2
3 #G r f i a s p o l a r e s
4 from m a t p l o t l i b . pylab import f i g u r e , arange , pi , show
5
6 #C r e a l a f i g u r a
7 fig = figure ()
8
9 #A g r e g a una g r a f i a ( s u b p l o t 1 1 1 e s s l o una g r f i a ) ,
92
que
sea
polar
10
11
12
13
14
15
16
17
18
19
ax = f i g . add_subplot ( 1 1 1 , p o l a r=True )
#C r e a
los
datos
r=arange ( 0 , 1 , 0 . 0 0 1 )
t h e t a =4 p i r
#G r a f i a
l i n e , = ax . p l o t ( theta , r , o l o r= '#ee8d18 ' , lw =3)

l i n e , = ax . p l o t ( r , r , o l o r= ' #151 e 8 ' , lw=3)
show ( )
93

Tutorial

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Tutorial

Diunggah oleh

Hak Cipta:

Format Tersedia

Python 2.

opiar, distribuir y omuni ar publi amente esta obra.

ha er obras derivadas y/o omplementarias.

Re ono imiento. Debes re ono er y dar redito al autor original.

No puedes utilizar esta obra on nes de lu ro.

1.0.1. Programa, Algoritmo, Lenguaje de Programa in !!!! . . . . . . . .

3. Mi Primer Programa en Python.

3.1. Hola mundo en Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4. Estru turas de Control

4.0.1. La Senten ia Condi ional if.

6.1. Fun iones Predenidas. . . . . . .

7.0.2. Opera iones on Ar hivos: Abrir, Leer, Es ribir y Cerrar. . . . . . 46

8. Programa in Orientada a Objetos.

8.1. Introdu in a la Programa in Orientada a Objetos.

10.Metodos de Ordenamiento y Busqueda

Programa, Algoritmo, Lenguaje de Programa in !!!!

Que es un Lenguaje de Programa in?

Los Operadores Aritmti os.

x=3.5/2 resultado 1.75

x=3.5//2 resultado 1.0

La multipli a in * es un operador binario, la nota in matemti a es 2

La diferen ia entre divisin y divisin entera, es omo lo indi a su nombre, en la divisin

Operadores Lgi os y de Compara in.

(nega in): Cambia el valor de verdad de verdadero a falso y

Un operador de ompara in omo su nombre lo indi a ompara sus operandos y

Menor o igual que

Mayor o igual que

Tipos Bsi os de Datos.

En Python existen tres tipos bsi os de datos:

sera equivalente a 0,1 103 .

3 Mi Primer Programa en Python.

print " Hola mundo"

y desde la onsola omo si se tratara de un eje utable ualquiera:

La extensin de los  heros de Python

3 Mi Primer Programa en Python.

print " h o l a mundo"

3.3. Entrada/Salida de Datos.

nombre = raw_input ( ' E s r i b e tu nombre ' )

print " Bienvenido a Python , " + nombre

Si ne esitamos un entero en lugar de una adena, podemos utilizar la fun in int. La

nombre = raw_input ( ' E s r i b e tu nombre ' )

edad = i n t ( raw_input ( ' Cual e s tu edad ' ) )

Si queremos utilizar la fun in oat

3 Mi Primer Programa en Python.

nombre = raw_input ( ' E s r i b e tu nombre ' )

print ' G r a i a s ' , nombre ' ' por u t i l i z a r Python '

Con la senten ia print podemos ontrolar un po o la aparien ia de la salida, para esto

print " Hola %s " % "mundo"

Lo que ha emos en la primera linea es introdu ir el valor despus de % que es la

Podemos introdu ir un nmero entre el % y el ar ter que indi a el tipo de formato,

print " %.5 f " 5.123456 7 8 9

4 Estru turas de Control

La Senten ia Condi ional if.

Asegurate de que la identa in esta omo en el ejemplo, ya que es la forma en que

4 Estru turas de Control

4.0.1.1. If ... else.

Nuestra sintaxis para utilizar esta ondi ional es:

a=f l o a t ( raw_input ( ' V alor de a : ' ) )

4 Estru turas de Control

=f l o a t ( raw_input ( ' V alor de : ' ) )

4 Estru turas de Control

o, lo que es lo mismo, el resultado de 1+2+3+....+1000.

op ion= ' '

Como podemos observar on esta pequea modi a in podemos al ular ualquier

No puedes utilizar esta obra on nes de lu ro.

6.1. Fun iones Predenidas. . . . . . .

La extensin de los heros de Python

Si queremos utilizar la fun in oat

Como podemos observar on esta pequea modi a in podemos al ular ualquier

Tambin podemos utilizar este operador para modi ar un elemento de la lista si lo

En la nota in matemti a el elemento que o upa, la la i-sima y la olumna i-esima

Como podemos observar, lo ni o que tenemos que ha er es modi ar el orden de

6.1. Fun iones Predenidas.

6.2. Fun iones Predenidas en Mdulos.

6.3. Deni in de Fun iones.

El mtodo read a ta sobre el hero abierto y re ibe omo argumento el nmero de