Introducción a la Física

Computacional

PROGRAMACIÓN

Sergio Antonio Alcalá.

 PROGRAMACIÓN EN
PYTHON
Scripts en Python.
Estructuras de Control, Funciones
y Entrada/Salida.
Sergio Antonio Alcalá.
 Scripts de Python.
Una vez que las secuencias de comandos se
complican, podría pasar que queramos repetir la misma
secuencia varias veces o bien reusar algunas
secuencias de comandos, sin embargo esto significaría
reescribir todo nuevamente en el interprete de
comandos.

Entonces sería conveniente poder guardar bloques de

instrucciones completos y correrlos de una sola vez.

Esto es posible realizando un programa, o script. Esto

consiste en un archivo de texto, cuyo nombre termina
en .py, en el cual se escribe y guarda la secuencia de
comandos.
 Scripts de Python.
Por ejemplo, consideremos el siguiente código:

from fractions import Fraction

a = Fraction(3, 5)
b = Fraction(1)
c = a + b
d = Fraction(4, 6)
d 
e = a + d

podemos escribirlo en un editor de textos y salvarlo

como un archivo cuad.py
 Scripts de Python.
Así podemos correr el código desde ipython con

In [9]: run cuad

Al terminar de correr el programa, el control

regresa a ipython, pero todavía tenemos acceso
a las variables y funciones definidas en el script.

Nota si no estamos en el mismo directorio donde

se guardo el archivo script.py, habrá que
especificar la ruta relativa o absoluta según sea
el caso.
 Scripts de Python.
De hecho, un script se puede considerar un
módulo en sí, que también se puede importar:

In [9]: from cuad import *

Nota: hay que correr python o ipython en el

mismo directorio donde se guardo el archivo
script.py.

O bien guardar el script en el mismo directorio

donde se ejecuto python o ipython.
 Scripts de Python.
Alternativamente, podemos tratar el script
como un programa (en Linux) en sí, al
ejecutar desde el shell

python cuad.py

Al terminar, el control regresa al shell, y

perdemos la información adentro del script.
 Scripts de Python.
Aunque no hay una forma rígida de programar, para escribir
un buen script (programa) se puede seguir la siguiente
estructura:
● Comentarios generales del programa!

● Importar bibliotecas (librerías o módulos)

● Definir funciones

● Definir variables globales

● Comandos  de  entrada  por  parte  del  usuario  (si  es 

necesario)

● Estructuras de control y/o cálculos

● Comandos de salida (si es necesario)
 Scripts de Python.
Por ejemplo:
 Estructuras de Control.
En Python existen las estructuras de control comunes
usadas en los lenguajes programación, que son las
condicionales (if) y las iteretivas (for y while).

Estás se usan junto con, los operadores lógicos y de

comparación ya mencionados y que tienen un formato
en común en casi todos los lenguajes de programación.

Operadores de comparación:
Igual que ( == ), Diferente que ( != ). Menor que ( < ),
Mayor que ( > ), Menor o igual que ( <= ),
Mayor o igual que ( >= )
Operadores de lógicos:
AND ( and ), OR ( or ), NOT ( ! )
 Estructuras de Control.
Sin embargo, a diferencia de otros lenguajes de
programación en Python, no existen instrucciones que
indiquen donde empieza y termina un bloque del
programa.

Un bloque empieza por :, y su extensión se indica por

el uso de una cantidad definida de espacio en blanco al
principio de cada línea.

Es muy importante dejar una identación (un

tabulador) después de que se inicia un bloque de
instrucciones definido por : .

Un buen editor de texto (como Kate) permite hacer eso

de manera automática.
 Estructuras Condicionales
Para checar una condición y ejecutar código
dependiente del resultado, se ocupa if :

a = raw_input('Dame el valor de a')
if a > 0:
print "a es positiva"
a = a + 1
elif a == 0: # Notese: dos veces =
print "a es 0"
else:
print "a es negativa"

En el primer caso, hay dos comandos en el bloque que

se ejecutará en el caso de que a > 0. Nótese que elif
es una abreviación de else:if
 Estructuras Condicionales
Las condiciones que se pueden ocupar incluyen:
<, <= y != (no es igual). Para combinar
condiciones se ocupan las palabras and y or:

a = 3; b=7

if a>1 and b>2:
print "Grandes"

