Python

Cursos de Formación en Informática - CFI
Introducción a la Programación en
Python
Esta obra está bajo una Licencia Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional
Cursos de Formación en Informática - CFI
Introducción a la Programación en Python
Tabla de contenidos
Introducción y herramientas
1.1 Introducción
1.2 Instalando las herramientas necesarias
1.3 Primer programa
Expresiones y variables
2.1 ¿Qué es un programa?
2.2 Comentarios
2.3 Expresiones numéricas
2.4 Cadenas de texto
2.5 Variables
2.6 Pedir datos al usuario
2.7 Ejercicios resueltos
2.8 Ejercicio 1 (Expresiones)
Instrucciones condicionales
3.1 Operadores de comparación
3.2 Instrucción IF
3.3 Operadores lógicos
3.4 Instrucciones IF más complejas
3.6 Ejercicio 2 (Condicionales)
Bucles y estructuras de datos
4.1 Instrucción WHILE
4.2 Instrucción FOR
4.3 Listas
4.4 Conjuntos
4.5 Diccionarios
4.7 Ejercicio 3 (Bucles y estructuras de datos)
Funciones
5.1 Usando funciones
5.2 Funciones con parámetros
5.3 Programación estructurada
5.5 Ejercicio 4 (Funciones)
Ficheros
6.1 Leer ficheros
6.2 Escribir y gestionar ficheros
6.4 Ejercicio 5 (Ficheros)
Sección 1.1
Sobre este curso
Objetivos del curso
Este es un curso de introducción a la programación usando el lenguaje Python. Durante el curso aprenderás
las instrucciones y estructuras básicas que se usan para construir programas. Estas estructuras no son
exclusivas de Python, existen en casi todos los lenguajes de programación, por lo que, tras completar este
curso, también te será más fácil aprender otros lenguajes de programación. Del mismo modo, si ya conoces
algún otro lenguaje de programación, muchos de los conceptos que explicamos te resultarán familiares.
Es importante entender desde el principio los objetivos de este curso. Cuando lo termines no serás un
programador experto, eso requiere muchos años de esfuerzo, pero sí serás capaz de escribir pequeños
programas que resuelvan tareas sencillas. Y lo que es aun más importante, contarás con los conocimientos
necesarios para abordar otros cursos más avanzados, por ejemplo de programación web o de uso de
Python para aplicaciones de cálculo numérico.
 ¿Conoces nuestro curso de Análisis de datos con Python? En este curso aprenderás a utilizar las principales
librerías relacionadas con el análisis estadístico y la visualización de datos.
Hemos enfocado este curso desde un punto de vista muy práctico. No te contaremos la historia de los
lenguajes de programación ni el proceso mediante el cual los programas se traducen a largas cadenas de
ceros y unos, que es lo que realmente entiende el ordenador. Nos centraremos en aprender a escribir
programas, en entender cómo funcionan las distintas instrucciones y cómo podemos combinarlas para
resolver problemas concretos.
A quién va dirigido
Este curso va dirigido a personas que quieran iniciarse en el mundo de la programación o personas que,
teniendo conocimientos básicos de programación en otros lenguajes, quieren aprender Python.
Para seguir este curso debes manejarte con soltura con el ordenador a nivel de usuario. En particular debes
ser capaz de instalar programas, usar el explorador de archivos, editar cheros de texto, etc.
¿Por qué Python?
Existen multitud de lenguajes de programación (y cada año siguen surgiendo nuevos), cada uno con sus
ventajas y sus inconvenientes. No existe el lenguaje perfecto, cada uno se centra en unos aspectos distintos,
por lo que el mejor lenguaje en cada momento dependerá de los objetivos y requisitos de cada persona y
proyecto. ¿Qué es mejor un pincel o una brocha? Pues depende, si quieres pintar un cuadro seguramente
pre eras el pincel pero si quieres pintar las paredes de tu casa, la brocha es la herramienta adecuada.
Algunos lenguajes se centran en la e ciencia (C/C++), otros en el desarrollo y mantenimiento de grandes

