Practica 5
Practica 5
Practica 5
Grado en Fı́sica
Curso 2017–18
5.1. Objetivo
Familiarizarse con las estructuras de control de flujo y las funciones de entrada y salida.
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. Por un lado, en los programas no existirı́a la posibilidad de elegir uno
de entre varios caminos en función de ciertas condiciones (sentencias alternativas). Y por el otro,
no podrı́an ejecutar algo repetidas veces, sin tener que escribir el código para cada una (sentencias
repetitivas).
Para estos dos problemas tenemos dos soluciones: las sentencias de control alternativas y las
repetitivas.
Las sentencias alternativas nos permiten seleccionar uno de entre varios caminos por donde seguirá
la ejecución del programa. Este tipo de sentencias se denominan Condicionales.
Las sentencias repetitivas se denominan también sentencias iterativas—ya que permiten realizar algo
varias veces (repetir, iterar)—, y de manera más corriente Bucles.
5.2.1. Condicionales
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 una condición.
Aquı́ es donde cobran su importancia el tipo booleano y los operadores lógicos y relacionales.
1
Universidad de Oviedo Departamento de Fı́sica
La forma más simple 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, su sintaxis es:
if condición:
código a ejecutar
La construcción if ... elif ... elif ... else se utiliza para condiciones múltiples
(elif es una contracción de else if). Su sintaxis es:
if condición:
código a ejecutar
elif condición:
código a ejecutar
else:
código a ejecutar
2. Ejecute el programa.
Ejemplo 5.2.2. Uso de la construcción if ... elif ... elif ... else.
2. Ejecute el programa.
Ejercicio 5.2.1. Sea la ecuación de segundo grado ax2 + bx + c = 0. Prepare un código en el que
dados los tres parámetros a, b y c nos determine el signo del discriminante ∆ = b2 − 4ac y según el
mismo calcule las raı́ces reales o complejas conjugadas de la ecuación y las imprima.
5.2.2. 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. Las construcciones que nos permiten crear
un bucle son las sentencias while y for.
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.
Ejemplo 5.2.3. Uso de la construcción while.
1. Cree un archivo con el nombre crea lista w.py y escriba el siguiente código:
nMax = 5
n = 1
a = [ ] # crea una lista vacı́a
while n < nMax:
a.append(1.0/n) # a~
nade un elemento a la lista
n = n + 1
print(a)
3. Observe la respuesta.
2. Ejecute el programa.
Al igual que con la construccion if, con la sentencia while también podemos utilizar más de dos
ramas usando el condicional encadenado, cuya sitaxis es:
while condición:
código a ejecutar
else:
código a ejecutar
Ejercicio 5.2.2. Genere la sucesión de números entre 1 y n (que es un dato) que sean a la vez
múltiplos de 11 y 13, imprimiendo término a término.
Ejercicio 5.2.3. Modifique el programa anterior para que guarde los múltiplos de 11 y 13 en una
lista, e imprima la lista al final.
La construcción for ... in (en inglés ”para ... en”) también nos permite realizar bucles y su
sintaxis es:
código a ejecutar
Para cada elemento de la secuencia ejecuta las lı́neas de código. En Python for se utiliza para
recorrer secuencias (listas, tuplas o cadenas), por lo que vamos a utilizar un tipo secuencia, como
es la lista, para nuestro ejemplo.
1. Cree un archivo con el nombre crea lista f.py y escriba el siguiente código:
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, tal y como se ilustra en el siguiente ejemplo.
Ejemplo 5.2.6. Comprensión de listas
1. Cree un archivo con el nombre crea lista fc.py y escriba el siguiente código:
nMax = 5
a = [1.0/n for n in range(1, nMax)]
print(a)
Ejercicio 5.2.4. Modifique el último ejercicio, generando la lista de números múltiplos de 11 y 13,
mediante comprensión de listas.
Se puede iterar en una lista mediante el ı́ndice y el elemento usando la función de lista enumerate.
Ejemplo 5.2.7. Uso de la función enumerate.
2. Escriba:
>>> z = [’a’, 5, (1.0, 2.0)]
>>> for i, e in enumerate(z):
... print(i, e)
...
4. Ahora escriba:
>>> for i, e in enumerate(z):
... print(e)
...
Ejercicio 5.2.5. Cree una lista con los números enteros de 1 hasta n (que es un dato) y luego
modifique los términos múltiplos de 3 cambiándolos de signo. Finalmente imprima la lista final para
comprobar que el programa funciona bien.
Ejemplo 5.2.8. Un 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).
Ejercicio 5.2.6. Cree un fichero con el nombre TemperaturasFC.py que calcule las temperaturas
en la escala Fahrenheit equivalentes el rango de temperaturas desde -20◦ C hasta 40◦ C con saltos de 5
◦ C. Para ello utilice un bucle while para crear dos listas Fdeg y Cdeg que almacenen respectivamente
Ejercicio 5.2.7. Repita el ejercicio anterior utilizando un bucle for en lugar de while.
5.2.3. Excepciones
La sentencia try (en inglés ”intentar”) permite controlar errores de ejecución sin que el programa
aborte. Su sintaxis es la siguiente:
try:
except:
else: # opcional
finally: # opcional
2. Ejecute el programa y vea la salida usando diferentes entradas enteras (incluyendo 0).
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 (podrı́amos traducirlo por ”comprobar”).
Ejemplo 5.2.11. Uso del comando assert:
1. En el programa del ejemplo anterior añadiremos una aserción de manera que si introducimos
un número negativo aborte el programa. Para ello introduzca el siguiente código en la segunda
lı́nea:
assert x > 0, ’x debe ser no negativa’
Ejercicio 5.2.8. Modifique el programa anterior para que muestre el resultado de calcular el inverso
de x.
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.
Si necesitamos un valor numérico (incluso una expresión matemática) como entrada en lugar de una
cadena utilizaremos la función input.
a = input(prompt)
Ejemplo 5.3.1. Uso de las función input .
En Python v3 raw input no existe. Hay que usar directamente input y para introducir una variable
numérica es mediante la sentencia eval(input(prompt))
La forma más sencilla de mostrar algo en la salida estándar es mediante el uso de la función print
(en inglés “imprimir”). 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.
Hola mundo
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. Es posible usar los caracteres especiales para
cambiar la forma de mostrar los parámetros por pantalla.
Ejemplo 5.3.2. Uso de la función print.
Para especificar el formato de salida de los valores es necesario usar el operador de formato %.
Cuando se aplica a enteros, % es el operador de módulo, pero cuando el primer operando es una
cadena, % es el operador de formato.
El operador % puede utilizarse para construir una tupla. La sentencia de conversión es:
Donde format1, format2, etc., son las especificaciones de formato de cada objeto dentro de la tupla.
El resultado es una cadena que contiene los valores de las expresiones, formateados de acuerdo a la
cadena de formato.
ws Cadena
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. Los
caracteres s, d, f y e se escriben tal cual.
Ejemplo 5.3.3. Uso del operador de formato.
2. Escriba:
>>> print(’n = %6d’ % n)
la respuesta será:
n = 9876
5. Escriba:
>>> motos = 52
>>> ’ %d’ % motos
la respuesta será:
’52’
El resultado es la cadena ’52’, que no debe confundirse con el valor entero 52.
Una secuencia de formato puede aparecer en cualquier lugar de la cadena de formato, de modo
que podemos incrustar un valor en una frase.
6. Escriba:
>>> motos = 52
>>> ’En julio vendimos %d motos.’ % motos
La respuesta es:
’En julio vendimos 52 motos.’
8. Si escribe:
>>> ’ %d %d %d’ % (1,2)
la respuesta será:
TypeError: not enough arguments for format string
9. y si escribe:
>>> ’ %d’ % ’euros’
la respuesta será:
TypeError: illegal argument type for built-in operation
Para tener más control sobre el formato de los números, podemos detallar el número de dı́gitos
como parte de la secuencia de formato.
10. Escriba:
>>> ’ %6d’ % 62
‘62’
>>> ’ %12f’ % 6.1
’6.100000’
El número tras el signo de porcentaje es el número mı́nimo de espacios que que ocupará el
número. Si el valor necesita menos dı́gitos se añaden espacios en blanco delante del número.
Si el número de espacios es negativo, se añaden los espacios tras el número.
11. Escriba:
>>> ’ %-6d’ % 62
la respuesta (hemos sustituido los espacios por una barra baja para que se vean) será:
’62 ’
También podemos especificar el número de decimales para los números en coma flotante.
12. Escriba:
>>> ’ %12.2f’ % 6.1
la respuesta será:
’ 6.10’
el resultado ocupa doce espacios e incluye dos dı́gitos tras la coma. Este formato es util para
imprimir cantidades con las comas alineadas.
5.4. Ficheros
Mientras un programa se está ejecutando, sus datos están en la memoria. Cuando el programa
termina, o se apaga el computador, los datos de la memoria desaparecen. Para almacenar los datos
de forma permanente se deben poner en un archivo o fichero. Antes de poder escribir en un fichero
o acceder a los datos del mismo, se debe crear un objeto fichero con el comando open (en inglés
“abrir”):
siendo nombre fichero la cadena que especifica el fichero que va a ser abierto, incluido su camino
de búsqueda (path) si es necesario. 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, si existe lo sobreescribe.
’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.
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()
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
del fichero. Se puede crear una lista con todas las lı́neas usando:
s.splitlines()
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.
objeto fichero.readlines()
Devuelve una lista de las lı́neas desde la primera lı́nea a la última lı́nea del fichero.
Las funciones read, readline, readlines, write, writelines y otras que se usan de la manera:
objeto.función(...)
se denominan métodos asociados al objeto (es una notación de la programación orientada a objetos).
1. Cree nuevamente una variable f que apunte al objeto fichero en modo ’w’ con el nombre
texto.dat
2. A continuación escriba:
>>> f.write(’Ya es hora’)
>>> f.write(’de cerrar el archivo’)
3. El cierre del fichero le dice al sistema que hemos terminado de escribir y lo deja listo para leer.
Para cerrar el fichero escriba:
>>> f.close()
1. Ya se puede abrir el archivo de nuevo para lectura y poner su contenido en una cadena. Esta
vez el argumento de modo es ’r’ para lectura. Escriba:
>>> f = open(’texto.dat’, ’r’)
2. Escriba:
>>> lectura = f.read()
>>> print(lectura)
la respuesta será:
Ya es horade cerrar el archivo
No hay un espacio entre ’hora’ y ’de’ porque no se escribió un espacio entre las cadenas.
3. La función read también puede aceptar un argumento que le indica cuántos caracteres leer,
para ello escriba:
>>> f = open(’texto.dat’, ’r’)
>>> print(f.read(7))
la respuesta será:
Ya es h
4. Si no quedan suficientes caracteres en el archivo, read devuelve los que hubiera. Escriba:
>>> print(f.read(1000006))
la respuesta será:
orade cerrar el archivo
5. Cuando se llega al final del archivo, read devuelve una cadena vacı́a. Escriba:
>>> print(f.read())
Ejemplo 5.4.4. Crear un archivo de texto con tres lı́neas de texto separadas por saltos de lı́nea.
1. Escriba:
>>> f = open(’lineas.dat’, ’w’)
>>> f.write(’lı́nea uno\nlı́nea dos\nlı́nea tres\n’)
>>> f.close()
2. El método readline lee todos los caracteres hasta e inclusive el siguiente salto de lı́nea.
Escriba:
>>> f = open(’lineas.dat’, ’r’)
>>> print(f.readline())
la respuesta será:
lı́nea uno
3. readlines devuelve todas las lı́neas que queden como una lista de cadenas:
>>> print(f.readlines())
[’l\xc3\xadnea dos\n’, ’l\xc3\xadnea tres\n’]
En este caso, la salida está en forma de lista, lo que significa que las cadenas aparecen
con comillas y el carácter de acentuado aparece como la secuencia \xc3\xad (que es de la
codificación de caracteres UTF8).
4. Al final del archivo, readline devuelve una cadena vacı́a y readlines devuelve una lista vacı́a.
Para comprobarlo escriba:
>>> print(f.readline())
>>> print(f.readlines())
El argumento de write debe ser una cadena, por lo que para poner otros valores en un archivo,
hay que convertirlos antes en cadenas. La forma más fácil de hacerlo es con la función str. Una
alternativa es usar el operador de formato % visto anteriormente.
1. Cree una variable f que apunte a un objeto fichero que se llame num.dat que esté preparado
para escribir:
>>> f=open(’num.dat’, ’w’)
3. Cierre el fichero y ejecute las órdenes correspondientes para su lectura tal y como mostramos
anteriormente. La respuesta observada debe ser:
’52’
Cuando se crea un archivo nuevo abriéndolo y escribiendo, el nuevo archivo va al directorio en uso
(aquél en el que estuviese al ejecutar el programa). Del mismo modo, cuando abre un archivo para
leerlo, Python lo busca en el directorio en uso. Si quiere abrir un archivo de cualquier otro sitio, tiene
que especificar la ruta del archivo, que es el nombre del directorio (o carpeta) donde se encuentra
éste.
Ejemplo 5.4.6. Para ilustrar el uso de directorios se propone abrir un archivo llamado words que
está en un directorio llamado dict, que está en share, que está en usr, que está en el directorio
raiz del sistema, llamado /. Para ello hay que escribir:
>>> print(f.readline())
Ejercicio 5.4.1. Cree un programa que genere un fichero de datos llamado temperaturasC.dat
donde se guarden las temperaturas Celsius desde -20 ◦ C a 40 ◦ C con un salto de 5 ◦ C. Guarde el
programa en una archivo con el nombre de generaTempC.py. Ejecute el programa y compruebe que
se genera el fichero temperaturasC.dat de forma correcta.
Ejercicio 5.4.2. Cree un programa que lea el archivo de datos temperaturasC.dat y que
convierta los grados Celsius en grados Fahrenheit y genere un archivo de resultados llamado
TemperaturasFC.dat donde se guarde la tabla de tempetaturas con el mismo formato que en
el programa TemperaturasFCv2.py. Guarde este programa con el nombre de generaTempFC.py.
Ejecute el programa y compruebe que funciona correctamente.