if a>0 or b>0:
print "Al menos uno positivo"
 Estructuras Iterativas
La parte central de muchos cálculos científicos consiste
en llevar a cabo ciclos (bucles).

El tipo de bucle más sencillo es un while, que ejecuta

un bloque de código mientras una cierta condición se
satisfaga, y suele ocuparse para llevar a cabo una
iteración en la cual no se conoce de antemano el
número de iteraciones necesarias.

Sin embargo hay que tener cuidado al usar el while

pues si no definimos bien la condición de termino puede
que el ciclo se repita indefinidamente y nunca acabe.

Cuando se conoce de antemano el número de

iteraciones es preferible usar el for.
 Estructuras Iterativas
Un ejemplo muy sencillo de un while, donde sí se
conoce la condición terminal, para contar hasta 9,
se puede hacer como sigue:

i = 0
while i < 10:
i += 1 # equivalente a i = i + 1
print i

Nótese que si la condición deseada es del tipo

“hasta. . . ”, entonces se tiene que utilizar un while
con la condición opuesta
 Estructuras Iterativas
Un ciclo tipo for se suele ocupar para llevar a cabo
un número de iteraciones que se conoce de
antemano. En el bucle de tipo for, encontramos
una diferencia importante con respecto a lenguajes
más tradicionales:

Se puede iterar sobre cualquier lista y ejecutar un

bloque de código para cada elemento de la lista:

l = [1, 2.5, ­3.71, "hola", [2, 3]]

for i in l:
print 2*l
 Estructuras Iterativas
Si queremos iterar sobre muchos elementos, es más útil
construir la lista. Por ejemplo, para hacer una iteración para
todos los números hasta 100, podemos utilizar

for i in range(100):
print 2*i

Recordemos que la función range crea una lista de N

elementos comenzado en el 0. O también podemos usar

for i in range(3,57,3):
print 2*i

Para poder indicar un inicio, un fin y un incremento de paso

en la iteración.
 Funciones.
Las funciones se pueden considerar como subprogramas
que ejecutan una tarea dada, pueden contener variables
propias (locales) así como estructuras de control y cálculos
en su interior. En Python, las funciones pueden o no aceptar
argumentos, y pueden o no regresar resultados.

La sintaxis para declarar una función es como sigue:

def f(x):
print "Argumento x = ", x
return x*x

y se llama así:

f(3)
f(3.5)
 Funciones.
Las funciones se pueden utilizar con argumentos de
cualquier tipo (el tipo de los argumentos nunca se
especifica). Si las operaciones llevadas a cabo no
se permiten para el tipo que se provee, entonces
Python regresa un error:

f("hola")

Las funciones pueden regresar varios resultados al

juntarlos en un tuple (n-ada):

def f(x, y):
return 2*x, 3*y
 Funciones.
Se puede proporcionar una forma sencilla de documentación
de una función al proporcionar un “docstring”:

def cuad(x):
"""Funcion para llevar un numero al cuadrado.
Funciona siempre y cuando el tipo de x permite 
multiplicacion.
"""
return x*x

Ahora si interrogamos al objeto cuad con ipython:

cuad?

nos da esta información. Si la función está definida en un

archivo, entonces cuad?? muestra el código de la definición
de la función.
 Funciones y BIBLIOTECAS.
Se puede escribir un script que solo tenga definiciones
de funciones, a la cual puede considerarse una
biblioteca propia, y también se puede importarse:

from mi_biblioteca import *

Así podemos llamar a esta biblioteca dentro de otro

script y usar sus funciones dentro de este.

O bien se puede importar desde el interprete de

comandos python (o el entrono ipython) con lo que
podemos llamar esas funciones o ver sus
características coma ya mencionamos.
 ENTRADA / SALIDA.
ENTRADA.
Como ya hemos visto, se puede pedir información del
usuario con raw_input:

a = raw_input('Dame el valor de a: ')

print "El cuadrado de a es ", a*a

Sin embargo, uno de los usos principales de Python

para el cómputo científico es el de procesar datos
generados en otro lado. Por lo tanto, es necesario saber
cómo importar y exportar archivos.
 ENTRADA (leer archivos)
Para leer un archivo, primero es necesario
abrirlo para leerse. Supongamos que tenemos
un archivo llamado datos.dat, entonces lo
podemos abrir para su lectura con:

entrada = open("datos.dat", "r")

El segundo argumento, "r", es para indicar

que se va a leer (“read”) el archivo.

El objeto entrada ahora representa el

archivo.
 ENTRADA (leer archivos)
Para leer del archivo abierto, hay varias
posibilidades. Podemos leer todo de un golpe con
entrada.read(), leer todo por líneas con
entrada.readlines(), o línea por línea con
entrada.readline(). Sin embargo, lo que se ha
leído ya no se puede leer de nuevo sin cerrar el
archivo con entrada.close() y volverlo a abrir.

Por ejemplo, podemos utilizar

for linea in entrada.readlines():
print linea
 ENTRADA (leer archivos)
Sin embargo, tal vez la opción más fácil e intuitiva
es

for linea in entrada:
print linea

Es decir, el archivo ¡se comporta como una

secuencia!

Ahora bien, la línea viene como una sola cadena,

con espacios etc. Para extraer la información,
primero necesitamos dividirlo en palabras:

palabras = linea.split()
 ENTRADA (leer archivos)
Si todos los datos en realidad son números, entonces
tenemos que procesar cada palabra, convirtiéndola en un
número:

datos = []
for i in palabras:
datos.append( float(i) )

Resulta que hay una manera más fácil, de más alto nivel
y más rápida de hacer esto:

map(float, palabras)

Eso literalmente mapea la función float sobre la lista

palabras.
 ENTRADA (leer archivos)
Combinando todo, podemos escribir

entrada = open("datos.dat", "r")

for linea in entrada:
datos = map(float, linea.split())

Y dentro del bucle podemos manipular los

datos como queramos.
 SALIDA
Como ya hemos visto en el interprete de comandos
python o en ipython, para mandar un resultado a la
salida simplemente hay que definirlo y después
escribirlo y presionar enter.

a = 17.3
a

b = “hola”
b

Adicionalmente se puede utilizar el comando print

print “imprimiendo datos”, a, b  
 SALIDA (escribir archivos)
Sin embargo si se trata de un script, en Linux, la manera
más fácil (pero no muy flexible) de guardar datos en un
archivo es utilizar la “redirección” que provee el shell
(Bash). Al correr un programa así desde Bash:

./programa > salida.dat

la salida estándar (lo que aparece en la pantalla al

correr el programa) se manda al archivo especificado.
Así que

python prog.py > salida.dat

mandará la salida del programa de python prog.py al

archivo salida.dat.
 SALIDA (escribir archivos)
El método de redirigir la salida es rápido y fácil. Sin
embargo, no es de ninguna manera flexible, por ejemplo
no podemos especificar desde nuestro programa el
nombre del archivo de salida, ni escribir en dos archivos
diferentes. Para hacer eso, necesitamos poder abrir un
archivo para escribirse:

salida = open("resultados.dat", "w")

La parte más complicada viene al momento de escribir

en el archivo. Para hacerlo, ocupamos la función

salida.write()
 SALIDA (escribir archivos)
Sin embargo, esta función puede escribir solamente
cadenas. Por lo tanto, si queremos escribir números
contenidos en variables, es necesario convertirlos
primero a la forma de cadena.

Una manera de hacer eso es con la función str(), y

concatenar (juntar) distintas cadenas con +:

a = 3
s = "El valor de a es " + str(a)

Sin embargo, para largas secuencias de datos eso se

vuelve latoso.
 SALIDA (escribir archivos)
La manera más elegante de hacerlo es con la sustitución de
variables en cadenas . En una cadena ponemos una
secuencia especial de caracteres, empezando por %, que
indica que se sustituirá el valor de una variable:

a = 3
s = "El valor de a es %d" % a

b = 3.5; c = 10.1
s = "b = %g; c = %g" % (b, c)

El carácter después del % indica el tipo de variable que incluir

en la cadena: d corresponde a un entero, g o f a un flotante,
y s a otra cadena. También se puede poner un número entero,
que es el tamaño del campo, y un punto decimal seguido por
un número, que da el número de decimales para el caso de f.
 SALIDA (escribir archivos)

Finalmente ahora podemos imprimir en el

archivo, por ejemplo

salida.write(" %g\t %g" % (a,b) )

Aquí, \t representa un tabulador, y \n una

nueva línea.