Introducción a la Física

Computacional

PROGRAMACIÓN

Sergio Antonio Alcalá.

 PROGRAMACIÓN EN
PYTHON

Interprete de comandos python e

ipython.
Sergio Antonio Alcalá.
 Python
Python es un interprete de comandos que se
ejecuta en una terminal de linux. En este se
escriben comandos como entrada y el
interprete regresa una respuesta como salida.

Es muy similar a otros interpretes de comandos

como el shell de de linux o gnuplot.

Además se puede utilizar para realizar computo

científico de una manera muy similar a algunos
interpretes de comandos muy populares como
MathLab, Mathematica o Maple.
 Python
Además de esto Python puede guardar datos como
texto o valores numéricos en variables.

Así como utilizar estructuras de control, lo que

permite realizar instrucciones repetidamente o
evaluar valores para poder tomar decisiones.

De esta manera al igual que en MathLab,

Mathematica o Maple, se pueden escribir scripts
para realizar cálculos de computo científico, ya que
dispone de un extenso numero de librerías (o
bibliotecas) diseñadas para realizar fácilmente
diferentes tareas.
 Python
Así Python no solo es un interprete de
comandos, sino un lenguaje de programación
(obviamente interpretado) que por si fuera poco
es orientado a objetos, ya que las librerías y las
funciones que se pueden construir permiten
programarse y usarse bajo este paradigma.

A pesar de su gran robustez y versatilidad

Python es un lenguaje muy fácil de aprender y
de usar. Por lo que es ideal para comenzar a
programar y como una herramienta eficaz para
acercarse por primera vez al computo científico y
en particular a la Física Computacional.
 El entorno ipython
ipython (Interactive Python) es otro interprete de
Python pero mucho mas robusto, está diseñado
para maximizar la productividad al utilizar Python.
Aquí podemos encontrar ciertas facilidades,
utilidades y comandos que no existen en otros
interpretes de Python.

Por ejemplo completar palabras parciales con la

tecla <TAB>, o bien podemos ejecutar un comando
del shell de linux anteponiendo el símbolo !

In [1]: !pwd

In [2]: !ls
 El entorno ipython
También es posible guardar una bitacora (log)
de la sesión. Esto se logra mediante el comando
logstart.

In [1]: logstart nombre_sesion.py

Al ingresar el comando logstart, seguido del

nombre del archivo que le queramos poner, todo
lo que teclea en la sesión actual se guarda
(incluso los fallos) dentro del archivo, en este
caso el archivo donde se guarda todo se llama
nombre_sesion.py, pero se puede llamar de
cualquier forma.
 El entorno ipython
Además, se cuenta con los comandos who y whos
proveen información de las funciones nuevas
agregadas en la sesión.

La documentación de cualquier función o comando

está disponible al poner ?, por ejemplo:

In [1]: who?

Y para funciones, se puede consultar código fuente

de estas (cuando está disponible) usando ?? .

In [1]: funcion??
 BIBLIOTECAS
La gran versatilidad de python vine dada en gran
parte por el conjunto de bibliotecas que este ya
tiene incorporadas, así que hay que aprovechar lo
que ya esta hecho! Por ejemplo:

python-numpy [librería de arreglos matemáticos]

●

python-scipy [rutinas para uso científico]

●

python-matplotlib [gráficas en 2 dimensiones]

●

python-visual [animaciones en 3 dimensiones]

●

mayavi2
●
 BIBLIOTECAS
De esta manera, se deben instalar estas bibliotecas
(librerias), para poder usarlas.

La forma de instalarlas depende de la distribución

de Linux que usemos (o del sistema operativo). Si
estamos usando Ubuntu se pude hacer desde la
terminal con cualquiera de los dos comandos
siguientes:

sudo apt-get install biblioteca

sudo aptitude install biblioteca
Ejemplo:
sudo apt-get install ipython
sudo aptitude install python-numpy
 BIBLIOTECAS
Python cuenta una biblioteca estándar amplia, lo
cual siempre está disponible en cualquier
instalación de Python.

La documentación para esta biblioteca está

disponible en http://docs.python.org/library/

Sin embargo para poder hacer un uso mucho más

