Apuntes I Python
Apuntes I Python
Bloque C: Programación
Programando en Python
1. Introducción
Un ordenador es, en esencia, un sistema capaz de realizar cálculos y tomar decisiones lógicas a
una velocidad increíblemente alta.
Dentro de estos sistemas distinguimos una parte física, hardware, formada por todos los
componentes que “se pueden tocar” y una parte lógica, software, compuesta por todos los datos
que la máquina es capaz de procesar y almacenar.
El ordenador procesará (utilizará) estos datos según el control realizado por una secuencia de
instrucciones predefinidas a las que llamaremos programas.
Programa informático: “texto” que incluye las instrucciones que un ordenador va a necesitar
ejecutar para poder resolver un problema.
Al igual que podríamos utilizar distintos lenguajes (inglés, español…) para escribir un texto
tradicional, existen muchos lenguajes de programación diferentes.
El objetivo de esta unidad es aprender a utilizar el lenguaje Python para crear programas que
resuelvan situaciones concretas.
-1-
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
2. Algoritmos
Algoritmo: Serie de pasos a seguir para realizar una determinada tarea técnica.
Un algoritmo se parece a una receta. Una receta dice cómo preparar un plato siguiendo una
serie de pasos. Por ejemplo, para preparar un pastel los pasos a seguir serían: Precalentar el
horno, mezclar la harina con el azúcar y los huevos, poner la mezcla en un molde… y así
sucesivamente.
Sin embargo, el término algoritmo es un término técnico más específico que una simple receta.
Para que una “receta” pueda llegar a ser llamada algoritmo ha de cumplir las siguientes
condiciones:
1. Descripción no ambigua que define que debe hacerse en cada paso. En una receta, un paso
del tipo “cocinar hasta que esté hecho” es ambiguo, no deja claro que quiere decir “hecho”.
Una descripción más objetiva como “cocinar hasta que el queso comience a burbujear” es
más adecuada.
2. Un algoritmo ha de definir el tipo de entradas, tipo de datos que se van a suministrar al
programa. Por ejemplo, se puede requerir dos números y que ambos sean mayores que
cero. O puede requerir una palabra, o una lista de tres números.
3. Un algoritmo generará un conjunto de salidas con características definidas. Por ejemplo,
puede generar el número que sea mayor de dos entradas, la versión en mayúsculas de una
palabra, una lista ordenada de números…
4. El algoritmo siempre ha de terminar y producir un resultado en un tiempo finito.
5. Un algoritmo ha de ser capaz de generar el resultado correcto en cualquier situación. No
sería útil tener un algoritmo que resolviera un problema en el 99% de casos posibles.
6. Si un algoritmo impone una condición a las entradas (precondición), esa condición se debe
satisfacer. Por ejemplo, una precondición podría ser que el algoritmo solamente aceptara
números positivos como entradas. Si las precondiciones no se cumplen sería aceptable que
el algoritmo produjera una respuesta incorrecta o que nunca llegara a terminar.
Crear el algoritmo que resuelva el problema es un paso básico en el proceso de programación.
Ejemplo: Dada una lista de números positivos, devuelve el número mayor de la lista.
- Entradas (Inputs): Una lista L de números positivos, debe contener al menos un número.
- Salidas (outputs): Una “caja” que llamaremos max, almacenará el número mayor de la lista.
- Algoritmo:
o Asignar a max el valor 0.
o Para cada número x en la lista L, comparar su valor con max. Si x es mayor que max,
asignar a max el valor x.
o Mostrar el valor almacenado en max que contiene el valor máximo en la lista.
¿Satisface esta “receta” los criterios para ser considerada un algoritmo?
1. ¿Es no ambigua? Si. Cada paso es una operación sencilla fácilmente traducible a un
código de programación (Python en nuestro caso).
2. ¿Se definen las entradas? Sí
3. ¿Se definen las salidas? Sí.
4. ¿Está garantizada su finalización? Sí. La lista L tiene un tamaño finito, por lo tanto, tras
revisar cada elemento de la lista el algoritmo se detendrá.
-2-
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
5. ¿Produce el resultado correcto? Si. En un entorno más formal habría que probar su
corrección de forma más rigurosa.
3. Diagramas de flujo
La representación de algoritmos a través de bloques de texto es tediosa y difícil de interpretar
por una persona distinta de la que lo ha elaborado. Normalmente utilizaremos los llamados:
Diagrama de flujo: Representación gráfica mediante símbolos de un algoritmo.
Dentro de los símbolos se escribirán los pasos a seguir en el proceso.
Los diagramas de flujo, son herramientas importantes ya que permiten crear la estructura del
programa sin necesidad de dominar un lenguaje de programación.
La creación del diagrama es la primera fase del desarrollo del programa; previa a la
codificación.
Un diagrama de flujo permitirá que otros puedan comprender fácilmente nuestro algoritmo.
La única desventaja que supone utilizar diagramas de flujo es el espacio necesario para su
desarrollo. El orden es sumamente importante, las hojas deben ser numeradas y señaladas.
Actualmente contamos con software diseñado para la elaboración de diagramas de flujo y
herramientas online que permiten hacer el trabajo de forma más fácil y rápida.
Software instalado en los ordenadores de la sala de informática yEd graph Editor.
Proceso
-3-
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Proceso Predefinido
Llama a una subrutina para ejecutarse, de tal forma que ya
no es necesario volver a crear su diagrama. Por ejemplo, si
hemos creado un diagrama para ordenar números podemos
volver a llamarla, lo cual lo hace un elemento muy práctico. Sub-rutina
Líneas de flujo
-4-
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
-5-
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
-6-
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
-7-
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
-8-
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
-9-
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Siguiendo los pasos que se ven en la siguiente imagen nos dirigimos al lugar donde hayamos
guardado nuestro [Link]:
- 10 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Mostrará:
También es posible ejecutar el programa haciendo doble clic sobre su icono (parecerá
que no, ya que se cierra al terminar la ejecución) o a través del IDE que estemos
utilizando (esta opción la veremos más adelante).
Desde el punto de vista del intérprete de Python
Al ejecutar la aplicación suceden varias cosas a nivel interno, que el programador no observa:
1. Compila el código fuente en algo llamado “bytecode”.
Compilar: Proceso de traducción mediante el cual transformamos la información contendida
en el archivo .py, dividiéndola en procesos más sencillos y traduciéndola a un idioma de más
bajo nivel (más cercano a lo que el ordenador puede entender directamente).
Estos bytecodes son multiplataforma y por lo tanto portables y capaces de funcionar en
cualquier ordenador que tenga instalada la versión de Python en la que el bytecode ha sido
compilado.
Si el proceso Python tiene acceso al proceso de escritura en el ordenador guardará el archivo
con una extensión .pyc (py compilado). Estos archivos se guardarán en un subdirectorio llamado
_pycache_ situado en el directorio donde reside el .py y con un nombre que también indicará la
versión con la que fue creado (ej. [Link]).
Una vez creado el pyc, cuando volvamos a ejecutar el programa, Python saltará el proceso de
compilación y por lo tanto la ejecución será mucho más rápida.
En caso de que el intérprete detecte que ha cambiado algo en código fuente o que la versión de
Python que intenta ejecutar la aplicación sea diferente se volvería a ejecutar la compilación.
Si Python no tiene acceso al proceso de escritura en el ordenador, el proceso de compilación se
tendrá que ejecutar cada vez que ejecutemos el código fuente, ralentizando el proceso. Siempre
que sea posible es aconsejable trabajar de la primera forma.
Si trabajamos desde el terminal, nunca podremos generar el archivo .pyc.
2. Enviamos el bytecode a una “máquina virtual”. Una vez compilado y cargado en memoria
el bytecode es enviado para su ejecución a una aplicación llamada Máquina virtual de
Python (PVM).
- 11 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Máquina virtual de Python: Parte del intérprete de Python capaz de ejecutar estos
bytecodes. Software que simula el funcionamiento de un ordenador prescindiendo de las
características específicas de cada sistema operativo y configuración de hardware.
Estamos hablando pues de un proceso intermedio entre un traductor (lenguajes como basic)
que tendría que compilar completamente cada línea de código cada vez que se ejecuta en el
programa y un lenguaje compilado puro (C++) en el cual el proceso de compilación genera un
archivo en un código máquina que entienda directamente MI ordenador. La velocidad es
intermedia, pero la ventaja es que la PVM es capaz de tratar el bytecode y transformarlo en algo
que CUALQUIER ordenador entenderá, adaptándolo a su propia arquitectura.
Tipos de Python
Existen múltiples distribuciones diferentes del lenguaje Python. Las tres más importantes son:
- CPython: Es el estándar, la llamamos CPython para contrastarla del resto, sino nos
referiremos a ella como Python simplemente.
- Jython, para Java: Compila el código fuente en un bytecode propio del lenguaje Java y el
resultado se ejecuta en una máquina virtual de Java (JVM). La integración es total, un
programa en Jyhton funcionará aparentemente como una aplicación Java, el código podrá
importar otras clases (programas) escritos en Java…
- IronPython, para .NET: Similar al anterior pero diseñado para trabajar con las
aplicaciones .NET de Microsoft (y el equivalente Mono de Linux).
A lo largo de esta unidad trabajaremos con CPython.
- 12 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
En Windows también podemos seleccionar la opción Python contenida en el menú del mismo
nombre contenida en el menú de inicio.
En que veamos los iconos >>> quiere decir que estamos en una sesión interactiva del intérprete
de Python y podemos ejecutar ordenes en Python.
Atajo: La forma más rápida de acceder al intérprete de Python es abrir el cuadro de
diálogo ejecutar (tecleando TeclaWindows+R) y escribir en él la palabra python.
El hecho de que al teclear Python sin más el ordenador sea capaz de ejecutarlo se debe a que el
sistema operativo es capaz de encontrar donde está instalado Python por haberlo incluido esta
ruta en su path de búsqueda de programas cuando hemos realizado la instalación.
A esta forma de trabajar, escribiendo algo de código en la ventana y ejecutarlo directamente se
le llama crear código interactivamente. Cada vez que se pulsa enter, se muestra el resultado de la
orden ejecutada (ni siquiera haría falta poner print)
>>>pera = 'okay'
>>>pera
'okay'
>>>2 ** 8
256
Esta forma de trabajo no permite guardar código, normalmente no la utilizaremos, pero
permite experimentar con el lenguaje sin riesgo a estropear cosas en el programa real.
Cuando utilizamos una orden que requiere más de una línea de código (ordenes
compuestas) es necesario hacer dos veces clic en Enter para ejecutarla.
Vamos a comenzar a utilizar algunos sencillos comandos de Python, para comprender su
funcionamiento utilizaremos una sesión interactiva a través de la consola.
Salir de la sesión interactiva: Ejecuta la orden exit()
- 13 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
7. Tipos de datos
Python puede manejar los siguientes tipos de datos:
- 14 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 15 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 16 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
En la siguiente línea el operador * actúa sobre la variable ancho multiplicando su valor. Así el
resultado de la operación es 40.
Sin embargo, si hacemos:
>>> ancho = "hola"
>>> ancho * 2
'holahola'
El resultado es diferente. Ancho pasa a ser una variable tipo texto. Con este tipo de variables
(y de datos) el operador * no actúa como multiplicador, si no que se utiliza para ver cuantas veces
es necesario representar la cadena de texto.
Las variables deben existir antes de ser utilizadas
En caso de que queramos mostrar el valor contenido dentro de una variable que todavía no ha
sido definida obtendríamos un mensaje de error (la siguiente pantalla muestra el resultado de
hacer una llamada a la variable k que todavía no ha sido definida).
- 17 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 18 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 19 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 20 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Observa que si no definimos el índice inicial de la porción de lista se toma por defecto
el valor cero y si no definimos el índice final se toma la longitud total de la cadena.
- 21 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
11. Listas
Lista: Tipo de variable que se capaz de almacenar más de un valor. Cada uno de los valores
queda definido por un subíndice.
Definimos una lista agrupando los elementos entre corchetes separándolos entre sí por comas:
>>> cuadrados = [1, 4, 9, 16, ‘palabra’]
>>> cuadrados
[1, 4, 9, 16, ‘palabra’]
Cada elemento de la lista pasa a estar identificado por su índice. El valor de cada índice será un
número entero, asignado de forma correlativa y comenzando por el 0. En ejemplo anterior:
>>>cuadrados[0] # añadiendo un índice se muestra su valor asociado
1
>>>cuadrados[-1] # índices negativos comienzan a contar por la derecha (-1)
‘palabra’
>>>print(cuadrados[-1])
palabra
>>>cuadrados[-3:] # porción de listas retornan una nueva lista
[9, 16, ‘palabra’]
Modificar el valor almacenado en un elemento de la lista:
>>>cubos = [1, 8, 27, 65, 125] # hay algo mal aquí
>>> 4 ** 3 # el cubo de 4 es 64, no 65!
64
>>>cubos[3] = 64 # reemplazar el valor incorrecto
>>>cubos
[1, 8, 27, 64, 125]
En el ejemplo anterior modificamos el valor almacenado en el cuarto elemento de la lista.
Modificar los valores almacenados en una porción de lista
Podemos modificar, borrar parcialmente, borrar completamente…
Ojo: Recuerda que el intervalo está cerrado por la izquierda y abierto por la derecha.
>>>letras = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>>letras
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # reemplazar algunos valores
>>>letras[2:5] = ['C', 'D', 'E']
>>>letras
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # ahora borrarlas
>>>letras[2:5] = []
>>>letras
['a', 'b', 'f', 'g']
>>> # borrar la lista reemplazando todos los elementos por una lista vacía
>>>letras[:] = []
>>>letras
[]
- 22 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Si un elemento está repetido en la lista, index nos indicará la posición del que tenga un
índice menor.
Comprobar si un valor está en una lista
La operación in permite comprobar si un valor está incluido en una lista:
- 23 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 24 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 25 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 26 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Una variación. Podemos utilizar las propiedades de la ventana de comandos, así si ejecutamos
el programa según:
python [Link] > [Link]
El resultado se guardará en un archivo de nombre [Link] en el directorio de trabajo.
En Windows 7 podemos escribir directamente el nombre modulo (sin anteponer la
palabra Python) ya que el SO reconoce la extensión .py
- 27 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
A partir de ese momento cuando abras Sublime Text siempre se abrirá ese directorio y se
mostrará la estructura de carpetas de tu directorio Python:
- 28 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 29 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 30 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Ejercicio: Crea un proyecto que sea capaz de leer dos números enteros que introduciremos a
través del teclado, realizará la suma de los dos y mostrará el resultado por pantalla. Añade tantos
comentarios como sea necesario para conseguir que el código sea fácilmente entendible.
La salida debe ser similar a:
Introduce el primer entero: 45
Introduce el Segundo entero: 72
La suma es: 117
- 31 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 32 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
true or true
or O lógico true or false false or false
false or true
not Negación not false not true
Crea un módulo que pida al usuario un número positivo. La respuesta ha de ser almacenada en un
variable a la que llamaremos numero. Comprueba si el número es negativo. Si lo es, el programa
debe avisar del error. Finalmente, el programa muestra siempre el número por pantalla.
- 33 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
if condición1:
bloque de órdenes que se ejecutarán si la condición1 es cierta.
elif condificón2:
bloque de órdenes que se ejecutará si la condición2 es cierta.
else:
bloque de órdenes que se ejecutarán si todas las condiciones son falsas.
Se pueden incluir tantos bloques elif como sean necesarios.
Observa que en este tipo de sentencia las opciones son siempre mutuamente
excluyentes. En cualquier caso solamente se ejecutará uno de los bloques.
En este tipo de estructuras hay que ser cuidadoso con el orden con que escribimos las
condiciones. Con ello:
- Evitaremos olvidar alguna de las situaciones posibles.
- Evitaremos que el programa ejecute un bloque de instrucciones no deseado.
Veamos el siguiente ejemplo:
Modifica el programa anterior de tal forma que distinga tres situaciones. Si introducimos un valor
negativo el programa mostrará un mensaje de error. Si el valor está comprendido entre 0 y 17,
mostrará un mensaje indicando que el usuario es menor de edad y si es mayor o igual a 18 el
mensaje informará de la mayoría de edad del usuario.
Existen múltiples soluciones sin embargo alguna de ellas nos puede dar resultados extraños
como informar de que una persona que tenga -14 años sea menor de edad por ser el valor menor
de 18. Investiga la mejor solución.
Compliquemos ahora las cosas un poco. Utilizando un único bloque if..elif..else diseña un
programa que indique si un número es múltiplo de dos, de dos y de cuatro o si no es múltiplo de
dos. El problema radica en que todos los múltiplos de cuatro son múltiplos de dos pero no todos
los múltiplos de dos son múltiplos de cuatro.
- 34 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Diseña un programa que haciendo sólo con dos preguntas al usuario sea capaz de adivinar el
número entre 1 y 4 que este está pensando.
- 35 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
color=True
talla=False
if ((color==True) and (talla==False)):
print("Ejemplo sencillo")
Si queremos simplificarlo podríamos hacer:
color=True
talla=False
if (color and talla==False):
print("Ejemplo sencillo")
- 36 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Cuerpo del bucle Indentado y contiene las órdenes a ejecutar en cada iteración.
- 37 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
En otros casos el valor que toma la variable de control en cada iteración es fundamental.
Modifica el código del ejemplo anterior para, utilizando un bucle for con tres iteraciones, calcular
los cuadrados de 3, 4 y 5.
Python considerará que pertenece al bucle todo el código indentado que tenga la
misma indentación que la línea siguiente a la línea con la orden for.
La lista puede contener cualquier tipo de elementos, no sólo números.
Modifica el código del ejemplo anterior para, utilizando un bucle for con tres iteraciones, crear
tres saludos personalizados a tres amigos que se llaman Luis, Mireia y Andrés.
Bucle controlado por una cadena de caracteres
En este caso:
- El bucle realizará tantas iteraciones como caracteres tenga la cadena de caracteres.
- En cada iteración la variable irá tomando sucesivamente en cada iteración cada uno de
los caracteres.
for i in "AMIGO":
print("Dame una ", i)
print("¡AMIGO!")
Mostrará como resultado:
Dame una A
Dame una M
Dame una I
Dame una G
Dame una O
¡AMIGO!
Escribe un programa que, utilizando un bucle for, muestre la tabla de multiplicar de un número
que el usuario introduzca a través del teclado.
Bucle controlado por un range()
Un tipo range se puede definir de tres maneras:
- 38 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Ejemplo: Código para mostrar diez veces la palabra Hola utilizando un bucle for y un tipo
range(a).
print("Comienzo")
for i in range(10):
print("Hola ", end="")
print()
print("Final")
Ejemplo: Código muestra los 100 primeros números naturales utilizando un bucle for y un tipo
range(a,b).
for i in range(1,101):
print(i)
Ejemplo: Múltiplos del 3 contenidos entre 1 y 100.
for i in range(3,101,3):
print(i)
Contador: Variable que lleva la cuenta del número de veces que se ha cumplido una
condición.
El código asociado a un contador sería:
i=i+1
Crea un programa que determine cuantos números naturales menores de 100 son múltiplos de
tres.
- 39 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 40 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
- 41 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Cuando se está ejecutando el programa desde otras instancias, la ejecución del mismo se
interrumpirá pulsando la combinación de teclas Ctrl+C. En ese caso se mostrará un mensaje tipo:
Traceback (most recent call last):
File "[Link]", line 3, in <module>
print(i)
Keyboard Interrupt
Encuentra la razón por la que se genera un bucle infinito en cada uno de los siguientes ejemplos:
i=1
while i<= 10:
print(i, "", end="")
i=1
while i> 0:
print(i, "", end="")
i += 1
i=1
while i!= 100:
print(i, "", end="")
i += 2
- 42 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
else Solamente se ejecuta si el bucle termina normalmente (no por acción del break.
pass No hace nada. Se utiliza para dar contenido a una orden que no va a hacer nada
pero necesita por sintaxis tener algo escrito en ella.
17.2.1 break
Partimos del programa:
i=1
while i<= 10:
print(i,'- ',end='')
i += 1
print("Programa terminado")
El bucle se ejecutará normalmente, realizado diez iteraciones, mostrando el resultado:
1 – 2 – 3 – 4 – 5 – 6 – 7 – 8 – 9 – 10 – Programa terminado
Si simplemente introducimos la orden break:
i=1
while i<= 10:
print(i,'- ',end='')
i += 1
break
print("Programa terminado")
El resultado tendrá la forma:
1 - Programa terminado
La orden break actúa en la primera iteración y por lo tanto termina la ejecución del bucle mñas
próximo en la que está incluida (en este caso es el único).
Utilizar la orden break de esta forma no tiene mucho sentido ya que siempre se va a ejecutar,
deteniendo el bucle. Normalmente la orden estará incluida dentro de un condicional. Con ello el
bucle se saltará cuando se cumpla dicha condición. Un ejemplo sencillo:
i=1
while i<= 10:
print(i,'- ',end='')
i += 1
if i==7:
break
- 43 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
print("Programa terminado")
En este caso la salida sería:
1 – 2 – 3 – 4 – 5 – 6 – Programa terminado
17.2.2 continue
Si en lugar de break utilizamos continue, el resultado es diferente:
i=1
while i<= 10:
print(i,'- ',end='')
i += 1
if i==7:
continue
print("Programa terminado")
El resultado será:
1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - Programa terminado
Parece que continue no ha hecho nada ya que el resultado es el mismo que en caso del
programa sencillo. Pero no es así, el problema es que el resultado no es apreciable. Piensa en
ello, continue termina la ejecución de la vuelta actual del bucle. Al estar colocado al final de la
iteración el que i sea igual a 7 o no lo sea no afecta al resultado del bucle. Debemos cambiar la
posición de la orden incremental:
i=1
while i<= 10:
print(i,'- ',end='')
if i==7:
continue
i += 1
print("Programa terminado")
En este caso el programa creará un bucle infinito que no terminará nunca ya que al llegar i al
valor 7, la condidicón del if es cierta, se ejecuta el continue, terminando la vuelta del bucle actual y
por lo tanto desde ese momento nunca se vuelve a ejecutar la orden i += 1 con lo que i continúa
valiendo 7.
Si queremos evitar este problema podemos utilizar el código:
i=1
while i<= 10:
print(i,'- ',end='')
if i==7:
i += 2
continue
i += 1
print("Programa terminado")
En este caso la salida será:
1 - 2 - 3 - 4 - 5 - 6 - 7 - 9 - 10 - Programa terminado
- 44 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Sin mostrar el valor 8 ya que cuando i vale 7 modificamos su valor sumando dos unidades en
lugar de una, la orden continue hace que i+=1 no se ejecute cuando i vale 7.
17.2.3 else
El else asociado a un bucle while o for delimita un conjunto de órdenes que solamente se
ejecutan si hemos salido del bucle sin que se haya ejecutado una orden break.
Según el ejemplo anterior:
i=1
while i<= 10:
print(i,'- ',end='')
if i==7:
break
i += 1
else:
print("Programa terminado")
La salida será:
1-2-3-4-5-6-7-
Cuando i=7 el bucle se interrumpe, por lo tanto el bloque de ordenes asociado a else no se
ejecutará.
En cambio:
i=1
while i<= 10:
print(i,'- ',end='')
if i==77:
break
i += 1
else:
print("Programa terminado")
La salida en este caso será:
1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - Programa terminado
La orden break no llega a ejecutarse ya que i nunca puede llegar a tomar el valor 77. Por lo
tanto el bucle termina normalmente y a continuación se ejecuta el bloque de instrucciones
asociados al else.
17.2.4 pass
La mejor forma de entender la funcionalidad de esta orden es ver un ejemplo. Siguiendo con el
caso anterior:
i=1
while i<= 10:
print(i,'- ',end='')
if i==77:
break
i += 1
else:
- 45 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
^
SyntaxError: unexpected EOF while parsing
Se genera un error de sintáctico ya que else requiere que en su interior exista al menos una
orden. La solución es incluir la orden pass que no tiene ninguna utilidad más que la de dar
contenido (hacer montón).
i=1
while i<= 10:
print(i,'- ',end='')
if i==77:
break
i += 1
else:
pass
La salida es:
1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 -
- 46 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
18. Funciones
Listado de las funciones más habituales.
Función Descripción
str() Transforma un número en cadena de caracteres.
int() Transforma una cadena de caracteres en un número entero.
float() Transforma una cadena de caracteres en un número decimal.
round(a,b) Redondea el número a con b decimales.
chr(num) Devuelve el carácter correspondiente al valor “num” en código ASCII.
ord(‘x’) Devuelve el código ASCII del carácter ‘x’.
# Separador de miles:
print(format(numero, ','))
print(format(numero, '0,.1f'))
# Notación científica:
print(format(numero, 'e'))
print(format(numero, '0.2E'))
19. Métodos
Listado de métodos de interés.
Función Descripción
[Link]() Devuelve la cadena de caracteres o variable en letras minúsculas.
[Link]() Devuelve la cadena de caracteres o variable en letras mayúsculas.
- 47 -
TIC 1º BTO IES Grande Covián
Informática I Zaragoza
Tabla de contenido
1. Introducción......................................................................................................................................1
2. Algoritmos........................................................................................................................................2
3. Diagramas de flujo............................................................................................................................3
3.1 Principales elementos en un Diagrama de Flujo.......................................................................................................3
3.2 Reglas para la elaboración de un Diagrama de Flujo................................................................................................4
3.3 Como hacer un diagrama de flujo.............................................................................................................................5
3.4 Ejemplos de Diagramas de Flujo................................................................................................................................6
4. Tipos de lenguajes de programación................................................................................................8
4.1 ¿Por qué Python?.......................................................................................................................................................9
5. Ejecutar un programa Python........................................................................................................10
6. Utilizar Python desde la línea de comandos..................................................................................13
7. Tipos de datos.................................................................................................................................14
8. Operadores. Trabajando con números..........................................................................................15
9. Comenzando a utilizar variables.....................................................................................................16
10. Cadenas de caracteres – función print()......................................................................................18
10.1 print() con más de un argumento..........................................................................................................................18
10.2 Opciones sencillas cadenas de caracteres y print()...............................................................................................19
10.3 Funciones de tipo f.................................................................................................................................................20
10.4 Índices en las cadenas de texto.............................................................................................................................21
11. Listas.............................................................................................................................................22
11.1 Opciones trabajando con listas............................................................................................................................23
12. Ejecutar un archivo .py.................................................................................................................26
12.1 Ejecutar el archivo desde la línea de comandos....................................................................................................26
12.2 Ejecutar haciendo clic en el icono del módulo.......................................................................................................27
13. Programar con Sublime Text. Primer programa..........................................................................28
14. Pasando valores al programa –input().........................................................................................30
14.1 Números e input()..................................................................................................................................................30
14.2 Argumento de la función input()...........................................................................................................................31
15. Sentencias condicionales: if… elif…else….....................................................................................32
15.1 Sentencia condicional if… (Una opción).................................................................................................................32
15.2 if … else … (dos opciones)......................................................................................................................................33
15.3 if… elif… else… (más de dos opciones)...................................................................................................................33
15.4 Sentencias condicionales anidadas.......................................................................................................................34
15.5 Sintaxis alternativa con valores lógicos.................................................................................................................35
15.6 Concatenación de comparadores lógicos..............................................................................................................36
15.7 If con el operador in...............................................................................................................................................36
16. El bucle for....................................................................................................................................37
16.1 Contadores y acumuladores..................................................................................................................................39
16.2 Bucles anidados.....................................................................................................................................................40
17. Bucle while....................................................................................................................................41
17.1 Bucles infinitos.......................................................................................................................................................42
17.2 Ordenes break, continue, pass y else en bucles.....................................................................................................43
18. Funciones......................................................................................................................................47
18.1 Formateando la presentación de números...........................................................................................................47
19. Métodos........................................................................................................................................47
- 48 -