proyectos (Java, C#), otros están muy enfocados a la web (Javascript), etc. Python es un lenguaje de
propósito general (con el que se pueden desarrollar aplicaciones muy diversas) que permite escribir código
compacto y sencillo de leer. De hecho, su losofía de diseño hace especial hincapié en escribir código legible
y sencillo de entender, y por ese motivo se usa en muchos centros de enseñanza para enseñar a programar.
Python es además uno de los lenguajes más populares en GitHub, la plataformas de desarrollo colaborativo
más popular hoy en día. Python también es uno de los lenguajes más elegidos para aplicaciones de cálculo
cientí co y desarrollo web.
Estructura del curso
El curso está estructurado en temas y cada tema se divide en secciones. En cada tema se aborda el uso de
un determinado tipo de instrucciones o estructuras que te permitirán resolver problemas cada vez más
complejos.
Cada sección se centra en un aspecto muy concreto de cada tema. Es importante que asimiles los conceptos
que se explican en cada sección antes de pasar a la siguiente, porque cada concepto nuevo se apoya en los
anteriores.
En cada sección encontrarás muchos programas de ejemplo. Te animamos a que pruebes cada uno de
estos programas y los modi ques para entender mejor su funcionamiento. Lo bueno de aprender a
programar es que sólo necesitas un ordenador para hacer todas las pruebas que quieras.
Al nal de algunas secciones encontrarás ejercicios para practicar. Estos ejercicios estás propuestos para
ayudarte a profundizar en los conceptos que se explican en la sección, pero son totalmente voluntarios, no
tienes que entregarlos y no se evaluarán.
En la penúltima sección de cada tema encontrarás una sección de ejercicios resueltos en los que se aplican
todos los conceptos explicados durante el tema. Estos ejercicios te servirán para repasar y aprender a
escribir buen código.
Al nal de cada tema encontrarás ejercicios para entregar. Estos ejercicios son obligatorios y deberás
enviarlos a través de la herramienta de entrega de ejercicios del campus para que los evaluemos.
 Es necesario aprobar todos los ejercicios para entregar que hay al nal de cada tema para obtener el diploma
de aprovechamiento del curso. También es necesario aprobar todos estos ejercicios para presentarse al
examen presencial y obtener el diploma de aptitud que permite convalidar créditos.
Código en los apuntes
El código de los programas aparecerán en los apuntes en el siguiente formato:
# Calcula el área de un cuadrado a partir de la longitud de su lado.

lado = float(input("Introduce la longitud del lado: "))
area = lado * lado
print("El area del cuadrado es", area)
Por ahora no te preocupes por cómo funciona el programa anterior, aunque seguro que eres capaz de
intuirlo. La salida de los programas, es decir, el resultado de ejecutarlos, aparecerá en los apuntes en el
siguiente formato:
Introduce la longitud del lado: 3

El area del cuadrado es 9.0
En los apuntes normalmente aparecerá primero el programa y a continuación su salida como se muestra a
continuación:
# Calcula el área de un cuadrado a partir de la longitud de su lado.

lado = float(input("Introduce la longitud del lado: "))
area = lado * lado
print("El area del cuadrado es", area)
Introduce la longitud del lado: 3

El area del cuadrado es 9.0
Sección 1.2
Instalando las herramientas necesarias
Antes de empezar el curso, debes con gurar tu ordenador con las herramientas necesarias para escribir los
programas. En concreto, necesitarás instalar:
El entorno de Python, que contiene las herramientas necesarias para ejecutar los programas.
Un editor de textos en el que escribir los programas.
A continuación explicamos paso a paso cómo hacerlo. El tutorial está hecho para Windows, pero ambas
herramientas están disponibles también para Mac OS y Linux.
Instalar Python 3
Vamos a empezar instalando Python en nuestro equipo. Para ello accederemos a la página principal de la
Python Software Foundation que puedes ver en la siguiente imagen.
Página web www.python.org
La comunidad de desarrolladores de Python es muy activa, y en esta página encontrarás siempre las últimas
versiones del lenguaje, noticias de actualidad, tutoriales, foros, etc. A nosotros nos interesa la zona de
descargas, así que pulsaremos en la opción Downloads.
Actualmente conviven dos versiones de Python, la 2 y la 3. En este curso vamos a centrarnos en la más
moderna así que pulsa en la opción Download Python 3.x.x para descargar el instalador. Es importante que
instales la versión correcta porque existen diferencias importantes entre ellas y los ejemplos que
encontrarás en el curso están pensados para la versión 3 del lenguaje.
Página de descarga de Python 3
Durante la instalación, es importante que selecciones la opción Add Python 3.x to PATH que aparece en la
parte inferior de la primera pantalla. A continuación pulsa en Install Now y sigue las instrucciones del
asistente.
Asistente de instalación de Python 3
Una vez terminada la instalación, ya deberías tener en tu equipo todas las herramientas y librerías
necesarias para ejecutar programas Python.
Instalar PyCharm Community Edition
Aunque los programas Python se pueden escribir en cualquier editor de texto plano, como el bloc de notas
de Windows, nosotros vamos a utilizar un editor especializado llamado PyCharm. PyCharm no es sólo un
editor de texto, es un entorno de programación profesional que nos ayudará durante la escritura y prueba
de los programas. Aunque PyCharm es muy versátil y proporciona muchas opciones de programación
avanzada, nosotros nos contentaremos con usar sus funciones más básicas en este curso.
Página principal de PyCharm
Para descargar el entorno pulsamos en Download Now y a continuación descargamos la versión

Community. La otra versión, la Professional contiene muchas más opciones que nosotros no necesitamos.
Página de descarga de PyCharm
Una vez descargado el instalador, sigue las instrucciones del asistente y selecciona las opciones Create
Desktop shortcut y Create associations .py. La primera opción creará un lanzador del programa en tu
escritorio, y la segunda te permitirá abrir los archivos de Python con este programa al hacer doble clic sobre
ellos.
Asistente de instalación de PyCharm
Enhorabuena, ya deberías tener instaladas todas las herramientas que necesitas para realizar el curso.
Sección 1.3
Mi primer programa
En esta sección vamos a crear nuestro primer programa Python paso a paso. Nos servirá para comprobar
que todas las herramientas que instalamos en la sección anterior funcionan correctamente.
Configuración inicial de PyCharm
Comenzamos ejecutando la aplicación PyCharm haciendo doble clic sobre el icono nuevo que se debe haber
creado en el escritorio. La primera vez que ejecutes el programa, aparecerá una ventana como la siguiente,
en la que se pregunta si quieres importar la con guración de una instalación anterior. En nuestro caso es la
primera vez que instalamos PyCharm, así que seleccionaremos la segunda opción.
Importar con guraciones anteriores de PyCharm
A continuación, PyCharm nos permite seleccionar entre distintas aspectos visuales y con guraciones de
teclado. Estas opciones son útiles para programadores experimentados que están acostumbrados a
trabajar usando otros editores y quieren seguir usando los mismos atajos de teclado en PyCharm. Las
opciones que vienen seleccionadas por defecto son perfectamente válidas para nosotros.
Con guración de los atajos de teclado y aspecto visual de PyCharm
Estas opciones sólo aparecerán la primera vez que ejecutemos el programa, pero en cualquier momento las
puedes modi car accediendo al menú de Preferencias.
Creación de un nuevo proyecto
La siguiente ventana de bienvenida nos permite elegir entre crear un nuevo proyecto o abrir uno existente.
Pantalla de inicio de PyCharm
En nuestro caso crearemos un nuevo proyecto al que llamaremos CursoPython. Por defecto la carpeta de
proyectos de PyCharm está en C:\Users\<usuario>\PycharmProjects pero puedes elegir una carpeta distinta
si lo pre eres.
Pantalla de inicio de PyCharm
El campo intérprete debería aparecer relleno con la ruta del programa que sabe como ejecutar código
Python.
 Si el campo intérprete aparece vacío, es porque al instalar Python 3 no seleccionaste la opción Add Python 3.x
to PATH. En ese caso tienes dos opciones: volver a instalar Python 3 seleccionando la opción anterior, o
con gurar manualmente el intérprete que por defecto se instala en la ruta C:\Users\
<usuario>\AppData\Local\Programs\Python\Python36-32\python.exe en las versiones actuales de Windows.
Mi primer programa
La ventana de nuevo proyecto consta de varias áreas. En la parte superior aparece el menú de opciones
que por ahora no usaremos. En la parte izquierda aparece el área de proyecto , que mostrará los cheros
con el código de nuestros programas. La carpeta CursoPython aparece vacía en este momento porque aún
no hemos añadido ningún chero al proyecto. El área más grande a la derecha es el `área de edición donde
escribiremos el código de nuestro programa.
Pantalla de nuevo proyecto de PyCharm
Vamos a comenzar creando un chero de código. Para ello pulsamos con el botón derecho del ratón en el
área de proyecto (el área izquierda) y seleccionamos la opción New >> Python File como se muestra
en la siguiente imagen.
Añadir un nuevo chero de código al proyecto
A continuación escribimos el nombre de nuestro chero, por ejemplo ejemplo. No conviene usar espacios,
ni tildes, ni eñes en los nombres de los cheros.
Dar nombre al nuevo chero de código
El nuevo chero de código aparecerá justo debajo de la carpeta CursoPython. Un proyecto puede contener
muchos cheros de código distinto.
 Te recomendamos crear un chero distinto para cada ejercicio y tenerlos todos dentro del mismo proyecto, en
distintas carpetas, pero puedes organizar los cheros como quieras.
Los cheros de código Python tienen extensión .py. Como puedes observar, el editor ha añadido
automáticamente esa extensión al nombre de tu chero. Al hacer doble clic sobre el chero se abrirá en el
área de edición (a la derecha).
Vamos a escribir nuestro primer programa, que está compuesto de un única línea. Es importante que
escribas todos los caracteres tal y como aparecen a continuación:
print("Hola mundo!")
En este momento deberías tener algo parecido a la siguiente imagen.
Escribir el código del primer programa
Nuestro programa es muy sencillo y lo único que debería hacer es mostrar el mensaje Hola mundo!. Vamos
a ejecutarlo, a ver si funciona correctamente. Para ello pulsa con el botón derecho del ratón sobre el chero
ejemplo.py en el área de proyecto y selecciona la opción Run 'ejemplo' .
Ejecutar mi primer programa
En la parte inferior de la aplicación aparecerá un nuevo área, la consola , que muestra el resultado de
ejecutar nuestro programa.
Consola con la salida del programa
En la consola aparecen 3 líneas de texto. La primera línea muestra que se ha ejecutado el intérprete de
Python sobre nuestro chero de código. La segunda línea muestra la salida que genera nuestro programa,
en este caso el mensaje Hola mundo!. La tercera línea indica que la ejecución terminó correctamente, con
código 0.
 Si la consola muestra algún mensaje de error en lugar de la salida anterior, comprueba que has escrito
correctamente el programa.
Tras ejecutar el programa por primera vez, podemos volver a ejecutarlo tantas veces como sea necesario
usando los botones de Play ( ) que aparecen tanto en la zona superior derecha del área de edición
como a la izquierda de la `consola.
¡Enhorabuena!, ya has escrito tu primer programa Python.
Siguientes pasos
Durante el curso encontrarás multitud de ejemplos y ejercicios. Para probarlos debes seguir el proceso
descrito en la sección anterior:
1. Añade un nuevo chero al proyecto

2. Escribe el código del programa
3. Ejecútalo y comprueba el resultado en la consola.
Es normal que los programas no funcionen correctamente a la primera, no te preocupes. La única manera
de aprender a programar es probando distintas cosas y cometiendo errores. Ya verás como cada vez te
resultará más sencillo escribir los programas.
Sección 2.1
¿Qué es un programa?
¿Qué es un programa?
Ya hemos visto que los programas Python se escriben en cheros de texto con extensión .py. Cada
programa consta de un conjunto de instrucciones y cada instrucción se escribe en una línea distinta. Por
ejemplo, ya sabemos que el siguiente programa:
print("Hola mundo!")
imprime el mensaje Hola mundo! en la consola:
Hola mundo!
Para imprimir algo en la consola debemos usar la función print y a continuación escribir lo que queremos
imprimir entre paréntesis. En el ejemplo anterior imprimimos la cadena de texto Hola mundo!.
También podemos imprimir números. El siguiente programa imprime en la consola el número 43:
print(43)
43
Los mensajes de texto se escriben entre comillas mientras que los números se escriben sin ellas. El número
43 representa un número entero, mientras que el texto “43” representa una secuencia de dos caracteres, el
“4” y el “3”. Quizás la distinción es un poco confusa por ahora, no te preocupes lo explicaremos con detalle
más adelante. La idea intuitiva es que los números se pueden sumar, restar, multiplicar, etc. y esas
operaciones no tienen sentido con cadenas de texto.
Los programas pueden contener varias instrucciones (cada una en una línea) que se ejecutan de manera
secuencial. Por ejemplo, el siguiente programa imprime dos mensajes uno debajo de otro:
print("Hola a todos")
print("Vamos a aprender a programar en Python")
Hola a todos
Vamos a aprender a programar en Python
Cuando los programas empiezan a crecer es una buena idea dejar líneas en blanco para separar bloques de
código y que el código sea más sencillo de entender. El intérprete de Python ignorará esas líneas, por lo que
el programa anterior es equivalente al siguiente:
Hola a todos
No debes confundir dejar líneas en blanco en el chero de código con imprimir líneas en blanco en la
consola. Para imprimir una línea en blanco en la salida del programa debes usar una instrucción print sin
argumentos:
print()
Hola a todos
Por ahora nuestros programas no son demasiado interesantes, es cierto, pero poco a poco iremos
aprendiendo nuevas instrucciones con las que hacer más cosas.
Cómo se ejecutan los programas
El proceso mediante el cual se ejecutan los programas en el ordenador es bastante complejo y, de hecho, no
es necesario conocerlo para escribir programas sencillos. Por ahora piensa que al instalar Python en tu
ordenador, se instaló un programa llamado intérprete que sabe como leer los cheros .py que escribes y es
capaz de ejecutar las instrucciones en el ordenador.
Existen muchos lenguajes de programación diferentes, seguro que has oído hablar de algunos de ellos:
Basic, C/C++, Java, Python, Ruby, Javascript, etc. Cada uno de estos lenguajes proporciona un conjunto de
instrucciones y herramientas con los que escribir programas. Todos ellos son lenguajes de alto nivel,
lenguajes pensados para programadores, que posteriormente se traducen al lenguaje máquina que
entiende el ordenador. El lenguaje máquina está formado por largas secuencias de ceros y unos que son las
que se ejecutan realmente en tu ordenador.
En general todo este proceso es transparente para el programador, que sólo necesita preocuparse de
escribir el programa en el lenguaje elegido y ejecutarlo.
Sección 2.2
Comentar el código
Documentar el código
Los programadores habitualmente tenemos que trabajar con código que escribieron otras personas, o
modi car código que escribimos nosotros mismos hace años. Cuando los programas son pequeños es
relativamente sencillo entender cómo funcionan, pero cuando los programas crecen de tamaño, cada vez es
más complicado. Una forma sencilla de mejorar la legibilidad del código consiste en incluir comentarios que
expliquen su funcionamiento. Esto es lo que se conoce habitualmente como documentar el código y es
mucho más importante de lo que puede parecer inicialmente.
Los comentarios son líneas de texto que se insertan en medio del código y que ayudan a los programadores
a entender cómo funciona. El intérprete de Python que ejecuta el programa los va a ignorar, así que
podemos escribir en ellos lo que queramos. Los comentarios comienzan con el símbolo almohadilla ( # ) y se
extienden hasta el nal de la línea. Podemos escribir comentarios que ocupen toda una línea o comentarios
a la derecha de una instrucción particular:
# Esto es un comentario que ocupa toda una línea

print("Hola") # Esto es un comentario a la derecha de una instrucción
# Para escribir comentarios que ocupen varias líneas

# comenzamos cada una de ellas con el símbolo almohadilla
print("Adios")
Al ejecutar el programa anterior los comentarios se ignoran, es como si no existieran, así que en la consola
sólo veremos el resultado de ejecutar las dos instrucciones print :
Hola
Adios
En los ejemplos que verás en el curso aparecen muchos comentarios que te ayudarán a entender mejor el
código.
 Acostúmbrate a documentar correctamente tu código desde el principio.

Sección 2.3
Expresiones numéricas
Usando Python como una calculadora
Vamos a empezar utilizando Python como si fuera una calculadora. Intenta adivinar el resultado de ejecutar
el siguiente programa:
print(7)
print(1.5)
print(3 + 7)
El programa consta de 3 instrucciones que se ejecutan una detrás de otra, y cada una imprime un número
por la consola. La primera instrucción imprime el número entero 7, la segunda instrucción imprime el
número real 1.5, y la tercera instrucción imprime el resultado de evaluar la expresión 3 + 7, es decir, 10:
7
1.5
10
Podemos utilizar los operadores habituales para trabajar con números: la suma, la resta, la multiplicación, la
división, etc. Por ejemplo:
print(3 * 5)
print(5 - 8)
print(10 / 2)
print(2 + 3 * 4) # Cuidado, * tiene más precedencia que +
15
-3
5
14
Fíjate en el último ejemplo, donde la multiplicación tiene más precedencia que la suma y se calcula antes (3
por 4 y al resultado se le suma 2). Si queremos cambiar el orden en el que se calcula la suma y la
multiplicación podemos utilizar paréntesis. Por ejemplo:
print(2 + 3 * 4)
print((2 + 3) * 4) # Podemos usar paréntesis para cambiar la precedencia
14
20
Operadores aritméticos
La siguiente tabla resume el conjunto de operadores aritméticos que podemos utilizar para construir
expresiones numéricas.
Operador Operación Ejemplo Resultado
+ Suma 5+2 7
- Resta 5-2 3
* Multiplicación 5*2 10
/ División 5/2 2.5
// División entera 5 // 2 2
% Módulo 5%2 1
** Potencia 5 ** 2 25
Los operadores de suma ( + ), resta ( - ), multiplicación ( * ) y división ( / ) funcionan del modo habitual. Los
últimos 3 operadores no son tan comunes:
La división entera ( // ) devuelve el cociente de la división entera. Por ejemplo 7 // 3 devuelve 2

porque 7 dividido por 3 tiene cociente 2 y resto 1.
El módulo ( % ) devuelve el resto de la división entera. Por ejemplo 7 % 2 devuelve 1.
La potencia ( ** ) eleva un número a otro. Por ejemplo 5 ** 3 devuelve 125 porque 5 elevando al cubo
es 125.
Números enteros y números reales
Distinguiremos dos tipos de números: los enteros ( int ) que no pueden contener decimales, y los reales
( float ) que si tienen decimales. Por ejemplo, el número 10 es un número entero mientras que el número
10.0 es un número real (aunque ambos representan el mismo valor). Podemos convertir reales a enteros y
viceversa usando las funciones int() y float() como se muestra en el siguiente ejemplo:
print(4) # Imprime 4
print(3.7) # Imprime 3.7
print(float(4)) # Imprime 4.0
print(int(3.7)) # Imprime 3 (elimina la parte decimal)
Precisión
Al contrario de lo que ocurre en otros lenguajes de programación, Python es capaz de trabajar con números
enteros de cualquier tamaño. Por ejemplo, podemos imprimir el valor numérico de 2256 con una sencilla
instrucción:
print(2 ** 256)
que mostrará por consola el siguiente número:
115792089237316195423570985008687907853269984665640564039457584007913129639936
En el caso de los números reales, no siempre es posible representarlos de manera exacta con un número
nito de dígitos. Piensa, por ejemplo, en el número real 1/3 que equivale a 0.33333333… con un número
in nito de treses en la parte decimal. También existen otros números reales con in nitos decimales que ni
siquiera se pueden representar como fracciones, los llamados irracionales, como por ejemplo π que Python
aproxima como 3.141592653589793.
Python representa los números reales con cierto nivel de precisión (bastante alto) que suele ser su ciente
en la mayoría de los casos. Sin embargo, en cierto tipo de aplicaciones debemos ser conscientes de que
pueden producirse errores de redondeo al operar con números reales.
Ejercicios para practicar
 Intenta adivinar el resultado de ejecutar el siguiente programa:
print(10 + 5 * 2)
print(5 * 2 + 10)
print((10 + 5) * 2)
print(7 / 2 - 0.5)
print(3.14 * 100)
print(2 ** 3)
print(14 // 5)
print(15 % 5)
print((2 + 3) * (2 - 3))
print(int(5 / 2))
print(float(5 // 2))
Sección 2.4
Cadenas de texto
Imprimiendo texto
En el mundo de la programación, los mensajes de texto se denominan cadenas de texto y representan

secuencias de caracteres. Por ejemplo, la cadena de texto “Python” representa una secuencia de 6
caracteres: P, y, t, h, o y n. Las cadenas de texto se pueden escribir indistintamente entre comillas dobles
( " ) o comillas simples ( ' ). Por ejemplo, el siguiente programa:
print("Esto es una cadena de texto")

print('Esto también es una cadena de texto')
genera la salida:
Esto es una cadena de texto

Esto también es una cadena de texto
Podemos combinar comillas simples y dobles en una misma cadena de texto para conseguir que la salida
por consola contenga comillas. Ten en cuenta que si la cadena empieza con " no terminará hasta que
aparezca otra " . Por ejemplo:
print("La palabra 'hacker' proviene del inglés")

print('María dijo: "esta vez vamos a ganar"')
La palabra 'hacker' proviene del inglés

María dijo: "esta vez vamos a ganar"
Podemos escribir cadenas de texto que ocupen varias líneas usando comillas triples:
print("""Esto es un ejemplo
de cadena que ocupa 3 líneas
distintas.""")
Esto es un ejemplo
distintas.
Ten en cuenta que también podríamos haber producido la misma salida usando tres instrucciones print :
print("Esto es un ejemplo")
print("de cadena que ocupa 3 líneas")
print("distintas.")
Esto es un ejemplo
distintas.
Caracteres especiales
Dentro de las cadenas de texto podemos incluir algunos caracteres que se interpretan de manera especial
al imprimirlos. Estos caracteres aparecen precedidos por el símbolo \ y nosotros sólo vamos a ver dos de
ellos:
\n se imprime como un salto de línea.
\t se imprime como un tabulador.
Veamos un ejemplo:
print("Línea 1\nLínea 2")

print("Animal\tMineral\tVegetal")
Línea 1
Línea 2
Animal Mineral Vegetal
Operadores para cadenas
La cadenas de texto se pueden concatenar (juntar) usando el operador + . Por ejemplo:
print("Hola" + "mundo") # Al juntar las cadenas se juntan las palabras

print("Hola " + "mundo") # Ahora ya no
Holamundo
Hola mundo
La función len() devuelve la longitud de una cadena de texto, es decir, el número de caracteres que
contiene:
print(len("hola"))
print(len("Esto es una cadena más larga."))
4
29
El operador de repetición ( * ) permite repetir una cadena varias veces:
print(3 * "a") # Imprime aaa

print(3 * "ma") # Imprime mamama
print(5 * "a" + 3 * "!") # Imprime aaaaa!!!
Las cadenas son secuencias de caracteres y podemos acceder a los caracteres individuales usando el
operador [] y su posición. El primer carácter de la cadena está en la posición 0, el segundo en la posición
1, etc. Por ejemplo:
print("abcd"[0]) # Imprime a
print("abcd"[1]) # Imprime b
print("abcd"[2]) # Imprime c
print("abcd"[3]) # Imprime d
Como puedes ver, el operador [] es un poco diferente de los anteriores y se escribe a la derecha de la
cadena. En realidad este operador es mucho más potente y nos permite acceder a trozos de la cadena
original. Por ejemplo “abcd”[0:3] devuelve la cadena que contiene los caracteres de la posición 0 (incluido) a
la 3 (excluido), es decir, “abc”. Veamos algunos ejemplos:
print("En un lugar de la Mancha"[0]) # Imprime: E

print("En un lugar de la Mancha"[0:2]) # Imprime: En
print("En un lugar de la Mancha"[3:11]) # Imprime: un lugar
print("En un lugar de la Mancha"[18:24]) # Imprime: Mancha
La siguiente tabla resumen los principales operadores para cadenas:
+ Concatenar “aprend” + “er” “aprender”
* Repetir 2 * “casa” “casacasa”
len() Longitud len(“cadena”) 6
[] Subcadena “gato”[1] “a”

[:] Subcadena “gato”[1:3] “at”
Conversiones ente cadenas y números
Podemos transformar números a cadenas usando el operador str() y cadenas a números usando los
operadores int() y float() . Por ejemplo:
print(str(123)) # Imprime la cadena 123

print(int("123")) # Imprime el número 123
print(int("5") + 10) # Imprime el número 15 (suma de números)
print(str(5) + "10") # Imprime la cadena 510 (concatenación de cadenas)
123
123
15
510
Métodos especiales de las cadenas
La cadenas tienen un conjunto de métodos que nos permiten obtener información sobre su contenido o
modi carlo. En este apartado sólo vamos a ver algunos de ellos, pero existen muchos más.
Los métodos son parecidos a las funciones pero se escriben a la derecha de la cadena de texto, separados
por un punto . y terminan con paréntesis () . Por ejemplo, podemos transformar una cadena a letras
mayúsculas usando el método upper :
print("hola mundo".upper()) # Imprime HOLA MUNDO
En realidad, el método upper no está modi cando la cadena original, está creando una nueva cadena de
texto “HOLA MUNDO” que es la que luego se imprime.
Existen métodos que permiten transformar letras minúsculas a mayúsculas y viceversa:
print("hola mundo".upper()) # Transforma a mayúsculas

print("HOLA MUNDO".lower()) # Transforma a minúsculas
print("hola mundo".capitalize()) # Convierte la primera letra en mayúscula
HOLA MUNDO
hola mundo
Hola mundo
También existen métodos que permiten obtener información sobre la cadena. Veamos algunos ejemplos:
print(len("antonio")) # Número de caracteres de la cadena

print("antonio".islower()) # ¿la cadena sólo contiene minúsculas?
print("antonio".isupper()) # ¿la cadena sólo contiene mayúsculas?
print("hola mundo 123".isalpha()) # ¿la cadena sólo contiene letras?
print("123".isnumeric()) # ¿la cadena sólo contiene dígitos?
7
True
False
False
True
Los valores True y False representan los valores lógicos para cierto y falso en Python.
También hay métodos que permiten consultar si una cadena contiene otra subcadena. En este caso la
subcadena buscada debe aparecer entre los paréntesis de la derecha:
print("Mi casa".startswith("Mi")) # ¿La cadena empieza por "Mi"?

print("Mi casa".startswith("Tu")) # ¿La cadena empieza por "Tu"?
print("Mi casa".endswith("asa")) # ¿La cadena termina con "asa"?
print("Mi casa".endswith("o")) # ¿La cadena termina con "o"?
print("Mi casa".count("a")) # ¿Cuantas veces aparece la subcadena "a"?
True
False
True
False
2
El palabra reservada in permite saber si una cadena aparece en otra cadena. Su uso es un poco distinto de
los anteriores ya que se escribe entre ambas cadenas:
print("casa" in "mi casa está en la ciudad")

print("montaña" in "mi casa está en la ciudad")
True
False
El programa anterior imprimirá True en la primera instrucción porque la cadena “casa” aparece en “mi casa
está en la ciudad”. Del mismo modo, imprimirá False en la segunda instrucción porque “montaña” no
aparece en la cadena de la derecha.
Finalmente, existen otros operadores que nos permiten eliminar caracteres de la cadena original o incluso
reemplazarlos por otros nuevos.
print(" hola y adios ".strip()) # Elimina los espacios al principio y al fina
l de la cadena
print("mi casa".replace("casa", "teléfono")) # Reemplaza "casa" por "teléfono"
El programa anterior produce la siguiente salida:
hola y adios
mi teléfono
 Esta sección contiene mucha información sobre las cadenas de texto. No te preocupes si no recuerdas todas
las operaciones que hemos explicado o algunas de ellas te han resultado un poco confusas. A lo largo del curso
las iremos empleando y comprenderás mejor su funcionamiento.
 Intenta adivinar lo que imprime el siguiente programa:
print(3 * "coche")
print("Hola" + " " + "mundo")
print("Califragilístico"[0:4])
print(str(12345)[1])
print(float("5.5") * 2)
 Intenta adivinar lo que imprime el siguiente programa:
# Mayúsculas y minúsculas
print("ordenador".upper())
print("ordenador".lower())
print() # Deja una línea en blanco
# Contenido de la cadena
print("100".isnumeric())
print("cien".isnumeric())
print()
# Subcadenas
print("Mi mama me mima".count("m"))
print("Mi mama me mima".startswith("Mi mama"))
print("Mi mama me mima".startswith("mi mama"))
print("mi" in "mi casa")
print("mi" in "Mi casa")
print()
Sección 2.5
Variables
Las variables son uno de los elementos más importantes en la programación. Podemos pensar en ellas
como cajas que contienen valores. Por ejemplo, el siguiente programa de ne una variable x que contiene
el valor 5:
x = 5
El programa anterior no imprime nada (no tiene ninguna instrucción print ), sólo crea una variable con
nombre x y le asigna el valor 5. El operador de asignación ( = ) sirve para dar valor a las variables.
Una vez hemos asignado un valor a una variable, cada vez que la utilicemos se sustituirá por su valor. Por
ejemplo:
x = 5
print(x)
genera la siguiente salida:
porque el valor contenido en la variable es el número 5.
El siguiente ejemplo es un poco más complejo, intenta averiguar lo que imprime. Ten en cuenta que cada
vez que aparece la variable x en el programa se sustituye por su valor:
x = 10
print(2 * x)
print(x / 5)
print (x + x * x)
20
2
110
Podemos modi car el valor almacenado en una variable asignándole un nuevo valor con el operador de
asignación ( = ). En este sentido, las variables son como cajas en las que podemos almacenar valores de
manera temporal. Por ejemplo:
x = 5
print(x + 1)
x = 10
print(x - 2)
6
8
Vamos a analizar el programa anterior paso a paso:
1. La primera línea asigna el valor 5 a la variable x .

2. La segunda línea imprime el resultado de evaluar la expresión x + 1 que en este caso es 6.
3. La tercera línea modi ca el valor contenido en la variable y lo cambia por 10.
4. La última instrucción imprime un 8.
 La variables pueden tener casi cualquier nombre que comience por una letra minúscula pero no pueden tener
espacios, ni tildes, ni caracteres especiales. Cuando el nombre de la variable contiene varias palabras los más
habitual es separarlas con un guión bajo o empezar la segunda con letra mayúscula. Por ejemplo, nombres
válidos de variables serían: velocidad , velocidad_actual o velocidadActual .
 Para mejorar la legibilidad del código, es importante usar nombres signi cativos que representen el valor
almacenado en la variable.
El siguiente programa usa 3 variables distintas:
velocidad = 5
tiempo = 10
espacio = velocidad * tiempo
print(espacio)
50
Vamos a analizar el programa anterior:
1. La primera línea crea una variable velocidad a la que asignamos el valor 5.

2. La segunda línea de ne una nueva variable tiempo a la que asignamos el valor 10. Ahora mismo
tenemos dos variables creadas en nuestro programa con valores distintos.
3. En la línea 3 creamos una nueva variable espacio y le asignamos el resultado de evaluar la
expresión velocidad * tiempo que en este caso es 50.
4. La última instrucción imprime el valor de la variable espacio .
Podemos utilizar los nombres de variables que queramos, pero es importante que el código sea fácil de
entender. En el programa anterior podría haber llamado a las variables a , b y c y seguiría haciendo lo
mismo, pero no sería tan fácil entender lo que estamos haciendo.
Ejemplos un poco más complejos
El valor de una variable se puede cambiar en base a su propio valor. Aunque suena un poco enrevesado, es
sencillo de entender con un ejemplo:
a = 1
print(a)
a = a + 2 # Ahora a contiene un 3
print(a)
a = a * 3 # Ahora a contiene un 9
print(a)
1
3
9
Lo importante es entender que la expresión a la derecha del = se evalúa primero y después se asigna ese
valor a la variable de la izquierda. Analicemos el programa anterior:
1. La primera línea asigna el valor 1 a la variable a .

2. La segunda línea imprime 1.
3. En la tercera línea, la expresión a + 2 vale 3 (porque a valía 1) y ese es el nuevo valor que se asigna
a la variable a . A partir de ese momento la variable a contiene el valor 3.
4. La cuarta línea imprime un 3.
5. En la quinta línea, la expresión a * 3 vale 9 (porque a valía 3) y ese es el nuevo valor que se asigna
a la variable a .
6. La última línea imprime un 9.
 A veces encontrarás código en el que los programadores usan instrucciones del tipo a += 1 . Es simplemente
una forma abreviada de escribir a = a + 1 . Nosotros usaremos la segunda manera porque es más sencilla de
entender pero ambas son equivalentes.
Las variables pueden contener distintos tipos de datos. Por ejemplo, en el siguiente programa se asigna una
cadena de texto a la variable nombre y un número entero a la variable edad . A partir de ese momento
podemos utilizar la variable nombre en cualquier sitio donde podríamos utilizar una cadena de texto y la
variable edad en cualquier sitio donde podríamos utilizar un entero. Por ejemplo:
nombre = "Pedro"
edad = 22
print(nombre[0:3]) # Recuerda el operador [] de las cadenas
print(edad * 2)
Ped
44
Imprimir mensajes que dependen de variables
La función print puede aceptar varios parámetros separados por comas y, en ese caso, los imprime todos
en la misma línea separados por espacios. Esto es especialmente útil cuando se quiere mostrar un mensaje
junto con el valor de una variable:
nombre = "Pedro"
edad = 22
print(nombre, "tiene", edad, "años")
Pedro tiene 22 años
En este caso el mensaje que vamos a imprimir depende del valor almacenado en las variables nombre y
edad .
Variables y operaciones con cadenas
Las operaciones con cadenas que vimos en el apartado anterior producen valores que se pueden almacenar
en variables. Por ejemplo, el método upper devuelve una nueva cadena en la que todas las letras se han
convertido en mayúsculas:
nombre = 'antonio'
nombre_en_mayusculas = nombre.upper()
print("Nombre original:", nombre)
print("Nombre en mayúsculas:", nombre_en_mayusculas)
Nombre original: antonio

Nombre en mayúsculas: ANTONIO
Las variables permiten crear código más reutilizable
Veamos un ejemplo un poco más interesante. Existen distintas escalas para medir la temperatura. En
España utilizamos los grados centígrados, en Estados Unidos utilizan los grados fahrenheit y en el sistema
internacional se usan los grados kelvin. Afortunadamente existen fórmulas que permiten convertir de una
escala a otra:
fahrenheit = 9/5 * centigrados + 32

kelvin = centigrados + 273.15
Vamos a crear un programa que dado un valor en grados centígrados imprima los valores equivalentes en
las otras dos escalas.
# Valor inicial en grados centígrados

centigrados = 30
# Conversiones entre escalas

# Imprimir el resultado
print(centigrados, "grados centígrados son",
fahrenheit, "grados fahrenheit y", kelvin, "grados kelvin")
Como puedes ver, el código está dividido en tres bloques: asignar los valores iniciales, calcular lo que nos
piden e imprimir los resultados. Cada bloque está separado del siguiente por una línea en blanco y
precedido por un comentario que explica lo que hace. Esta forma de escribir los programas mejora la
legibilidad.
Además, como la ultima instrucción es muy larga, la hemos dividido en dos líneas diferentes. Al intérprete
de Python no le importan que pongamos los argumentos de print en distintas líneas de texto.
Al ejecutar el programa anterior obtenemos la siguiente salida:
30 grados centígrados equivalen a 86.0 grados fahrenheit y 303.15 grados kelvin
Una de las ventajas de trabajar con variables es que ahora podemos transformar cualquier cantidad de
grados centígrados en fahrenheit y kelvin simplemente modi cando la primera línea de nuestro programa.
El resto está escrito en función de los valores almacenados en variables por lo que sigue siendo válido:
# Valor inicial en grados centígrados
centigrados = 0
# Conversiones entre escalas

# Imprimir el resultado
print(centigrados, "grados centígrados son",
fahrenheit, "grados fahrenheit y", kelvin, "grados kelvin")
0 grados centígrados equivalen a 32.0 grados fahrenheit y 273.15 grados kelvin
 Usar variables permite crear programas más reutilizables porque el código se independiza de los valores
concretos almacenados en las variables.
 Escribe un programa que dado el valor del radio de una circunferencia, imprima el valor de
su longitud y el área del círculo que delimita. Para hacerlo sigue los siguiente pasos:
Declara una variable pi y asígnale el valor 3.14159.

Declara una variable radio y asígnale el valor 5.
Usa la siguientes fórmulas para calcular la longitud de la circunferencia y el área del
círculo:
longitud = 2 * pi * radio
area = pi * radio * radio
Imprime el resultado
Sección 2.6
Pedir datos al usuario
Pedir datos de tipo texto
Todos los programas que hemos escrito hasta ahora realizan cálculos sencillos e imprimen mensajes. Ahora
vamos a aprender cómo hacer programas que solicitan datos al usuario.
Para pedir un dato al usuario utilizamos la función input() :
nombre = input("Dime tu nombre: ")

print("Tu nombre es", nombre)
Este sencillo programa imprime el mensaje Dime tu nombre: y se queda esperando hasta que el usuario
introduce algún dato. Para introducir tu nombre haz click con el ratón en el área de la consola, escribe tu
nombre y pulsa la tecla intro. El texto que el usuario ha introducido se asigna a la variable nombre y, a
continuación, se usa para mostrar un mensaje. Suponiendo que el nombre introducido es Ana la ejecución
del programa imprimirá lo siguiente:
Dime tu nombre: Ana

Tu nombre es Ana
Siguiendo la misma idea podemos leer cadenas de varias palabras:
nombre = input("Dime tu nombre: ")

libro = input("Dime tu libro favorito: ")
print("A", nombre, "le gusta", libro)
que dependiendo de los datos introducidos por el usuario generará algo parecido a:
Dime tu nombre: Raquel

Dime tu libro favorito: La vida es sueño
A Raquel le gusta La vida es sueño
Pedir datos de tipo numérico

Los valores que devuelve la función input() son siempre de tipo cadena de texto, pero podemos
transformalos a números enteros usando int() o a números reales con float() :
nombre = input("Introduce tu nombre: ")

edad = int(input("Introduce tu edad: "))
altura = float(input("Introduce tu altura en metros: "))
print(nombre, "tiene", edad, "años y mide", altura, "metros")
La primera instrucción pide el nombre y lo asigna directamente a la variable nombre porque esperamos
que el usuario introduzca una cadena de texto. La segunda instrucción espera que el usuario introduzca un
número entero de años y por eso transforma la cadena a entero usando int() . La última instrucción
espera que el usuario introduzca un número de metros posiblemente con decimales por lo que usa
float() para almacenar la altura como un número real.
El resultado de ejecutar el programa anterior, dependiendo de los datos introducidos, será algo similar a lo
siguiente:
Introduce tu nombre: Antonio

Introduce tu edad: 30
Introduce tu altura en metros: 1.75
Antonio tiene 30 años y mide 1.75 metros
Recuerda que existen 3 funciones para transformar entre enteros, reales y cadenas:
int(x) transforma x en un número entero.
float(x) transforma x en un número real.
str(x) transforma x en una cadena de texto.
Errores al leer los datos
Las conversiones pueden generar errores si el usuario se equivoca al introducir los datos. Por ejemplo,
supongamos que en el siguiente programa el usuario introduce la cadena veintiuno.
El programa no sabe como transformar esa cadena de texto en un número por lo que generará un error:
Introduce tu edad: veintiuno

Traceback (most recent call last):
File "C:\Users\<usuario>\Documents\PycharmProjects\CursoPython\ejemplo.py", line
1, in <module>
ValueError: invalid literal for int() with base 10: 'veintiuno'
Aunque este tipo de errores se puede controlar, nosotros supondremos que el usuario introduce siempre
los datos en el formato correcto.
 Haz un programa que pida al usuario su nombre y escriba el número de letras que contiene.
 Haz un programa que pida al usuario la longitud de un lado de un cuadrado e imprima su

perímetro y su área.
Sección 2.7
Ejercicios resueltos
En este apartado mostraremos un conjunto de ejercicios resueltos porque una de las mejores maneras de
aprender a programar es leyendo código escrito por otros programadores.
Te aconsejamos que una vez entiendas las soluciones intentes escribirlas tú desde cero. Quizás llegues a
otras soluciones distintas que también son correctas.
 Escribe un programa que calcule el volumen de un cono a partir del radio de la base y su
altura. Usa la siguiente fórmula:
volumen = pi * radio * radio * altura / 3
Solicita los valores de radio y altura al usuario. Recuerda que el valor aproximado de pi es
3.14159.
# Pedir datos al usuario

radio = float(input("Radio de la base del cono: "))
altura = float(input("Altura del cono: "))
# Calcular el volumen
pi = 3.14159
volumen = pi * radio * radio * altura / 3
# Mostrar volumen
print("El volumen del cono es", volumen)
 Escribe un programa que calcule la nota nal de un alumno a partir de las cali caciones de
los 3 exámenes parciales que ha realizado, teniendo en cuenta que el primer examen
parcial vale un 20% , el segundo un 30% y el último un 50% de la nota nal.
nota1 = float(input("Introduzca la primera nota: "))
nota2 = float(input("Introduzca la segunda nota: "))
nota3 = float(input("Introduzca la tercera nota: "))
# Calcular nota final

nota_final = nota1 * 0.2 + nota2 * 0.3 + nota3 * 0.5
# Imprimir resultado
print("La nota final es:", nota_final)
Sección 2.8
Ejercicio 1. Expresiones
Escribe un programa que pida al usuario el valor del radio y a continuación imprima la longitud de la
circunferencia y el área del círculo asociados. Te recordamos las fórmulas matemáticas que debes usar:
longitud circunferencia = 2 * pi * radio

área círculo = pi * radio * radio
Recuerda que el valor aproximado de pi es 3.14159. La ejecución debería ser similar a la siguiente:
Introduzca la longitud del radio: 2

La longitud de la circunferencia es 12.56636
El área del círculo es 12.56636
Cuando termines el ejercicio, entrega el chero .py con el código del programa a través del Campus para
que te lo corrijamos. La entrega para este ejercicio se llama Entrega del Ejercicio 1 .
Sección 3.1
Operadores de comparación
Comparando números
Además de los operadores aritméticos para sumar, restar o multiplicar números que ya conocemos, existen
otro conjunto de operadores que permiten compararlos. Los operadores de comparación se resumen en la
siguiente tabla.
Operador Signi cado Ejemplo
== Igual a == b
!= Distinto a != b
> Mayor a>b
>= Mayor o igual a => b
< Menor a<b
<= Menor o igual a <= b
Por ejemplo, la expresión a < 3 comprueba si el valor almacenado en la variable a es estrictamente

menor que 3. Y la expresión 5 == (2 + 3) comprueba si el valor 5 es igual que el resultado de sumar 2 y 3.
 No confundas el operador de asignación ( = ) que se usa para asignar un valor a una variable con el operador
de igualdad ( == ) que comprueba si dos valores son iguales.
El resultado de evaluar una expresión de este tipo puede ser cierto ( True ) o falso ( False ). Por ejemplo, la
expresión 3 <= 5 es cierta, pero la expresión 5 <= 3 es falsa.
A continuación se muestran algunas expresiones, intenta averiguar si son ciertas o falsas:
3<6
(2 * 3) < 6
(2 * 3) == (3 * 2)
5 != (6 - 2)
2 <= 2
Puedes comprobar la respuesta correcta escribiendo un programa que imprima el resultado de evaluar
cada una de ellas:
print(3 < 6)
print((2 * 3) < 6)
print((2 * 3) == (3 * 2))
print(5 != (6 - 2))
print(2 <= 2)
True
False
True
True
True
Comparando cadenas de texto
Además de números, también podemos comparar cadenas de texto. Los operadores == y != comprueban
si dos cadenas de texto son iguales, distinguiendo entre mayúsculas y minúsculas:
print("Casa" == "Casa")
print("Casa" == "casa") # Distingue entre mayúsculas y minúsculas
print("Casa" != "Coche")
print("Casa" == "Ca" + "sa") # Recuerda que + concatena cadenas
True
False
True
True
Los operadores < y > comparan cadenas de texto usando el orden alfabético (orden lexicográ co). De esa
forma, "mesa" < "silla" porque la m aparece antes que la s en el alfabeto. Si las primeras letras de las
cadenas coinciden se miran las siguientes hasta que alguna sea diferente o alguna de las cadenas se acabe.
Por ejemplo, "casa" < "cosa" y "ta" < "taza" .
Debemos tener cuidado con las mayúsculas y las minúsculas porque son consideradas distintas. En
particular las mayúsculas son menores que las minúsculas por lo que "Juan" < "juan" .
Al utilizar los operadores de comparación debemos tener en cuenta el tipo de los operandos. Por ejemplo,
una cadena de texto y un número siempre serán distintos porque son de distinto tipo.
print("123" == 123)
print(int("123") == 123)
print("123" == str(123))
False
True
True
La primera instrucción muestra False porque estamos comparando una cadena de texto y un número. El
número 123 no es lo mismo que la cadena de texto con los caracteres “123”. La segunda instrucción
muestra True porque la función int("123") convierte la cadena de texto en el número 123. La tercera
instrucción también muestra True porque la función str(123) convierte el número 123 en la cadena
“123”.
Los operadores < , <= , > y >= sólo se pueden utilizar para comparar valores del mismo tipo. El siguiente
programa generará un error al ejecutarlo:
print("python" <= 123) # Error: no se puede comparar una cadena y un número!!!
Finalmente, en las operaciones de comparación también podemos utilizar variables:
x = 10
y = 7
z = 3
print(x < 5)
print(x == y + z)
print(x != x)
print(y == 10 - 3)
False
True
False
True
Sección 3.2
Instrucción IF
Instrucción condicional
Todos los programas que hemos escrito hasta ahora consisten en una secuencia de instrucciones que se
ejecutan una detrás de otra. En este capítulo estudiaremos la manera de escribir instrucciones que sólo se
ejecutan cuando se cumplen determinadas condiciones.
Para hacerlo usaremos la instrucción if que, en su versión más sencilla, sigue el siguiente esquema:
if <condición>:
<instrucciones_dentro_del_if>
<resto_del_programa>
Las instrucciones dentro del if sólo se ejecutan si la condición es cierta. Fíjate que después de la condición
se escriben dos puntos ( : ) y que las instrucciones dentro del if están sangradas hacia la derecha usando
un tabulador.
Veamos un ejemplo sencillo:
x = 10
if x >= 0:
print("El número x es positvo")
En este caso el programa imprimirá la frase El número x es positivo porque la condición del if es cierta.
Pero si cambiamos el valor de la variable x como se muestra a continuación:
x = -10
if x >= 0:
print("El número x es positivo")
el programa no generará ninguna salida porque la condición del if ahora es falsa. Es decir, las
instrucciones sangradas a la derecha justo después del if sólo se ejecutan cuando la condición es cierta.
Veamos otro ejemplo:

print("Inicio")
numero = int(input("Introduce un número entero: "))
if numero >= 0:
print("El número", x, "es positivo")
print("El doble de", x, "es", 2*x)
print("Fin")
En este caso el comportamiento del programa dependerá del número que introduzca el usuario. Si
introduce un número positivo generará una salida similar a la siguiente:
Inicio
Introduce un número entero: 2
El número 2 es positivo
El doble de 2 es 4
Fin
Es decir, las instrucciones sangradas dentro del if se ejecutan. Pero si introducimos un número negativo
obtendremos una salida como la siguiente:
Inicio
Introduce un número entero: -3
Fin
Como puedes observar, la instrucción if sólo afecta a las instrucciones que están a continuación
sangradas a la derecha. La última instrucción print("Fin") se ejecuta siempre porque está al mismo nivel
que el if .
Instrucción IF-ELSE
En realidad la instrucción if puede tener una estructura más compleja:
if condición:
<instrucciones_parte_if>
else:
<instrucciones_parte_else>
Las instrucciones de la parte if sólo se ejecutarán si la condición es cierta. Las instrucciones de la parte
else sólo se ejecutarán si la condición es falsa. El resto del programas se ejecutará siempre. Fíjate que
después de else también aparecen los dos puntos (:).
Por ejemplo, el siguiente programa pide dos números al usuario e imprime el mayor:
a = int(input("Número 1: "))
b = int(input("Número 2: "))
if a >= b:
print("El mayor es", a)
else:
print("El mayor es", b)
La tercera línea del programa compara los dos números introducidos. Si a es mayor o igual que b la
condición del if se hace cierta y por tanto se ejecuta la instrucción de la línea 4 (pero no la de la línea 6). En
caso contrario, si a es menor que b , se ejecuta la instrucción de la línea 6 (pero no la de la 4).
A continuación se muestran dos ejemplos de ejecución:
Número 1: 3
Número 2: 8
El mayor es 8
Número 1: 10
Número 2: 5
El mayor es 10
 ¿Qué ocurriría si los dos números introducidos son iguales?
Veamos otro ejemplo un poco más interesante. El siguiente programa calcula el índice de masa corporal del
usuario y le indica si tiene sobrepeso.
# Pedimos los datos al usuario

peso = float(input("Introduce tu peso en kilos: "))
# Calculamos el índice de masa corporal

indiceMasa = peso / (altura * altura)
# Indicamos si el usuario tiene sobrepeso

if indiceMasa >= 25:
print("Debes cuidarte, tienes sobrepeso.")
else:
print("No tienes sobrepeso.")
print("Gracias por usar este programa")
A continuación mostramos una posible ejecución del programa:

Introduce tu altura en metros: 1.75
Introduce tu peso en kilos: 70
No tienes sobrepeso.
Gracias por usar este programa
Instrucción IF-ELIF-ELSE
Existe una versión aún más compleja de la instrucción if que permite distinguir más de dos posibilidades:
if <condición A>:
<instrucciones_parte_A>
elif <condición B>:
<instrucciones_parte_B>
elif <condicion C>:
<instrucciones_parte_C>
else:
En este caso hay varios posibles caminos de ejecución:
Si la condición A es cierta se ejecutan las instrucciones de la parte A.

Si la condición A es falsa y la condición B es cierta, se ejecutan las instrucciones de la parte B.
Si la condición A es falsa y la condición B es falsa y la condición C es cierta, se ejecutan las
instrucciones de la parte C.
Si todas las condiciones anteriores son falsas se ejecutan las instrucciones de la parte else.
En cualquier caso, a continuación se ejecutará el resto del programa.
Es decir, las condiciones se van evaluando en orden y en cuanto una de ellas sea cierta sólo se ejecutan las
instrucciones correspondientes a esa opción (las instrucciones de esa rama).
Por ejemplo, podemos escribir una versión más completa del programa que calcula el índice de masa
corporal para que distinga entre sobrepeso, peso normal y peso demasiado bajo:
# Pedimos los datos al usuario
peso = float(input("Introduce tu peso en kilos: "))
# Calculamos el índice de masa corporal

indiceMasa = peso / (altura * altura)
# Indicamos si el peso del usuario es el adecuado

if indiceMasa >= 25:
print("Debes cuidarte, tienes sobrepeso.")
elif indiceMasa >= 18.5:
print("Tu peso es normal, ¡enhorabuena!.")
else:
print("Debes cuidarte, tu peso es demasiado bajo.")
print("Gracias por usar este programa")
Veamos cómo funciona exactamente:
La primera condición del if comprueba si el índice de masa corporal es superior o igual a 25, en
cuyo caso el usuario tiene sobrepeso.
Si el usuario no tiene sobrepeso se comprueba si su índice es superior o igual a 18.5, en cuyo caso su
peso es normal. Ten en cuenta que sabemos que es normal porque sólo se ejecuta el código de la
segunda condición si la primera es falsa, es decir si el valor del índice está entre 18.5 y 25.
Si ninguna de las dos condiciones es cierta, sabemos que el índice es inferior a 18.5 y por tanto el
peso del usuario es demasiado bajo.
 Escribe un programa que pida dos números enteros al usuario y a continuación imprima el
menor.
 Escribe un programa que pida al usuario el nombre de un país europeo y a continuación

escriba su población según la siguiente tabla.
España Francia Portugal Alemania Reino Unido
46M 64M 10M 81M 65M
Si el país introducido no está en la tabla anterior el programa dirá que no conoce la

población de ese país.
¿Se te ocurre como hacer que funcione independientemente de como escriba el usuario el
nombre del país: mayúsculas, minúsculas o una mezcla de ambas?
Pista: cuando el usuario introduzca una cadena puedes pasarla a minúsculas y después
compararla con los países escritos de esa manera.
Sección 3.3
Operadores lógicos
Podemos de nir condiciones más complejas usando los siguiente operadores lógicos:
Operador Ejemplo Cierto si …
and cond1 and cond2 ambas condiciones son ciertas
or cond1 or cond2 al menos una condición es cierta
not not cond1 cond1 es falsa
A continuación mostramos ejemplos de uso de cada uno de estos operadores.
Operador and
El operador and exige que ambas condiciones sean ciertas para que la expresión completa sea cierta:
1 < 5 and 3 == 1 + 2 es cierto porque 1 < 5 y además 3 == 1 + 2 .
6 <= 6 and 7 < 6 es falso porque la segunda condición 7 < 6 no es cierta y por tanto la expresión
completa es falsa.
Por ejemplo el siguiente programa comprueba si el número introducido por el usuario es mayor que 0 y
menor que 10:
num = int(input("Introduce un número mayor que 0 y menor que 10: "))

if num > 0 and num < 10:
print("Gracias")
else:
print("Número incorrecto")
A veces podemos omitir el operador and cuando comparamos varios números de forma similar a como
hacemos al escribir expresiones matemáticas:
num = int(input("Introduce un número entre 1 y 10: "))
if 1 <= num <= 10:
print("¡Perfecto!")
else:
print("El número no está entre 1 y 10")
La expresión 1 <= num <= 10 es equivalente a 1 <= num and num <= 10 .
Operador or
El operador or sólo exige que al menos una de las condiciones sea cierta para que la expresión completa
sea cierta:
1 < 6 or 6 == 3 es cierto porque la primera condición 1 < 6 es cierta, da igual el valor de la
segunda.
3 < 3 or 3 == 3 es cierto porque la segunda condición 3 == 3 es cierta.
1 > 2 or 2 == 3 es falso porque las dos condiciones son falsas.
Por ejemplo, el siguiente programa pregunta el nombre de nuestro planeta e indica si la respuesta es
correcta:
nombre = input("¿Cual es el nombre de nuestro planeta? ")

if nombre == "tierra" or nombre == "Tierra":
print("¡Correcto!")
else:
print("Incorrecto")
Operador not
El operador not exige que la siguiente condición sea falsa para que la expresión completa sea cierta:
not 1 == 3 es cierto porque 1 == 3 es falso
not 1 < 3 es falso porque 1 < 3 es cierto
Por ejemplo, los siguientes dos programas hacen lo mismo:
x = int(input("Introduce un número: "))

if x >= 0:
print("El número es positivo")

if not x < 0:
print("El número es positivo")
Expresiones lógicas compuestas
Podemos construir expresiones lógicas más complejas combinando los 3 operadores lógicos anteriores. A la
hora de evaluar estas expresiones debemos tener en cuenta dos cosas:
La prioridad de los operadores de mayor a menor es: not , and y or .

Dentro de la misma prioridad, los operadores se evalúan de izquierda a derecha.
Veamos algunos ejemplos:
print(1 < 5 and 5 < 10 and 10 < 15) # Cierto porque todo es cierto
print(1 > 5 or 3 == 3 or 5 > 10) # Cierto porque la 2ª condicion es cierta
print(1 == 2 or not 3 == 4) # Cierto porque not 3 == 4 es cierto
print(1 < 3 < 5) # Cierto porque todo es cierto
 Escribe un programa que solicite al usuario la base y la altura de un triángulo y calcule su

área (base * altura / 2). Si alguno de los datos introducidos no es válido (por ejemplo altura
negativa o cero) debe mostrar un mensaje de error y no hacer ningún cálculo.
Sección 3.4
Instrucciones IF más complejas
Instrucciones anidadas
Ya sabemos que el esquema general de una instrucción IF-ELSE es el siguiente:
if condición:
<instrucciones_parte_if>
else:
Las instrucciones que aparecen en la parte if y else pueden ser cualquier cosa. En particular pueden ser
otras instrucciones if .
Por ejemplo, el siguiente programa comprueba si el número introducido por el usuario es menor que 0, si
está entre 0 y 10, o si es mayor que 10:

if x < 0:
print("El número es negativo")
else:
if (x <= 10):
print("El número está entre 0 y 10")
else:
print("El número es mayor que 10")
La primera instrucción if comprueba si el número es menor que 0. Si lo es, se imprime el mensaje El

número es negativo y el programa acaba. Si el número es positivo se mete por la parte else y se encuentra
una nueva instrucción IF-ELSE que debe evaluar.
El siguiente ejemplo es un poco más complejo, El programa solicita 3 números al usuario y calcula el mayor
de ellos. Intenta entender cómo funciona:
# Pedimos los números al usuario
a = int(input("Introduce el primer número: "))
b = int(input("Introduce el segundo número: "))
c = int(input("Introduce el tercer número: "))
# Comprobamos cuál es el mayor

if a >= b:
# b seguro que no lo es
if a >= c:
print(a)
else:
print(c)
else:
# a seguro que no lo es
if (b > c):
print(b)
else:
print(c)
Condiciones compuestas
El siguiente programa también calcula el mayor de 3 números, pero usando operadores lógicos:
# Pedimos los números al usuario

a = int(input("Introduce el primer número: "))
b = int(input("Introduce el segundo número: "))
c = int(input("Introduce el tercer número: "))
# Comprobamos cuál es el mayor

if a >= b and a >=c:
print(a)
elif b >= a and b >= c:
print(b)
else:
print(c)
A veces podemos escribir programas que hacen lo mismo de distintas formas. En ese caso debes elegir la
que te parezca más sencilla de entender.
Condiciones muy largas
Cuando las condiciones de las instrucciones if son muy largas se pueden escribir en varias líneas. Para
hacerlo podemos terminar cada línea con una barra invertida \ o rodear la expresión completa entre
paréntesis.
Por ejemplo, supongamos que queremos saber si la provincia introducida por el usuario pertenece a
Andalucía. Una forma de hacerlo sería la siguiente:
provincia = input("Introduzca el nombre de una provincia española: ")
provincia = provincia.lower() # La transformamos a minúsculas
if (provincia == "huelva" or provincia == "sevilla" or
provincia == "cádiz" or provincia == "córdoba" or
provincia == "málaga" or provincia == "granada" or
provincia == "jaén" or provincia == "almería"):
print(provincia, "está en Andalucía")

else:
print(provincia, "no está en Andalucía") s
La otra forma sería terminar cada línea de la condición con una línea invertida en lugar de rodearla con
paréntesis:
provincia = input("Introduzca el nombre de una provincia española: ")

provincia = provincia.lower() # La transformamos a minúsculas
if provincia == "huelva" or provincia == "sevilla" or \
provincia == "cádiz" or provincia == "córdoba" or \
provincia == "málaga" or provincia == "granada" or \
provincia == "jaén" or provincia == "almería"):
print(provincia, "está en Andalucía")

else:
print(provincia, "no está en Andalucía")
Ejercios para practicar
 Escribe un programa que solicite al usuario 4 números y después imprima el mayor de

todos ellos.
Sección 3.5
 Escribe un programa que calcule la nota media de un alumno dadas las notas de sus dos
exámenes parciales. El alumno estará suspenso si no ha aprobado ambos parciales.
Solución:

nota1 = float(input("Nota del primer parcial: "))
nota2 = float(input("Nota del segundo parcial: "))
# Comprobar que ha aprobado ambos parciales

if nota1 >= 5 and nota2 >= 5:
# Calcular la nota media
nota_final = (nota1 + nota2) / 2
print("Nota final: ", nota_final)
else:
# Ha suspendido algún parcial
print("Para aprobar tenías que aprobar ambos parciales")
 Casi todo el mundo piensa que los años bisiestos son los divisibles por 4 (por ejemplo 1988,
1992 y 1996 son años bisiestos). Pero existe una excepción a esa regla: los años divisibles
por 100 sólo son bisiestos sin además son divisibles por 400. Por ese motivo el año 1600 es
bisiesto pero el 1700 no lo es.
Haz un programa que pida un año al usuario y diga si es bisiesto o no.
Solución:
anyo = int(input("Introduzca un año: "))
# Comprobamos si es divisible por 4

if anyo % 4 == 0:
# Es dividible por 4
# Comprobamos si es sivisible por 100
if anyo % 100 != 0:
# Dividible por 4 pero no por 100
print("El año es bisiesto")
elif anyo % 400 == 0:
# Divisible por 4, por 100 y por 400
print("El año es bisiesto")
else:
# Divisible por 4 y por 100 pero no por 400
print("El año no es bisiesto")
else:
# Si no es dividible por 4 no es bisiesto
print("El año no es bisiesto")
Sección 3.6
Ejercicio 2. Condicionales
Escribe un programa que pregunte al usuario un nombre de mes y escriba el número de días que tiene. El
nombre del mes puede estar escrito en mayúsculas o minúsculas. Consideraremos que el año no es bisiesto
y por tanto febrero siempre tiene 28 días. Si el usuario introduce un mes que no existe el programa
mostrará un mensaje indicando que no conoce ese mes.
A continuación se muestran varios ejemplos de ejecución:
Introduzca el nombre del mes: enero

enero tiene 31 días.
Introduzca el nombre del mes: Abril

Abril tiene 30 días
Introduzca el nombre del mes: diciemb

No conozco ese mes
Sección 4.1
Instrucción while
Repitiendo instrucciones
En ocasiones necesitamos ejecutar un conjunto de instrucciones varias veces. Por ejemplo, supongamos
que necesitamos imprimir 3 veces el número 10. La solución es sencilla, ¿verdad?
print(10)
print(10)
print(10)
¿Y si necesitamos imprimir el número 10.000 veces? ¿o un millón de veces? No podemos escribir la

instrucción print 1.000.000 de veces (ni siquiera cortando y pegando). Para resolver este tipo de
problemas, los lenguajes de programación incorporan instrucciones que permiten repetir trozos de código
un determinado número de veces o hasta que deje de cumplirse alguna condición.
La instrucción while
La instrucción while tiene la siguiente forma:
while <condición>:
<instrucciones_dentro_del_while>
Mientras la condición del while se siga cumpliendo, se ejecutarán las instrucciones que haya dentro. Tras
ejecutar esas instrucciones se volverá a comprobar la condición del while . Si la condición sigue siendo
cierta se volverán a ejecutar las instrucciones que hay dentro del while . Y así hasta que la condición deje
de ser cierta, momento en el que salimos del bucle y seguimos ejecutando el resto de programa.
Por ejemplo, el siguiente programa imprime los números del 1 al 3:

i = 1
while i <= 3:
print(i)
i = i + 1
produciendo la siguiente salida:
1
2
3
Analicemos paso a paso la ejecución del programa anterior:
La primera crea una variable ( i ) y le asigna el valor 1

A continuación se evalúa la condición del bucle i <= 3 y como es cierta (1 <= 3) se ejecuta el cuerpo
del bucle.
Se imprime el valor de la variable i (en este caso 1)
Se incrementa en uno el valor de la variable i (que ahora contiene un 2)
Volvemos a evaluar la condición del bucle i <= 3 y sigue siendo cierta (2 <= 3) así que volvemos a
ejecutar el cuerpo del bucle.
Volvemos a evaluar la condición del bucle i <= 3 y sigue siendo cierta (3 <= 3) así que volvemos a
ejecutar el cuerpo del bucle.
Volvemos a evaluar la condición del bucle i <= 3 y en este caso ya no es cierta así que salimos de la
instrucción while . Si hubiera más instrucciones en nuestro programa, se ejecutarían a continuación.
En realidad podríamos haber impreso los números del 1 al 3 con tres instrucciones print sin necesidad de
usar un bucle. La ventaja de usar un bucle es que ahorramos código cuando tenemos que repetir las
mismas instrucciones muchas veces. Por ejemplo, podemos modi car fácilmente el programa anterior para
imprimir los números entre 1.000 y 10.000:
i = 1000
while i <= 10000:
print(i)
i = i + 1
Modi cando mínimamente el programa podemos hacer que se impriman los números del 1 a 1.000.000 o el
rango que queramos (aunque puede que tarde un rato en terminar).
La variable que se usa para iterar (dar vueltas al bucle) se denomina índice del bucle. En el programa
anterior, el índice sería la variable i .
 Es posible crear bucles in nitos si la condición del bucle nunca se hace falsa. Si tu programa tarda demasiado
en terminar, seguramente ha entrado en un bucle in nito. Recuerda que puedes interrumpir la ejecución de un
programa en cualquier momento pulsando el botón de stop (cuadrado rojo) que aparece a la izquierda de la
consola.
Número indeterminado de repeticiones
A veces no conocemos cuántas veces debe ejecutarse un bloque de código porque depende de un valor
introducido por el usuario. Por ejemplo, el siguiente programa juega con el usuario a adivinar un número:
secreto = 5
adivinado = input("Adivina el número: ")

while adivinado != secreto:
adivinado = int(input("Adivina el número: "))
print("Lo adivinaste! El número era", secreto)
El programa seguirá pidiendo números al usuario hasta que introduzca el 5. El usuario puede introducirlo a
la primera, a la quinta o no adivinarlo nunca.
Al principio de la sección vimos que imprimir 3, 5, 10 o 20 números podía ser tedioso, pero al n y al cabo
era algo que podíamos hacer sin bucles. Sin embargo, no podríamos construir un programa como el
anterior sin tener instrucciones que permitan construir bucles como el while .
 En realidad se puede hacer usando recursión, pero es un concepto de programación avanzado que no veremos
en este curso.
 Escribe un programa que pida palabras al usuario hasta que introduzca alguna que
comience por la letra a (mayúscula o minúscula). Antes de nalizar, el programa indicará el
número total de palabras introducidas.
Sección 4.2
Instrucción for
Bucles for
La instrucción for permite escribir bucles en los que conocemos de antemano el número de repeticiones
que vamos a hacer. La instrucción for tiene la siguiente estructura:
for variable in range(inicio, fin):

<instrucciones_del_bucle>
La variable va tomando los valores inicio, inicio+1, inicio+2, … hasta llegar a n-1 y para cada uno de esos
valores se ejecutan las instrucciones del bucle. Cuando la variable alcanza el límite superior del intervalo ( n)
el bucle termina.
Por ejemplo, el siguiente programa imprime los números del 5 al 10 usando una instrucción for :
for i in range(5, 11):

print(i)
5
6
7
8
9
10
La variable i (el índice del bucle) va tomando valores desde el 5 hasta el 10 y para cada uno de esos valores
ejecuta las instrucciones del bucle, que en este caso imprime el número por consola.
Fíjate que el bucle nunca llega a imprimir el valor 11. Cuando la variable i alcanza el límite superior
de nido en la función range , el bucle termina.
Podríamos haber conseguido el mismo efecto usando un bucle while de los que vimos en la sección
anterior:
i = 5
while i < 11:
print(i)
i = i+1
Como puedes observar, la versión que usa la instrucción for es un poco más compacta porque en la
misma línea se de ne la variable que sirve para iterar, su valor inicial y su valor nal.
Comparación de los bucles while y for
Los bucles while son más generales que los bucles for porque permiten escribir programas en los que
no se conoce el número de veces que se repetirá un bloque de código (como el programa que proponía al
usuario adivinar números). Si se conoce el número de repeticiones, los bucles for permiten escribir código
más compacto.
 En realidad la verdadera potencia de las instrucciones for es que pueden usarse para recorrer los elementos
almacenados en distintas estructuras de datos, pero eso lo veremos más adelante en el curso.
Contar hacia atrás
Los bucles no tienen por qué tener un índice creciente. Por ejemplo, ¿qué pasaría si queremos simular la
cuenta atrás en el lanzamiento de un cohete espacial?
i = 10
print("Starting countdown...")
while i > 0:
print(i, "...")
i = i - 1
print("Ignition!")
Y su correspondiente versión del bucle for :
print("Starting countdown...")
for i in range(10, 0, -1):
print(i, "...")
print("Ignition!")
En este ejemplo podemos observar que la función range admite un tercer argumento opcional que indica
como modi car el valor de la variable que usamos para iterar (en este ejemplo restando 1). La variable i
empieza valiendo 10, después vale 9, …, hasta llegar a 1. Cuando la variable i alcanza el valor 0 se sale del
bucle.
En ambos casos la salida es la misma:
Starting countdown...
10 ...
9 ...
8 ...
7 ...
6 ...
5 ...
4 ...
3 ...
2 ...
1 ...
Ignition!
Contando de 3 en 3
El tercer argumento de la función range nos permite elegir cuánto queremos incrementar (o decrementar)
el valor del índice en cada vuelta. Podemos usar ese valor para, por ejemplo, imprimir los múltiplos de 3 de
manera sencilla:
for n in range(3, 20, 3):

print(n)
3
6
9
12
15
18
Usando el índice del bucle
A veces el valor del índice del bucle sirve para calcular cosas. Por ejemplo, ¿cuánto vale la suma de los 10
primeros números naturales?
1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55
¿Y de los 100 primeros números naturales? ¿Y del primer millón de números naturales? Desde luego, eso
parece un trabajo perfecto para un programa de ordenador.
suma = 0
valor_maximo = 10
for i in range(1, valor_maximo + 1):

suma = suma + i
print("La suma de los", valor_maximo,

"primeros números naturales vale", suma, ".")
La suma de los 10 primeros números naturales vale 55 .
La variable suma sirve para acumular los valores que vamos recorriendo con el bucle. Por eso es
importante que empiece conteniendo el valor cero al principio del programa.
Bucles con instrucciones condicionales
Podemos combinar bucles e instrucciones condicionales para comprobar muchos valores y sólo hacer cosas
con algunos de ellos.
Por ejemplo, supongamos que queremos mostrar por pantalla los números menores que 100 que sean
divisible por 3 y por 7 a la vez. Decimos que un número es divisible por 3 cuando el resto de la división
entera (operador módulo % ) es cero:
for i in range(1, 100):

if i % 3 == 0 and i % 7 == 0:
print(i)
21
42
63
84
El bucle for ha ejecutado 99 veces la instrucción if con valores i == 1, i == 2, … pero la instrucción if

sólo ha permitido imprimir los valores que eran divisibles por 3 y por 7 a la vez.
En realidad, sabiendo un poco de matemáticas podríamos haber comprobado sólo los múltiplos del mínimo
común múltiplo de 3 y 7 (mcm(3,7) = 21`). Por ejemplo, este programa sería más e ciente:
for i in range(21, 100, 21):

print(i)

 Vuelve a hacer el ejercicio de imprimir la suma de los números naturales, pero esta vez
pregunta al usuario desde qué número quiere empezar a sumar y hasta que número quiere
llegar. Por ejemplo, si el usuario introduce los números 5 y 10, el programa debe calcular
5+6+7+8+9+10.
 Escribe un programa que imprima la tabla de multiplicar de un número introducido por el

usuario usando una instrucción for . Por ejemplo, si el usuario introduce el 7, el programa
debe imprimir la tabla del 7.
Sección 4.3
Listas
Hasta ahora hemos utilizado variables que eran capaces de almacenar un único valor. Sin embargo, es
posible crear variables que almacenen grandes cantidades de datos. Estos datos pueden estar organizados
de distintas maneras en la memoria del ordenador dependiendo de cómo queramos utilizarlos. Las
estructuras de datos permiten almacenar grandes cantidades de información de manera e ciente.
En este curso vamos a estudiar 3 estructuras de datos principales: listas, conjuntos y diccionarios.
Una lista es una secuencia de elementos. El término secuencia es importante porque indica que los
elementos están ordenados. Por ejemplo, una lista de empleados contendrá la información de los
empleados de una empresa ordenados por algún criterio (quizás los apellidos o la fecha de incorporación).
Los pasos de una receta de cocina también los podríamos almacenar como una lista porque el orden en que
se ejecutan es importante (no es lo mismo echar primero el aceite que el huevo). El concepto de orden es
importante porque diferencia las listas de otras estructuras de datos como, por ejemplo, los conjuntos.
Crear listas
Podemos de nir una lista escribiendo sus elementos entre corchetes y separados por comas:
[1, 2, 3, 4, 5]
La lista anterior contendría 5 elementos, todos ellos números enteros. Las listas también pueden contener
elementos de distintos tipos:
[1, "cfi", 52.3, "python", 9242]
Podemos almacenar listas en variables con el operador de asignación habitual:
mi_lista = [1, "cfi", 52.3, "python", 9242]

print(mi_lista)
[1, 'cfi', 52.3, 'python', 9242]

Finalmente, para crear una lista vacía (sin elementos) escribiremos los corchetes sin poner ningún elemento
dentro:
lista_vacia = []
Número de elementos
La función len devuelve la longitud de la lista, es decir, el número de elementos que contiene:

print(mi_lista)
print("La lista contiene", len(mi_lista), "elementos")
[1, 'cfi', 52.3, 'python', 9242]

La lista contiene 5 elementos
Una lista vacía no contiene ningún elemento:
lista_vacia = []
print(lista_vacia)
print("La lista contiene", len(lista_vacia), "elementos")
[]
La lista contiene 0 elementos
Consular si contiene un elemento
Podemos consultar si un elemento aparece en la lista con el operador in :
colores = ["rojo", "verde", "azul", "amarillo"]

if "verde" in colores:
print("El verde es un color")
else:
print("El verde no es un color")
Acceder a los elementos
Podemos acceder a los elementos de una lista escribiendo su posición entre corchetes. Es importante
recordar que el primer elemento de una lista está en la posición 0:
print(mi_lista[0])
print(mi_lista[1])
print(mi_lista[2])
1
'cfi'
52.3
Además de acceder a un elemento concreto, podemos acceder a una sublista indicando la posición inicial y
nal del siguiente modo:
print(mi_lista[1:3])
['cfi', 52.3]
En este caso se imprime la sublista que comienza en la posición 1 y termina en la posición 2 (el último
elemento del rango no se selecciona).
Fíjate que el operador corchete puede devolver un elemento individual o una lista dependiendo de si lo
usamos con una posición concreta o con un rango de posiciones.
Si intentamos acceder a una posición de la lista que no existe se producirá un error:
print(mi_lista[5]) # Las posiciones válidas son 0, ..., 4
Traceback (most recent call last):

File "/Users/antonio/PycharmProjects/CFI/pruebas.py", line 2, in <module>
print(mi_lista[5])
IndexError: list index out of range
 Seguramente habrás notado lo similar que son las listas y las cadenas de caracteres. Las cadenas de caracteres
son como listas de caracteres. La principal diferencia es que los elementos de una lista de pueden modi car y
los de las cadenas de caracteres no.
Modificar los elementos
Podemos modi car uno de los elementos existentes en la lista simplemente asignándole un nuevo valor:
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9]
numeros[0] = 11
print(numeros)
[11, 2, 3, 4, 5, 6, 7, 8, 9]
También podemos modi car varios elementos de una lista usando rangos:
numeros[1:4] = [12, 13, 14]

print(numeros)
[11, 12, 13, 14, 5, 6, 7, 8, 9]
El rango 1:4 contiene 3 elementos (recuerda que el último queda fuera del rango) y por tanto tenemos que
asignarle una lista de longitud 3.
Añadir nuevos elementos
Si queremos añadir un elemento nuevo a la lista, podemos añadirlo al nal con el método append :
lista = []
lista.append(100)
lista.append(200)
lista.append(300)
print(lista)
[100, 200, 300]
También podemos añadir elementos en una posición determinada usando el método insert que recibe
dos argumentos: la posición en la que insertar y el nuevo elemento:
lista.insert(1, 42)
print(lista)
[100, 42, 200, 300]
Observa como al insertar el número 42 en la posición 1 de la lista, todos los elementos a partir de esa
posición se han desplazado una posición a la derecha.
Eliminar un elemento
Podemos eliminar el elemento que ocupa una posición determinada en la lista usando la palabra reservada
del :
del lista[1]
print(lista)
[100, 200, 300]
Observa como el elemento de la posición 1 se ha eliminado y todos los elementos a la derecha de esa
posición se han desplazado una posición a la izquierda para no dejar huecos.
También podemos eliminar la primera aparición de un elemento en una lista con el método remove :
letras = ['a', 'b', 'c', 'd']

letras.remove('b')
print(letras)
['a', 'c', 'd']
Encontrar un elemento
Podemos encontrar la posición que ocupa un elemento en la lista usando el método index :
letras = ['a', 'b', 'c', 'd']

print(letras.index('d'))
Si el elemento aparece varias en la lista, el método index devolverá la posición de la primera aparición. Si
el elemento buscado no aparece en la lista se producirá un error.
Recorrer los elementos
Podemos recorrer los elementos de una lista usando una instrucción de tipo for :
pares = [2, 4, 6, 8, 10]

for numero in pares:
print(numero)
2
4
6
8
10
La variable numero va tomando los distintos valores de la lista pares y la instrucción print los imprime
por la consola.
Las instrucciones for sirven para recorrer estructuras de datos como las listas. De hecho, la función
range que vimos en la sección anterior crea un objeto iterable que, aunque no es exactamente una lista, se
comporta de manera similar. La instrucción for permite recorrer los elementos del rango devuelto por
range :
for numero in range(1, 10, 2):

print(numero)
Por ejemplo, range(1, 10, 2) devuelve un objeto iterable que contiene los valores [1, 3, 5, 7, 9].
 La función range no devuelve una lista porque sería muy ine ciente construir la lista en memoria con todos
sus elementos sólo para recorrerlos. La función range devuelve un objeto iterable que simula una lista pero
que sólo mantiene en memoria el elemento actual.
Si queremos, podemos transformar el rango devuelto por range en una lista usando la función list :
pares = list(range(2, 10, 2))

print(pares)
[2, 4, 6, 8]
Finalmente, a veces será útil recorrer los elementos de una lista conociendo la posición que ocupan.
Podemos hacer esto con la función enumerate :
lista = ["casa", "pelota", "helado"]

for posicion, valor in enumerate(lista):
print(posicion, valor)
0 casa
1 pelota
2 helado
Listas por comprensión (list comprehensions)
Ya conocemos 2 formas de crear listas: enumerando sus elementos entre corchetes o creando una lista
vacía y luego añadiendo elementos con la operación append .
Existe una tercera forma de crear listas a partir de los elementos de otras listas:
lista = [x*x for x in range(1,10)]
print(lista)
En este ejemplo la lista se crea con los cuadrados ( x*x ) de los números entre 1 y 9. Y por tanto la salida
será la siguiente:
[1, 4, 9, 16, 25, 36, 49, 64, 81]
Es una forma muy compacta de crear listas que los programadores de Python usan de manera habitual.
Pero recuerda que puedes conseguir lo mismo usando las operaciones que ya conocías:
lista = []
for x in range(1,10):
lista.append(x*x)
print(lista)
 Crea un programa que realice los siguientes pasos imprimiendo la lista tras cada uno de
ellos:
pida 5 palabras al usuario y las almacene en una lista.

pida al usuario un nuevo elemento y lo añada al nal de la lista
pida al usuario una posición y elimine el elemento en esa posición. Si la posición no es
válida se deben seguir pidiendo posiciones hasta que se introduzca una posición
válida.
Sección 4.4
Conjuntos
Un conjunto es una estructura de datos que también permite almacenar grandes cantidades de
información. A diferencia de las listas, los conjuntos no pueden tener elementos repetidos y, además, sus
elementos no se almacenan en ningún orden determinado.
En los conjuntos, al igual que en las listas, podemos añadir y eliminar elementos o consultar si contienen un
elemento determinado. Sin embargo, como los elementos del conjunto no están ordenados, no tiene
sentido pedir el primer o tercer elemento del conjunto.
Crear conjuntos
La forma más sencilla de crear un conjunto es enumerar sus elementos entre llaves:
mi_conjunto = {1, "hola", 3.3, "adios"}

print(mi_conjunto)
{1, 3.3, 'adios', 'hola'}
Como puedes ver, los elementos no se imprimen en el mismo orden en el que se declararon. Los conjuntos
no almacenan los elementos en ningún orden concreto.
Para crear un conjunto vacío debemos usar la función set() .
conjunto_vacio = set()
 No podemos crear conjuntos vacíos usando llaves vacías {} porque las llaves también se usan para crear
diccionarios, que se explicarán en la siguiente sección.
También podemos crear conjuntos a partir de los elementos de una lista:

lista = [1, 1, 2, 3, 3, 3, 3]
conjunto = set(lista)
print("Lista:", lista)
print("Conjunto:", conjunto)
Lista: [1, 1, 2, 3, 3, 3, 3]
Conjunto: {1, 2, 3}
Como puedes observar, han desaparecido todos los elementos repetidos. Un conjunto no puede contener
elemento repetidos.
Número de elementos
Al igual que en las listas, la función len devuelve el número de elemento en el conjunto.
mi_conjunto = {1, "hola", 3.3, "adios"}

print(mi_conjunto)
print(len(mi_conjunto))
{1, 3.3, 'adios', 'hola'}

4
Los conjuntos vacíos no contienen ningún elemento:
conjunto_vacio = set()
print(len(conjunto_vacio))
Consultar si contiene un elemento
Para comprobar si un elemento pertenece a un conjunto usamos el operador in :
conjunto = { "uno", "dos", "tres", "cuatro" }

if "dos" in conjunto:
print("El dos está en el conjunto")
else:
print("El dos no está en el conjunto")
Añadir elementos
El método add permite añadir elementos a un conjunto. Si el elemento ya existe en el conjunto no se
añadirá.
conjunto = set() # Creamos un conjunto vacío

conjunto.add("uno") # Añadimos elementos
conjunto.add("dos")
conjunto.add("tres")
conjunto.add("tres")
print(conjunto)
{'uno', 'dos', 'tres'}
Eliminar elementos
Podemos eliminar elementos de un conjunto con la operación discard .
conjunto = {'uno', 'dos', 'tres'}

conjunto.discard("uno")
conjunto.discard("cuatro")
print(conjunto)
{'tres', 'dos'}
Si el elemento que queremos eliminar no está en el conjunto, la operación no hace nada.
Operaciones entre conjuntos
Existen métodos para realizar las operaciones más habituales con conjuntos:
La unión de dos conjuntos contiene todos los elementos que aparecen en alguno de ellos.
La intersección de dos conjuntos contiene los elementos comunes de ambos.
La diferencia de dos conjuntos contiene los elementos que están en uno pero no en el otro.
Todas estas operaciones devuelven un nuevo conjunto con el resultado.
a = { 1, 3, 5, 7, 9 }
b = { 1, 2, 3, 4, 5 }
print("Unión:", a.union(b))
print("Intersección:", a.intersection(b))
print("Diferencia:", a.difference(b))
Unión: {1, 2, 3, 4, 5, 7, 9}
Intersección: {1, 3, 5}
Diferencia: {9, 7}
Recorrer los elementos de un conjunto
Podemos recorrer los elementos de un conjunto usando una instrucción for :
conjunto = {"unos", "dos", "tres", "cuatro"}

for elemento in conjunto:
print(elemento)
cuatro
unos
dos
tres
Como puedes observar, cuando recorremos los elementos de un conjunto no podemos saber a priori en
que orden los vamos a obtener.
Transformar listas en conjuntos y viceversa
Podemos transformas listas en conjuntos usando la función set :
conjunto = set([1, 2, 1, 3, 1, 4])

print(conjunto)
{1, 2, 3, 4}
Del mismo modo podemos crear listas a partir de conjuntos usando la función list :
lista = list({1, 2, 3, 4})

print(lista)
[1, 2, 3, 4]
Conjuntos por comprensión (set comprehensions)
Al igual que en las lista, podemos crear conjuntos de manera compacta a partir de los elementos en otro
conjunto o lista:
pares = { x for x in range(2, 10, 2) }

print(pares)
{8, 2, 4, 6}
 Pide al usuario 10 palabras y almacénalas en un conjunto usando un bucle. Imprime

después el número de palabras distintas introducidas por el usuario.
 Crea un conjunto con los nombres de los meses. Después pide nombres de meses al
usuario e indica, para cada uno de ellos, si es un nombre de mes válido o no usando la
operación de pertenencia a conjunto.
Sección 4.5
Diccionarios
Los diccionarios son estructuras de datos que almacenan pares clave : valor y nos permiten recuperar
los valores asociados a las claves de manera muy rápida.
Los diccionarios juegan un papel muy similar al de las estructuras o registros en otros lenguajes de
programación: permiten almacenar información asociada a atributos. Por ejemplo, podemos utilizar un
diccionario para almacenar la información de un empleado en una empresa: su nombre, apellidos, edad,
puesto de trabajo, estudios, etc. Cada uno de esos campos será una clave en nuestro diccionario que tendrá
asociado un valor concreto para ese empleado.
Crear diccionarios
La forma más sencilla de crear un diccionario es enumerando los pares clave : valor entre llaves:
persona = { "nombre" : "juan", "edad" : 25, "profesión" : "informático"}

print(persona)
{'nombre': 'juan', 'edad': 25, 'profesión': 'informático'}
Este diccionario contiene 3 claves (“nombre”, “edad” y “profesión”) y tres valores asociados a esas respectivas
claves (“juan”, 25 e “informático”).
Podemos crear diccionarios vacíos usando {} :
dic_vacio = {}
Número de claves
La función len devuelve el número de claves almacenadas en el diccionario:

persona = { "nombre" : "juan", "edad" : 25, "profesión" : "informático"}
print(persona)
print(len(persona))
{'nombre': 'juan', 'edad': 25, 'profesión': 'informático'}

3
Los diccionarios vacíos no contienen ninguna clave:
len({})
Consultar si contiene una clave
Al igual que con las listas y los conjuntos, podemos comprobar si una clave aparece en el diccionario usando
el operador in :
if "apellidos" in persona:
print(persona["apellidos"])
else:
print("La persona no tiene apellidos")
La persona no tiene apellidos
Acceder y modificar el valor asociado a una clave
Para acceder al valor asociado a una clave escribimos la clave entre corchetes:
print(persona["nombre"])
print(persona["edad"])
print(persona["profesión"])
juan
25
informático
Del mismo modo, podemos modi car el valor asociado a una clave asignándole el nuevo valor:
persona["nombre"] = "pedro"
print(persona)
{'nombre': 'pedro', 'edad': 25, 'profesión': 'informático'}
Añadir elementos
Para añadir elementos a un diccionario basta con asignar un valor a una clave que aún no existe:
persona["nacionalidad"] = "española"
print(persona)
{'nombre': 'pedro', 'edad': 25, 'profesión': 'informático', 'nacionalidad': 'español

a'}
Eliminar elementos
Para eliminar una clave del diccionario y su valor asociado usamos la palabra reservada del :
del persona["nacionalidad"]
print(persona)
{'nombre': 'pedro', 'edad': 25, 'profesión': 'informático'}
Si intentamos eliminar una clave que no existe en el diccionario, se producirá un error.
Recorrer los elementos
Podemos recorrer las claves almacenadas en un diccionario de la siguiente forma:
for clave in persona: # Otra forma: for clave in persona.keys():

print(clave)
nombre
edad
profesión
Para recorrer los valores almacenados en el diccionario usamos el método values() :
for valor in persona.values():

print(valor)
pedro
25
informático
Finalmente, podemos recorrer explícitamente los pares clave : valor usamos el método items :
for clave, valor in persona.items():

print(clave, valor)
nombre pedro
edad 25
profesión informático
Diccionarios por comprensión (dictionary comprehensions)
Podemos crear diccionarios de forma compacta de manera análoga a como hacíamos con las listas y los
conjuntos, pero en este caso tendremos que especi car la clave y el valor de cada par:
cuadrados = { x : x*x for x in range(1, 10)}

print(cuadrados)
print("El cuadrado de 5 es", cuadrados[5])
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

El cuadrado de 5 es 25
 Crea un diccionario que contenga como claves los nombres de los números del 1 al 10 en
español (uno, dos, …) y como valores los nombres de los mismos números en inglés (one,
two, …). Después pide al usuario números en español y muéstrale su traducción al inglés.
Sección 4.6
 Escribe un programa que clasi que los elementos de una lista en positivos y negativos. Los
elementos positivos deben añadirse a una lista y los negativos a otra. Si la lista original
contiene ceros, se deben ignorar.
# La lista original
lista_original = [7, 6, -9, 234, -4, 0, -7]
# Listas que recibirán el contenido

positivos = []
negativos = []
# Recorrer los elementos de la lista original

for elemento in lista_original:
if elemento > 0:
positivos.append(elemento)
elif elemento < 0:
negativos.append(elemento)
print("Positivos:", positivos)
print("Negativos:", negativos)
 Escribe un programa que dada una lista elimine todos los elementos duplicados. No nos
importa el orden en el que aparezcan los elementos en la lista nal.
# La lista original
lista = [1, 3, 3, 7, 3, 1, 5, 1, 5, 0]
# Convertimos la lista a un conjunto para eliminar duplicados

conjunto = set(lista)
# Convertimos el conjunto en una lista

lista_sin_repetidos = list(conjunto)
print("Lista sin repetidos:", lista_sin_repetidos)
 Escribe un programa que almacene las notas obtenidas por cada alumno en clase. El
profesor introducirá cada vez el nombre de un alumno y una de sus notas. Al nal del
programa se mostrarán las notas obtenidas por cada uno de los alumnos.
# Vamos a representar las notas como un diccionario de listas

# La clave del diccionario será el nombre del alumno
# El valor del diccionario será la lista de notas de ese alumno
notas_clase = {}
nombre = input("Nombre del alumno ('fin' para terminar):")

while nombre != 'fin':
nota = float(input("Nota:"))
# ¿El alumno ya exitía?

if nombre in notas_clase:
# Recuperar la lista de notas del alumno
notas_alumno = notas_clase[nombre]
# Añadir la nueva nota al final de la lista
notas_alumno.append(nota)
else:
# El alumno no existía: añadirlo
# Creamos una lista con la única nota que tenemos
notas_alumno = [ nota ]
# Asociamos la lista de notas con el nuevo alumno
notas_clase[nombre] = notas_alumno
# Pedir siguiente nombre

nombre = input("Nombre del alumno ('fin' para terminar):")
# Mostrar las notas por alumno

for nombre, notas_alumno in notas_clase.items():
print(nombre, ":", notas_alumno)
Sección 4.7
Ejercicio 3. Bucles y estructuras de datos
Escribe un programa que te ayude a llevar un registro de tus gastos. El programa te hará 3 preguntas para
cada gasto: el motivo, el lugar y la cantidad. Tras cada gasto introducido, el programa te preguntará si
quieres introducir otro gasto más. Al nalizar, el programa debe imprimir todos los gastos en el mismo
orden que los introdujiste y la cantidad total de dinero gastado.
A continuación mostramos un ejemplo de cómo debería funcionar tu programa:
Quieres introducir más gastos (si/no): si

Motivo del gasto: camiseta
Lugar del gasto: El Corte Inglés
Cantidad gastada: 15
Quieres introducir más gastos (si/no): si
Motivo del gasto: fruta
Lugar del gasto: mercado
Cantidad gastada: 20
Quieres introducir más gastos (si/no): no
Gastos:
camiseta en El Corte Inglés : 15.0 euros
fruta en mercado : 20.0 euros
Cantidad total : 35.0 euros
La información de cada gasto la debes almacenar como un diccionario con 3 claves: motivo, lugar y
cantidad. Para almacenar la secuencia de gastos debes usar una lista. Es decir, la estructura de datos que
almacena la información es una lista donde cada elemento es un diccionario.
Como este ejercicio es un poco más complicado que los anteriores, a continuación te proponemos la
estructura que debería tener tu programa. Al escribir el programa en Python deberás traducir cada línea en
una o más instrucciones Python.
crear lista de gastos vacía
preguntar al usuario si quiere introducir más gastos
mientras haya más gastos
pedir datos del gasto al usuario
crear diccionario con la información del gasto
añadir el diccionario a la lista de gastos
preguntar al usuario si quiere introducir más gastos
cantidad_total = 0
para cada gasto en la lista de gastos:
imprimir información del gasto
acumular la cantidad del gasto en cantidad_total
imprimir cantidad_total
Sección 5.1
Uso de funciones
Las funciones son uno de los conceptos más importantes en la programación. Permiten escribir estructuras
de código que podemos reutilizar en distintas partes de nuestro programa sin tener que preocuparnos de
cómo funcionan exactamente por dentro.
A lo largo de este curso has estado utilizando funciones creadas por otros todo el tiempo. Por ejemplo,
print es una función que se encarga de imprimir por la consola los datos que recibe como parámetros:
print("Mensaje", 3, 5.4, True, [10, 11, 12], {"a", "b", "c"})
¿Sabes cómo funciona internamente? ¿Cómo se imprime una cadena de texto o un número en la consola?
¿Y un conjunto? En realidad no importa, lo importante es saber que puedo usarla para imprimir cosas.
Parámetros
A lo largo del curso has usado muchas funciones:
print imprime mensajes en la consola.
input solicita un dato al usuario y lo devuelve como cadena de texto.
int , float , str convierten respectivamente a entero, real y cadena de texto.
range devuelve objetos iterables que se pueden recorrer como listas.
list , set , dict permiten crear listas, conjuntos y diccionarios vacíos o a partir de otras
estructuras de datos.
Las funciones pueden recibir o no parámetros que afectan a su comportamiento. Por ejemplo, la función
range puede devolver distintos rangos dependiendo de los valores de sus parámetros:
numeros_pequeños = list(range(0, 10))
print("Pequeños:", numeros_pequeños)
numeros_grandes = list(range(1000000, 1000010))
print("Grandes:", numeros_grandes)
numeros_impares = list(range(1, 10, 2))
print("Impares:", numeros_impares)
numeros_pares = list(range(2, 10, 2))
print("Pares:", numeros_pares)
numeros_decrecientes = list(range(10, 0, -1))
print("Decrecientes:", numeros_decrecientes)
Pequeños: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Grandes: [1000000, 1000001, 1000002, 1000003, 1000004, 1000005, 1000006, 1000007, 10
00008, 1000009]
Impares: [1, 3, 5, 7, 9]
Pares: [2, 4, 6, 8]
Decrecientes: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
Valores devueltos
Todas las funciones anteriores (excepto print ) devuelven valores. Por ejemplo, la función input devuelve
la cadena de texto introducida por el usuario y la función int devuelve el valor entero del parámetro que
recibe.
Los valores devueltos por las funciones se suelen almacenar en variables, o se utilizan como parámetros de
otras funciones:

persona = { "nombre" : nombre, "edad" : edad }
print("Datos:", persona)
Algunas funciones devuelven más de un valor. Por ejemplo, la función divmod devuelve el cociente y el
resto de la división entera:
cociente, resto = divmod(10, 3) # Cociente y resto de 10 entre 3

print("cociente:", cociente)
print("resto:", resto)
cociente: 3
resto: 1
Cuando una función devuelve varios parámetros podemos asignarlos a variables separándolas por comas a
la izquierda del = , como en el ejemplo anterior.
Módulos
Python proporciona muchas funciones ya creadas. Las más habituales se pueden utilizar directamente,
como hemos hecho nosotros hasta ahora. El resto de funciones se agrupan en módulos que debemos
importar para poder utilizarlas.
Por ejemplo, el módulo math contiene muchas funciones matemáticas que nos pueden resultar útiles. Para
usar las funciones de este módulo debemos importarlo usando la instrucción import :
import math
raiz = math.sqrt(16) # raiz cuadrada

print(raiz)
4.0
Para usar una función de un módulo debemos escribir el nombre del módulo y un punto antes de la
función, como en el ejemplo anterior. Veamos algunas otras funciones del módulo math :
import math
print(math.sqrt(16)) # Raiz cuadrada de 16

print(math.cos(0)) # Coseno de un águlo de 0 radianes
print(math.radians(90)) # Radianes equivalentes a 90 grados
print(math.log10(1000)) # Logaritmo en base 10 de 1000
print(math.pow(5, 3)) # 5 elevado a 3
4.0
1.0
1.5707963267948966
3.0
125.0
En lugar de importar todas las funciones de un módulo, también podemos importar funciones concretas y
de ese modo evitar tener que escribir el nombre del módulo cada vez que queramos usar la función:
from math import sqrt, pow
print(sqrt(25))
print(pow(2,10))
Otras cosas que no son funciones
Durante el curso hemos utilizado otras cosas que se parecen a las funciones pero que no son exactamente
lo mismo: operadores, palabras reservadas y métodos.
Los operadores suelen constar de uno o dos símbolos y permiten escribir expresiones de tipo matemático.
Ejemplos de operadores son la suma + , la multiplicación * , la igualdad == o el símbolo de menor < .
Las palabras reservadas forman parte del lenguaje de programación. Ejemplos de palabras reservadas son
in para comprobar la pertenencia de un elemento a una estructura de datos, o del para eliminar
elementos de las estructuras.
Los métodos son muy parecidos a las funciones pero se escriben después de la variable o constante a la
que afectan. Por ejemplo, la operación upper de las cadenas o la operación append de las listas:
palabra_mayusculas = "python".upper()
lista = []
lista.append(3)
La mayoría de las operaciones que hemos visto asociadas a cadenas y estructuras de datos son métodos.
 Los métodos son parte de un tipo de programación denominada Orientada a Objetos que no estudiaremos en
este curso.
Las funciones reciben todos sus parámetros entre paréntesis y para invocarlas es su ciente con escribir su
nombre. Por ejemplo, len es una función que recibe una estructura de datos y nos dice el número de
elementos que contiene:
print(len(["a", "e", "i", "o", "u"]))
No te preocupes sin la distinción entre todas estas operaciones te resulta un poco confusa, es un asunto
más bien teórico. Seguramente las has estado usando durante todo el curso sin preocuparte de si se
trataban de operadores, palabras reservadas, métodos o funciones.
En cualquier caso, ahora que ya sabemos cómo usar funciones escritas por otros, el siguiente paso es
aprender a de nir nuestras propias funciones.
Sección 5.2
Definir funciones
La funciones se de nen usando la palabra reservada def y siguiendo el siguiente esquema:
def nombre_funcion (parametro1, parámetro2, ...):

<cuerpo_de_la_función>
El nombre de la función y el número de parámetros dependerá de la nueva operación que estamos

construyendo. A la hora de nombrar nuestras funciones y sus parámetros, es importante elegir nombres
signi cativos que nos ayuden a recordar cómo se usan.
Veamos un ejemplo. A continuación de nimos una función que imprime un texto rodeado de asteriscos:
def adorna(texto):
print("**********")
print(texto)
print("**********")
En este caso el nombre de la función es adorna y recibe un único parámetro llamado texto . Los
parámetros funcionan como las variables que ya conocemos, pero su valor se establece cuando se usa la
función.
Nuestras funciones se utilizan igual que las que ya vienen prede nidas en Python:
# Definimos la función
def adorna(texto):
print("**********")
print(texto)
print("**********")
# Usamos la función
adorna("Python es genial")
El programa anterior generará la siguiente salida:
**********
Python es genial
**********
Como puedes ver, el parámetro texto toma el valor con el que se invocó la función, en este caso la cadena
del texto “Python es genial”. A continuación se ejecuta el cuerpo de la función, en este caso imprimiendo el
mensaje entre asteriscos.
Una vez hemos de nido una función, podemos usarla tantas veces como queramos en nuestro programa:
# Definimos la función
def adorna(texto):
print("**********")
print(texto)
print("**********")
adorna("Python es genial")
adorna("Hola mundo")
mensaje = "¡Ya lo entiendo!"
adorna(mensaje)
**********
Python es genial
**********
**********
Hola mundo
**********
**********
¡Ya lo entiendo!
**********
Cada vez que invocamos la función adorna , el parámetro texto toma el valor con el que llamamos a la
función y, por tanto, aunque se ejecuta el mismo código, el resultado es distinto (en nuestro caso se
imprimen distintos mensajes). Los parámetros sirven para modi car el comportamiento de la función y
adaptarlo a nuestras necesidades.
Funciones que devuelven valores
Las funciones pueden o no devolver valores. La función adorna , por ejemplo, no devuelve nada, sólo
imprime mensajes en la consola. A continuación vamos a crear una función que sí calcula y devuelve un
valor.
def doble(x):
return 2 * x
d = doble(5)
print(d) # también valdría: print(doble(5))
10
Las funciones que devuelven valores utilizan una palabra reservada return para indicar el valor que se
desea devolver. En este caso la función doble devuelve el valor que resulta de calcular 2*x , es decir,
devuelve el doble del valor que recibe como parámetro.
Veamos otro ejemplo. La siguiente función calcula el valor absoluto de un número:
def valor_absoluto(n):
if n >= 0:
resultado = n
else:
resultado = -n
return resultado
print(valor_absoluto(4))
print(valor_absoluto(-5))
4
5
La primera vez que se invoca la función valor_absoluto el parámetro n tiene el valor 4. A continuación se
ejecuta el cuerpo de la función que asigna a la variable resultado el valor 4. Finalmente, la instrucción
return devuelve el valor 4 almacenado en esa variable.
La segunda vez que se invoca la función valor_absoluto el parámetro n tiene el valor -5. A continuación
se ejecuta el cuerpo de la función que asigna a la variable resultado el valor 5 (- -5 es equivalente a 5).
Finalmente, la instrucción return devuelve el valor 5 almacenado en esa variable.
Las funciones pueden devolver más de un valor. Para hacerlo, separamos los valores devueltos con comas:
def pide_datos():
apellidos = input("Introduce tus apellidos: ")
return nombre, apellidos
nombre_usuario, apellidos_usuario = pide_datos()

print(nombre_usuario, apellidos_usuario)
Introduce tu nombre: Pedro

Introduce tus apellidos: García Pérez
Pedro García Pérez
Como la función pide_datos devuelve dos valores, necesitamos dos variables en las que almacenarlos al
invocar la función.
Ámbito de las variables y parámetros

Los parámetros de una función sólo son accesibles dentro del cuerpo de esa función.
def suma(x, y):

return x + y
print(suma(5, 6)) # Imprime 11

print(x) # ¡¡Error!! La variable x no está definida
El programa anterior generaría un error porque el parámetro x sólo existe dentro de la función suma . Los
parámetros de una función sólo se pueden utilizar dentro de la función.
Pasa los mismo con las variables locales de las funciones. Ya hemos visto que las variables se crean
asignándoles un valor. Cuando de nimos nuevas variables dentro de una función, esas variables sólo se
pueden usar dentro de la función.
def valor_absoluto(n):
if n >= 0:
resultado = n
else:
resultado = -n
return resultado
print(valor_absoluto(-10))
print(resultado) # ¡¡Error!! Variable no definida
En el ejemplo anterior la variable resultado se de ne dentro de la función valor_absoluto y por tanto

no se puede usar fuera.
El ámbito de las variables y parámetros es muy importante para poder reutilizar el código. Básicamente
permite que dos variables distintas en distintos ámbitos puedan tener el mismo nombre. Veamos un
ejemplo:
def doble(x):
return 2*x
def triple(x):
return 3*x
# Programa principal
x = doble(4)
print(x)
y = triple(10)
print(y)
8
30
El parámetro x de la función doble es distinto del parámetro con el mismo nombre en la función triple .
Y de hecho también es distinto del parámetro x que aparece en el programa principal.
Esto puede resultar un poco confuso al principio, pero permite que puedas utilizar los nombres de variables
que quieras en cada función porque, aunque se llamen igual, serán variables distintas que pueden contener
valores distintos.
Por ejemplo, mira el siguiente programa:
def pide_datos():
apellidos = input("Introduce tus apellidos: ")
return nombre, apellidos
nombre, apellidos = pide_datos()
print(nombre, apellidos)
El programa funciona correctamente aunque las variables locales nombre y apellidos se llamen igual que
las variables del programa principal. Es decir, el usuario de la función pide_datos no necesita conocer
cómo está implementada para poder utilizarla.
 Recuerda que cada función SÓLO puede utilizar los parámetros y variables locales que de na. En el cuerpo de
una función NUNCA debes acceder a variables que se hayan declarado fuera de la función.
Parámetros por copia y por referencia
¿Qué ocurre si modi camos los valores de los parámetros dentro de la función? En general, los cambios sólo
serán visibles dentro de la función porque los parámetros almacenan una copia de los valores con los que
se invocó a la función.
Por ejemplo, la siguiente función seguramente no se comporta como esperas:
def incrementa(x):
x = x + 1
x = 5
incrementa(x)
print(x)
5
Aunque el parámetro x cambia su valor dentro de la función, esos cambios no son visibles desde fuera de
la función. La explicación es que el parámetro x contiene una copia del valor almacenado en la variable x
del programa principal. Al modi car el parámetro, estamos modi cando la copia, pero no el original.
 Los parámetros que contienen tipos básicos (números enteros, reales, cadenas de texto) se pasan por copia. Es
decir, el parámetro contiene una copia del valor original con el que se invocó a la función. Por tanto, cambiar su
valor dentro de la función no tiene efectos fuera de la función.
La manera correcta de escribir el código anterior sería la siguiente:
def incrementa(x):
return x + 1
x = 5
x = incrementa(x)
print(x)
Los parámetros que representan estructuras de datos (listas, conjuntos y diccionarios) no se pasan por
copia, sino por referencia. Eso quiere decir que las modi caciones que realicemos dentro de la función sí
serán visibles cuando salgamos de la función. Piensa que las estructuras de datos pueden contener miles o
millones de datos en memoria y hacer una copia cada vez que se pasan a una función sería muy ine ciente.
def anyade_elemento(lista, elemento):

lista.append(elemento)
mi_lista = []
print(mi_lista)
anyade_elemento(mi_lista, 5)
print(mi_lista)
anyade_elemento(mi_lista, 6)
print(mi_lista)
[]
[5]
[5,6]
Documentar las funciones
La forma correcta de documentar las funciones es escribiendo un comentario con triples comillas (sencillas
o dobles) justo después de la de nición de la función. Las triples comillas permiten escribir comentarios que
ocupan varias líneas.
El comentario asociado a la función deben explicar qué hace y cómo se usa (qué parámetros recibe y qué
valores devuelve). Por ejemplo:
def suma_elementos(lista):
""" Devuelve la suma de los elementos de una lista.
Si la lista es vacía devuelve 0.
"""
suma = 0
for elemento in lista:
suma = suma + elemento
return suma
Un ejemplo un poco más complejo
Vamos a crear dos funciones:
La primera función va a preguntar al usuario el nombre de sus amigos y va a devolver una lista con
esos nombres.
La segunda función va a recibir la lista de amigos y la va a imprimir por consola.
def pide_amigos():
""" Pide al usuario los nombres de sus amigos y los devuelve en una lista.
"""
# Creamos una lista vacía
amigos = []
# Pedimos el nombre de los amigos

nombre = input("Escribe el nombre de un amigo ('fin' para terminar): ")
while nombre != "fin":
# Añadimos el nombre a la lista
amigos.append(nombre)
# Pedimos el siguiente nombre

nombre = input("Escribe el nombre de un amigo ('fin' para terminar): ")
# Devolvemos la lista de amigos

return amigos
def imprime_amigos(amigos):
""" Imprime por consola los nombres de hay en la lista de amigos
"""
print("Lista de amigos:")
for nombre in amigos:
print(nombre)
lista_amigos = pide_amigos()
imprime_amigos(lista_amigos)
Escribe el nombre de un amigo ('fin' para terminar): Carmen
Escribe el nombre de un amigo ('fin' para terminar): Sofía
Escribe el nombre de un amigo ('fin' para terminar): Juan
Escribe el nombre de un amigo ('fin' para terminar): fin
Lista de amigos:
Carmen
Sofía
Juan
 Crea una función reciba una lista de números y devuelva cuántos de ellos son positivos.
 Crea una función que solicite al usuario un número entre 1 y 10. Si el usuario introduce un
número incorrecto, la función debe seguir pidiéndole otro número hasta que introduzca
uno correcto. Cuando el usuario introduzca un número válido, la función debe devolverlo.
 Crea una función que imprima la tabla de multiplicar del número que se le pase como
parámetro.
Sección 5.3
Programación estructurada
Cuando creamos un programa tenemos que decidir dos cosas:
Como representamos la información, es decir, qué estructuras de datos usamos.

Como dividimos la funcionalidad en pequeños trozos reutilizables, es decir, qué funciones de nimos.
Dividir las tareas que tiene que realizar el programa en funciones es una de las tareas más complicadas
cuando se empieza a programar. Intuitivamente, piensa que debes crear una función por cada tarea
compleja de tu programa. Además, debes crear funciones para tareas pequeñas que uses varias veces.
Dividir una tarea compleja en tareas más sencillas
Supongamos que necesitamos obtener una lista con todos los números primos menores 1000. Un número
primo es aquel que sólo es divisible entre 1 y él mismo. Por ejemplo, el número 7 es primo porque no es
divisible ni por 2, ni por 3, …, ni por 6. Y el número 10 no es primo porque se puede dividir por 2 y por 5.
La idea sería recorrer todos los números menores que 1000 y para cada uno de ellos preguntar si es primo.
Aquellos que sean primos los meteremos en una lista.
Pensado de esta forma tenemos que crear 2 funciones:
La primera de ellas recibe un número y devuelve un valor booleano (cierto o falso) indicando si es
primo.
La segunda recibe el número más alto que se quiere comprobar y devuelve una lista con todos los
números primos encontrados menores que dicho límite.
Empecemos por diseñar la primera función:

def es_primo(n):
""" Comprueba si el número n es primo.
"""
# Intentamos dividir n por 2, por 3, ..., por n-1
for i in range(2, n):
if n % i == 0:
# n es divisible por i luego no es primo
return False
# Si llegamos a este punto del programa es porque n es primo

return True
La función va comprobando si n es divisible por 2, por 3, … Si es divisible por alguno de ellos devuelve
False . Si no es divisible por ninguno de ellos devuelve True .
Vamos a comprobar si funciona correctamente:
for i in range(2,10):
print(i, es_primo(i))
2 True
3 True
4 False
5 True
6 False
7 True
8 False
9 False
Tiene buena pinta. Vamos ahora con la segunda función:
def lista_primos(limite):
""" Devuelve una lista con los números primos menores que el límite.
"""
# Añadimos los números primos a la lista
primos = []
for n in range(2, limite):
if es_primo(n):
primos.append(n)
return primos
La función va comprobando todos los números entre 2 y límite-1. Cuando alguno de esos valores es primo,
lo añade a la lista. Vamos a comprobar si funciona:
print(lista_primos(20))
[2, 3, 5, 7, 11, 13, 17, 19]
Parece que funciona. Finalmente, vamos a resolver el problema con el que comenzamos: crear una lista con
los números primos menores que 1000.
primos = lista_primos(1000)
print(primos)
El programa completo quedaría así:
def es_primo(n):
""" Comprueba si el número n es primo.
"""
# Intentamos dividir n por 2, por 3, ..., por n-1
for i in range(2, n):
if n % i == 0:
# n es divisible por i luego no es primo
return False
# Si llegamos a este punto del programa es porque n es primo

return True
def lista_primos(limite):
""" Devuelve una lista con los números primos menores que el límite.
"""
# Añadimos los números primos a la lista
primos = []
for n in range(2, limite):
if es_primo(n):
primos.append(n)
return primos
# Programa
print(lista_primos(1000))
 Crea un programa que imprima tablas de multiplicar de números. El programa debe tener
las siguientes funciones:
Una función imprime_tabla_multiplicar que recibe como parámetro un número e

imprime su tabla de multiplicar. Por ejemplo, si recibe el 7 debe imprimir: 7 * 1 = 7, 7
* 2 = 14, …, 7 * 10 = 70 cada uno en una línea.
Una función pide_datos que pide al usuario la tabla de multiplicar que desea ver y
devuelve dicho valor. Si el número introducido es negativo o mayor que 10, volverá a
preguntar al usuario hasta que introduzca un valor correcto.
El programa principal que usa las funciones anteriores debe ser el siguiente:
n = pide_datos()
while (n != 0):
imprime_tabla_multiplicar(n)
n = pide_datos()
Sección 5.4
 Vamos a crear un programa que permita gestionar la lista de pacientes que está esperando
al médico. Cuando llega un nuevo paciente se añade al nal de la lista. El médico siempre
atiende al primer paciente de la lista.
Debemos implementar las siguientes operaciones:
llega_nuevo_paciente añade un paciente al nal de la lista de pacientes
medico_atiende_paciente elimina el primer paciente de la lista de pacientes
imprime_numero_de_pacientes imprime el número de pacientes en la lista
imprime_lista imprime la lista de pacientes
Todas las operaciones necesitan operar sobre la lista de pacientes (para leerla o modi carla)
así que se la tendremos que pasar como parámetro. Además, la función
llega_nuevo_paciente necesita el nombre del nuevo paciente para incorporarlo a la lista.
def llega_nuevo_paciente(lista_pacientes, nuevo_paciente):
""" Añade un nuevo paciente al final de la lista de pacientes.
"""
lista_pacientes.append(nuevo_paciente)
def medico_atiende_paciente(lista_pacientes):
""" Elimina el primer paciente de la lista.
Si la lista está vacía no hace nada.
"""
if len(lista_pacientes) > 0:
del lista_pacientes[0]
def imprime_numero_de_pacientes(lista_pacientes):
""" Imprime por consola el número de pacientes en la lista.
"""
print("Pacientes esperando:", len(lista_pacientes))
def imprime_lista(lista_pacientes):
""" Imprime la lista de pacientes
"""
print("Lista de pacientes esperando:")
for paciente in lista_pacientes:
print(paciente)
Fíjate que todas las funciones reciben la estructura de datos sobre la que deben operar, en
este caso la lista de pacientes. Recuerda: las funciones necesitan recibir como parámetros
todos los valores que utilizan.
A continuación vamos a crear un programa que utilice las funciones anteriores para
comprobar que funcionan correctamente:
# Creamos una nueva lista de pacientes
lista_pacientes = []
# Llegan unos cuantos pacientes

llega_nuevo_paciente(lista_pacientes, "Marcos Santos")
llega_nuevo_paciente(lista_pacientes, "Eva González")
llega_nuevo_paciente(lista_pacientes, "Pablo Sánchez")
llega_nuevo_paciente(lista_pacientes, "Ana Pérez")
# Estado actual de la lista de espera

imprime_numero_de_pacientes(lista_pacientes)
imprime_lista(lista_pacientes)
# El médico atiende a un par de ellos

medico_atiende_paciente(lista_pacientes)
medico_atiende_paciente(lista_pacientes)
# Estado actual de la lista de espera

imprime_numero_de_pacientes(lista_pacientes)
imprime_lista(lista_pacientes)
Pacientes esperando: 4
Lista de pacientes esperando:
Marcos Santos
Eva González
Pablo Sánchez
Ana Pérez
Pacientes esperando: 2
Lista de pacientes esperando:
Pablo Sánchez
Ana Pérez
Sección 5.5
Ejercicio 4. Funciones
No siempre se puede formar un triángulo juntando 3 segmentos. Para que formen un triángulo deben
cumplir que la suma de dos lados cualesquiera debe ser estrictamente mayor que el lado restante. Es decir,
si las longitudes de los lados son a, b y c, sólo podrán formar un triángulo si se cumplen las siguiente 3
condiciones:
a+b>c
a+c>b
b+c>a
Crea una función tipo_triangulo que reciba las longitudes de 3 segmentos e imprima un mensaje por
consola indicando si con esos segmentos se puede o no formar un triángulo. En caso de que sí se pueda, la
función debe indicar si forman un triá́ngulo equilátero (3 lados iguales), isósceles (2 lados iguales y 1
diferente) o escaleno (3 lados distintos).
A continuación se muestra el programa principal con el que puedes probar tu función y la salida esperada:
tipo_triangulo(1, 1, 1)
Equilátero
Isósceles
Escaleno
No es un triángulo
No es un triángulo
No es un triángulo
Acuérdate de documentar la función de manera adecuada con un comentario entre triples comillas justo
debajo de la de nición de la función.
que te lo corrijamos. La entrega para este ejercicio se llama Entrega del Ejercicio 4
Sección 6.1
Leer ficheros
Ficheros y persistencia
Todos los programas que hemos escrito tienen una limitación importante: cada vez que los ejecutamos
tenemos que volver a introducir toda la información. Cuando el programa termina, toda la información que
tenemos almacenada en las variables del programa (enteros, cadenas, listas, diccionarios) se pierde.
Necesitamos algún mecanismo que nos permita almacenar esa información de manera que se conserve
entre distintas ejecuciones del programa. Y el mecanismo más habitual para almacenar datos persistentes
son los cheros.
Aprender a manejar cheros también nos permitirá compartir los datos que generan nuestros programas
con otras personas. O al revés, trabajar con datos recopilados por terceros. Por ejemplo, podríamos
descargar cheros públicos con datos sobre meteorología (temperaturas máximas y mínimas,
precipitaciones, etc) y crear un programa en Python que los procese.
Existen dos tipos de cheros: de texto y binarios. Los primeros almacenan la información en cheros que se
pueden leer y escribir con un editor de textos (como PyCharm, el bloc de notas, sublime, …). Los segundos
almacenan la información en largas secuencias de números que sólo tienen sentido para los programas. En
este curso nos centraremos en los cheros de texto para poder visualizar y compartir los datos de manera
sencilla.
Abrir y cerrar ficheros
Vamos a empezar creando un chero de texto usando un editor de textos. Puedes usar el mismo programa
PyCharm para crear cheros de texto. Pulsa con el botón derecho en el area de proyecto (el panel de la
izquierda donde aparecen los cheros) y selecciona New >> File . Nombra el chero como datos.txt e
introduce el siguiente texto:
En un lugar de la Mancha
de cuyo nombre no quiero acordarme
no ha mucho tiempo que vivía un hidalgo...
Guarda los cambios y comprueba que se ha creado el chero datos.txt en la misma carpeta donde están
tus programas Python.
 Los cheros de texto se pueden editar con cualquier editor de textos como PyCharm o el bloc de notas de
Windows. No utilices nunca procesadores de texto tipo Word.
Vamos a crear un programa que lea ese chero de texto. Es importante que el programa esté en la misma
carpeta que el chero datos.txt :
fichero = open("datos.txt") # Abrir el fichero

contenido = fichero.read() # Leer el contenido
fichero.close() # Cerrar el fichero
print(contenido)
Analicemos el programa:
La primera línea llama a la función open que abre el archivo y lo prepara para que podamos leer. A
partir de este momento la variable fichero nos permitirá leer el contenido del chero.
La segunda línea llama al método read del chero que devuelve una cadena de texto con todo en
contenido del chero.
La tercera línea cierra el chero. Es importante cerrar los cheros cuando ya no los vamos a utilizar
más.
La última línea del programa imprime el contenido del chero en la consola.
La salida del programa es la siguiente:
En un lugar de la Mancha
de cuyo nombre no quiero acordarme
no ha mucho tiempo que vivía un hidalgo...
El parámetro de la función open es una ruta al chero. Podemos usar rutas absolutas y rutas relativas. Si
nos limitamos a trabajar con cheros que están en la misma carpeta que el programa, podemos escribir
simplemente el nombre del chero entre comillas.
Si nos equivocamos al escribir el nombre del chero, o el chero no está en la misma carpeta que nuestro
programa, se producirá el siguiente error:
FileNotFoundError: [Errno 2] No such file or directory: 'datos2.txt'
Leer línea a línea
El método read del chero nos permite leer de una vez todo el contenido como una única cadena de texto.
Podemos romper la cadena de texto en líneas usando el método splitlines que devuelve una lista de
líneas:
# Abrir, leer y cerrar el fichero
fichero = open("datos.txt")
contenido = fichero.read()
fichero.close()
lineas = contenido.splitlines() # Separar las líneas

for linea in lineas: # Imprimir cada línea
print(linea)
El problema de trabajar de esta manera es que cargamos todo el contenido del chero en memoria. Y si
trabajamos con cheros grandes, nuestro programa consumirá mucha memoria. Si trabajamos con chero
pequeños, no es un problema.
Existe una manera mejor de hacerlo. Los cheros son objetos iterables que también podemos recorrer con
instrucciones for :
# Abrir el fichero
fichero = open("datos.txt")
# Recorrer el fichero línea a línea

for linea in fichero:
print(linea.strip()) # Eliminar el carácter de salto de línea
# Cerrar el fichero
fichero.close()
El bucle for va recorriendo el chero línea a línea de manera que sólo es necesario mantener en memoria
la línea actual en cada momento. El método strip sirve para eliminar los caracteres de salto de línea que
había en el chero original porque print introduce otro salto de línea. Si no ponemos strip las líneas de
texto se imprimirán separadas con 2 saltos de texto (el original y el que añade print ).
Un ejemplo
Vamos a crear otro chero temperaturas.txt que contenga mediciones de temperaturas con los
siguientes valores, uno en cada línea:
10
12
18
15
16
14
Ahora vamos a hacer un programa que lea las temperaturas del chero y que calcule la temperatura media:
def lee_temperaturas():
""" Lee las temperaturas del fichero y las devuelve en una lista
"""
temperaturas = []
fichero = open("temperaturas.txt")
valor = float(linea) # convertir de cadena a número
temperaturas.append(valor)
fichero.close()
return temperaturas
def calcula_media(temperaturas):
""" Calcula la media de las temperaturas
"""
suma = 0
for valor in temperaturas:
suma = suma + valor
return suma / len(temperaturas)
# Programa
temperaturas = lee_temperaturas()
media = calcula_media(temperaturas)
print("Temperaturas:", temperaturas)
print("Temperatura media:", media)
Temperaturas: [10.0, 12.0, 18.0, 15.0, 16.0, 14.0]

Temperatura media: 14.166666666666666
Hemos separado el problema en dos funciones
lee_temperaturas lee los datos del chero y los devuelve como una lista de números. Fíjate en que
usamos la función float para transformar la línea de texto a un número.
calcula_media calcula el valor medio de los valores almacenados en una lista.
 Crea un archivo de texto con 5 líneas, e imprímelas por pantalla separadas por la cadena
“———”.
 Crea un programa que lea el mismo chero de temperaturas y calcula la temperatura

máxima y mínima del periodo.
Sección 6.2
Escribir ficheros
Además de leer, también podemos escribir información en cheros de texto. Para hacerlo debemos abrir el
chero en modo escritura:
# Abrir el fichero en modo escritura

fichero = open("prueba.txt", "w")
# Escribir información
fichero.write("primera línea\n") # Añadir el salto de línea
fichero.write("segunda línea\n")
# Cerrar el fichero
fichero.close()
El segundo parámetro de la función open indica qué operaciones vamos a realizar con el chero:
"r" sólo leer. Es el valor por defecto si no se usa el segundo parámetro.
"w" sólo escribir borrando antes el contenido. También sirve para crear cheros nuevos.
"a" sólo escribir pero añadiendo la nueva información a continuación de la que ya existe.
"r+" leer y a escribir.
El método write permite escribir una cadena de caracteres en el chero. Si queremos escribir información
en líneas distintas tendremos que añadir nosotros el carácter de salto de línea \n al nal de la cadena.
Podemos comprobar el contenido del chero prueba.txt abriéndolo con PyCharm o con el editor de
textos que pre eras. El contenido debería ser el siguiente:
primera línea
segunda línea
Escribiendo números
Escribir números en cheros de texto es muy sencillo. Sólo tenemos que recordar dos cosas:
antes de escribirlos debemos transformar los números a cadenas de caracteres con la función str
para que los números aparezcan en líneas distintas, tenemos que añadir el carácter de salto de línea
\n .
Por ejemplo, el siguiente programa guarda en el chero cuadrados.txt los cuadrados de números
menores que 100:
# Abrir el fichero en modo escritura

fichero = open("cuadrados.txt", "w")
# Escribir información
for n in range(1, 100):
cuadrado = n * n
fichero.write(str(cuadrado) + "\n")
# Cerrar el fichero
fichero.close()
Puedes comprobar el resultado abriendo el chero, que debería empezar así:
1
4
9
16
25
...
Palabra reservada with
El esquema que hemos visto para trabajar con cheros consta de 3 pasos: abrir el chero, leer o escribir
información y cerrar el chero.
La palabra reservada with puede utilizarse para que Python se encargue de cerrar el chero por nosotros.
En realidad, esta forma de trabajar tiene algunas ventajas si se produce un error al intentar leer o escribir en
el chero (por ejemplo, porque el disco duro falle). La forma de usarlo es la siguiente:
with open("datos.txt") as fichero:

print(linea.strip())
Básicamente el código sigue siendo muy parecido, sólo hay 3 cambios:
la instrucción que abre el chero cambia ligeramente

el código que trabaja con el chero tiene que estar dentro del with
ya no tenemos que llamar al método close
Podemos escribir datos de manera similar:

with open("cuadrados.txt", "w") as fichero:
for n in range(1, 100):
cuadrado = n * n
fichero.write(str(cuadrado) + "\n")
 Crea un programa que:
escriba los números del 1 al 1000 en un chero de texto

a continuación, lea los números del chero de uno en uno y los sume
Sección 6.3
 Escribe un programa que lea nombres de personas del chero nombres.txt e imprima por
consola sólo aquellos que empiezan por una vocal.
El contenido del chero nombres.txt es el siguiente:
Juan
Amparo
Lourdes
Eduardo
Ignacio
Susana
def es_vocal(l):
""" Indica si l es una vocal
"""
l = l.lower()
if l == 'a' or l == 'e' or l == 'i' or l == 'o' or l == 'u':
return True
else:
return False
# Leer nombres del fichero

with open("nombres.txt") as fichero:
for nombre in fichero:
if es_vocal(nombre[0]):
print(nombre.strip()) # Eliminar salto de línea extra
 Escribe en un chero los múltiplos de 5 menores que 100.
with open("multiplos5.txt", "w") as fichero:

for n in range(5, 100, 5):
fichero.write(str(n) + "\n")
 Escribe una función que lea los números del chero multiplos5.txt y los devuelva en una
lista de enteros.
def lee_numeros(nombre_fichero):
""" Lee números del fichero que recibe como parámetro y los
devuelve como una lista.
"""
lista = []
with open(nombre_fichero) as fichero:
lista.append(int(linea)) # convertir a entero
return lista
# Programa
lista = lee_numeros("multiplos5.txt")
print(lista)
Sección 6.4
Ejercicio 5. Ficheros
Descarga este chero que contiene unos cuantos números y copialo al directorio donde tengas tus
programas. Después escribe las siguientes funciones:
lee_fichero que recibe el nombre de un chero de texto y devuelve su contenido como una lista de
enteros
solo_pares que recibe una lista de enteros y devuelve otra lista que sólo contiene los números
pares
escribe_fichero que recibe una lista de enteros y un nombre de chero, y escribe en ese chero
los números de la lista (un número en cada línea).
Prueba que funciona correctamente con el siguiente programa principal:
# Leemos los números del fichero ej5datos.txt

numeros = lee_fichero('ej5datos.txt')
print('Números leídos:', len(numeros))
# Nos quedamos sólo con los números pares

pares = solo_pares(numeros)
print('Números pares:', pares)
# Los guardamos en el fichero pares.txt

escribe_fichero(pares, 'pares.txt')
Números leídos: 20
Números pares: [30, 90, 84, 88, 84, 56, 18, 60, 16, 24, 80]
Y comprueba que se ha creado un chero pares.txt que contiene los números anteriores.
Recuerda que debes documentar cada función de manera adecuada con un comentario entre triples
comillas justo debajo de la de nición de la función.

Python

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Python

Cargado por

Copyright:

Formatos disponibles

Cursos de Formación en Informática - CFI

Introducción a la Programación en Python

Sobre este curso

Objetivos del curso

¿Por qué Python?

Algunos lenguajes se centran en la e ciencia (C/C++), otros en el desarrollo y mantenimiento de grandes

Estructura del curso

Código en los apuntes

El código de los programas aparecerán en los apuntes en el siguiente formato:

# Calcula el área de un cuadrado a partir de la longitud de su lado.

Introduce la longitud del lado: 3

# Calcula el área de un cuadrado a partir de la longitud de su lado.

Introduce la longitud del lado: 3

Instalando las herramientas necesarias

Instalar PyCharm Community Edition

Para descargar el entorno pulsamos en Download Now y a continuación descargamos la versión

Configuración inicial de PyCharm

Importar con guraciones anteriores de PyCharm

Creación de un nuevo proyecto

Pantalla de inicio de PyCharm

Dar nombre al nuevo chero de código

En este momento deberías tener algo parecido a la siguiente imagen.

Escribir el código del primer programa

¡Enhorabuena!, ya has escrito tu primer programa Python.

1. Añade un nuevo chero al proyecto

imprime el mensaje Hola mundo! en la consola:

print("Vamos a aprender a programar en Python")

Vamos a aprender a programar en Python

Cómo se ejecutan los programas

# Esto es un comentario que ocupa toda una línea

# Para escribir comentarios que ocupen varias líneas

 Acostúmbrate a documentar correctamente tu código desde el principio.

Usando Python como una calculadora

Operador Operación Ejemplo Resultado

/ División 5/2 2.5

La división entera ( // ) devuelve el cociente de la división entera. Por ejemplo 7 // 3 devuelve 2

Números enteros y números reales

que mostrará por consola el siguiente número:

Ejercicios para practicar

 Intenta adivinar el resultado de ejecutar el siguiente programa:

En el mundo de la programación, los mensajes de texto se denominan cadenas de texto y representan

print("Esto es una cadena de texto")

Esto es una cadena de texto

print("La palabra 'hacker' proviene del inglés")

La palabra 'hacker' proviene del inglés

\n se imprime como un salto de línea.

\t se imprime como un tabulador.

print("Línea 1\nLínea 2")

Operadores para cadenas

La cadenas de texto se pueden concatenar (juntar) usando el operador + . Por ejemplo:

print("Hola" + "mundo") # Al juntar las cadenas se juntan las palabras

El operador de repetición ( * ) permite repetir una cadena varias veces:

print(3 * "a") # Imprime aaa

print("En un lugar de la Mancha"[0]) # Imprime: E

La siguiente tabla resumen los principales operadores para cadenas:

Operador Operación Ejemplo Resultado

+ Concatenar “aprend” + “er” “aprender”

* Repetir 2 * “casa” “casacasa”

len() Longitud len(“cadena”) 6

[] Subcadena “gato”[1] “a”

[:] Subcadena “gato”[1:3] “at”

Conversiones ente cadenas y números

print(str(123)) # Imprime la cadena 123

Métodos especiales de las cadenas