amplio y poderoso de python se puede hacer uso
del resto de las bibliotecas disponibles una vez que
estén instaladas. Por ejemplo para llevar a cabo
cálculos con funciones más avanzadas, es
necesario importar la biblioteca estándar de
matemáticas math.
 BIBLIOTECAS
Así ya instaladas se puede hacer uso de las
bibliotecas importándolas, para que python sepa
que las debe usar.

Para esto se debe dar una instrucción especial

(sentencia de importación) para que python (ya sea
en el interprete de comandos, desde ipython o bien
en un script) pueda acceder a ellas.

Para poder usar una biblioteca (o parte de ella)

simplemente se tiene que indicar que biblioteca
estamos llamando e importar de ella lo que vamos
a usar.
Ejemplos:

from fractions import Fraction

Aquí se está importando la función Fraction de la

librería fractions (que está en la sección 9 de la
biblioteca estándar). O bien:

from math import *

from visual import *

Aquí se está importando todas las funciones de las

bibliotecas math y de la biblioteca visual.
NOTA: Cuando llamamos una función de una biblioteca que no está
instalada o no se ha importado python nos reportará un error.
Como ya se menciono Python es tan poderoso
pues es lenguaje orientado a objetos.

Cada ‘cosa’ en Python es un objeto, que tiene

propiedades y operaciones disponibles
(métodos).

Por ejemplo, Fraction es un tipo de objeto

(clase); sus operaciones están disponibles en
ipython a través de Fraction.<TAB>.

Las que empiezan con __ son internos y deberan

de ignorarse por el momento; las demás son
accesibles al usuario.
 Manejo de Información
Python (ya sea mediante el interprete de comandos
o bien mediante el entorno ipython) nos permite
resolver problemas y realizar operaciones
matemáticas de una manera interactiva, en la que
se ejecutan comandos (entrada) y python a su vez
da una respuesta (salida) en el mismo momento. De
esta manera, python se puede usar como si fuera
una calculadora muy potente.

De esta manera podemos realizar funciones

aritméticas usando los operadores que ya se han
mencionado y que son estándares en casi todos los
lenguajes de programación Suma ( + )Resta ( - )
Producto ( * ) División ( / ).
 ARITMÉTICA
3 + 2
3 * (­7.1 + 10**2)

Aquí ** indica una potencia, y los paréntesis alteran la

prioridad en las operaciones.

Es necesario tener cuidado al hacer manipulaciones

con enteros como en:

1 / 2

3 / 2

ya que el resultado se redondea al entero más cercano.

Para evitar eso, basta un punto decimal:

1 / 2.
 ARITMÉTICA
Los números sin punto decimal se consideran enteros, y
los con punto decimal flotantes (de doble precisión).

Los enteros pueden ser arbitrariamente grandes:

2 ** 2 ** 2 ** 2 ** 2

Python también cuenta con números complejos, utilizando

la notación 1j para la raiz de −1:

1 + 3j
1j * 1j

j # da un error

‘#’ indica un comentario (no se lee, por lo que no cuenta) que

se extiende hasta el final de la línea.
 VARIABLES
Para llevar a cabo cálculos, necesitamos
variables. Las variables se declaran sin necesidad
de indicar su tipo de dato (entero, flotante, etc.):

a
a = 3
b = 17.5
c = 1 + 3j

print a + b / c

Python reconoce de manera automática el tipo de

la variable según su forma.

El comando print imprime el argumento (valor interior) de

la variable.
 VARIABLES
Recordemos que el símbolo “ = ” no estrictamente
equivalente al símbolo igual en matemáticas, en
programación este símbolo significa asignación (es
decir, guardar un valor en una variable) y asimismo
sirve para reasignarle un valor a la misma.

En python, al reasignar una variable, se pierde la

información de su valor interior, incluyendo el tipo:

a = 3
a = ­5.5

Por lo que hay que tener cuidado al usar el el

símbolo “ = ” para no perder información.
 Conversión entre tipos de datos.
Aunque no haya que declararlos al definir variables,
hay distintos tipos de números en Python,
principalmente enteros (int) y flotantes (float).

Para convertir entre diferentes tipos, incluyendo

