Notas de Python

7/24/2019 Notas de Python

1/118

ndice general

1 Introduccin a Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.1 Manejo bsico de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.2 Aspectos bsicos del lenguaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.3 Mdulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.4 Control de ujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

1.5 Funciones denidas por el usuario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231.6 Entrada y salida de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

1.7 Ms sobre estructuras de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

1.8 Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

1.9 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

2 NumPy y SciPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452.1 Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

2.2 Funciones para creararrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

2.3 Slicing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

2.4 Operaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

2.5 Otras operaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

2.6 Lectura de cheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

2.7 Bsqueda de informacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

2.8 SciPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

2.9 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

1


2/118

2 NDICE GENERAL2 NDICE GENERAL2 NDICE GENERAL

3 Grcos con Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

3.1 Grcos interactivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833.2 Aadiendo opciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

3.3 Congurando varios elementos del grco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

3.4 Grcos y objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

3.5 Grcos 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

3.6 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

4 Programacin Orientada a Objetos . . . . . . . . . . . . . . . . . . . . . . . . 105

4.1 Deniendo clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

4.2 Controlando entradas y salidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

4.3 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117


3/118

1Introduccin a Python

Python es un lenguaje de programacin creado por Guido Van Rossuma nales de los ochenta. Su nombre deriva de la acin de su creador algrupo de humor ingls Monty Python. Se trata de un lenguaje de alto nivel,interpretado, interactivo y de propsito general cuyo diseo hace especialhincapi en una sintaxis limpia y una buena legibilidad.

Los lectores con conocimiento de algn lenguaje de programacin encon-trarn en Python un lenguaje sencillo, verstil y que proporciona cdigo fcil-mente legible. Para aqullos que no estn familiarizados con la programacin,Python supone un primer contacto agradable pues los programas pueden sercomprobados y depurados con facilidad, permitiendo al usuario concentrarsems en el problema a resolver que en los aspectos concretos de la programa-cin.

Aproximadamente a partir de 2005, la inclusin de algunas extensionesespecialmente diseadas para el clculo numrico han permitido hacer de

Python un lenguaje muy adecuado para la computacin cientca, disponiendohoy en da de una coleccin de recursos equivalente a la que podemos encontraren un entorno bien conocido como MATLAB, y que continua en permanentecrecimiento.

Python es software de cdigo abierto que est disponible en mltiplesplataformas (GNU/Linux, Unix, Windows, Mac OS, etc.). Se encuentra en laactualidad con dos versiones en funcionamiento. La mayor parte del cdigoque se encuentra escrito en Python sigue las especicaciones de la versin 2,aunque hace ya algn tiempo que la versin 3 se encuentra disponible. En

estas notas se usar la versin 2 del lenguaje.1

1Aunque es conveniente saber que existen funciones para avisarnos si alguna parte denuestro cdigo no es compatible con la versin 3.

3


4/118

4 Tema 1 Introduccin a Python4 Tema 1 Introduccin a Python4 Tema 1 Introduccin a Python

1 1

MANEJO BSICO DE PYTHON

En esta introduccin veremos algunos aspectos generales relacionados conel uso del intrprete, as como las caractersticas bsicas del lenguaje, sin entraren los aspectos relativos a la instalacin en una plataforma determinada. Estasnotas estn creadas en un sistema GNU/Linux, por lo que es posible queel lector encuentre diferencias poco signicativas en cuanto al uso en otrasplataformas.

En Python podemos trabajar de dos formas distintas: a travs de la consolao mediante la ejecucin de scriptso guionesde rdenes. El primer mtodo esbastante til cuando queremos realizar operaciones inmediatas y podemoscompararlo con el uso de una calculadora avanzada. El uso de scriptsderdenes corresponde a la escritura de cdigo Python que es posteriormenteejecutado a travs del intrprete.

Para iniciar una consola Python bastar escribir la orden pythonen unaterminal, obtenindose algo por el estilo:

P yt ho n 2 .7 .3 ( de fa ul t , J an 2 2 01 3 , 1 6: 53 :0 7)

[ G CC 4 .7 .2 ] o n l in ux 2

T yp e " h el p ", " c o py r ig ht " , " c re di t s " o r " l ic en s e " f or m or e

information.

>>>

que nos informa de la versin que tenemos instalada y nos seala el prompt>>> del sistema, el cual indica la situacin del terminal a la espera de rdenes.

Podemos salir con la orden exit()o pulsando las teclas Ctrl+D.Una vez dentro del intrprete podemos ejecutar rdenes del sistema, por

ejemplo

>>> print "Hola Mundo"

Hola Mundo

>>>

Obviamente la orden printimprime la cadena de textoo string Hola Mundoque va encerrada entre comillas para indicar precisamente que se trata de unstring. Una vez ejecutada la orden el sistema vuelve a mostrar elprompt.

La otra alternativa a la ejecucin de rdenes con Python es la creacin deunscript. Se trata de un archivo de texto en el que listamos las rdenes Pythonque pretendemos ejecutar. Para la edicin del archivo nos vale cualquier editorde texto sin formato. Escribiendo el comando

print "Hola Mundo"

en un archivo,2 lo salvamos con un nombre cualquiera, por ejemplo hola.py.Podemos ejecutar el cdigo sencillamente escribiendo en una consola la orden

2Para diferenciar la escritura de rdenes en el intrprete de los comandos que introduci-remos en los archivos los ilustraremos con fondos de diferente color.


5/118

1.1 Manejo bsico de Python 5

python hola.py(obviamente situndonos correctamente en el patho rutadonde se encuentre el archivo). Tambin es posible hacer ejecutable el cdigoPython escribiendo en la primera lnea del archivo3

#!/usr/bin/env python

y dando permisos de ejecucin al archivo con la orden chmod a+x hola.pydesde una consola. En tal caso podemos ejecutarlo escribiendo ./hola.pyenuna consola.

Se pueden utilizar codicaciones diferentes de la ASCII4 en los scriptsdePython aadiendo justo detrs del shebangla lnea

# -* - c od in g : c o di f ic ac i n -* -

donde codicacinse reere al cdigo de caracteres que empleemos (tpica-mente utf-8). El empleo de caracteres no ASCII en un scriptsin esta lneaproduce errores.

Cuando queremos escribir una orden de longitud mayor a una lnea debe-mos usar el carcter de escape \, tanto en el intrprete como en los scripts:

>>> print " est o es un a or de n \

... de m s de una l ne a"

e st o es un a o rd en de m s de u na l n ea

> > > 1 5 - 2 3 + 3 8 \

... -20 + 10

20

Aunque en el caso de operaciones aritmticas, la apertura de un parntesishace que no resulte obligatorio el carcter de escape:

>>> (24 + 25

... - 3 4)

15

1 1 1 La consola IPython

En lugar del intrprete Python habitual existe una consola interactivadenominada IPython con una serie de caractersticas muy interesantes quefacilitan el trabajo con el intrprete. Entre ellas podemos destacar la presenciadeautocompletado, caracterstica que se activa al pulsar la tecla de tabulaciny que nos permite que al teclear las primeras letras de una orden aparezcantodas las rdenes disponibles que comienzan de esa forma. Tambin existe unoperador ?que puesto al nal de una orden nos muestra una breve ayuda

acerca de dicha orden, as como acceso al historial de entradas recientes conla tecla3Esto es lo que se conoce como el shebang, y es el mtodo estndar para poder ejecutar

un programa interpretado como si fuera un binario.4Es decir, codicaciones que admiten caracteres acentuados.


6/118


De forma idntica a la apertura de una consola Python, escribiendoipythonen un terminal obtenemos:

P yt ho n 2 .7 .3 ( de fa ul t , J an 2 2 01 3 , 1 6: 53 :0 7)T yp e " c o py ri g ht " , " c r ed it s " o r " l i ce ns e " f or m or e i nf o rm a ti o n .

I P yt ho n 0 .1 3. 1 - - A n e nh an c ed I n te r ac t iv e P yt ho n .

? -> Introduction and overview of IPython 's features .

%quickref -> Quick reference.

help -> Python 's own help system .

o bj ec t ? - > D et ai ls a bo ut ' ob je ct ' , u se ' ob je ct ?? ' f o r e xt ra

details.

I n [ 1] :

Obsrvese que ahora el promptcambia, y en lugar de >>>aparece In [1]:.Cada vez que realizamos una entrada el nmero va aumentando:

I n [ 1] : 2 3* 2

Out[1]: 46

I n [ 2] :

Si como ocurre en este caso, nuestra entrada produce una salida Out[1]:

46, podemos usar la numeracin asignada para reutilizar el dato mediante lavariable _1,

In [2]: _1 + 15

Out[2]: 61

que hace referencia al valor almacenado en la salida [1]. O tambin

I n [ 3 ] : _ * 2 # _ h ac e r ef er en ci a a l lt im o v al or

Out[3]: 122

I n [ 4 ] : _ 2 + _Out[4]: 183

Adems, esta consola pone a nuestra disposicin comandos del entorno (cd,ls, etc.) que nos permiten movernos por el rbol de directorios desde dentrode la consola, y comandos especiales, conocidos como funciones mgicasqueproveen de funcionalidades especiales a la consola. Estos comandos comienzanpor el carcter % aunque si no intereren con otros nombres dentro delsistema se puede prescindir de este carcter e invocar slo el nombre delcomando. Entre los ms tiles est el comando run con el que podemosejecutar desde la consola un scriptde rdenes. Por ejemplo, para ejecutarel creado anteriormente:

I n [ 5] : r un h ol a . py

Hola Mundo


7/118

1.1 Manejo bsico de Python 7

Y entre otras varias posibilidades que no mencionaremos, tambin esposible salvar a un archivo de texto algunas de las entradas introducidas enla consola. Por ejemplo,

I n [ 6] : print "Primera lnea"

Primera lnea

I n [ 7] : print "Segunda lnea"

Segunda lnea

I n [ 8] : %s av e a rc hi vo 6 7

T he f o ll o wi ng c om ma n ds w er e w ri t te n t o file `archivo.py`:

print "Primera lnea"

print "Segunda lnea"

Y ahora, el chero archivo.pycontiene:

# c od in g : u tf - 8



El lector puede probar a escribir %y pulsar el tabulador para ver un listadode las funciones mgicas disponibles.

IPython Notebook

El IPython Notebook es una variacin de la consola IPython, que usa unnavegador web como interfaz y que constituye un entorno de computacinque mezcla la edicin de texto con el uso de una consola. Es una forma muyinteresante de trabajar con Python pues auna las buenas caractersticas dela consola IPython, con la posibilidad de ir editando las entradas las vecesque sean necesarias. Para correr el entorno hemos de escribir en una terminalla orden ipython notebook, lo que nos abrir una ventana en un navegadorweb, con un listado de los notebooksdisponibles y la posibilidad de navegaren un rbol de directorios. Los notebooksson cheros con extensin .ipynb

que pueden ser importados o exportados con facilidad al entorno web.Adems de las caractersticas mencionadas, los notebookspermiten aadir

texto en diversos formatos (LATEX inclusive) con los que disear pginasinteractivas con cdigo Python e informacin.

Entornos de Desarrollo Integrados

Los denominados IDE (Integrated Development Environment) son progra-mas que facilitan el desarrollo de cdigo incluyendo tpicamente un editorde cdigo fuente acompaado de una consola o herramientas de compilacin

automticas, y en ocasiones algn complemento de depuracin, o listado devariables presentes, etc. En el caso de Python, existen diversos entornos deeste tipo entre los que podemos citar IDLE, Stanis Python Editor,Eric IDE,NinJa IDE, Spyder, entre otros. Son herramientas interesantes para escribircdigo de forma ms cmoda que el uso aislado de un editor de texto.


8/118


1 2

ASPECTOS BSICOS DEL LENGUAJE

Python es un lenguaje dinmicamente tipado, lo que signica que lasvariables pueden cambiar de tipo en distintos momentos sin necesidad deser previamente declaradas. Las variables son identicadas con un nombre,que debe obligatoriamente comenzar por una letra y en el que se hace ladistincin entre maysculas y minsculas, y son denidas mediante el operadorde asignacin =.

1 2 1 Variables numricas

Veamos algunos ejemplos:

> >> a =2 # d ef in e un e nt er o

> >> b = 5. # d ef in e un n m er o r ea l

> >> c = 3+ 1 j # d e fi ne u n n me ro c o m pl ej o

> >> d =complex (3,2) # d ef in e u n n m er o c o mp le j o

Obsrvese la necesidad de poner un punto para denir el valor como real yno como entero, el uso de jen lugar de ien los nmeros complejos junto conla necesidad de anteponer un nmero, y el uso de la funcin complex. Ntese

tambin que la asignacin de una variable no produce ninguna salida.Podemos recuperar el tipo de dato de cada variable con la orden type,

>>> type (a)

>>> type (b)

>>> type (c)

Como vemos, Python asigna el tipo a cada variable en funcin de su denicin.Es importante resaltar la diferencia entre los tipos numricos, pues si no somoscuidadosos podemos caer en el siguiente error:

> >> a =5 ; b =2 # d e fi n ic i n m lt ip l e d e v a ri a bl es

> >> a + b

7

> >> a / b

2

Claramente a+bcalcula la suma de los valores de las variables, sin embargo

a/bparece que no calcula correctamente la divisin. En realidad la respuestaes correcta dado que ambas variables son enteros, y por tanto se realiza ladivisin entre enteros, que corresponde a la parte entera de la divisin. Si loque esperamos es obtener la divisin real debemos escribir al menos uno delos nmeros en forma real, lo que se hace con el comando float:


9/118

1.2 Aspectos bsicos del lenguaje 9

> >> a /float(b)

2. 5

Cuando Python opera con nmeros de distinto tipo, realiza la operacintransformando todos los nmeros involucrados al mismo tipo, segn una

jerarqua establecida que va de enteros a reales y luego a complejos:

> >> a = 3.

>>> b=2+3j

> >> c = a+ b # s um a d e r ea l y c om pl ej o

> >> c

(5+3j)

>>> type (c)

Los operadores aritmticos habituales en Python son:+(suma),-(resta),*(multiplicacin),/(divisin),**(potenciacin, que tambin se puede realizarcon la funcin pow), //(divisin entera), que da la parte entera de la divisinentre dos reales, y el operador % (mdulo), que proporciona el resto de ladivisin entre dos nmeros:

> >> a = 5. ; b = 3.

> >> a * *b # ab

125.0

>>> po w (a,b) # ab

125.0

> >> a / b

1.6666666666666667

> >> a / /b

1. 0

>>> in t (a)/in t (b)

1

>>> in t (a) % in t (b) # R es to d e la d iv is i n

2

Ntese el uso de la funcin de conversin a entero int.

1 2 2 Objetos

Python sigue el paradigma de la Programacin Orientada a Objetos(POO). En realidad, todo en Python es un objeto. Podemos entender unobjeto como un tipo especial de variable en la que no slo se almacena unvalor, o conjunto de valores, sino para el que tenemos disponible tambin unaserie de caractersticas y de funciones concretas, que dependern del objetoen cuestin.

Por ejemplo, si creamos un nmero complejo

>>> a=3+2j


10/118


estaremos creando un objeto para el cual tenemos una serie de propiedades,o en el lenguaje de la POO, de atributos, como pueden ser su parte real y suparte imaginaria:

> >> a .real

3. 0

> >> a .imag

2. 0

Los atributos son caractersticas de los objetos a las que se accede medianteel operador .de la forma objeto.atributo.

Cada tipo de objeto suele tener disponible ciertos mtodos. Un mtodo esuna funcin que acta sobre un objeto con una sintaxis similar a la de un

atributo, es decir, de la forma objeto.mtodo(argumentos). Por ejemplo, laoperacin de conjugacin es un mtodo del objeto complejo:

> >> a .conjugate ()

(3-2j)

Los parntesis indican que se trata de una funcin y son necesarios. Encaso contrario, si escribimos

> >> a .conjugate

el intrprete nos indica que se trata de un mtodo del objeto complejo, perono proporciona lo esperado.

Pulsando el tabulador despus de escribir objeto.en la consola IPython,sta nos muestra los atributos y funciones accesibles al objeto:

In [1 ]: a =complex (3,2)

In [2 ]: a . # P ul sa r < TA B >

a. conjugate a. imag a. real

1 2 3 Listas

Las listasson colecciones de datos de cualquier tipo (inclusive listas) queestn indexadas, comenzando desde 0:

>>> a=[1,2.,3+1j]

>>> type (a)

> >> a [ 1]

2. 0> >> a [ 3]

T ra c eb ac k ( m os t r ec en t c al l l as t ):

File "", li ne 1 , in

IndexError : list index o ut o f range


11/118


Hemos denido una lista encerrando sus elementos (de tipos diversos) entrecorchetes y separndolos por comas. Podemos acceder a cada uno de loselementos de la lista escribiendo el nombre de la lista y el ndice del elementoentre corchetes, teniendo en cuenta que el primer elemento tiene ndice 0.Ntese que el tercer elemento corresponde al ndice 2, y si intentamos accederal elemento a[3]obtenemos un error.

Si algn elemento de la lista es otra lista, podemos acceder a los elementosde esta ltima usando el corchete dos veces, como en el siguiente ejemplo:

>>> a =[1,2.,3+1j,[3,0]]

> >> a [ 3]

[3 , 0 ]

>>> a[3][1]

0

Las listas son estructuras de datos muy potentes que conviene aprender amanejar con soltura. Podemos consultar los mtodos a los que tenemos accesoen una lista usando el autocompletado en IPython:

In [ 2] : a . # P u l sa r < T AB >

a. append a. extend a. insert a. remove a. sort

a. count a. index a. po p a. reverse

El siguiente ejemplo muestra el funcionamiento de alguno de estos mtodos:

> >> a =[ 25 , 33 , 1 , 1 5, 3 3]

> >> a .append (0 ) # a gr eg a 0 al f in al

> >> a

[25 , 33 , 1 , 15 , 33 , 0]

> >> a .insert (3,-1) # i ns er ta -1 en la p os ic i n 3

> >> a

[25 , 33 , 1 , -1 , 15 , 33 , 0]

> >> a .reverse () # i nv ie rt e e l o rd en

> >> a

[0 , 33 , 15 , -1 , 1 , 33 , 25]

> >> a .pop () # e li mi na el lt im o e le me nt o y lo d ev ue lv e

25

> >> a

[0 , 33 , 15 , -1 , 1 , 33 ]

> >> a .pop (3 ) # e li mi na e l e le me nt o d e nd ic e 3

-1

> >> a

[0 , 33 , 15 , 1 , 33]

> >> a .extend ([10,20,30]) # a a de e le me nt os a la l is ta

> >> a

[0 , 33 , 15 , 1 , 33 , 10 , 20 , 30]> >> a .append ([10,20,30]) # a a de el a rg um en to a l a l is ta

> >> a

[0 , 33 , 15 , 1 , 33 , 10 , 20 , 30 , [10 , 20 , 30 ]]


12/118


Por otra parte, es frecuente que Python utilice los operadores aritmticoscon diferentes tipos de datos y distintos resultados. Por ejemplo, los operadoressuma y multiplicacin pueden aplicarse a listas, con el siguiente resultado:

>>> a=[1,2,3]; b=[10,20,30]

> >> a *3

[ 1 , 2 , 3 , 1 , 2 , 3 , 1 , 2 , 3 ]

> >> a + b

[1 , 2 , 3 , 10 , 20 , 30]

Esta ltima accin se podra haber obtenido usando el mtodo extend:

> >> a .extend (b)

> > > a

[1 , 2 , 3 , 10 , 20 , 30]

Ntese que el uso del mtodo hubiera sido equivalente a escribir a=a+b. Engeneral, el uso de mtodos proporciona mejor rendimiento que el uso de otrasacciones, pero hemos de ser conscientes de que el objeto sobre el que se aplicapuede quedar modicado al usar un mtodo.

