Download cadenas - Universidad de Oviedo

Universidad de Oviedo
Grado en Física
Curso 2013-14
Introducción a la Física
Computacional
Tema 4
Python como lenguaje algorítmico
Tema 4. Python como lenguaje
algorimico
●
Introducción
●
Usando Python
●
Variables y tipos de datos. Operadores
●
Estructuras de control de flujo: condicionales,
bucles y excepciones
●
Entrada y salida de datos
●
Funciones y módulos
Tema 4. Python como lenguaje
algorimico
●
Introducción
●
Usando Python
●
Variables y tipos de datos. Operadores
●
Estructuras de control de flujo: condicionales,
bucles y excepciones
●
Entrada y salida de datos
●
Funciones y módulos
Introducción
●
●
¿Qué es Python?
●
Lenguaje interpretado o de script
●
Tipado dinámico y fuertemente tipado
●
Multiplataforma y totalmente libre
●
Orientado a objetos y a la vez de tipo funcional
●
Módulos prefabricados (bibliotecas de programas)
¿Por qué Python?
●
Ventajas de Python respecto a otros lenguajes
●
Comparación con otros lenguajes
¿Qué es Python?
●
●
Python es un lenguaje de programación creado
por Guido van Rossum a principios de la
década de 1990 cuyo nombre está inspirado en
el grupo de cómicos ingleses Monty Python.
Se trata de un lenguaje interpretado o de script,
con tipado dinámico, fuertemente tipado,
multiplataforma, libre y orientado a objetos.
Lenguaje interpretado o de script
●
●
Un lenguaje interpretado o de script es aquel
que se ejecuta utilizando un programa
intermedio llamado intérprete, en lugar de
compilar el código a lengua máquina que
pueda comprender y ejecutar directamente una
computadora (lenguajes compilados).
La ventaja de los lenguajes compilados es que
su ejecución es más rápida. Sin embargo los
lenguajes interpretados son más flexibles y
más portables.
Lenguaje interpretado o de script
●
●
Python tiene, no obstante, muchas de las
características de los lenguajes compilados,
por lo que se podría decir que es semiinterpretado.
En Python el código fuente se traduce en
ocasiones a un código intermedio llamado
bytecode la primera vez que se ejecuta
(generando archivos .pyc o .pyo, que son los
que se ejecutarán en sucesivas ocasiones).
Tipado dinámico
●
No es necesario declarar el tipo de dato que va
a contener una determinada variable, sino que
su tipo se determinará en tiempo de ejecución
según el tipo del valor al que se le asigne, y el
tipo de esta variable puede cambiar si se le
asigna un valor de otro tipo:
x = 3.0
# asigna a x un número real
x = log
# ahora asigna a x la función log
Fuertemente tipado
●
●
No se permite tratar a una variable como si
fuera de un tipo distinto al que tiene, es
necesario convertir de forma explícita dicha
variable al nuevo tipo previamente.
Por ejemplo, si tenemos una variable que
contiene un texto (tipo cadena) no podremos
tratarla como un número (sumar la cadena “9”
con el número 8 está prohibido).
Multiplataforma
●
El intérprete de Python está disponible en
multitud de plataformas (Unix, Solaris, Linux,
MS/Dos, Windows, Mac OS, etc.) por lo que si
no utilizamos bibliotecas específicas de cada
plataforma nuestro programa podrá correr en
todos estos sistemas con pocos cambios.
Python es software libre
●
●
No hay una empresa comercial detrás, sino
toda la comunidad internacional. Por ello, no
está sujeto a los caprichos de una compañía.
Eso no quiere decir que no podamos realizar
desarrollos comerciales en Python: excepto
que usemos una biblioteca de módulos que lo
cite expresamente, una aplicación que
desarrollemos en Python puede ser vendida y
reportar beneficios.
Orientado a objetos y funcional
●
●
●
La orientación a objetos (OO) es un paradigma de
programación en el que los conceptos del mundo
real relevantes para nuestro problema se trasladan
a clases y objetos en nuestro programa. La
ejecución del programa consiste en una serie de
interacciones entre los objetos.
La programación funcional (FP de sus siglas en
inglés) es otro paradigma avanzado de
programación.
En el presente curso no desarrollaremos los
aspectos de OO ni la FP.
Módulos prefabricados
●
●
●
●
Python tiene una ventaja respecto a otros
lenguajes: posee infinidad de módulos
prediseñados (quizá sea el que más tiene).
Cada módulo contiene herramientas de
programación para realizar tareas relacionadas
entre sí.
Se puede usar un módulo (conociendo su
funcionamiento) de una manera simple.
El diseño de nuevos módulos es sencillo.
Algunos módulos prefabricados
●
Matemáticas (math, numpy, scipy, sympy, etc.)
●
Estadística (stats, etc.)
●
Representaciones gráficas 2D y 3D (matplotlib, visual,
Gnuplot, etc.)
●
Interfaces gráficas (tkinter, wxPython, etc.)
●
Bases de datos (pySQLite, etc.)
●
Tratamiento de imágenes (PIL, etc.)
●
Manipulación de bases de datos científicas como (NetCDF, etc.)
●
Servidor de aplicaciones web (zope) ---no es exactamente un
módulo
¿Por qué Python?
●
●
●
●
●
Es uno de los mejores lenguajes para comenzar a
programar: su curva de aprendizaje es poco empinada.
Su aprendizaje puede ser realizado incrementalmente
de manera ventajosa (dejando, por ejemplo, la
programación FP y OO para el final).
Está disponible en muchas plataformas.
Están disponibles bibliotecas de programas para casi
cualquier tema que se nos ocurra.
Puede combinarse fácilmente con lenguajes compilados
(C, C++, Fortran) para las tareas que requieran
velocidad de cálculo.
Ventajas de Python
●
●
●
●
Su sintaxis es tan sencilla y cercana al lenguaje
natural que los programas elaborados en Python
parecen pseudocódigo.
El tipado es dinámico, lo que nos evita tener que estar
continuamente definiendo variables y asignando
memoria.
El gestor de memoria simplifica el uso de variables (la
memoria se libera automáticamente cuando no se
necesita).
La gran cantidad de bibliotecas disponibles y la
potencia del lenguaje, hacen que desarrollar una
aplicación en Python sea sencillo y muy rápido.
Comparación con otros lenguajes
●
●
●
Es un lenguaje completo y con sintaxis
homogénea y coherente (a diferencia de Matlab
y Octave, por ejemplo).
Es más lento que los lenguajes compilados pero
mucho más rápido desarrollar las aplicaciones.
Es más fácil realizar el mantenimiento de
programas que con otros lenguajes (con el paso
del tiempo todos los programas tienen errores
que eliminar).
Tema 4. Python como lenguaje
algorimico
●
Introducción
●
Usando Python
●
Variables y tipos de datos. Operadores
●
Estructuras de control de flujo: condicionales,
bucles y excepciones
●
Entrada y salida de datos
●
Funciones y módulos
Usando Python
●
●
Existen dos maneras de usar el intérprete de
Python: modo interactivo y modo no interactivo
(modo script).
En el modo interactivo se invoca:
$ python
>>>
●
El intérprete nos indica con >>> (se denomina
prompt en inglés) que está esperando una orden
del usuario.
Python en modo interactivo
●
En el modo interactivo Python se puede usar
como una calculadora:
>>> 3+4
7
>>> r = 3; s = 3.1416*r**2
>>> s
28.2744
(Ctrl-D)
# para salir en Unix
(Ctrl-Z+Enter) # para salir en Windows
Python en modo no interactivo
●
●
Se usa indicándole al intérprete qué fichero
queremos usar para ejecutar en Python.
Supongamos que el fichero hola.py contiene:
# ----- hola.py ---print('Hola amigo')
$ python hola.py
Hola amigo
$
●
En el modo no interactivo Python no se puede usar
como una calculadora (no imprime las operaciones
directamente).
Tema 4. Python como lenguaje
algorimico
●
Introducción
●
Usando Python
●
Variables y tipos de datos. Operadores
●
Estructuras de control de flujo: condicionales,
bucles y excepciones
●
Entrada y salida de datos
●
Funciones y módulos
Variables y tipos de datos
●
●
En la mayoría de los lenguajes el nombre de
una variable representa un tipo y un valor
almacenado en una posición fija de memoria.
El valor puede cambiarse pero el tipo no.
Esto no ocurre en Python donde ya hemos
dicho que las variables tienen tipos dinámicos.
Identificadores y palabras reservadas
●
Los nombres de las variables en Python pueden
contener letras (sin acentos ni la ñ), números y el
carácter “_” (barra baja). Ejemplos:
aviso, x, f7, fecha_de_nacimiento
●
No pueden empezar por un número y es
recomendable no empezarlos por “_”. No valdrían:
5solos, año, carbón, acel-gravedad
●
Existen algunas palabras que no se pueden usar
como nombres de variables. Se llaman palabras
reservadas: if, while, for, try, ...
Tipos de datos
●
Números (enteros, reales, complejos)
●
Valores booleanos
●
Cadenas
●
Operaciones con datos
●
Colecciones de datos
Enteros
●
●
Los números enteros son aquellos números
positivos o negativos que no tienen decimales
(incluido el cero).
En Python se pueden representar mediante:
●
int (de integer, entero)
●
long (largo).
Enteros: tipo int
●
En una variable de tipo int de Python
podemos almacenar con 32 bits números de
31
31
−2 a 2 −1, o lo que es lo mismo, de
−2.147.483.648 a 2.147.483.647.
●
En plataformas de 64 bits, el rango es de
−9.223.372.036.854.775.808 hasta
9.223.372.036.854.775.807.
Enteros: tipo long
●
●
El tipo long de Python permite almacenar
números de cualquier precisión, estando
limitados solo por la memoria disponible en la
máquina.
Al asignar un número entero a una variable
esta pasará a tener tipo int, a menos que el
número sea tan grande como para requerir el
uso del tipo long.
Reales: tipo float (I/II)
●
●
Los números reales son los que tienen
decimales. En Python se expresan mediante el
tipo float.
Python implementa su tipo float utilizando 64
bits y sigue el estándar IEEE 754: 1 bit para el
signo, 11 para el exponente, y 52 para la
mantisa. Esto significa que los valores que
podemos representar van desde (aprox.)
±2,225x10
−308
308
hasta ±1,798×10
.
Reales: tipo float (II/II)
●
En realidad se pueden manejar números
menores en valor absoluto (más cercanos a
−324
cero), hasta 4,941x10
(números
subnormalizados), pero en las operaciones
aritméticas se comenten errores de redondeo y
se recomienda evitarlos.
Complejos
●
●
Los números complejos son aquellos que
tienen parte imaginaria. Este tipo se denomina
complex en Python.
complex se almacena usando dos valores
float, debido a que estos números son una
extensión de los números reales.
Valores booleanos
●
●
●
Una variable de tipo booleano (también
denominado lógico) sólo puede tener dos
valores: True (verdadero) y False (falso).
Estos valores son importantes para las
expresiones condicionales y los bucles, como
veremos más adelante.
Python también acepta como falso un valor
entero 0 y como verdadero un valor entero
diferente de 0 (como por ejemplo 1).
Cadenas de caracteres (strings)
●
●
Una cadena es una secuencia de caracteres
entre comillas simples ' o dobles “.
Dentro de las comillas se pueden añadir
caracteres especiales como:
●
\ (carácter de continuación)
●
\n (carácter de nueva línea)
●
\t (carácter de tabulación)
Cadenas (ejemplos)
>>> c = ”Hola mundo”
# c es de tipo cadena
>>> print(c)
Hola mundo
# podemos comprobarlo con la función type
>>> type(c)
Cadenas
●
●
También es posible encerrar una cadena entre
triples comillas (simples o dobles). De esta forma
podremos escribir el texto en varias líneas, y al
imprimir la cadena, se respetarán los saltos de
línea que introdujimos sin tener que recurrir al
carácter \n, así como las comillas sin tener que
utilizar al carácter \.
Una cadena es un objeto inmutable. Un carácter
no puede ser modificado con una declaración, y
tiene una longitud fija. El intento de violar su
inmutabilidad dará un error.
Algunas operaciones con cadenas
●
●
●
Existen funciones para manejo de cadenas
como upper (convierte a mayúsculas), lower (a
minúsculas).
La longitud de la cadena s se obtiene usando
la función len(s).
Los elementos de las cadenas se numeran
empezando con 0 hasta len(s)-1 siempre.
Algunas operaciones con cadenas
●
●
El operador + se utiliza para unir (concatenar)
cadenas.
El operador : se utiliza para extraer una
porción de cadena
●
●
s[i:j] nos devuelve la subcadena desde i
hasta j-1.
Si i y/o j son negativos son índices desde el
final de la cadena: si n es la longitud de la cadena,
-1 es equivalente a n-1.
Cadenas (ejemplos)
>>> cadena1 = ’Presiona return para salir ’
>>> cadena2 = ’del programa’
>>> print cadena1 +’ ’+ cadena2 # concatenación
Presiona return para salir del programa
>>> print(cadena1[0:12]) # extracción
Presiona return
>>> cad = cadena1[-5:]
# por el final
>>> cad
salir
>>> cad.upper()
SALIR
# ojo con esta forma de invocar upper
Cadenas (ejemplos)
>>> s = ’Presiona return para salir’
>>> len(s)
26
>>> s[0] = ’p’
Traceback (most recent call last):
File ’’<pyshell#1>’’, line 1, in ?
s[0] = ’p’
TypeError: object doesn’t support item
assignment
Operadores
●
Operadores aritméticos
●
Operadores relacionales
●
Operadores condicionales
Operadores aritméticos
Operador
Descripción
Ejemplo
+
Suma
r = 2+3
#r es 5
-
Resta
r = 4-7
#r es -3
-
Negación
r = -7
#r es -7
*
Multiplicación
r = 2*6
#r es 12
**
Exponente
r = 2**6
#r es 64
/
División
r = 3.5/2
#r es 1.75
División entera
r = 3.5//2 #r es 1.0
Módulo
r = 7%2
//
%
#r es 1
Operadores aritméticos
●
Si una operación aritmética incluye números de
diferentes tipos, los números se convierten
automáticamente a un tipo común después de
la operación:
int → long → float → complex
Operadores aritméticos (ejemplos)
>>> b = 2
# b es de tipo entero
>>> print(b)
2
>>> b = b * 2.0 # ahora es de tipo coma flotante
>>> print(b)
4.0
# podemos comprobarlo con la función type
>>> type(a)
>>> type(b)
Operadores aritméticos (ejemplos)
●
●
●
La asignación b = 2 crea una asociación entre
el nombre b y el valor entero 2.
La siguiente declaración evalúa la expresión:
b*2.0 y asocia el resultado con b eliminando la
asociación original con el entero 2. Después de
esta declaración b se refiere a un punto flotante
de valor 4.0.
El signo # indica que comienza un comentario.
Todos los caracteres entre # y el final de línea
son ignorados por el intérprete.
Operadores aritméticos
●
●
●
Algunas de estas operaciones también están
definidas para cadenas, pero con otro
significado.
El operador + concatena dos cadenas (como
ya hemos visto) y también listas.
El operador * cuando un multiplicando es un
entero y el otro una cadena hace que la cadena
se repita. También se aplica a listas.
Operadores aritméticos (ejemplos)
>>> s = ’Hello ’
>>> t = ’to you’
>>> a = [1, 2, 3]
>>> print(3*s) # Repetición
Hello Hello Hello
>>> print(3*a) # Repetición
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> print(a + [4, 5]) # Añade elementos
[1, 2, 3, 4, 5]
>>> print(s + t) # Concatena
Hello to you
Operadores aritméticos (ejemplos)
Pero cuidado:
>>> print(3+s)
# Esta suma no tiene sentido
Traceback (most recent call last):
File ’’<pyshell#9>’’, line 1, in ?
print(n + s)
TypeError: unsupported operand types for +:
’int’ and ’str’
Más operadores aritméticos
●
Las versiones posteriores a Python 2.0 han aumentado la
asignación de los operadores, de manera que resulten
familiares a los usuarios de C. A la izquierda el operador, a
la derecha la equivalencia
a
a
a
a
a
a
+=
-=
*=
/=
**=
%=
b
b
b
b
b
b
a
a
a
a
a
a
= a + b
= a - b
= a * b
= a / b
= a**b
= a % b
Operadores relacionales
●
Los operadores relacionales devuelven True (1 en
operaciones) si es cierto y False (0 en operaciones)
si es falso.
Operador
Descripción
Ejemplo
<
Menor que
5<3
False
>
Mayor que
5>3
True
<=
Menor o igual 5<=5
True
>=
Mayor o igual 5>=3
True
==
!=
Igual a
Distinto a
5==3
False
5!=3
True
Operadores relacionales (ejemplos)
>>> a = 2 # Entero
>>> b = 1.99 # Coma flotante
>>> c = ’2’ # Cadena
>>> print(a > b)
True
>>> print(a == c)
False
>>> print((a > b) and (a != c))
True
>>> print((a > b) or (a == b))
True
Operadores condicionales
●
Los operadores condicionales devuelven True (1 en
operaciones) si es cierto y False (0 en operaciones)
si es falso.
Operador
Descripción
Ejemplo
and
¿se cumple a y b? 5>3 and 5<3
False
or
¿se cumple a o b? 5>3 or 5<3
True
not
no
not 5<=3
True
Colecciones
●
Además de los tipos básicos de datos que
hemos visto, números, cadenas y booleanos,
existen otros tipos de colecciones de datos:
●
Tuplas
●
Listas
●
Diccionarios
Tuplas
●
●
●
Una tupla es una secuencia de objetos
arbitrarios separados por comas y encerrados
entre paréntesis. Si la tupla contiene sólo un
objeto, se requiere una coma al final, por
ejemplo, x=(2,).
Los elementos de las tuplas se numeran
empezando con 0 siempre y acaban en n-1
(siendo n la longitud de la tupla).
Las tuplas soportan las mismas operaciones
que las cadenas, son también inmutables.
Tuplas (ejemplos)
>>> t = (1)
>>> type(t)
<type 'int'>
>>> t = (1,)
>>> type(t)
<type 'tuple'>
Tuplas
●
Para referirse a elementos de una tupla se usa el operador
[]
>>> t = (1, 2, 3)
>>> type(t)
<type 'tuple'>
●
>>> mi_var = t[0]
# mi_var es 1
>>> mi_var = t[0:2]
# mi_var es (1, 2)
Podemos utilizar el operador [] debido a que las tuplas, al
igual que las cadenas, forman parte de un tipo de objetos
llamados secuencias.
Tuplas (ejemplos)
>>> rec = (’Smith’, ’John’, (6, 23, 68)) # Esto es una tupla
>>> apellido, nombre, fecha_nac = rec
>>> print(nombre)
John
>>> anno_nac = fecha_nac[2]
>>> print(anno_nac)
68
>>> nombre = rec[1] + ’ ’ + rec[0]
>>> print(nombre)
John Smith
>>> print(rec[0:2])
(’Smith’, ’John’)
# desempaquetando la tupla
Listas
●
●
●
●
●
Una lista es similar a una tupla, pero puede ser
modificada, de manera que pueden cambiarse sus
elementos y su longitud.
Una lista se identifica encerrándola entre corchetes.
Sería equivalente a lo que en otros lenguajes se
conoce por arrays y vectores.
Las listas pueden contener cualquier tipo de dato:
números, cadenas, booleanos, etc., y también listas.
Los elementos de las listas se numeran empezando
con 0 siempre.
Algunas operaciones con listas
Si s es una lista:
●
len(s) nos devuelve la longitud de la lista.
●
s.append(x) añade x al final de la lista s.
●
s.insert(k,x) inserta x en la posición k de la lista s.
●
●
●
del s[k] elimina de la lista s el elemento en la posición
k.
s[i:j] nos devuelve una sublista desde el elemento i
inclusive hasta el j-1.
[x]*n genera una lista de longitud n cuyos elementos
son x.
Listas (ejemplos)
>>> a = [1.0, 2.0, 3.0]
>>> a.append(4.0)
# Creamos
una lista
# Añadimos 4.0 a la lista
>>> print(a)
[1.0, 2.0, 3.0, 4.0]
>>> a.insert(0, 'a')
# Insertamos 'a' en la posición 0
>>> print(a)
['a', 1.0, 2.0, 3.0, 4.0]
>>> print(len(a))
# Determinamos la longitud de la lista
5
>>> a[2:4] = [1.0, 1.0] # Modificamos los elementos seleccionados
# la
>>> print(a)
['a', 1.0, 1.0, 1.0, 4.0]
Listas
●
●
●
Si a es un objeto mutable, la declaración b = a
no da como resultado un nuevo objeto b,
simplemente crea una nueva referencia a a.
cualquier cambio realizado a b se reflejará en a.
Para crear una copia independiente de una lista
a, usaremos la declaración c=a[:].
Para realizar copias de listas que incluyen listas
u otras colecciones se deben utilizar funciones
dentro del módulo copy.
Listas (ejemplos)
>>> a = [1.0, 2.0, 3.0]
>>> b = a
# ’b’ es un alias de ’a’
>>> b[0] = 5.0
# cambia ’b’
>>> print(a)
[5.0, 2.0, 3.0]
>>> c = a[:]
# el cambio se refleja en ’a’
# ’c’ es copia independiente de ’a’
>>> c[0] = 1.0
# cambia ’c’
>>> print(a)
[5.0, 2.0, 3.0]
# ’a’ no está afectada
Listas
●
●
●
Podemos representar matrices mediante listas
anidadas, donde cada fila se representa por
una lista.
Salvo algunas excepciones no utilizaremos
listas para crear matrices numéricas.
Para crear matrices es mas conveniente utilizar
el módulo numpy (que veremos más adelante).
Listas (ejemplos)
Creemos una lista de listas
>>> a = [[1, 2, 3], \
... [4, 5, 6], \
... [7, 8, 9]]
>>> print(a[1])
# Imprime la segunda fila
[4, 5, 6]
>>> print(a[1][2]) # Imprime el tercer elemento
# de la segunda fila
6
Listas (ejemplos)
●
●
Recordemos que el símbolo \ al final de línea
es el carácter de continuación de Python.
Las secuencias en Python tienen un offset
(desplazamiento) cero, de manera que a[0]
representa la primera fila, a[1] la segunda y
así sucesivamente.
Operaciones con listas y cadenas
●
Se puede romper una cadena y crear una lista:
>>> s = 'esto es
>>> s.split()
una cadena'
# rompe por los blancos
['esto', 'es', 'una', 'cadena']
●
Se pueden concatenar los elementos de una lista para
formar una cadena:
>>> l = ['a', 'b', 'c']
>>> '/=!'.join(l) # une separando con /=!
a/=!b/=!c
Diccionarios
●
Los diccionarios, también llamados matrices
asociativas, deben su nombre a que son
colecciones que relacionan una clave y un
valor. Por ejemplo, veamos un diccionario con
algunas unidades derivadas del SI:
UniSI = {“frecuencia”: “hercio”,
“fuerza”: “newton”}
●
Debemos fijarnos en las dos llaves, una al
principio { y otra al final }.
Diccionarios
●
●
El primer valor se trata de la clave y el segundo del
valor asociado a la clave. Como clave podemos
utilizar cualquier valor inmutable, podríamos usar
números, cadenas, booleanos, tuplas, etc., pero no
listas o diccionarios, dado que son mutables.
La diferencia principal entre los diccionarios y las
listas o las tuplas es que a los valores almacenados
en un diccionario se les accede no por su índice,
porque de hecho no tienen orden, sino por su clave,
utilizando de nuevo el operador []
d[“frecuencia”] # devuelve “hercio”
Diccionarios
●
●
Al igual que en listas y tuplas también se puede
utilizar este operador para reasignar valores.
d[“potencia”] = “vatio”
Sin embargo en este caso no se puede utilizar
slicing ('troceado', como hemos visto con las
sublistas) entre otras cosas porque los
diccionarios no son secuencias, si no 'mapeados'
(o asociaciones).
Tema 4. Python como lenguaje
algorimico
●
Introducción
●
Usando Python
●
Variables y tipos de datos. Operadores
●
Estructuras de control de flujo: condicionales,
bucles y excepciones
●
Entrada y salida de datos
●
Funciones y módulos
Estructuras de control de flujo
●
Condicionales
●
Bucles
●
Excepciones (control de errores)
Condicionales
●
●
Si un programa no fuera más que una lista de
órdenes a ejecutar de forma secuencial, una
por una, no tendría mucha utilidad.
Los condicionales nos permiten comprobar
condiciones y hacer que nuestro programa se
comporte de una forma u otra, que ejecute un
fragmento de código u otro, dependiendo de
esta condición. Aquí es donde cobran su
importancia el tipo booleano y los operadores
lógicos y relacionales.
Condicionales
●
La forma más simple de una construcción
condicional es un if (del inglés si) seguido de la
condición a evaluar, dos puntos (:) y en la(s)
siguiente(s) línea(s) e indentado, el código a
ejecutar en caso de que se cumpla dicha
condición:
if condición:
código a ejecutar
Cómo se definen bloques
●
Los bloques se identifican con dos puntos (:) y en la(s)
siguiente(s) línea(s) e indentado, el código a ejecutar en caso
de que se cumpla dicha condición:
if condición:
►►►►Esta es la línea 1 del bloque
►►►►Esta es la línea 2 del bloque
►►Esta línea tiene mal el indentado
Esta línea no pertenece al bloque anterior
Ojo: el indentado debe ser el mismo en cada bloque
Condicionales
●
La construcción if ... else se utiliza
cuando queremos que se ejecuten ciertas
órdenes en el caso de que la condición no se
cumpliera
if condición:
código a ejecutar
else:
código a ejecutar
Condicionales
●
La construcción if ... elif ... elif ...
else se utiliza para condiciones múltiples (elif es
una contracción de else if):
if condición:
código a ejecutar
elif condición:
código a ejecutar
else:
código a ejecutar
Condicionales (ejemplos)
def signo_de_a(a):
if a < 0.0:
signo = ’negativo’
elif a > 0.0:
signo = ’positivo’
else:
signo = ’cero’
return signo
a = 1.5
print(’a es ’ + signo_ de_ a(a))
a es positivo
Bucles
●
Mientras que los condicionales nos permiten
ejecutar distintos fragmentos de código
dependiendo de ciertas condiciones, los
bucles nos permiten ejecutar un mismo
fragmento de código un cierto número de
veces, mientras se cumpla una determinada
condición.
Bucles
●
Construcción while
while condición:
código a ejecutar
●
El código se ejecuta mientras la condición sea
verdadera. Este proceso continuará hasta que
la condición sea falsa.
Bucles
●
Construcción while
while condición:
código a ejecutar
else:
código a ejecutar
●
Podemos utilizar un else para ejecutar un
código alternativo cuando la condición sea
falsa.
Bucles (ejemplos)
nMax = 5
n = 1
a = [] # Crea una lista vacía
while n < nMax:
a.append(1.0/n) # Añade elementos a la lista
n = n + 1
print(a)
[1.0, 0.5, 0.33333333333333331, 0.25]
Bucles
●
Construcción for ... in
for elemento in secuencia:
código a ejecutar
Para cada elemento de la secuencia ejecuta
las líneas de código.
●
En Python for se utiliza como una forma
genérica de iterar sobre una secuencia. Y
como tal intenta facilitar su uso para este fin.
Bucles
●
Los for se utilizan en Python para recorrer
secuencias (principalmente listas o tuplas), por
lo que vamos a utilizar un tipo secuencia, como
es la lista, para nuestro ejemplo.
Bucles (ejemplos)
nMax = 5
a = []
for n in range(1, nMax):
a.append(1.0/n)
print(a)
Aquí la secuencia es la lista [1, 2, ..., nMax-1], que
hemos creado llamando a la función range. Otra manera
de hacerlo es con comprensión de listas:
a = [1.0/n for n in range(1, nMax)]
Bucles (ejemplos)
También se puede iterar en una lista mediante el índice y el
elemento usando la función de lista enumerate:
>>> z = ['a', 5, (1.0, 2.0)]
>>> for indice, elem in enumerate(z):
...
print(indice, elem)
...
(0, 'a')
(1, 5)
(2, (1.0, 2.0))
Bucles
●
●
Cualquier bucle puede finalizarse con la
sentencia break.
En el ejemplo siguiente, para obtener lo que el
usuario escriba en pantalla utilizamos la función
raw_input (que luego veremos).
Bucles (ejemplo)
lista = [’Marta’, ’Juan’, ’Pedro’, ’Carmen’]
nombre = raw_ input(’Escribe un nombre: ’)
Encontrado = False
for i in range(len(lista)):
if lista[i] == nombre:
print(nombre, ’es el número’, i+1, ’de la lista’)
encontrado = True
break
if not encontrado: print(nombre, ’no está en la lista’)
Bucles
●
La sentencia continue. Esta sentencia salta
directamente a la siguiente iteración del bucle.
Bucles (ejemplos)
x = []
# Crea una lista vacía
for i in range(1,100):
if i % 7 != 0: continue
# un if de una sola línea
# si no es divisible por 7 salta
# a siguiente iteración
x.append(i)
print(x)
[7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]
Excepciones
●
La sentencia try ... except ... else ...
finally ... nos permite controlar errores de
ejecución sin que el programa aborte:
try:
sentencias que se prueban
except:
sentencias que se ejecutan en caso de error
else:
# opcional
sentencias que se ejecutan si no hay error
finally:
# opcional
sentencias que se ejecutan siempre al final
Excepciones (ejemplo)
# un ejemplo sencillo
x = eval(raw_input('x ? ')) # se evalúa una expresión
try:
y = 1/x
except:
print('se divide por cero')
else:
print('no se divide por cero')
finally:
print('esto se ejecuta siempre al final')
Comprobaciones (“aserciones”)
●
Para comprobar una afirmación que si es falsa nos
muestra un mensaje de error y aborta el programa, y si es
verdadera se continua la ejecución, se usa assert:
assert x >= 0, 'x debe ser no negativa'
Tema 4. Python como lenguaje
algorimico
●
Introducción
●
Usando Python
●
Variables y tipos de datos. Operadores
●
Estructuras de control de flujo: condicionales,
bucles y excepciones
●
Entrada y salida de datos
●
Funciones y módulos
Funciones de entrada y salida
●
Entrada estándar
●
Salida estándar
●
Ficheros
Entrada estándar
●
●
La forma más sencilla de obtener información
por parte del usuario es mediante la función
raw_input.
Esta función toma como parámetro una cadena
a usar como prompt (texto a mostrar al usuario
pidiendo la entrada) y devuelve una cadena
con los caracteres introducidos por el usuario.
nombre= raw_input(“¿Como te llamas?”)
print(“Encantado, “ + nombre)
Entrada estándar
●
Si necesitamos un valor numérico (incluso una
expresión matemática) como entrada en lugar
de una cadena utilizaremos la función
eval(cadena).
Entrada estándar (ejemplo)
a = raw_input(’Introduce a: ’)
print(a, type(a))
# Muestra en pantalla el
# valor de a y su tipo
b = eval(a)
print(b, type(b))
# Muestra en pantalla el
# valor de b y su tipo
Entrada estándar (ejemplo)
Si ejecutamos el programa dos veces obtendremos:
Introduce a: 10.0
10.0 <type ’str’>
10.0 <type ’float’>
Introduce a: 11**2
11**2 <type ’str’>
121 <type ’int’>
Entrada estándar
●
Una forma de introducir una variable numérica
es mediante la sentencia:
a = eval(raw_input(prompt))
que es equivalente a:
a = input(prompt)
Salida estándar
●
●
●
La forma más sencilla de mostrar algo en la salida
estándar es mediante el uso de la función print.
Nota: en Python v2 print es una instrucción y se
puede usar también sin paréntesis. Es preferible
usar paréntesis que funciona en Python v3.
En su forma más básica a la función print le
sigue una cadena, que se mostrará en la salida
estándar al ejecutarse la sentencia.
>>> print(“Hola mundo”)
Hola mundo
Salida estándar
●
La función:
print(objeto1, objeto2, ...)
Convierte cada objeto en una cadena y los
muestra por pantalla en la misma línea
separados por espacios.
●
Pueden usarse los caracteres especiales para
cambiar la formar de mostrar los parámetros
por pantalla.
Salida estándar (ejemplo)
>>> a = 1234.56789
>>> b = [2, 4, 6, 8]
>>> print(a, b)
1234.56789 [2, 4, 6, 8]
>>> print(’a =’+str(a)+’\nb =’+str(b))
a = 1234.56789
b = [2, 4, 6, 8]
# se salta línea debido a \n
Salida estándar
●
●
El operador % puede utilizarse para construir
una tupla.
La sentencia de conversión es:
'%format1 %format2 ...' % tupla
Donde format1, format2, etc., son las
especificaciones de formato de cada objeto
dentro de la tupla.
Salida estándar
●
Las especificaciones para los formatos más
utilizados son:
wd
Entero
w.nf Coma flotante
w.ne Notación exponencial
Donde w es la anchura del campo y n es el
número de dígitos después del punto decimal.
Salida estándar (ejemplos)
>>> a = 1234.56789
>>> n = 9876
>>> print(’%7.2f’ % a)
1234.57
>>> print(’n = %6d’ % n)
n =
9876
# 2 espacios
>>> print(’n = %06d’ % n)
n = 009876
# 2 ceros
>>> print(’%12.4e %6d’ % (a, n))
1.2346e+003
9876
Ficheros
●
Abrir y cerrar ficheros
●
Leer datos de un fichero
●
Escribir datos en un fichero
Abrir y cerrar ficheros
●
Antes de poder acceder a los datos de un fichero,
debes crear un objeto fichero con el comando:
objeto_fichero = open(nombre_fichero, acción)
Siendo nombre_fichero la cadena que especifica
el fichero que va a ser abierto, incluido su camino
de búsqueda (path) si es necesario.
Abrir y cerrar ficheros
La acción es una de las siguientes cadenas:
acción
Definición
'r'
Leer de un fichero existente (se usa por
defecto si no se especifica la acción)
'w'
Escribir en un fichero. Si el fichero no existe
lo crea.
'a'
Añade al final de un fichero.
'r+'
Lee y escribe en un fichero existente.
'w+'
Lo mismo que 'r+', pero si el fichero no
existe, lo crea.
'a+'
Lo mismo que 'w+', pero los datos son
añadidos al final del fichero.
Abrir y cerrar ficheros
●
●
Es una buena práctica de programación cerrar
el fichero si no se va a acceder a él durante un
tiempo largo dentro del programa.
Para ello ejecutamos el comando:
objeto_fichero.close()
Leer datos de un fichero
●
Existen tres métodos para leer datos de un
fichero.
1)
S = objeto_fichero.read(n)
Lee n caracteres y los devuelve como una
cadena S. Si se omite n, se leerán todos los
caracteres.
Se puede crear una lista con las líneas:
s.splitlines()
Leer datos de un fichero
2)
objeto_fichero.readline(n)
Lee n caracteres de una línea y los devuelve
como una cadena. Los caracteres los
devuelve como cadena que termina con \n.
Si se omite n se lee toda la línea.
Leer datos de un fichero
3)
objeto_fichero.readlines()
Devuelve una lista de las líneas desde la
primera línea a la última línea del fichero.
Escribir datos en un fichero
●
Para escribir una cadena en un fichero:
objeto_fichero.write()
●
Para escribir una lista de cadenas:
objeto_fichero.writelines()
Ninguno de los métodos añade el carácter '\n' al
final de la linea.
Escribir datos en un fichero
●
La función print puede ser utilizada para escribir
en un fichero de salida.
print(objeto1, objeto2, . . ., file=objeto_fichero)
Este método añade el carácter '\n' al final de la
linea.
●
NOTA: esta forma de usar print sólo es válida
en python 3.x
Tema 4. Python como lenguaje
algorimico
●
Introducción
●
Usando Python
●
Variables y tipos de datos. Operadores
●
Estructuras de control de flujo: condicionales,
bucles y excepciones
●
Entrada y salida de datos
●
Funciones y módulos
Funciones
●
Qué es una función
●
Funciones de conversión de tipos
●
Funciones matemáticas
●
Funciones definidas por el usuario
Qué es una función
●
●
Una función es un fragmento de código con un
nombre asociado que realiza una serie de
tareas y devuelve un valor.
A los fragmentos de código que tienen un
nombre asociado y no devuelven valores se les
suele llamar procedimientos. En Python no
existen los procedimientos, ya que cuando el
programador no especifica un valor de retorno
la función devuelve el valor None (nada).
Funciones de conversión de tipos
●
●
Hemos visto que los números de diferentes
tipos se convierten automáticamente a un tipo
común después de la operación aritmética o
una comparación.
También se pueden cambiar los tipos con
funciones.
Funciones de conversión de tipos
función
int(a)
Descripción
Convierte a en un entero
long(a)
Convierte a en un entero largo
float(a)
Convierte a en un real de coma flotante
complex(a)
Convierte a en un complejo a+0j
complex(a,b)
Convierte a en un complejo a+bj
Funciones de conversión de tipos
●
●
Las funciones anteriores solo trabajan
convirtiendo cadenas en números tan largos
como las cadenas de manera que representen
un número valido.
La conversión de coma flotante a entero se
realiza con un proceso de truncamiento, no por
redondeo.
Conversión de tipos (ejemplos)
>>> a = 5
>>> print(float(d))
>>> b = -3.6
4.0
>>> d = ’4.0’
>>> print(int(d))
>>> print(a + b)
# This fails: d is not
int type
1.4
>>> print(int(b))
-3
>>> print(complex(a,b))
(5-3.6j)
Traceback (most recent
call last):
File ’’<pyshell#7>’’,
line 1, in ?
print(int(d))
ValueError: invalid
literal for int(): 4.0
Funciones matemáticas
●
El núcleo de Python sólo contiene las siguientes funciones
matemáticas.
Función
Descripción
abs(a)
Valor absoluto de a
max(secuencia)
El mayor elemento de una secuencia
min(secuencia)
El menor elemento de una secuencia
round(a,n)
Redondea a con n decimales
cmp(a,b)
Devuelve
-1 si a<b
0 si a=b
1 si a>b
Funciones matemáticas
●
La mayoría de las funciones matemáticas se
encuentran en el módulo math (luego lo
analizaremos), por ejemplo:
Función
Descripción
sin(a)
Calcula el seno de a (en radianes)
exp(a)
Calcula e
log(a)
Calcula el logaritmo natural de a
a
Funciones definidas por el usuario
●
En Python la definición (o declaración) de una
función se realiza de la manera siguiente:
def nombre_funcion (param1, param2, ...):
sentencias
return valor_devuelto
donde param1, param2, …, son los parámetros
(también denominados argumentos formales).
En Python un parámetro puede ser cualquier
objeto, incluida una función.
Documentación sobre una función
●
También podemos encontrarnos con una cadena de texto
como primera línea del cuerpo de la función. Estas cadenas
se conocen con el nombre de docstring (cadena de
documentación) y, como su nombre indica, sirven de
documentación de la función:
def iden (p1, p2):
“””
Esta funcion imprime los dos valores
pasados como argumentos
”””
print(p1)
print(p2)
Funciones definidas (ejemplo)
>>> def iden (p1, p2):
...
print(p1)
...
print(p2)
# definición
...
>>> nombre = 'Sara'
>>> apellido = 'Silva'
>>> iden(nombre, apellido)
Sara
Silva
# invocación
Invocación de una función
●
Al declarar la función lo único que hacemos es asociar
un nombre al fragmento de código que conforma la
función, de forma que podamos ejecutar dicho código
más tarde referenciándolo por su nombre. Es decir, a la
hora de escribir estas líneas no se ejecuta la función.
Para llamar (o invocar) a la función (ejecutar su código)
se escribiría:
iden(“Sara”, “Silva”)
●
Es decir, el nombre de la función a la que queremos
llamar seguido de los valores que queramos pasar como
argumentos entre paréntesis.
Argumentos actuales
●
●
Los argumentos que se pasan cuando se invoca la función se
denominan argumentos actuales (o argumentos a secas).
El número de valores que se pasan como argumentos actuales
al llamar a la función tiene que coincidir con el número de
argumentos formales que la función acepta según la
declaración de la función.
En caso contrario Python dará un error:
>>> iden(“Sara”)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: iden() takes exactly 2 arguments (1 given)
Asociación de argumentos y parámetros
●
Los argumentos de invocación se asocian a los
parámetros de la definición por posición:
def hacer (a, b, c, d):
# definición
hacer (“hola”, 3, abs, [1, 2]) # invocación
●
Cuando se invoca hacer se asocia:
a ← “hola”
# una cadena
b ← 3
# un entero
c ← abs
# la función abs
d ← [1, 2]
# una lista
Argumentos con valores por defecto
●
Los valores por defecto para los argumentos se
definen situando un signo igual después del
nombre del argumento y a continuación el valor
por defecto:
>>> def imprimir (texto, veces=1):
...
print(veces * texto)
>>> imprimir(“hola”)
hola
>>> imprimir(“hola”, 2)
holahola
Número variable de argumentos
●
Es posible definir funciones con un número variable
de argumentos. Para ello se usa un parámetro final
cuyo nombre debe ir precedido del carácter *:
>>> def varios (par1, par2, *otros):
●
...
for valores in otros:
...
print(valores)
Esta sintaxis funciona creando una tupla (de nombre
otros en el ejemplo) en la que se almacenan los
valores de todos los parámetros extra pasados como
argumento.
Número variable de argumentos (ejemplo)
>>> varios(1, 2)
>>> varios(1, 2, 3)
3
>>> varios(1, 2, 3, 4)
3
4
>>> varios('a', 'b', 'c', 'd')
c
d
Argumentos con nombre
●
●
También se puede preceder el nombre del
último argumento con **, en cuyo caso en
lugar de una tupla se utilizaría un diccionario.
Las claves de este diccionario serían los
nombres de los argumentos indicados al llamar
a la función y los valores del diccionario, los
valores asociados a estos argumentos.
Argumentos con nombre
●
En el siguiente ejemplo se utiliza la función items
de los diccionarios, que devuelve una lista con
sus elementos, para imprimir los argumentos que
contiene el diccionario.
>>> def varios (par1, par2, **mas):
...
...
for i in mas.items():
print i
...
>>> varios(1, 2, tercero=3)
('tercero', 3)
Paso de argumentos por valor y referencia
●
●
No todos los cambios que hagamos a los
parámetros dentro de una función Python se
reflejarán fuera de esta.
En Python existen objetos inmutables, como
las tuplas, las cadenas y los números, por lo
que si intentáramos modificar una tupla pasada
como argumento lo que ocurriría en realidad es
que se crearía una nueva instancia, por lo que
los cambios no se verían fuera de la función
(aunque sí dentro de ella).
Paso de argumentos por valor y
referencia (ejemplos)
●
En este ejemplo se hace uso de la función append de las listas:
>>> def f(x, y):
...
x = x + 3
...
y.append(23)
...
print('dentro de f', x, y)
...
>>> x = 22
>>> y = [22]
>>> f(x, y)
>>> print('fuera de f', x, y)
Paso de argumentos por valor y
referencia (ejemplos)
●
El resultado de la ejecución de este programa
sería:
('dentro de f', 25, [22, 23])
('fuera de f',
●
22, [22, 23])
Como vemos la variable x no conserva los
cambios una vez salimos de la función porque los
enteros son inmutables en Python. Sin embargo la
variable y si los conserva, porque las listas son
mutables.
Retornando valores en una función
●
La sentencia return permite devolver valores.
>>> def sumar (x,y):
...
return x+y
...
>>> print(sumar(2, 3))
5
Esta función suma los valores pasados como
argumentos y devuelve el resultado como
valor de retorno.
Retornando valores en una función
●
También podríamos devolver varios valores con
return.
>>> def cuadrados (x, y):
...
return x**2, y**2
...
>>> cuadrados(2, 4)
(4, 16)
>>>
Aquí Python crea una tupla cuyos elementos son los
valores a devolver y esta tupla es la que se devuelve.
Funciones definidas (ejemplos)
(Mejor introducir este programa en un fichero difs.py)
from math import atan
def finite_diff (f, x, h = 0.0001):
''' aproxima la primera y segunda derivada
de f en x; h tiene un valor por defecto'''
fm, f0, fp = f(x-h), f(x), f(x+h)
df, ddf = (fp-fm)/(2*h), (fp-2*f0+fm)/h**2
return df, ddf
x = 0.5
df, ddf = finite_diff(atan, x)
print(’Primera derivada = ’, df)
print(’Segunda derivada = ’, ddf)
Funciones definidas (ejemplos)
●
●
La función arco tangente (atan) se pasa a
finite_diff como argumento.
La salida del programa será:
('Primera derivada = ', 0.79999999957308665)
('Segunda derivada = ', -0.63999999189157109)
Sentencia lambda
●
Si la función tiene la forma de una expresión,
puede ser definida de forma sencilla con la
sentencia lambda, que permite funciones de una
sola línea:
nombre-funcion = lambda arg1, arg2, ...: expresion
●
lambda se utiliza normalmente en programación
funcional.
Sentencia lambda (ejemplo)
>>> c = lambda x, y : x**2 + y**2
>>> print(c(3, 4))
25
Módulos
●
●
●
●
Funciones relacionadas entre sí se pueden agrupar en
módulos.
Hay muchos (cientos) módulos preparados por
desarrolladores para realizar tareas relacionadas entre
sí.
Un módulo también puede contener submódulos. En
ese caso el módulo principal se denomina paquete
(package).
Excepto en el caso de programas muy simples, es
conveniente subdividir las tareas en funciones
asociadas en módulos.
Pidiendo ayuda sobre módulos
●
Dentro de Python se obtiene una lista de módulos
usando:
>>> help(“modules”)
(Ojo, es una lista muy larga.)
●
La ayuda de un módulo concreto se obtiene así:
>>> help(nombre_del_módulo)
por ejemplo:
>>> help(“time”)
nos da ayuda acerca de funciones sobre tiempo y
fecha.
El diseño de módulos no es difícil
●
●
●
●
Un programador puede diseñar un módulo
juntando funciones en un mismo fichero.
El nombre del fichero pasará a ser el nombre
del módulo.
En el ejemplo siguiente se tiene un fichero
“aritmetica.py” que puede usarse como
módulo.
Define dos variables (cero y uno) y dos
funciones (suma y resta).
Ejemplo (fichero “aritmetica.py”)
“””Define diversas funciones y variables”””
uno
= 1
cero = 0
def suma (x, y):
“””suma variables”””
return x+y
def resta (x, y):
“””resta variables”””
return x-y
Ejemplo (fichero “aritmetica.py”)
>>> from aritmetica import *
>>># la línea anterior hace conocido todo lo
>>># definido en el fichero aritmetica.py
>>>print(uno)
1
>>>print(cero)
0
>>>suma(3, 4)
7
>>>resta(3, 4)
-1
Ejemplo (fichero “aritmetica.py”)
>>> import aritmetica
>>># la línea anterior hace conocido todo lo definido en
>>># el fichero aritmetica.py pero la invocación
>>># necesita ser precedida del nombre del módulo (aritmetica)
>>>print(aritmetica.uno)
1
>>>print(aritmetica.cero)
0
>>>aritmetica.suma(3, 4)
7
>>>aritmetica.resta(3, 4)
-1
Listar el contenido de un módulo
●
●
El contenido de un módulo puede ser mostrado
con la sentencia dir(modulo).
En el ejemplo anterior:
>>> import aritmetica
>>> dir(aritmetica)
['__builtins__', '__doc__', '__file__',
'__name__', '__package__', 'cero', 'resta',
'suma', 'uno']
Ayuda sobre un módulo
●
Se pide ayuda sobre contenido de un módulo mediante help(modulo).
●
En el ejemplo anterior:
>>> import aritmetica
>>> help(aritmetica)
# la salida siguiente es aproximada
Help on module aritmetica:
NAME
aritmetica - Define diversas funciones y variables
FILE
aritmetica.py
FUNCTIONS
resta(x, y)
resta variables
(continua con más texto)
Variables globales y locales
●
Las variables definidas en un fichero fuera de una
función son globales y se conocen a partir de su
definición dentro del fichero (incluso dentro de las
funciones):
x = 3
def f (y):
print(x, y)
f('a')
# imprime (3, 'a')
Variables globales y locales
●
Sin embargo si dentro de una función se asigna una variable de
ese nombre se pierde el acceso a la vieja:
x = 3
def f (y):
x = 8
# crea una nueva variable local a la función
print(x, y) # usa la nueva x; no hay acceso a la otra
f('a')
# imprime:
(8, 'a')
print(x) # fuera de la función, imprime 3
Variables globales y locales
●
Si queremos asignar a una variable un valor dentro dentro de una
función se debe usar la sentencia global:
x = 3
def f (y):
global x
# esta x no es nueva, sino la definida antes
x = 8
print(x, y)
f('a')
# imprime (8, 'a')
print(x) # imprime 8
●
●
Se dice que existe un efecto lateral y debe tenerse especial cuidado.
Se denomina función pura aquélla que no tiene efectos laterales (no
usa variables globales, ni paso por referencia ni maneja ficheros).
Algunos módulos estándar
●
●
●
En Python la mayoría de las funciones
matemáticas se encuentran en el módulo math.
El módulo time nos da información sobre
tiempo y fecha.
El módulo sys nos permite interaccionar con el
sistema operativo (también existe otro módulo
os con más funciones).
Módulo math
●
●
En Python la mayoría de las funciones matemáticas se
encuentran en el módulo math.
Existen tres formas de acceder a las funciones dentro
del módulo:
●
●
●
Cargado todas las funciones del módulo
from math import *
Seleccionando las funciones
from math import func1, func2
El utilizado por la mayoría de los programadores que
consiste en tener habilitado el módulo
import math
Funciones dentro del módulo math
●
Dentro de math tenemos las funciones:
acos, acosh, asin, asinh, atan, atan2,
atanh, ceil, copysign, cos, cosh, degrees,
erf, erfc, exp, expm1, fabs, factorial,
floor, fmod, frexp, fsum, gamma, hypot,
isinf, isnan, ldexp, lgamma, log, log10,
log1p, modf, pow, radians, sin, sinh, sqrt,
tan, tanh, trunc
y las variables:
e
= 2.7182818284590451
pi = 3.1415926535897931
Módulo time
●
Nos proporciona funciones para el manejo de
fechas y del tiempo. Algunas interesantes son:
●
●
●
●
time.time() nos devuelve el número de segundos
desde un instante inicial (dependiente del SO).
time.ctime(x) nos devuelve una cadena con la
fecha que corresponde al tiempo x en segundos. Si no
se indica x se usa la fecha y hora actuales.
time.sleep(x) suspende la ejecución durante x
segundos.
time.clock() nos devuelve el tiempo de ejecución
de CPU hasta ese momento del intérprete de Python.
Ejemplo de uso de time.clock()
Tecleemos el fichero pruebacos.py:
import time, math
t = time.clock()
for i in range(1000000):
math.cos(i)
dt = (time.clock()-t)/1000000
print('un coseno tarda %e s de CPU' % dt)
$ python pruebacos.py
un coseno tarda 5.200000e-07 s de CPU
Módulo sys
●
Nos proporciona funciones para interaccionar con el
sistema operativo. Algunas interesantes son:
●
sys.platform es una cadena con el nombre del
sistema operativo.
●
●
sys.exit(n) acaba el programa, devolviendo un
número entero n al sistema operativo como código de
finalización.
sys.argv es una lista con los argumentos que
hemos utilizado al llamar al intérprete de Python.
Sirve para pasar información a nuestro programa. El
primer elemento de la lista es siempre el nombre de
nuestro programa.
Ejemplo de uso de sys.argv
Tecleemos el fichero param.py:
import sys
for i, a in enumerate(sys.arg):
print(i, a)
$ python param.py 1.2 'y=2*log(x)' 'mi nombre'
(0, 'param.py')
(1, '1.2')
(2, 'y=2*log(x)')
(3, 'mi nombre')