cadenas, podemos utilizar:

a = float(3) pi = float('3.1416')
b = int(17.)    edad = int(”19”)

Las cadenas en Python son cadenas de caracteres

entre apóstrofes o comillas.

"hola"
'mi edad es: '
 Aritmética con precisión arbitraria.
A veces, es necesario poder llevar a cabo operaciones
aritméticas con números flotantes (reales) con
precisión superior a los 16 dígitos que provee el float
(número de “doble precisión”) de Python. Para hacerlo,
existen varios proyectos que proveen bibliotecas con
este fin.

Una opción, la biblioteca mpmath, que está escrita

completamente en Python. En principio eso lo hace
más lento, pero más fácil de entender y modificar el
código.

Para cargar la biblioteca, hacemos:

from mpmath import *

 Aritmética con precisión arbitraria.
De ésta manera para cambiar la precisión, hacemos

mp.dps = 50

y, para crear un número flotante de esta precisión,

hacemos

x = mpf('1.0')
donde el número se expresa como cadena.

Al hacer manipulaciones con x, los cálculos se llevan a

cabo en precisión múltiple. Por ejemplo,

print x/6. , x*10
print mpf('2.0')**2**2**2**2
 Aritmética con precisión arbitraria.
Con mpmath, no hay límite del exponente que se
puede manejar. También están definidas muchas
funciones, por ejemplo sin, exp y log.

Para imprimir un número con una precisión dada,

usamos:

nprint(x, 20)

x = mpf('31.346')
x = x**2**2**2**2
x/6.
nprint(x, 20)
 Arreglos
En Python hay 3 tipos diferentes de arreglos. Las
listas, las n-adas (o tuples) y los arreglos numpy,
estos últimos son mas robustos y con ellos se puede
representar vectores e incluso matrices.

Listas.
La estructura de datos principal en Python es la lista.
Consiste literalmente en una lista ordenada de cosas, y
reemplaza a los arreglos en otros lenguajes. La
diferencia es que las listas en Python son
automáticamente de longitud variable, y pueden contener
objetos de cualquier tipo.
 Listas
Una lista se define entre corchetes ([ y ]):

l = [3, 4, 6]

Puede contener cualquier cosa, ¡incluyendo a otras listas!:

l = [3.5, ­1, "hola", [1.0, [3, 17]]]

Los elementos de la lista se pueden extraer y cambiar

usando la notación l[i], donde i indica el número del
elemento, empezando desde 0:

l = [1, 2, 3]
print l[0], l[1]
l[0] = 5
l
 Listas
Se pueden manipular rebanadas (“slices”) de
la lista con la notación l[1:3]:

l = [1, 2, 3, 6, 7]
l[1:3]
l[:3]
l[3:]

La longitud de una lista se puede encontrar

con
len(l)
 Listas
Se pueden agregar elementos a la lista con

l = []   # lista vacía
l.append(17)
l.append(3)
print l, len(l)

Como siempre, las otras operaciones que se

pueden llevar a cabo con la lista se pueden
averiguar en ipython con

l.<TAB>
 Listas (la función range)
Para averiguar que es lo que hace una
función, se puede investigar de manera
interactiva con ipython:

In [1]: range??

range(N) devuelve una lista que contiene

una progresión aritmética de enteros.

In [2]: range(10)
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 Listas (la función range)
Nótese que la lista comienza en 0 (cero) y que se
omite el elemento final, por ejemplo range(4)
es una lista de cuatro elementos que llega hasta
el 3.

In [3]: range(4)
Out[3]: [0, 1, 2, 3]

También se le puede indicar en donde inicia y

donde termina la lista:

range(3,10)
[3, 4, 5, 6, 7, 8, 9]
 Listas (la función range)
O bien también se le puede indicar un paso de
incremento:

range(3,17,2)
[3, 5, 7, 9, 11, 13, 15]

range(3,17,3)
[3, 6, 9, 12, 15]

range(3,17,5)
[3, 8, 13]

También nótese que range no acepta argumentos

de punto flotante.
 n - adas
Otra estructura parecida es una n-ada (“tuple”). Es
parecido a una lista, pero se escribe con (o
incluso, a veces, sin paréntesis), y no se puede
modificar:

t = (3, 5)
t[0]
t[0] = 1 # error!

Las n-adas se utilizan para agrupar información y

se pueden asignar como sigue:

a, b = 3, 5
print a; print b
 Arreglos numpy (vectores).
Por lo general las listas y tuples se utilizan para guardar
y manipular datos. Sin embargo, las listas no se
comportan como vectores, y menos como matrices (al
sumarlos no se comportan de la manera adecuada,
etc.). El propósito de la biblioteca numpy es justamente
el de proporcionar objetos que representan a vectores
y matrices matemáticos, con todas las bondades que
traen consigo este tipo de objetos.

La biblioteca se carga con

from numpy import *

Y provee muchas funciones para trabajar con vectores y

matrices.
 Arreglos numpy (vectores).
Los vectores se llaman (aunque es un poco confuso)
arrays, (arreglos) y se pueden crear de distintas
maneras. Son como listas, pero con propiedades y
métodos adicionales para funcionar como objetos
matemáticos. La manera más general de crear un vector
es justamente convirtiendolo desde una lista de números:

from numpy import *
a = array( [1, 2, ­1, 100] )

Un vector de este tipo puede contener sólo un tipo de

objetos, a diferencia de una lista normal de Python. Si
todos los números en la lista son enteros, entonces el tipo
del arreglo también lo es, como se puede comprobar con

a.dtype
 Arreglos numpy (vectores).
Es común querer crear vectores de cierto
tamaño con todos ceros:

b = zeros(10)
print b

o todos unos:

b = ones(10)
print b
 Arreglos numpy (vectores).
También hay distintas maneras de crear
vectores que consisten en rangos ordenados,
por ejemplo arange, que funciona como
range, con un punto inicial, un punto final, y un
paso:

a = arange(0., 10., 0.1)

y linspace, donde se especifica puntos

iniciales y finales y un número de entradas:

l = linspace(0., 10., 11)
 Arreglos numpy (vectores).
Una notación abreviada para construir vectores es r_, que
se puede pensar como una abreviación de “vector
renglón”:

a = r_[1,2,10,­1.]

Este método se extiende para dar una manera rápida de

construir rangos:

r_[3:7]
r_[3:7:0.5]
r_[3:7:10j]

Este ultimo utiliza un “número complejo” simplemente

como otra notación, y es el equivalente de
linspace(3,7,10).
 Arreglos numpy (vectores).
Los vectores creados de esta manera se pueden
sumar, restar etc., como si fueran vectores
matemáticos. Todas las operaciones se llevan a
cabo entrada por entrada:

a = array( [1., 4., 7. ])
b = array( [1., 2., ­2. ])
print a+b, a­b, a*b, a/b, a**b

Las funciones más comunes entre vectores ya están

definidas en numpy, entre las cuales se encuentran
dot(a,b) para productos escalares de dos
vectores de la misma longitud, y cross(a,b) para
el producto cruz de dos vectores de longitud 3.
 Arreglos numpy (vectores).
Además, cualquier función matemática como sin y
exp se puede aplicar directamente a un vector, y
regresará un vector compuesto por esta función
aplicada a cada entrada del vector. Es más: al
definir una función el usuario, esta función
normalmente también se pueden aplicar
directamente a un vector:

def gauss(x):
return 1./(sqrt(2.)) * exp(­x*x / 2.)

gauss( r_[0:10] )
 Arreglos numpy (vectores).
Para extraer subpartes de un vector, la misma
sintaxis funciona como para listas: se extraen
componentes (entradas) individuales con

a = array([0, 1, 2, 3])
print a[0], a[2]

y subvectores con

b = a[1:3]
 Arreglos numpy (vectores).
Nótese, sin embargo, que en este caso la variable 
b no es una copia de esta parte de a. Más bien, es
una vista de a, así que ahora si hacemos

b[1] = 10

entonces la entrada correspondiente de a ¡también

cambia! Este fenómeno también funciona con listas:

l=[1,2,3]; k=l; k[1] = 10

En general, en Python las variables son nombres de