Slicing

Una de las formas ms interesantes de acceder a los elementos de una listaes mediante el operador de corte o slicing, que permite obtener una parte delos elementos de una lista:

> > > a = [ 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0 ] # c re am o s u na l is ta

>>> a[2:5] # a cc ed e mo s a l os e l em en t os 2 ,3 , 4

[7 , 6 , 5]

Como vemos, el slicing[n:m]accede a los elementos de la lista desde nhastam(el ltimo sin incluir). Admite un parmetro adicional, y cierta exibilidaden la notacin:

>>> a[1:7:2] # desde 1 hasta 6, de 2 en 2

[8 , 6 , 4]>>> a[:3] # a l o mi ti r e l p ri me ro s e t om a d es de e l i ni ci o

[9 , 8 , 7]

>>> a[6:] # al o mi ti r el lt im o se t om a h as ta el f in al

[ 3 , 2 , 1 , 0 ]

Aunque el acceso a ndices incorrectos genera error en las listas, no ocurre lomismo con el slicing:

>>> a[:20]

[ 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0 ]

>>> a[12:15] # si no h ay e le me nt os , r es ul ta u na c ad en a v ac a

[]

En las listas, y por supuesto tambin con el slicing, se pueden usar ndicesnegativos que equivalen a contar desde el nal:


13/118


>>> a[-1] # -1 r ef ie re l a lt im a p os i ci n

0

>>> a[-5:-3]

[4 , 3 ]

>>> a[3:-3]

[ 6 , 5 , 4 , 3 ]

El slicingtambin permite aadir, borrar o reemplazar elementos en laslistas:

> > > a = [ 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0 ]

>>> a[1:3]=[] # b orr a e le me nt os 1 y 2

> >> a

[ 9 , 6 , 5 , 4 , 3 , 2 , 1 , 0 ]

>>> a[2:5]=[-1,-2, -3,-4] # r ee mp la za e le me nt os 2 a 4

> >> a

[9 , 6 , -1, -2 , -3 , -4 , 2 , 1 , 0]

>>> a[1:1]=[0,1,2] # a ad e la l is ta en la p os ic i n 1

> >> a

[9 , 0, 1, 2, 6, -1, -2, -3, -4, 2, 1, 0]

>>> a[:0]=a[-5:-1] # a a d im os a l i ni ci o

> >> a

[ -3, -4, 2, 1, 9, 0, 1, 2, 6, -1, -2, -3, -4, 2, 1, 0]

> >> a [:] = [] # v ac ia mo s l a l is ta

> >> a[]

1 2 4 Cadenas de caracteres

Las cadenasno son ms que texto encerrado entre comillas:

> >> a ="Hola"; b='mundo'

>>> print a

Hola

>>> print bmundo

>>> type (a)

en las que se puede comprobar que da igual denirlas con comillas simples odobles, lo que es til si queremos cadenas que incluyan estos caracteres:

> >> a =" E st o e s u na ' s tr in g ' "

>>> print a

E st o e s u na 'string'

Si queremos construir cadenas con ms de una lnea usamos la triplecomilla """:

> >> a =" "" E s to e s u n c ad en a

. .. m uy l ar ga q ue t ie ne


14/118


... muchas lineas"""

>>> print a

E st o es u n c ad en a

mu y lar ga qu e tien e

muchas lineas

Ntese que el intrprete aade automticamente unos puntos suspensivos(...) al pulsar la tecla enter.

En ocasiones es preciso incluir caracteres no ASCII en una cadena, para locual Python provee de soporte Unicode. Para sealar que una cadena poseecaracteres extraosusaremos el indicador ual comienzo de la misma (antesde las comillas). Por ejemplo

c ad en a = u ' 'En otros momentos, necesitaremos que la cadena de caracteres sea inter-

pretada tal cual (sin caracteres de escape), para lo cual usaremos una r(porraw string) precediendo a la cadena:

c ad en a = r'\LaTeX'

Podemos acceder a los elementos individuales de una cadena medianteindices, como si fuera una lista:

>>> cadena="Hola mundo"

>>> cadena[0]'H'

>>> cadena[4]

' '

>>> cadena[5]='M' # e rr or : la c ad en a n o es m od if ic ab le



TypeError : 'str' object does no t support item assignment

pero las cadenas son inmutables, esto es, no es posible alterar sus elementos(veremos este asunto ms adelante en la seccin ??). Eso signica que cual-

quier transformacin que llevemos a cabo con un mtodo no alterar la cadenaoriginal.

El slicingtambin funciona con las cadenas de caracteres

> >> a =" E st o e s u na c ad en a d e c a ra c te r es "

>>> a[:19]

' Es to es u na c ad en a '

>>> a[19:]

'de caracteres'

Hay una gran cantidad de mtodos para manejar stringsque permitencambiar la capitalizacin, encontrar caracteres dentro de una cadena o separarcadenas en trozos en funcin de un caracter dado. Emplazamos al lector a usarla ayuda en lnea del intrprete para aprender el funcionamiento de stos yotros mtodos.


15/118


1 2 5 Diccionarios

En algunas ocasiones es interesante disponer de listas que no estn indexa-

das por nmeros naturales, sino por cualquier otro elemento (stringshabitual-mente, o cualquier tipo de dato inmutable). Python dispone de losdiccionariospara manejar este tipo de listas:

>>> colores={'r': 'rojo', 'g': 'verde', 'b': 'azul'}

>>> type (colores)

>>> colores['r']

'rojo'

>>> colores['k']= 'negro' # a a di m os u n n ue vo e le m en to

>>> colores{'k': 'negro', 'r': 'rojo', 'b': 'azul', 'g': 'verde'}

Observar que el orden dentro de los elementos de la lista es irrelevante puesla indexacin no es numerada.

El objeto que se usa como ndice se denomina clave. Podemos pensarentonces en un diccionario como un conjunto no ordenado de pares, clave:valor donde cada clave ha de ser nica (para ese diccionario). Podemosacceder a ellas usando los mtodos adecuados:

>>> colores.keys () # c l av es

['k', 'r', 'b', 'g']>>> colores.values () # v a l or es

['negro', 'rojo', 'azul', 'verde']

Entre los diversos mtodos accesibles para un diccionario disponemos delmtodo popque permite eliminar una entrada en el diccionario:

>>> colores.po p ('b')

'azul'

>>> colores

{'k': 'negro', 'r': 'rojo', 'g': 'verde'}

1 2 6 Tuplas

Para terminar con los tipos de datos principales haremos mencin a lastuplas. Las tuplas son un tipo de dato similar a las listas (es decir, unacoleccin indexada de datos) pero que no pueden alterarse una vez denidas(son inmutables):

>>> a=(1,2.,3+1j,"hola")

>>> type (a)

> >> a [ 2]

(3+1j)

>>> a[0]=10. # e rr or : n o s e p ue de m od if ic ar u na t up la

T ra c eb a ck ( m os t r ec en t c al l l as t ):


16/118



TypeError : 'tuple' object does no t support item assignment

La denicin es similar a la de una lista, salvo que se usan parntesis en lugarde corchetes, y el acceso a los elementos es idntico. Pero como podemosobservar, no es posible alterar sus elementos ni tampoco aadir otros nuevos.

La tuplas son muy tiles para empaquetar y desempaquetar datos, comopuede verse en el siguiente ejemplo:

>>> a=1,2, 'hola' # c re am os u na t up la ( s in p a r n te s is ! )

>>> type (a)

> > > a

(1 , 2 , 'hola')

> > > x , y , z = a # d e se m pa q ue t am o s l a t up la e n v ar i ab le s x , y ,z

> > > x

1

> > > y

2

> > > z

'hola'

Atencin a la creacin de tuplas de un nico elemento:

> > > a = ( 1 )

> > > b = ( 1 , )> > > c = 1 ,

>>> p ri n t t y pe (a), type (b), type (c)

Como veremos luego, las tuplas son tiles para pasar un conjunto de datosa una funcin. Tambin estn detrs de la asignacion mltiple de variables:

> > > a = s , t , r = 1 ,'dos' ,[1,2,3]

> > > a

(1 , 'dos', [ 1 , 2 , 3 ] )

> > > t'dos'

que es particularmente til para intercambiar valores de variables:

>>> a,b=0,1

> >> b , a =a , b # i nt er ca mb ia mo s a y b

>>> print a, b

1 0

1 3

MDULOS

Una de las caractersticas principales de Python es su modularidad. Lamayora de funciones accesibles en Python estn empaquetas en mdulos,


17/118

1.3 Mdulos 17

que precisan ser cargados previamente a su uso, y slo unas pocas funcionesson cargadas con el ncleo principal. Por ejemplo, no se dispone de formainmediata de la mayor parte de funciones matemticas comunes si no seha cargado antes el mdulo apropiado. Por ejemplo, la funcin seno no estdenida:

>>> si n (3.)


File "", line 1 , in

NameError : n am e 'sin' is n ot defined

Si queremos poder usar sta u otras funciones matemticas debemosimportarel mdulo con la orden import:

>>> import math

Ahora tenemos a nuestra disposicin todas las funciones del mdulo matem-tico. Puesto que todo en Python es un objeto (incluidos los mdulos), el lectorentender perfectamente que el acceso a las funciones del mdulo se haga dela forma math.funcin:

>>> math .si n (3.)

0.1411200080598672

Para conocer todas las funciones a las que tenemos acceso dentro del

mdulo disponemos de la orden dir5

>>> di r (ma th )