objetos; al poner b = a, tenemos ¡un mismo objeto con dos
nombres!
 Arreglos numpy (Marices).
Las matrices se tratan como vectores de vectores, o listas
de listas:

M = array( [ [1, 2], [3, 4] ] )

La forma de la matriz se puede ver con

M.shape

y se puede manipular con

M.shape = (4, 1); print M

o con

M.reshape( 2, 2 )
 Arreglos numpy (Marices).
De hecho, eso es una manera util de crear las
matrices:

M = r_[0:4].reshape(2,2)

Tambien podemos crear una matriz desde una

función:

def f(i, j):
return i+j

M = fromfunction(f, (3, 3))
 Arreglos numpy (Marices).
Dado que las matrices son vectores de vectores, al
hacer
print M[0]

nos regresa la primera componente de M, que es

justamente un vector (el primer renglón de M). Si
queremos cierta entrada de la matriz, entonces más
bien necesitamos especificar dos coordenadas:

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

[También podemos poner M.item(1) que aparentemente

es más eficiente.]
 Arreglos numpy (Marices).
Para extraer ciertas renglones o columnas de M,
utilizamos una extensión de la notación para
vectores:

M = identity(10)
M[3:5]
M[:, 3:5]
M[3:9, 3:5] #matriz identidad de 10x10

Una función poderosa para construir matrices

repetidas es tile

tile( M, (2,2) )
 Arreglos numpy (Marices).
Otros métodos útiles son diagonal, que
regresa una diagonal de un arreglo:

diagonal(M)
diagonal(M, 1)

y diag, que construye una matriz con el

vector dado como diagonal:

diag([1,2,3])
diag([1,2,3], 2)
 Arreglos numpy (números aleatorios).
La biblioteca numpy incluye un módulo amplio para
manipular números aleatorios, llamado random. Las
funciones se llaman, por ejemplo con,
random.random(). Pero para facilitarnos la vida,
podemos importar todas estas funciones al espacio
de nombres con:

from numpy import *
random?  #informacion sobre el modulo
from random import * #'random' esta

o bien

from numpy.random import *
 Arreglos numpy (números aleatorios).
Nótese que hay otro módulo random que existe
afuera de numpy, con distinta funcionalidad. La
funcionalidad básica del módulo es la de generar
números aleatorios distribuidos de manera uniforme
en el intervalo [0, 1):

random()

for i in xrange(10):
random()

Al poner random(N), nos regresa un vector de

números aleatorios de longitud N.
 Arreglos numpy (números aleatorios).
Para generar una matriz aleatoria, podemos
utilizar

rand(10, 20)

También hay diversas funciones para generar

números aleatorios con distribuciones no
uniformes, por ejemplo exponential(10) y
randn(10,5,10) para una distribución normal,
o binomial(10,3,100) para una distribución
binomial.
 ipython y bibliotecas matemáticas
Como ya se menciono para llevar a cabo
cálculos con funciones más avanzadas, es
necesario importar la biblioteca estándar de
matemáticas:

from math import *

Sin embargo esto no es necesario al invocar al

entorno ipython (ejecutar en el shell) con

ipython -pylab

que invoca un modo específico de ipython.

 ipython y bibliotecas matemáticas
Pero además al cargar ipython de esta manera, importa
mucho más que la simple biblioteca de matemáticas.
Python está escrito en lenguaje C, así que la biblioteca
math provee acceso a las funciones matemáticas que están
en la biblioteca estándar de C.

Para permitir operaciones con números complejos como

posibles respuestas, se ocupa la biblioteca (módulo) cmath.
Si hacemos

from cmath import *

entonces se importan las funciones adecuadas, por

ejemplo:

sqrt(­1)
 ipython y bibliotecas matemáticas
Sin embargo, al hacer esto “se perderán” las funciones
anteriores, es decir, las nuevas funciones han reemplazado
a las distintas funciones con los mismos nombres que había
antes. Una solución es importar la biblioteca de otra
manera:

import cmath

Ahora las funciones que se han importado de cmath tienen

nombres que empiezan por cmath.:

cmath.sqrt(­1)

ipython ahora nos proporciona la lista de funciones adentro

del módulo si hacemos cmath.<TAB>.