['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin'

, 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', '

cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1

', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum',

'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', '

log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', '

sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

o tambin podemos usar el tabulador en IPython:I n [ 1] : import math

I n [ 2] : math . # P ul sa r < TA B >

mat h . acos math . degrees math . fsum math .pi

mat h . acosh math .e math. gamma math . po w

mat h . asin math .er f math . hypot math . radians

mat h . asinh math . erfc math . isinf math . si n

mat h . atan math .ex p math . isnan math . sinh

mat h . atan2 math . expm1 math . ldexp math . sqrt

mat h . atanh math . fabs math . lgamma math . ta n

mat h . ceil math . factorial math . lo g math . tanh

5Sin argumentos, la order dir() devuelve un listado de las variables actualmentedenidas.


18/118


mat h . copysign math . floor math . log10 math . trunc

mat h .co s math . fmod math . log1p

mat h . cosh math . frexp math .mo df

Una de las caractersticas ms apreciadas de Python es su extensa biblio-teca de mdulos que nos proveen de funciones que permiten realizar las tareasms diversas. Adems, esta modularizacin del lenguaje hace que los progra-mas creados puedan ser reutilizados con facilidad. Sin embargo, no suele serbien aceptada la necesidad de anteponer el nombre del mdulo para teneracceso a sus funciones. Es posible evitar el tener que hacer esto si cargamoslos mdulos del siguiente modo:

>>> from math import *

Ahora, si queremos calcular2, escribimos>>> sqrt (2 )

1.4142135623730951

Lgicamente, esta forma de cargar los mdulos tiene ventajas evidentes encuanto a la escritura de rdenes, pero tiene tambin sus inconvenientes. Porejemplo, es posible que haya ms de un mdulo que use la misma funcin,como es el caso de la raz cuadrada, que aparece tanto en el mdulo mathcomo en el mdulo cmath. De manera que podemos encontrarnos situaciones

como la siguiente:>>> import math

>>> import cmath

>>> math . sqrt (-1)



ValueError : math domain error

>>> cmath . sqrt (-1)

1j

Como vemos, hemos cargado los mdulos mathycmathy calculado la razcuadrada de1con la funcin sqrtque posee cada mdulo. El resultado esbien distinto: la funcin raz cuadrada del mdulo mathno permite el uso denmeros negativos, mientras que la funcin sqrtdel mdulo cmaths. Si enlugar de cargar los mdulos como en el ltimo ejemplo los hubisemos cargadoas:

>>> from cmath import *

>>> from math import *

qu ocurrir al hacer sqrt(-1)? Como el lector puede imaginar, la funcinsqrtdel mdulo cmathes sobreescrita por la del mdulo math, por lo queslo la ltima es accesible.

Existe una tercera opcin para acceder a las funciones de los mdulos queno precisa importarlo al completo. As,


19/118

1.3 Mdulos 19

>>> from cmath import sqrt

>>> from math import co s , si n

nos deja a nuestra disposicin la funcin raz cuadrada del mdulo cmathylas funciones trigonomtricas seno y coseno del mdulo math. Es importantesealar que con este mtodo de importacin no tenemos acceso a ningunaotra funcin de los mdulos que no hubiera sido previamente importada. Estaltima opcin es de uso ms frecuente en los scripts, debido a que con ellacargamos exclusivamente las funciones que vamos a necesitar y de esa formamantenemos el programa con el mnimo necesario de recursos.

En el uso de la consola interactiva es ms frecuente cargar el mduloal completo, y es aconsejable hacerlo sin el uso de *. De hecho, hay unaposibilidad adicional que nos evita tener que escribir el nombre del mduloal completo, seguido del punto para usar una funcin. Si realizamos unaimportacin del mdulo como sigue.

>>> import math as m

entonces no es necesario escribir math.para acceder a la funciones, sino

> >> m .cos (m.pi )

-1.0

1 3 1 Otros mdulos de inters

La cantidad de mdulos disponibles en Python es enorme, y en estas notasveremos con detenimiento algunos de ellos relacionados con la computacincientca. No obstante, conviene conocer algunos otros mdulos de la biblio-teca estndar que se muestran en la siguiente tabla:


20/118


Mdulo Descripcin

math Funciones matemticascmath Funciones matemticas con complejos

fractions Nmeros racionales

os Funcionalidades del sistema operativo

sys Funcionalidades del intrprete

re Coincidencia en patrones de cadenas

datetime Funcionalidades de fechas y tiempos

pdb Depuracinrandom Nmeros aleatorios

ftplib Conexiones FTP

MySQLdb manejo de bases de datos MySQL

smtplib Envo de e-mails

1 4

CONTROL DE FLUJO

1 4 1 Bucles

Una caracterstica esencial de Python es que la sintaxis del lenguaje imponeobligatoriamente que escribamos con cierta claridad. As, los bloques de cdigodeben ser obligatoriamente sangrados:

>>> for i i n r an ge (3):

.. . print i

.. .

0

1

2

La sintaxis de la ordenfores simple: la variableirecorre la lista generada porrange(3), nalizando con dos puntos (:) obligatoriamente. La siguiente lnea,comenzada por...por el intrprete, debe ser sangrada, bien con el tabulador,bien con espacios (uno es suciente, aunque lo habitual es cuatro). Al dejar lasiguiente lnea en blanco el intrprete entiende que hemos nalizado el buclefory lo ejecuta. En un scriptvolveramos al sangrado inicial para indicar eln del bucle.

Ntese que el bucle en Python corre a travs de la lista y no de los ndicesde sta, como se muestra en el siguiente ejemplo:

> >> a =[ 'hola','mundo']


21/118

1.4 Control de flujo 21

>>> fo r b in a:

.. . print b

.. .

hola

mundo

No es seguro modicar la lista sobre la que se est iterando dentro delbucle. En caso de querer hacerlo es preciso iterar sobre una copia.

Ya hemos visto que la funcin range(n)crea una lista de nmeros de nelementos, comenzando en 0. Pero es posible que el rango comience en otrovalor, o se incremente de distinta forma:

>>> range ( 5 , 1 0)

[ 5 , 6 , 7 , 8 , 9 ]>>> range (1 , 10 , 3)

[1 , 4 , 7]

>>> range ( - 10 , - 10 0 , - 30 )

[ - 10 , - 40 , - 70 ]

De igual modo que iteramos sobre una lista, puede hacerse sobre una tuplao un diccionario. En este ltimo caso, es posible acceder de varias formas:

>>> colores={'r': 'rojo', 'g': 'verde', 'b': 'azul'}

>>> fo r i in colores. keys () :

.. . print i,colores[i]

.. .

r r oj o

b a zu l

g v er de

o simultneamente, con mtodo el iteritems:

>>> fo r x,y in colores. iteritems () :

.. . print x,y

.. .

r r oj ob a zu l

g v er de

Ntese el uso de la coma con la orden print.

1 4 2 Condicionales

La escritura de sentencias condicionales es similar a la de los bucles for,usando el sangrado de lnea para determinar el bloque:

>>> if 5 %3 == 0:.. . print " 5 e s d iv is ib le e nt re 3 "

.. . elif 5 %2 == 0:

.. . print " 5 e s d iv is ib le p or 2 "

.. . else :


22/118


.. . print " 5 n o d iv is ib le ni po r 2 ni p or 3 "

.. .

5 no es div isib le ni por 2 ni por 3

>>>

La orden ifevala la operacin lgica el resto de la divisin de 5 entre 3es igual a cero; puesto que la respuesta es negativa, se ejecuta la segundasentencia (elif), que evala si el resto de la divisin de 5 entre 2 es igual acero; como esta sentencia tambin es negativa se ejecuta la sentencia else.Es posible poner todos los elifque sean necesarios (o incluso no ponerlos),y el bloque elseno es obligatorio.

En Python, al igual que C, cualquier nmero distinto de cero es verdadero,mientras que cero es falso. Las condiciones pueden ser tambin una cadenade texto o una lista, que sern verdaderas si tienen longitud no nula, y falsassi son vacas. Por su parte, los operadores de comparacinen Python son ==(igual), !=(distinto), >(mayor que), >=(mayor o igual que), > a,b=0,1 # I n ic i al i za c i n d e l a s uc es i n d e F ib o na cc i

2 >>> while b>> for n i n r an ge (2,10):

2 .. . fo r x i n r an ge (2,n):

3 .. . if n % x == 0: # si n es div isib le por x 4 .. . print n, ' es i gu al a ',x ,'*',n/x

5 .. . break

6 .. . else :

7 .. . print n, ' es p ri mo '


23/118

1.5 Funciones definidas por el usuario 23

8 .. .

9 2 es p rim o

10 3 es p rim o

11 4 es igual a 2 * 2

12 5 es p rim o

13 6 es igual a 2 * 3

14 7 es p rim o

15 8 es igual a 2 * 4

16 9 es igual a 3 * 3

El breakde la lnea 5 interrumpe la bsqueda que hace el bucle que comienzaen la lnea 2. Si este bucle naliza sin interrupcin, entonces se ejecuta elbloque elsede la lnea 6.

Por ltimo, Python dispone tambin de la ordenpassque no tiene ningunaaccin, pero que en ocasiones es til para estructurar cdigo que an no hasido completado, por ejemplo

fo r n i n r an ge (10):

if n % 2 == 0:

print " n es pa r"

else:

pass # y a v e re mo s q u h ac em os a qu

1 5

FUNCIONES DEFINIDAS POR EL USUARIO

Las funciones son trozos de cdigo que realizan una determinada tarea.Vienen denidas por la orden defy a continuacin el nombre que las deneseguido de dos puntos. Siguiendo la sintaxis propia de Python, el cdigo dela funcin est sangrado. La principal caracterstica de las funciones es que

permiten pasarles argumentos de manera que la tarea que realizan cambia enfuncin de dichos argumentos.

>>> de f fibo(n): # s uc es i n d e F ib on ac ci h as ta n

... a,b=0 ,1

.. . while b>> fibo(100) # l la ma da a l a f u nc i n c on n =1 00

1 1 2 3 5 8 13 21 34 55 89

>>> fibo(1000) # l la ma da a l a f u nc i n c on n = 10 00 1 1 2 3 5 8 1 3 2 1 3 4 5 5 8 9 1 4 4 2 3 3 3 7 7 6 1 0 9 8 7

Como puede verse, esta funcin imprime los trminos de la sucesin deFibonacci menores que el valor nintroducido.


24/118


Si quisiramos almacenar dichos trminos en una lista, podemos usarla orden returnque hace que la funcin pueda devolver algn valor, si esnecesario:

1 >>> def fibolist(n): # l is ta de F ib on ac ci h as ta n

2 ... sucesion =[] # c r ea ci n d e l i st a v ac a

3 ... a,b=0 ,1

4 .. . while b>> fibolist(100)

10 [1 , 1 , 2 , 3 , 5 , 8 , 1 3, 21 , 34 , 55 , 89]11 >>> a=fibolist(250)

12 > > > a

13 [1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , 55 , 89 , 144 , 233]

A diferencia de la funcin fibodenida antes, la funcin fibolistde-vuelve la lista creada a travs de la orden return(lnea 7). Si returnno vaacompaado de ningn valor, se retorna None, al igual que si se alcanza elnal de la funcin sin encontrar return:

>>> a=fibo(50)

1 1 2 3 5 8 13 21 34

>>> print a

None

Si queremos devolver ms de un valor, lo podemos empaquetar en unatupla.

1 5 1 Importando funciones denidas por el usuario

Aunque las funciones pueden ser denidas dentro del intrprete para suuso, es ms habitual almacenarlas en un chero, bien para poder ser ejecutadasdesde el mismo, o bien para ser importadas como si se tratara de un mdulo.Por ejemplo, podemos denir una funcin matemtica y guardarla en unarchivo tang.py:

from math import si n ,cos ,pi

de f tangente(x):

if co s(x)!=0:

return sin (x)/co s (x)

else :

print " L a t an g en te e s i nf i ni ta "return

x=tangente(pi )

print ' La t an ge nt e de p i e s',x


25/118


Si ahora ejecutamos el archivo desde la consola:

$ p yt ho n t an g . py

L a t a ng en t e d e pi es -1.22460635382e-16

Aunque tambin podemos cargar la funcin tangente desde el intrprete comosi se tratara de un mdulo:

>>> import tang


>>> tang.tangente(3)

-0.1425465430742778

>>> tang.x

-1.2246063538223773e-16

> >> t an g .si n(tang.pi )1.2246063538223773e-16

> >> x



NameError : n am e 'x' is n ot defined

Ntese cmo al cargar el mdulo, ste se ejecuta y adems nos proporcionatodas las funciones y variables presentes en el mdulo (inclusive las importadaspor l), pero anteponiendo siempre el nombre del mdulo. Obsrvese que lavariable xno est denida, mientras que s lo est tang.x.

Si realizamos la importacin con *:> >> x = 5

>>> from tang import *


>>> tangente(pi /4 )

0.9999999999999999

> >> x

-1.2246063538223773e-16

tendremos todas las funciones presentes en el mdulo (salvo las que comiencen

por _) sin necesidad de anteponer el nombre, pero como podemos observaren el ejemplo, podemos alterar las variables propias que tengamos denidas,razn por la cual no recomendamos este tipo de importacin.

Finalmente si realizamos la importacin selectiva:

>>> from tang import tangente


>>> tangente(3)

-0.1425465430742778

> >> x



NameError : n am e 'x' is n ot defined

la funcin tangenteest disponible, pero nada ms. Aun as, obsrvese quese ha ejecutado el mdulo en el momento de la importacin. Para evitar que


26/118


el cdigo se ejecute cuando importamos podemos separar la funcin del restodel cdigo del siguiente modo:

from math import si n ,cos ,pide f tangente(x):

if co s(x)!=0:

return sin (x)/co s (x)

else :

print " L a t an g en te e s i nf i ni ta "

return

if __name__ == "__main__":

x=tangente(pi )

print ' La t an ge nt e d e p i es ',x

Lo que sucede es que cuando ejecutamos el cdigo con python tang.py,la variable __name__toma el valor '__main__', por lo que el fragmento nalse ejecuta, lo que no ocurre si lo importamos.

Es importante resaltar que por razones de eciencia, los mdulos se im-portan una sola vez por sesin en el intrprete, por lo que si son modicadoses necesario reiniciar la sesin o bien volver a cargar el mdulo con la ordenreload(mdulo).

Dnde estn los mdulos?

Cuando se importa un mdulo de nombre tang el intrprete busca unchero tang.pyen el directorio actual o en la lista de directorios dados porla variable PYTHONPATH. Si dicha variable no est congurada, o el chero nose encuentra all, entonces se busca en una lista de directorios que dependede la instalacin que se tenga. Podemos acceder a esta lista con la variablesys.pathdel mdulo sys.

Documentando funciones

Se puede documentar una funcin en Python aadiendo una cadena dedocumentacin justo detrs de la denicin de funcin:

de f mifuncion(parametro):

" "" E s ta f un ci n n o h ac e n ad a .

Absolutamente nada

"""pass

En tal caso, la funcin help(mifuncion)o escribiendo mifuncion?en IPyt-hon nos mostrar la documentacin de la funcin.


27/118


1 5 2 Argumentos de entrada

Es posible denir funciones con un nmero variable de argumentos. Una

primera opcin consiste en denir la funcin con valores por defecto:de f fibonacci(n,a=0,b=1):

sucesion=[]

while b>> de f media(*valores):

.. . if l en ( v a lo re s ) = = 0 : # le n = l on gi tu d de la t upl a

.. . return 0. 0

.. . else :.. . su m = 0.

.. . fo r x in valores:

.. . su m += x # equivale a sum = sum + x

.. . return su m / le n (valores)

.. .

>>> media(1,2,3,4,5,6)

3. 5

>>> media(3,6,7,8)

6. 0

La funcin calcula el valor medio de un nmero indeterminado de valoresde entrada que son empaquetados con el argumento *valoresen una tupla.

Si la funcin tiene adems argumentos por defecto, entonces podemosempaquetar la llamada a travs de un diccionario:


28/118


>>> def funarg(obligatorio,*otros,**opciones):

.. . print obligatorio

.. . print '-'*4 0

.. . print otros

.. . print '*'*4 0

.. . print opciones

.. .

>>> funarg("otro" ,2,3,4)

otro

----------------------------------------

(2 , 3 , 4)

****************************************

{}

>>> funarg("hola",a=2,b=4)hola

----------------------------------------

()

****************************************

{'a': 2, 'b': 4}

>>> funarg("hola","uno","dos","tres",a=2,b=3,c='fin')

hola

----------------------------------------

('uno', 'dos', 'tres')

****************************************{'a': 2, 'c': 'fin', 'b': 3}

No slo la denicin de funcin permite el empaquetado de argumentos,sino tambin es posible usarlo en las llamadas. Por ejemplo, la funcin mediadenida antes se puede llamar de la forma

>>> media(*range (1,11))

5. 5

o en la funcinfibonacci

,> >> d ={ 'a ':5 , 'b':3 }

>>> fibonacci(50,**d)

[3 , 8 , 11 , 19 , 30 , 49]

>>> c=(2,3)

>>> fibonacci(50,*c)

[3 , 5 , 8 , 13 , 21 , 34]

1 5 3 Funciones lambda

Las funcioneslambdason funciones annimas de una sola lnea que puedenser usadas en cualquier lugar en el que se requiera una funcin. Son tiles parareducir el cdigo, admiten varios parmetros de entrada o salida y no puedenusar la orden return:


29/118


> > > f = lambda x , y: ( x +y , x * *y )

>>> f(2,3)

(5 , 8 )

Son especialmente tiles si se quiere devolver una funcin como argumentode otra:

>>> import math

>>> de f seno(w):

.. . r e tu r n l a mb d a t: math .sin (t*w)

.. .

>>> f=seno(mat h .pi ); g=seno(2*ma th .pi )

> >> f ( .5 ) , g ( .5 )

(1.0, 1.2246063538223773e-16)

1 5 4 Variables globales y locales

Las variables globales son aqullas denidas en el cuerpo principal delprograma, mientras que las variables locales son aquellas variables internasa una funcin que slo existen mientras la funcin se est ejecutando, y quedesaparecen despus. Por ejemplo,

>>> de f area_rectangulo(lado):

... area =lado *lado

.. . print area

.. .

>>> area_rectangulo(3)

9

>>> print area



NameError : n am e 'area' i s n ot defined

observamos en este ejemplo que la variableareano se encuentra en el espaciode nombres por tratarse de una variable local de la funcin area_rectangulo,

es por tanto una variable local de la funcin. Qu ocurre si denimos estavariable previamente?

>>> area=10

>>> de f area_rectangulo(lado):


.. . print area

.. .


9

>>> print area

10

Como vemos, la variableareaahora s existe en el espacio de nombres global,pero su valor no se ve alterado por la funcin, pues sta ve su variable areade manera local.


30/118


Y si tratamos de imprimir el valor de areaantes de su evaluacin?

>>> area=10

>>> def area_rectangulo(lado):.. . print area


.. .




File "", li ne 2 , in area_rectangulo

UnboundLocalError: l oc al v ar ia b le 'area' referenced before

assignment

Entonces obtenemos un error debido a que intentamos asignar de manera localuna variable que se reconoce como global.Cualquier variable que se cambie o se cree dentro de una funcin es local,

a menos que expresamente indiquemos que esa variable es global, lo que sehace con la orden global:

>>> area=10

>>> def area_rectangulo(lado):

.. . global area

.. . print area


.. . print area

.. .


10

9

>>> print area

9

No obstante, las variables que son mutables puede ser alteradas en elcuerpo de una funcin de manera global sin necesidad de ser declaradas como

globales. Obsrvese el siguiente ejemplo:>>> def fun(a,b):

... a. append (0)

... b=a+b

.. . print a,b

.. .

> >> a = [1 ]; b = [0 ]

>>> fun(a,b)

[1 , 0] [1 , 0 , 0]

>>> print a,b

[1 , 0] [ 0]>>> fun(a,b)

[ 1 , 0 , 0 ] [ 1 , 0 , 0 , 0 ]

>>> print a,b

[1 , 0 , 0] [0]


31/118

1.6 Entrada y salida de datos 31

La funcin funusa el mtodo appendpara agregar el elemento 0a la lista a,y este mtodo modica la lista que ya existe de manera global. Por su parte,la asignacin que hacemos en b=a+bcrea una nueva varible local bdentro dela funcin, que no altera a la variable local bde fuera de ese espacio.

Por ltimo sealar que las variables del espacio global se pueden usar en ladenicin de parmetros por defecto, pero son evaluadas slo en la denicinde la funcin, y no en las llamadas:

> >> a = 2

>>> de f pot(x,y=a):

.. . return x**y

.. .

>>> pot(2), pot(2,3)(4 , 8 )

> >> a = 4

>>> pot(2)

4

1 6

ENTRADA Y SALIDA DE DATOS

Es habitual que nuestros programas necesiten datos externos que deben serpasados al intrprete de una forma u otra. Tpicamente, para pasar un datoa un programa interactivamente mediante el teclado (la entrada estndar)podemos usar la funcin raw_input

>>> raw_input ('Introduce algo\n') # \ n s al ta de l n ea

Introduce algo

h ol a 2 # i n tr o du c id o p or t ec la do

' h ol a 2 '

Obsrvese que la entrada estndar es convertida a una cadena de caracteres,que probablemente deba ser tratada para poder usar los datos introducidos.

En un scriptes ms frecuente el paso de parmetros en el momento dela ejecucin. Para leer los parmetros introducidos disponemos de la funcinargvdel mdulosys. Por ejemplo, si tenemos el siguiente cdigo en un archivollamado entrada.py

import sy s

print sys . argv

entonces, la siguiente ejecucin proporciona:

$ p yt ho n e nt ra da . py 2 2 5 " h ol a "

['entrada.py', '2', '25', 'hola']

Como vemos, sys.argvalmacena en una lista todos los datos de la llamada,de manera que es fcil manejarlos teniendo presente que son considerados


32/118


como cadenas de caracteres, por lo que es probable que tengamos que realizaruna conversin de tipo para tratarlos correctamente.

Por ejemplo, si tenemos el archivo fibo.py

con el siguiente contenido# -* - c od in g : utf - 8 -* -

import sy s

de f fibonacci(n,a=0,b=1):

" "" T rm in os d e l a s uc es i n d e F ib o na c ci h as ta o rd en n .

"""

sucesion=[]

while b

x=int(sy s . argv [1])

IndexError : l is t index o ut o f r an ge

La salida estndar (a pantalla) se realiza como ya hemos visto con la ordenprint. Para impresiones sencilllas nos bastar con concatenar adecuadamentecadenas de caracteres:

> >> x =3 ; y =4

>>> print " El valor de 'x ' es " + st r ( x ) + " y e l d e ' y ' e s "

+ st r(y)

E l v al or d e 'x' e s 3 y e l d e 'y' es 4

donde es preciso convertir el entero a stringcon la funcin str. Algunosmtodos para los strings, como por ejemplo ljusto rjustpermiten mejorarla salida:

>>> for x i n r an ge (5):.. . p r in t s tr (x**2).ljust (2), st r(x**3). rjust (3 )

.. .

0 0

1 1


33/118


34/118


>>> print f. read ()




El mtodo readdel objeto archivo lee el archivo al que referencia el objetocreado. Si se le proporciona un argumento numrico entonces lee un nmerodeterminado de bytesdel archivo;6 cuando es llamado sin argumento, lee elarchivo al completo. Cada llamada a readmueve el puntero de lectura delarchivo la ltimo lugar ledo, de manera que la llamada siguiente lee a partirde ah. Por eso:

> >> f .read ()

''

produce una cadena vaca, pues el puntero se halla al nal del archivo.Podemos usar el mtodoseekpara situarnos en cualquier posicin del archivo.

> >> f .seek (0 ) # V am os a l i ni ci o d el a rc hi vo

> >> f .read ()

'# coding: utf -8\nprint "Primera l\xc3\xadnea"\nprint "Segunda

l\xc3\xadnea"'

Ntese la diferencia entre la orden y la impresin: la cadena que contiene

el archivo es leda en formato de representacin interna, que diere de larepresentacin que se muestra con la orden print.Tambin es posible leer lnea a lnea con readline

> >> f .seek (0 )

> >> f .readline ()

' # c od in g : u tf - 8 \ n '

>>> print f. readline ()


> >> f .readline ()

'print "Segunda l\xc3\xadnea"'

o conf.readlines()que almacena cada una de las lneas del archivo en unalista:

> >> f .seek (0 )

>>> for x in f. readlines () :

.. . print x,

.. .


print "Primera lnea"print "Segunda lnea"

Otra opcin an ms cmoda es iterar sobre el propio objeto:

6Un bytepuede considerarse un carcter, aunque hay caracteres que ocupan ms de uno.


35/118

1.6 Entrada y salida de datos 35

> >> f .seek (0 )

>>> fo r x in f:

.. . print x,

.. .




Para cerrar un archivo usaremos el mtodo close:

f. close () # c er ra mo s el a rc hi vo v in cu la do al o bj et o f

La escritura en un archivo se lleva a cabo con el mtodo write. Para elloes necesario que el archivo se abra en modo escritura (o lectura/escritura):

> >> f =open ('hola.py','w ') # s l o e s cr it u ra ( n ue vo a rc hi vo )

>>> fo r x in ['primera','segunda','tercera']:

... f. write(x+'\n')

.. .

> >> f .read ()



IOError : F il e n ot o pe n f or reading

Al haber abierto el archivo en modo slo escritura, no podemos leer. Ser

preciso volver a abrir:> >> f .close ()

> >> f =open ('hola.py','r+') # l ec t ur a y e sc r it ur a

>>> print f. read ()

primera

segunda

tercera

> >> f .write('cuarta\n')

> >> f .seek (0 )

> >> f .readlines ()

['primera\n', 'segunda\n', 'tercera\n', 'cuarta\n']

Podemos escribir en cualquier punto del archivo si nos situamos correctamentecon el mtodo seek, el cual permite usar adems un parmetro adicional quenos indica desde dnde nos movemos (0 desde el inicio por defecto si seomite, 1desde la ltima referencia, 2desde el nal):

> >> f .seek (8 ) # n os c ol oc am os en la p os ic i n 8

> >> f .read (7 ) # l ee mo s 7 b yt es

'segunda'

> >> f .seek (9,1) # p o si ci n 9 d es de l a lt im a r e fe r en c ia

> >> f .read (6 ) #'cuarta'

> >> f .seek (-7,2) # p os ic i n -7 d es de e l f in al

> >> f .read (6 )

'cuarta'


36/118


Tambin disponemos del mtodo tellque nos indica con un entero la posicinen la que se encuentra el puntero del archivo.

La escritura con writetambin se puede hacer en pantalla si la usamoscomo un objeto tipo archivo con el atributo stdoutdel mdulo sys:

>>> import sy s

> >> g =sy s. stdout

> >> g .write('Hola mundo\n')

Hola mundo

lo que puede ser til para programar las salidas por pantalla durante laelaboracin de cdigo con write, de modo que cuando queramos direccionarla salida a un archivo slo necesitamos cambiar la salida.

1 7

MS SOBRE ESTRUCTURAS DE DATOS

1 7 1 Listas por comprensin

El lenguaje Python se adapta muy bien a la creacin de listas construidas apartir de otras mediante algn mecanismo que las modique. Veamos algunosejemplos:

> >> a =range (5 ) # l is ta i ni ci al

> >> [ x ** 2 fo r x in a] # c ua dr ad os d e l os e le me nt os d e a

[ 0 , 1 , 4 , 9 , 1 6 ]

>>> [[x**2,x**3] fo r x in a]

[[0 , 0] , [1 , 1] , [4 , 8] , [9 , 27] , [16 , 64 ]]

> > > a = range (10)

> >> [ x ** 3 fo r x in a if x %2 == 0] # c ub o de los m l ti pl os de 2

[0 , 8 , 64 , 216 , 51 2]

> >> a =[ x fo r x i n r an ge (1,7) if x %2==0]

> > > a[2 , 4 , 6]

b=[x fo r x i n r an ge (1,7) if (x+1) %2==0]

> > > b

[1 , 3 , 5]

> >> [ x *y fo r x in a fo r y in b] # r e co rr e mo s d os l is ta s

[2 , 6 , 1 0, 4 , 1 2, 20 , 6 , 1 8, 30]

>>> [a[i]*b[i] for i i n r an ge (le n(a))]

[2 , 12 , 3 0]

El ltimo ejemplo se puede construir de forma ms pythonic7 con la ordenzipque permite iterar sobre dos o ms secuencias al mismo tiempo:

7En el mundo de la programacin en Python se suele usar este adjetivo para referirse auna forma de escribir cdigo que usa las caractersticas propias y peculiares del lenguajePython que auna sencillez, brevedad, elegancia y potencia.


37/118

1.7 Ms sobre estructuras de datos 37

> >> [ x *y fo r x,y i n z ip(a,b)]

[2 , 1 2, 3 0]

En una lista, podemos obtener simultneamente el ndice de iteracin yel elemento de la lista con la orden enumerate. El lector podr imaginar elresultado del siguiente ejemplo:

a= range ( 10 ) ; a .reverse ()

[x*y fo r x,y i n e n um e r at e(a)]

En realidad enumeratees lo que se denomina un iterador, es decir, un ob-jeto sobre el que se pueden recorrer sus elementos. Otro iterador es reversedque como parece lgico, crea un iterador con el orden inverso. As, el ltimoejemplo equivale a

[x*y fo r x,y i n e n um e r at e( reversed ( range (10)))]

1 7 2 Copia y mutabilidad de objetos

Hemos mencionado anteriormente que las tuplas y las cadenas de carac-teres son objetos inmutables, mientras que las listas son mutables. Debemosaadir tambin que los diferentes tipos de nmeros son inmutables y los diccio-narios son mutables. Ahora bien, qu signica exactamente que los nmeros

sean inmutables? Quiere decir que no los podemos modicar?En realidad estas cuestiones estn relacionadas con el modo en el quePython usa las variables. A diferencia de otros lenguajes, en los que unavariable esencialmente referencia una posicin en memoria, cuyo contenidopodemos modicar, en Python, una variable en realidad no es ms que unareferencia al objeto, no contiene su valor, sino una referencia a l. Lo podemosver con un sencillo ejemplo; la orden idnos muestra el identicador de unobjeto, que bsicamente es la direccin de memoria en la que se encuentra. Siescribimos:

> > > x = 5 # x a pu nt a al o bje to 5 >>> id (x)

160714880

lo primero que hace Python es crear el objeto 5, al que le asigna la variablex. Ahora entenderemos por qu ocurre lo siguiente:

> >> y = 5 # y a pu nt a al o bj et o 5

>>> id (y)

160714880

No hemos creado un nuevo objeto, sino una nueva referencia para el mismoobjeto, por lo que tienen el mismo identicador. Lo podemos comprobar conla orden is:

> >> x is y

True


38/118


Qu ocurre si alteramos una de las variables?

>>> x = x + 2 # x a pu nt a a l o b je to 7

>>> id (x)160714856

vemos que el identicador cambia. Python evala la expresin de la derecha,que crea un nuevo objeto, y a continuacin asigna la variablexal nuevo objeto,por eso sta cambia de identicador. Obsrvese que:

>>> id (7 )

160714856

y ahora:

> > > x is y

False

Con las listas pasa algo similar, salvo que ahora est permitido modicarel objeto (porque son mutables), por lo que las referencias hechas al objetocontinuarn apuntado a l:

>>> a=[1,2]

>>> id (a) # i d en t if i ca d or d el o bj et o

3074955372L>>> a[0]=3 # m od i fi c am o s e l p ri me r e le me n to

> > > a

[3 , 2]

>>> id (a) # e l i de n ti f ic a do r n o c am bi a

3074955372L

La Ldel identicador se reere al tipo de entero que devuelve (long).La consecuencia de que las listas sean mutables se puede ver en el siguiente

ejemplo:

> >> x =range (3 )> >> y = x # y r ef er en ci a lo m ism o que x

>>> x[:0]=x # m od i fi c am o s x

> > > y # y t am bi n se m od if ic a

[ 0 , 1 , 2 , 0 , 1 , 2 ]

Sin embargo,

>>> x=x+[3] # n u e vo o bj et o

> > > y

[ 0 , 1 , 2 , 0 , 1 , 2 ]

Por qu no se ha modicadoyen este caso? La respuesta es que se ha creadoun nuevo objeto, al que se referencia con x, por lo quexya no apunta al objetoanterior, pero s y. Cmo podemos entonces copiar una lista? Podemos paraello usar el slicing:


39/118

1.8 Excepciones 39

> > > x = range (10)

> > > y = x [ : ] # copiam os x a y

>>> id (x), id (y)

(3074955372L, 3075028972L)

1 8

EXCEPCIONES

Para evitar los errores en el momento de la ejecucin Python disponede las secuencias de control try-except, que hacen que, en caso de que seproduzca una excepcin, sta pueda ser tratada de manera que la ejecucin

del programa no se vea interrumpida. Por ejemplo, supongamos que tenemosla siguiente situacin:

fo r a in [1,0]:

b=1/a

print b

Obviamente, la ejecucin de estas lneas producir una excepcin:

1



ZeroDivisionError: integer division or m od ul o b y z er o

Para evitarla, hacemos uso de las rdenes tryy exceptdel siguiente modo:

fo r a in [1,0]:

tr y :

b=1/a

except :

print " Se h a p r od uc i do u n e rr or "

b=0

print b

cuyo resultado es

1

S e h a p ro du ci do u n e rr or

0

El funcionamiento de estas sentencias es simple: el fragmento de cdigo dentrode la orden trytrata de ejecutarse; si se produce una excepcin, se salta alfragmento de cdigo correspondiente a la orden except, y ste se ejecuta. Deeste modo, el programa no se ve interrumpido por el error.

La orden except admite mayor sosticacin, pues permite tratar cadaexcepcin en funcin de su tipo. Podemos verlo en el siguiente ejemplo:

fo r a in [0 ,'1']:

tr y :


40/118


b=1/a

except ZeroDivisionError :

print " D i vi si n p or c er o "

b=0

except TypeError :

print "Divisin invlida"

b=1

print b

produce:

Divisin por cero

0

Divisin invlida

1

1 9

EJERCICIOS

E.1 Cul de las siguientes rdenes produce un error y por qu?

(a) a = complex(3,1)

(b) a = complex(3)+ complex(0,1)

(c) a = 3 + j

(d) a = 3+(2-1)j

E.2 Cul de las siguientes sentencias producir un error y por qu?

(a) a = [1,[1,1,[1]]]; a[1][2]

(b) a = [1,[1,1,[1]]]; a[2]

(c) a = [1,[1,1,[1]]]; a[0][0]

(d) a = [1,[1,1,[1]]]; a[1,2]

E.3 Dada la cadena s = 'Hola mundo', encuentra el mtodo adecuado deproducir las cadenas separadas a = 'Hola'y b = 'mundo'.

E.4 Explica el resultado del siguiente cdigo:

s=0

fo r i i n r an ge (100):

s + = iprint s

Usa el comando sumpara reproducir el mismo resultado en una lnea.

E.5 Usa el comando rangepara producir las listas


41/118

1.9 Ejercicios 41

(a) [10, 8, 6, 4, 2, 0]

(b) [10, 8, 6, 4, 2, 0, 2, 4, 6, 8, 10]

E.6 Calcula100i=1

1i

E.7 Calcula la suma de los nmeros pares entre 1 y 100.

E.8 Explica el resultado del siguiente cdigo:

s=[0]

fo r i i n r an ge (100):

s. append (s[i-1]+i)print s

E.9 Cmo puedes generar la siguiente lista:

[0, 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66, 78, 91, 105]

E.10 Utiliza la funcinrandintdel mdulo randompara crear una lista de100 nmeros aleatorios entre 1 y 10.

E.11 Construye el vigsimo elemento de la siguiente sucesin denida porrecurrencia:

un+3=un+2 un+1+ 3un, u0= 1, u1= 2, u3= 3.

E.12 Calcular la suma de todos los mltiplos de 3 o 5 que son menores que1000. Por ejemplo, la suma de todos los mltiplos de 3 o 5 que son menoresque 10 es: 3 + 5 + 6 + 9 = 23

E.13 Escribir una funcin reverseque acepte una cadena de caracteres ydevuelva como resultado la cadena de caracteres invertida en orden, es decir,el resultado de reverse('hola')debe ser 'aloh'.

E.14 Usando el Ejercicio E.13, escribir una funcin is_palindromoqueindentique palndromos, (esto es, palabras que ledas en ambas direccionesson iguales, por ejemplo radar). Es decir, is_palindromo('radar')deberadar como resultado True.

E.15 El Documento Nacional de Identidad en Espaa es un nmero naliza-do con una letra, la cual se obtiene al calcular el resto de la divisin de dicho

nmero entre 23. La letra asignada al nmero se calcula segn la siguientetabla:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

T R W A G M Y F P D X B N J Z S Q V H L C K E


42/118


Escribe un programa que lea el nmero por teclado y muestre la letra asignada.Por ejemplo, al nmero 28594978le debe corresponder la letra K. Tres lneasde cdigo debera ser sucientes.

E.16 Usando un bucle while escribe un programa que pregunte por unnmero por pantalla hasta que sea introducido un nmero impar mltiplo de3 y de 7 que sea mayor que 100.

E.17 Crea una lista aleatoria de nmeros enteros (usar Ejercicio E.10) yluego escribe un programa para que elimine los valores impares de dicha lista.

E.18 Escribir una funcin histogramaque admita una lista aleatoria denmeros enteros entre 1 y 5 (usar Ejercicio E.10) y elabore un diagrama defrecuencias de aparicin de cada uno de los elementos de la lista segn el

formato que sigue: por ejemplo, si la lista es[1, 4, 2, 1, 4, 4, 5, 5, 5, 3]

entonces la funcin debe imprimir:

1 **

2 *

3 *

4 * **

5 * **

E.19 Escribir una funcinmenorymayorque acepte un conjunto indetermi-nado de nmeros y obtenga el mayor y el menor de entre todos ellos. Es decir,la funcin debera hacer lo siguiente:

menorymayor (2 ,5 ,1 ,3 ,6 ,2 )

(1,6)

menorymayor (3 ,1 ,1 0 ,9 ,9 ,7 ,5 ,4 )

(1,10)

E.20 Escribir una funcin que acepte como parmetros dos valores ay b, yuna funcin ftal que f(a)f(b) < 0y que, mediante el mtodo de biseccin,devuelva un cero de f. La aproximacin buscada ser controlada por unparmetro que por defecto ha de ser104.

E.21 Considera la siguiente funcin:

de f media(*valores):

if l en( v a lo re s ) = = 0 : # l en = l on gi tu d de la t up la

return 0

else :

su m = 0

fo r x in valores:su m += x

return su m / le n (valores)

Explica por qu se obtiene el siguiente resultado:


43/118

1.9 Ejercicios 43

media (* range (1,5))

0

y corrgelo para que que proporcione el resultado correcto (2.5).E.22 Considera la funcin cuyo encabezado es el siguiente:

de f varios(param1 , param2 , *otros ,**mas):

El funcionamiento de la funcin es como sigue:

> >> v ar io s (1 , 2 )

1

2

> >> v ar io s (1 , 2 , 4 , 3)

1

2

****

** *

>>> varios(3,4,a=1,b=3)

3

4

-

---

Cul ser el resultado de la siguiente llamada?

varios(2,5,1,a=2,b=3)

Escribe el cdigo de la funcin.

E.23 Crea un chero de nombrehist.pyque incluya la funcinhistogramadel Ejercicio E.18. Luego crea un nuevo archivo Python de manera que acepteun nmeroncomo entrada, cree una lista aleatoria de nmeros enteros entre1y5de longitudn, y llame a la funcin histogramapara imprimir el recuentode cifras.


44/118


45/118

2NumPy y SciPy

NumPy y SciPy, que son los acrnimos de Numeric Pythony ScienticPython, respectivamente, son dos mdulos fundamentales para el clculocientco con Python. Con ellos se dispone de herramientas computacionalesy algoritmos matemticos de uso diverso que estn diseados para obtener unbuen nivel de rendimiento en la resolucin de una gran variedad de problemasde ndole cientco.

Hemos de tener en cuenta que en un lenguaje de programacin interpreta-do, como lo es Python, el acceso secuencial a estructuras que contengan unagran cantidad de datos afecta mucho al rendimiento de los programas. Por elloes imperativo evitar, en la medida de lo posible, el usar bucles para recorreruno a uno los elementos de una estructura de datos. En ese sentido, el mduloNumPy incorpora un nuevo tipo de dato, el array, similar a una lista, peroque es computacionalmente mucho ms eciente. El mdulo incorpora ade-ms una gran cantidad de mtodos que permiten manipular los elementos delarrayde forma no secuencial, lo que se denomina vectorizacin, y que ofreceun alto grado de rendimiento. Es por ello que los algoritmos programados en

el mdulo SciPy estn basados en el uso extensivo de arraysde NumPy.

2 1

ARRAYS

A diferencia de las listas, cuyos elementos pueden ser de cualquier tipo,un arrayde NumPy debe tener todos sus elementos del mismo tipo. Paradenirlo, ser necesario importar el mdulo, y usar la orden array:

>>> import numpy as np> >> a =np . array ([1.,3,6])

> >> a

array ([ 1. , 3., 6.])

45


46/118

46 Tema 2 NumPy y SciPy46 Tema 2 NumPy y SciPy46 Tema 2 NumPy y SciPy

Si aparecen elementos de distinto tipo, como es el caso, elarrayes denidosegn la jerarqua de tipos numricos existente. Como vemos, hemos denidoun arraycon un real y dos enteros, y ste se ha considerado como real. Elatributodtypenos lo conrma

>>> type (a)

> >> a .dtype

dtype ('float64')

Ntese que en NumPy, el tipo de datos numricos es un poco ms extenso,incluyendo reales en doble precisin (float64), simple precisin (float32),entre otros. Por defecto, el tipo floatde Python, corresponde a float64. Es

importante tener en cuenta el tipo con el que se dene un array, pues puedenocurrir errores no deseados:

> >> a =np . array ([1,3,5])

> >> a .dtype

dtype ('int32')

>>> a[0]=2.3 # L a m od if ic ac i n no e s l a e sp er ad a

> > > a

array ([ 2, 3 , 5 ])

Como el arrayes entero, todos los datos son convertidos a ese tipo. No

obstante, podemos cambiar de tipo todo el array,> >> a = a. astype ( float) # c am bi o d e t i po en n ue vo a rr ay

array ([ 2., 3., 5.])

>>> a[0]=3.6

> > > a

array ([ 3.6 , 3., 5.])

Para evitarnos el tener que cambiar de tipo lo ms sencillo es denirdesde el principio el arrayusando elementos del tipo deseado, o indicndoloexpresamente como en el siguiente ejemplo:

> >> a =np . array ([2,5,7],float )

> >> a .dtype

dtype ('float64')

Los arraystambin pueden ser multidimensionales:

> >> a =np . array ([[1.,3,5],[2,1,8]])

> > > a

array ([[ 1., 3., 5.] ,

[ 2., 1., 8.]])

y el acceso a los elementos puede hacerse con el doble corchete, o el doblendice:

> >> a [ 0] [2 ] , a [ 0 ,2 ]

(5.0, 5.0)


47/118

2.2 Funciones para creararrays 47

Tenemos diversos atributos y funciones para obtener informacin relevantedel array:

> >> a =np . array ([[1,3,5],[2,8,7]])> >> a .ndim # n m er o de e je s

2

> >> a .shape # d im en si on es d e l os e je s

(2 , 3 )

> >> a .size # n m er o t ot al d e e l em e nt os

6

>>> le n (a) # l on gi t ud d e l a p r im er a d im e ns i n

2

La orden innos permite saber si un elemento es parte o no de un array:

> >> 2 in a # el element o 2 est en a

True

> >> 4 in a # el element o 4 no est en a

False

2 2

FUNCIONES PARA CREAR ARRAYS

La orden arangees similar a range, pero crea un array:

>>> np . arange (10) # p or d ef ec to c om ie nz a e n 0

array ( [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] )

>>> np . arange (5,15) # n un ca i nc lu ye e l lt im o v al or

array ([ 5, 6, 7, 8, 9, 10, 11 , 12, 13, 14])

>>> np . arange (2,10,3) # p od em os e s pe c if ic a r u n p as o

array ( [2 , 5 , 8 ])

Esta orden tambin admite parmetros reales

>>> np . arange (1,3,0.1)array ([ 1. , 1.1 , 1.2 , 1.3 , 1.4 , 1.5 , 1.6 , 1.7 , 1.8 ,

1.9 , 2. , 2.1 , 2.2 , 2.3 , 2.4 , 2.5 , 2.6 , 2.7 , 2.8 ,

2.9])

tiles para dividir un intervalo en subintervalos de igual longitud. Ntese queel nal no se incluye. Si queremos dividir un intervalo con un nmero precisode subdivisiones, tenemos la orden linspace:

>>> np . linspace (0,1,10) # i nt er va lo ( 0, 1) e n 10 p un to s

array ([ 0. , 0.11111111 , 0.22222222 , 0.33333333 ,

0 .4 44 44 44 4 , 0 .5 55 55 55 6 , 0 .6 66 66 66 7 , 0 .7 77 77 77 8 ,0.88888889 , 1. ])

>>> np . linspace (0,1,10,endpoint = False) # s in e xt re mo f in al

array ([ 0. , 0.1 , 0.2 , 0.3 , 0.4 , 0.5 , 0.6 , 0.7 , 0.8 ,

0.9])


48/118

48 Tema 2 NumPy y SciPy48 Tema 2 NumPy y SciPy48 Tema 2 NumPy y SciPy

El parmetro opcional retstepnos devuelve adems la amplitud de cadasubintervalo:

>>> np . linspace (1,2,5,retstep = True )( array ([ 1. , 1.25 , 1.5 , 1.75 , 2. ]) , 0.25)

Con el mtodo reshapepodemos cambiar la forma de un array:

>>> np . arange (15).reshape (3,5) # c am bi o d e f or ma

array ([[ 0, 1, 2, 3, 4],

[ 5, 6, 7, 8, 9],

[1 0, 11 , 1 2, 13 , 1 4] ])

o tambin,

>>> np . arange (15).reshape (3,5,order='F')array ([[ 0, 3, 6, 9, 12] ,

[ 1, 4, 7, 10, 13] ,

[ 2, 5, 8, 11, 14]])

La opcin por defecto equivale a order='C'. Las iniciales 'C'y 'F'corres-ponden a los lenguajes C y FORTRAN, respectivamente, y se reeren al modoen el que estos lenguajes almacenan los datos multidimensionales.

El mtodo transposeen arraysbidimensionales es equivalente a la trans-posicin de matrices:

> >> a =np . arange (10). reshape (2,5)> >> a .transpose () # t r an s po s ic i n a . T t a mb i n e s v l id o

array ( [[ 0 , 5 ],

[ 1 , 6 ],

[ 2 , 7 ],

[ 3 , 8 ],

[ 4 , 9 ]] )

y con flattenobtenemos arraysunidimensionales:

> > > a

array ([[0 , 1 , 2 , 3 , 4] ,[5 , 6 , 7 , 8, 9]])

> >> a .flatten () # h ac em os 1 D f or f il as

array ( [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] )

> >> a .flatten ( order='F') # p or c ol u mn as ( e st il o F OR TR AN )

array ( [ 0 , 5 , 1 , 6 , 2 , 7 , 3 , 8 , 4 , 9 ] )

Ntese que todas estas funciones y mtodos crean nuevos objetos, es decir,no modican los existentes.

Las siguientes funciones son tiles para crear arraysde un tamao dado

(y reservar memoria en ese momento):> >> a =np . zeros (5 ) # ar ra y 1 D de 5 e le me nt os

> >> b =np . zeros ((2,4)) # a rr ay 2D , 2 f il as 4 c ol um na s

> >> c =np . ones(b. shape) # a rra y 2 D con un os

> > > a


49/118

2.3 Slicing 49

array ([ 0. , 0., 0., 0., 0.])

> >> b

array ([[ 0. , 0., 0. , 0.] ,

[ 0. , 0., 0. , 0.]])

> >> c

array ([[ 1. , 1., 1. , 1.] ,

[ 1. , 1., 1. , 1.]])

> >> d =np . zeros_like (b) # d e s c o m o b

> >> e =np . ones_like (c) # e e s c o m o c

>>> np .ey e (3 ) # m at ri z i de nt id ad de o rd en 3

array ([[ 1. , 0., 0.] ,

[ 0. , 1., 0.] ,

[ 0. , 0., 1.]])

>>> np .ey e (2,4)array ([[ 1. , 0., 0. , 0.] ,

[ 0. , 1., 0. , 0.]])

>>> np . diag (np . ey e (3)) # e xt r ac c i n d e l a d i ag on a l

array ([ 1. , 1., 1.])

>>> np . diag (np . arange (1,4)) # m at ri z c on d ia go na l d ad a

array ( [[ 1 , 0 , 0] ,

[0 , 2 , 0] ,

[0 , 0 , 3 ]] )

>>> np . diag (np . arange (1,3),-1) # la d ia go na l se p ue de m ov er

array ( [[ 0 , 0 , 0] ,[1 , 0 , 0] ,

[0 , 2 , 0 ]] )

>>> np . diag (np . arange (2,4),2) # m s de un l uga r

array ([[0 , 0 , 2 , 0] ,

[ 0 , 0 , 0 , 3 ] ,

[ 0 , 0 , 0 , 0 ] ,

[0 , 0 , 0 , 0] ])

>>>

Notas de Python

Documents

Transcript of Notas de Python