PROGRAMACIÓN EN PYTHON

CFGM Sistemas Microinformáticos y Redes

PROGRAMACIÓN EN PYTHON

Contenido
1. INTRODUCCION.............................................................................................................................2
1.1 Características.........................................................................................................................2
2. INSTALACIÓN EN WINDOWS.........................................................................................................4
1.1 Intérprete de Python...............................................................................................................4
3. INTRODUCCIÓN.............................................................................................................................8
3.1 Hola mundo.............................................................................................................................8
3.2 Comentarios............................................................................................................................9
4. VARIABLES.....................................................................................................................................9
5. TIPOS DE DATOS..........................................................................................................................11
5.1 Números................................................................................................................................12
5.1.1 Operadores matemáticos (aritméticos)..........................................................................14
5.1.2 Operadores de asignación..............................................................................................14
5.2 Cadenas.................................................................................................................................16
5.2.1 Leer datos. Input().........................................................................................................19
5.3 Booleano...............................................................................................................................20
5.4 Listas......................................................................................................................................23
5.5 Tuplas....................................................................................................................................30
5.6 Diccionarios...........................................................................................................................34
6. CONDICIONALES..........................................................................................................................38
6.1 if, if-else, if-elif-else...............................................................................................................38
6.2 try – except............................................................................................................................43
6.3 match....................................................................................................................................44
7. BUCLES........................................................................................................................................49
7.1 While.....................................................................................................................................49
7.1 For.........................................................................................................................................54

1
PROGRAMACIÓN EN PYTHON

1. INTRODUCCION
Python es un lenguaje de programación creado por Guido van Rossum en los
Países Bajos. Ha sido uno de los lenguajes más populares desde su lanzamiento
en 1991 y sigue siendo muy activo en la actualidad gracias a una comunidad de
desarrolladores de todo el mundo.

En el momento en que Van Rossum comenzó a trabajar en Python, no había

muchos lenguajes de programación de alto nivel en el mercado. Los lenguajes
existentes eran difíciles de aprender y no ofrecían una estructura clara y fácil de
entender. Este fue el comienzo de Python. Van Rossum quería crear un lenguaje
que fuera fácil de usar, legible y que tuviera una gran comunidad de
desarrolladores que trabajaran en él.

El nombre “Python” se inspiró en el programa de televisión de los años sesenta,

Monty Python’s Flying Circus con el fin de que fuera fácil de recordar y agradable.

1.1 Características
Sintaxis simple e intuitiva. Facilita la tarea de escribir código, su lectura,
comprensión y aprendizaje, incluso si no se tiene mucha experiencia en
programación.

Lenguaje interpretado. Se ejecuta utilizando un programa intermedio llamado

intérprete, en lugar de compilar el código a lenguaje máquina que pueda
comprender y ejecutar directamente una computadora (lenguajes compilados).

La ventaja de los lenguajes compilados es que su ejecución es más rápida. Sin

embargo, los lenguajes interpretados son más flexibles y más portables.

2
PROGRAMACIÓN EN PYTHON

Tipado dinámico. No es necesario declarar el tipo de dato que va a contener

una determinada variable, sino que su tipo se determinará en tiempo de ejecución
según el tipo del valor al que se asigne. El tipo de esta variable puede cambiar si
se le asigna un valor de otro tipo.

Fuertemente tipado. No se permite tratar a una variable como si fuera de un tipo

distinto al que tiene, es necesario convertir de forma explícita dicha variable al
nuevo tipo previamente.

Por ejemplo, si tenemos una variable que contiene un texto (variable de tipo
cadena o string) no podremos tratarla como un número (sumar la cadena “9” y el
número 8). En otros lenguajes el tipo de la variable cambiaría para adaptarse al
comportamiento esperado, aunque esto es más propenso a errores.

Lenguaje case-sensitive. Distingue entre letras mayúsculas y minúsculas al

interpretar nombres de variables, funciones y otros identificadores en el código.
Por lo tanto, miVariable, Mivariable y MIVARIABLE serían consideradas tres
identificadores completamente distintos.

Programación orientada a objetos. OOP (Object-Oriented Programming) es

una forma de estructurar un programa agrupando propiedades y comportamientos
relacionados en objetos individuales.

Un objeto es un elemento que, por ejemplo, representa a una persona que tiene
unas determinadas características como nombre, edad y dirección y cuenta,
además, con una serie de comportamientos como caminar, hablar, respirar y
correr.

Multiplataforma. El intérprete de Python está disponible en multitud de

plataformas (UNIX, Solaris, Linux, DOS, Windows, OS/2, Mac OS, etc.) por lo que
si no utilizamos librerías específicas de cada plataforma nuestro programa podrá
correr en todos estos sistemas sin grandes cambios. Además, Python es portable,
lo que significa que se puede ejecutar en diferentes tipos de dispositivos, como
equipos de escritorio, servidores y dispositivos móviles.

Código abierto. Cualquiera puede colaborar y agregar valor al lenguaje

mediante la contribución de nuevas características o corrección de errores. Esto
hace que Python sea una opción popular para aquellos que desean actuar como
contribuyentes en la creación de software.
3
PROGRAMACIÓN EN PYTHON

Gran cantidad de bibliotecas. Mejora notablemente su utilidad para muchas

tareas de programación. Estas bibliotecas pueden hacer que tareas como el
aprendizaje automático, la visualización de datos y las operaciones matemáticas
complejas sean más fáciles y eficientes.

Gran cantidad de desarrolladores. Python ha dado lugar a una comunidad

fuerte y activa, dando lugar a una gran cantidad de recursos en línea, como
tutoriales y foros de discusión, para ayudar a los programadores a su
conocimiento y uso. Gracias a su comunidad, Python tiene una gran cantidad de
bibliotecas y aplicaciones disponibles de forma gratuita.

2. INSTALACIÓN EN WINDOWS

1.1 Intérprete de Python

Descargar el instalador de Python en el enlace: [Link]
Desplegando la pestaña “Download” nos permite acceder a la descarga del
instalador.

Una vez descargado, hacer doble click sobre el archivo para ejecutarlo y seguir el
proceso de instalación. Durante el proceso, aparecerá una ventana que permitirá
seleccionar las opciones de configuración para Python. Asegurarse de seleccionar
la opción “Add Python to PATH” para que Python se pueda ejecutar desde la línea
de comandos.

4
PROGRAMACIÓN EN PYTHON

Una vez instalado, buscar la aplicación instalada, Python, en la barra de

búsqueda de Windows y ejecutarla.

5
PROGRAMACIÓN EN PYTHON

Aparece la consola de Python. Es muy similar en apariencia a la consola (cmd)

del Símbolo del Sistema de Windows, pero no tienen nada que ver una con otra.

Una vez insertado un comando o línea de ejecución en la consola, se ejecuta la

pulsar la tecla intro. Este sistema sólo permite ejecutar línea por línea, lo que
puede resultar incómodo y poco práctico para un conjunto de comandos que
tienen sentido en su conjunto, pero no por separado.

Normalmente, un desarrollador no trabaja en la consola, si no que utiliza un

entorno de desarrollo integrado (IDE Integrated Development Environment). Este
entorno actúa como un editor de código que permite ejecutar un conjunto de
líneas al mismo tiempo.

Existen varios IDE para Python: PyCharm, Spyder, IDLE, Jupyter, Visual Studio
Code, … En nuestro caso utilizaremos el último, VSC.

Descargar e instalar la aplicación Visual Studio Code (VSC).

[Link]

6
PROGRAMACIÓN EN PYTHON

Una vez instalada, ejecutar la aplicación. (1) Seleccionar el icono de extensiones,

situado en el menú vertical a la izquierda de la pantalla, y (2) buscar la extensión
de Python para VSC. (3) Instalarla.

Se instala la extensión de Prettier, para dar formato al código

y Python Indent, para indentar el código de forma automática.

7
PROGRAMACIÓN EN PYTHON

3. INTRODUCCIÓN

3.1 Hola mundo

El primer programa que se suele aprender al comenzar con un nuevo lenguaje de
programación consiste en imprimir la frase “Hola Mundo”.

La primera tarea será crear una carpeta para guardar los programas que se
vayan desarrollando.

El segundo paso será abrir el editor de código, en nuestro caso Visual Studio
Code, y crear un nuevo archivo, con extensión .py ya que es la extensión
propia de Python. Un archivo que contiene código se denomina script.

Una vez que hayas creado el archivo, escribe el siguiente código:

Este es un ejemplo muy básico de Python. La función print() se usa para imprimir
en la pantalla el mensaje que estaba dentro de los paréntesis y las comillas. En
este ejemplo, el mensaje es Hola mundo.

Para ejecutar el código, hacer click sobre la flecha de ejecución.

Una vez ejecutado, aparece el mensaje en el terminal, situado en la parte inferior

de la pantalla.

3.2 Comentarios
8
PROGRAMACIÓN EN PYTHON

Se llama comentario a un texto incluido dentro del código pero que no tiene
ningún efecto sobre la ejecución del código. Un comentario es una nota
aclaratoria sobre la funcionalidad del programa, el uso de una variable, o
cualquier otra aclaración que se considere necesaria para comprender mejor el
código que se está escribiendo.

Python permite varias formas de escribir comentarios:

 Con la almohadilla #, podemos escribir comentarios de una sola línea

 Con las triples comillas podemos escribir código de varias líneas. Son
válidas las comillas dobles “”” y las comillas simples ‘’’

# Comentario de una sola línea con almohadilla

a = 3 # Comentario al final de una línea con almohadilla

'''Comentario de varias
líneas con comillas simples'''

"""Comentario de varias
líneas con comillas dobles"""

4. VARIABLES
Una variable es un espacio de memoria reservado en nuestro programa para
almacenar un valor. Este valor puede ser un número, una cadena de texto, un
valor booleano, ...

En Python, las variables se crean al darles un nombre y asignarles un valor,

utilizando el símbolo “=”. No necesitan ser declaradas antes de utilizarlas. Por
ejemplo, si se desea crear una variable llamada “edad” que almacene un valor de
25, se puede escribir:

edad = 25
Ahora, por ejemplo, se podría imprimir el valor de la variable en la consola
utilizando la función “print”:

print(edad) # imprimirá 25
Para cambiar el valor almacenado en la variable “edad”, simplemente se le asigna
un nuevo valor:

edad = 30
Ahora, al imprimir el valor de “edad” nuevamente, se verá que ha cambiado:

9
PROGRAMACIÓN EN PYTHON

print(edad) # imprimirá 30
Las variables son dinámicas, lo que significa que no es necesario especificar de
antemano qué tipo de valor almacenarán. Por ejemplo, se define una variable
llamada “nombre” que almacena una cadena de texto:

nombre = "Ramón"
Y luego, se modifica su valor para almacenar un número:

nombre = 33
Aunque esta flexibilidad puede ser conveniente, también puede hacer que el
código sea más difícil de leer y mantener. Para ayudar a mitigar esto, es útil
seguir buenas prácticas de programación, como nombrar las variables de manera
descriptiva y utilizar comentarios para explicar su propósito.

Elegir nombres claros y descriptivos simplifica la tarea de escribir código. Por

ejemplo, en un programa que calcula la suma de dos números, se podrían definir
dos variables para guardar esos números:

numero1 = 5
numero2 = 7
En este caso, se han definido dos variables llamadas “numero1” y “numero2”,
asignándoles los valores 5 y 7, respectivamente.

Para realizar la suma de los valores de las variables “numero1” y “numero2”, se

puede plantear lo siguiente:

suma = numero1 + numero2

print(suma)
Se ha creado una nueva variable llamada “suma”, la cual guarda el resultado de la
operación “numero1 + numero2”. La función “print()” mostrará el valor de la
variable “suma” en la consola.

Ejercicio 1. Mostrar en la consola el siguiente mensaje: “La suma de 5 y 7 es

12”, donde 5, 7 y 12 son los valores de las 3 variables anteriores, numero1,
numero2 y suma.

Python permite definir varias variables en una misma línea, tanto con el mismo
valor, como con valores diferentes.

a = b = c = 8
x, y, z = 5, 10, 15

10
PROGRAMACIÓN EN PYTHON

También se puede visualizar el valor de las variables con una sola instrucción,
mostrando el resultado en el terminal.

x, y, z = 5, 10, 15
print(x, y , z) # 5 10 15
Los nombres de variables pueden contener números y letras, pero deben
comenzar con una letra.

En Python existen 35 palabras reservadas que no pueden utilizarse para dar

nombre a una variable:

5. TIPOS DE DATOS

En Python, existen diferentes tipos de datos que son utilizados para realizar
operaciones. Los tipos de datos son importantes ya que determinan la capacidad
de almacenamiento, los tipos de operaciones a realizar y contribuyen a la correcta
utilización de la memoria del equipo.

Los tipos de datos en Python incluyen:

11
PROGRAMACIÓN EN PYTHON

El tipo de dato de una variable se infiere automáticamente. Esto significa que no

es necesario especificar el tipo de dato al definir una variable. Por ejemplo, al
definir una variable y asignarle un valor entero, Python automáticamente la
considerará como un tipo de dato entero (int). En cambio, si se le asigna un valor
decimal, la considerará como un tipo de dato flotante (float).

entero = 5
decimal = 3.14
print(type(entero)) # int
print(type(decimal)) # float
En este caso, se han definido dos variables: una variable “entero”, a la que se le
ha asignado el valor 5 (un número entero), y una variable “decimal”, con valor
3.14 (un número decimal). La función “type()” permite conocer el tipo de dato de
cada variable en la consola.

5.1 Números

Son un tipo de dato utilizado para realizar operaciones matemáticas. Los números
pueden ser enteros (int), decimales (float) y complejos (complex) con una parte
real y una imaginaria.

entero = 5
decimal = 3.7

12
PROGRAMACIÓN EN PYTHON

complejo = 3+5j
print(type(entero)) # <class 'int'>
print(type(decimal)) # <class 'float'>
print(type(complejo)) # <class 'complex'>
Se pueden utilizar directamente números binarios (base 2) anteponiendo 0b al
número binario, octales (base 8) añadiendo 0o delante del número octal y
hexadecimales (base 16) añadiendo 0x delante del número hexadecimal y. El
primer dígito de 0b, 0o y 0x es un cero (no confundir con la letra o mayúscula).

binario = 0B10001101
octal = 0o173
hexadecimal = 0x7b
La función bin() convierte un número decimal en binario. La función oct()
convierte un número decimal en octal. La función hex() convierte un número
decimal en hexadecimal.

a = 79
bin_a = bin(a) # Convierte un número decimal en binario
oct_a = oct(a) # Convierte un número decimal en octal
hex_a = hex(a) # Convierte un número decimal en hexadecimal
print(bin_a) # b1001111
print(oct_a) # 0o117
print(hex_a) # 0x4f
La función int() convierte un número en base no decimal a decimal.

a = 0b10010110
print(int(a)) # 150
Ejercicio 2.

Crea una variable de tipo entero, otra de tipo decimal y otra de tipo complejo.
Muestra en el terminal el tipo de las variables creadas.

Convierte un número entero a binario, octal y hexadecimal. Muestra la conversión

en pantalla

Convierte un número binario a octal, entero y hexadecimal. Muestra la conversión

en pantalla

Convierte un número octal (base 8) a binario, entero y hexadecimal. Muestra la

conversión en pantalla

Convierte un número hexadecimal (base 16) a binario, octal y entero. Muestra la

conversión en pantalla.

13
PROGRAMACIÓN EN PYTHON

5.1.1 Operadores matemáticos (aritméticos)

Utilizan dos números para calcular una operación matemática y devolver su

resultado

a,b = 11, 7
print("a = 11, b = 7")
print("a + b =", a + b) # a + b = 18
print("a - b =", a - b) # a - b = 4
print("a x b =", a * b) # a x b = 77
print("a exp b =", a ** b) # a exp b = 19487171
print("a / b =", a / b) # a / b = 1.5714285714285714
print("cociente a / b =", a // b) # cociente a / b = 1
print("resto a / b =", a % b) # resto a / b = 4
La precedencia de operadores en programación se refiere a las reglas que
establecen el orden en que se deben ejecutar las operaciones dentro de una
expresión.

Orden de precedencia de mayor a menor: paréntesis, exponente, multiplicación y

división, suma y resta.

Convierte un número hexadecimal (base 16) a binario, octal y entero. Muestra la

conversión en pantalla.

5.1.2 Operadores de asignación

Realizan una operación y almacenan su resultado en la variable inicial.

14
PROGRAMACIÓN EN PYTHON

a, b = 7, 2
a += 1 # a = a + 1
print(a) # 8

a, b = 7, 2
a += 6 # a = a + 6
print(a) # 13

a, b = 7, 2
a += b # a = a + b
print(a) # 9

a = 5
a -= 3 # a = a -3
print(a) # 2

a, b = 7, 4
b *= a # b = b * a
print(b) # 28
print(a) # 7

a, b = 38, 7
a /= b # a = a / b
print(a) # 5.428571428571429

a, b = 38, 7
a //= b # a = a // b
print(a) # 5

a, b = 38, 7
a % b # a = a % b
print(a) # 3
La función round(x, y) permite redondear el valor x a un número máximo de
decimales indicado en y.

a, b = 38, 7
a /= b # a = a / b
print(a) # 5.428571428571429
print(round(a, 3)) #5.429

a, b = 9, 2
print(round(a/b, 3)) # 4.5

a, b = 9, 3
print(round(a/b, 3)) # 3.0

15
PROGRAMACIÓN EN PYTHON

5.2 Cadenas
Las cadenas de texto son un tipo de dato utilizado para representar texto, siempre
delimitado por comillas simples o dobles. Las cadenas de texto son inmutables;
una vez creadas, no se pueden modificar.

nombre = "Juan"
mensaje = "Hola, bienvenido"
La elección del delimitador sólo afecta a cómo se escriben las comillas en la
cadena: si el delimitador es una comilla doble, dentro del texto se puede utilizar la
comilla simple como un carácter. Si el delimitador es una comilla simple, dentro
del texto se puede utilizar la doble. las comillas delimitadoras se pueden incluir
dentro del texto escapándolas con una barra invertida (\).

a = "Me gustan las canciones de Sydney O'Connor"

print(a) # Me gustan las canciones de Sydney O'Connor

a = 'Me gustan las canciones de Sydney O\'Connor'

print(a) # Me gustan las canciones de Sydney O'Connor
El carácter “\n” permite cambiar de línea al mostrar un texto.

print("Hola clase") # Hola clase

print("Hola\clase") # Hola
# clase
El carácter “\t” realiza una tabulación del texto.

print("Las provincias de Aragón son:\n\tZaragoza\n\tHuesca\n\

tTeruel")
'''
Las provincias de Aragón son:
Zaragoza
Huesca
Teruel
'''
Es posible operar con cadenas: + es la concatenación, * la repetición y len()
devuelve la longitud de una cadena.

a = "Hola"
print(len(a)) # 5
b = " clase, "
print(len(b)) # 7
c = (a + b) * 2
print(c) # Hola clase, Hola clase,
print(len(c)) # 24
Si la función len() devuelve el valor 0 indica que la cadena está vacía.
16
PROGRAMACIÓN EN PYTHON

var = ""
print(len(var)) # 0
Python permite acceder a cada uno de los caracteres de la cadena, indicando el
nombre de la variable seguida de la posición que ocupa el carácter entre
corchetes [ ]. La primera posición tiene el valor 0.

var = "informativo"
print(len(var)) # 11
print(var[0]) # i
print(var[4]) # r
print(var[10]) # o
print(var[11]) # IndexError: string index out of range

Si el valor introducido entre corchetes es negativo, se empieza a contar desde la

última posición, teniendo en cuenta que el conteo se inicia desde el valor -1.

var = "informativo"
print(var[3]) # o
print(var[0]) # I
print(var[6]) # a
print(var[-1]) # o
print(var[-2]) # v
print(var[-3]) # i
La última posición de una cadena se obtiene restando una unidad al valor que
devuelve la función len()

var = "informativo"
print(len(var)) # 11
print(var[10]) # o
print(var[len(var)-1]) # o
Python dispone de métodos para obtener variaciones de la variable inicial. Para
invocar al método se une el nombre de la variable y el nombre del método,
separados por un punto.

 Upper() devuelve una copia de la cadena en mayúsculas.

17
PROGRAMACIÓN EN PYTHON

 Capitalize() devuelve una copia de la cadena con la primera letra en

mayúscula.
 Lower() devuelve una copia de la cadena en minúsculas.

a = "hola"
b = "CLASE"
print([Link]()) # HOLA
print([Link]()) # Hola
print([Link]()) # clase

 replace(“v”, “n”) devuelve una copia de la cadena donde se han

sustituido todas las apariciones de la cadena v por n.

a = "mama"
print([Link]("ma", "pe")) # pepe

 Split() devuelve una lista que contiene las palabras de la cadena.

Utilizando Split(“n”) utiliza la letra n como separador de palabras.

a = "En un lugar de la mancha"

print([Link]()) # ['En', 'un', 'lugar', 'de', 'la', 'mancha']
b = "PeraxManzanaxMelocotónxCiruela"
print([Link]("x")) # ['Pera', 'Manzana', 'Melocotón', 'Ciruela']
La palabra reservada “in” busca una cadena en un texto, devolviendo un valor
booleano (True o False).

texto = "La programación es el arte de crear algo de la nada"

var = 'arte' in texto
print(var) # True

Las cadenas se pueden trocear utilizando la notación de slice: a [b : c ].

Partiendo de la variable tipo cadena llamada a, se obtiene como resultado la
secuencia que va desde b hasta una posición antes de c.

var = "Informativo"
print(var[2:5]) # for
print(var[1:6]) # Inform
print(var[5:8]) # mat
Si se omite b se asume que su valor es 0. Var[:3] equivalente a Var[0:3]

var = "Informativo"
print(var[:1]) # I
print(var[:2]) # In

18
PROGRAMACIÓN EN PYTHON

print(var[;3]) # Inf
si se omite c, se asume que su valor es la longitud de la cadena. Var[3:]
equivalente a Var[3:10]

var = "Informativo"
print(var[1:]) # nformativo
print(var[:2]) # formativo
print(var[:3]) # ormativo
Se debe tener en cuenta que a[:x] + a[x:] = a

var = "Informativo"
print(var[:3]) # Inf
print(var[3:]) # ormativo
print(var[:3] + var[3:]) # Informativo
Ejercicio 3. Asignar a una variable la cadena “esto es un ejemplo”, y, hacer que
se escriba por pantalla la cadena “un ejemplo es esto” utilizando la notación slice.

Ejercicio 4. Asignar a una variable la cadena “Esto es un ejemplo”, y hacer que

se escriba por pantalla la cadena “Un ejemplo es esto” utilizando la notación slice.
Primero, obtener una solución de varias líneas y después intentarlo en una sola
línea.

5.2.1 Leer datos. Input()

La solicitud de datos al usuario se realiza a través de la función input(). Dentro

del paréntesis de la función se pasa, como argumento, el texto a mostrar en
pantalla al usuario. Esta función bloquea la ejecución de código hasta que el
usuario presiona la tecla “Enter” del teclado.

El valor de retorno es siempre una cadena de texto, aunque el usuario introduzca

un número, la cual se debe asociar a una variable.

var = input("introduce tu nombre: ") # Arturo

print(var) # Arturo
print(type(var)) # <class 'str'>

var = input("introduce un número: ") # 4

print(var) # 4
print(type(var)) # <class 'str'>

var1 = 3 * var
print(var1) # 444

19
PROGRAMACIÓN EN PYTHON

Si se desea utilizar el dato como un valor numérico, será necesario convertirlo a

entero.

var = input("introduce un número: ") # 4

var1 = int(var)
print(3 * var) # 12
También se puede escribir en una sola línea.

var = int(input("introduce un número: ")) # 4

print(type(var)) # <class 'int'>
print(3 * var) # 12
En caso de introducir un número con decimales, la conversión será a tipo float.

var = float(input("introduce un número: ")) # 4.5

print(type(var)) # <class 'float'>
print(3 * var) # 13.5

Ejercicio 5. Pide al usuario su nombre y ciudad de nacimiento. Muestra en

pantalla un texto con los datos introducidos: “Nombre nació en Ciudad”. Las
comillas dobles se deben de mostrar en pantalla.

Ejercicio 6. Solicita al usuario dos números enteros y muestra su suma, resta,

multiplicación, división con 3 decimales, cociente y resto.

Ejercicio 7. El usuario debe de introducir el precio de un producto en € y el

porcentaje de descuento en %. Con estos datos se ha de mostrar en pantalla el
precio sin descuento, el descuento en %, el descuento aplicado en € y el precio
final una vez aplicado el descuento.

Ejercicio 8. Solicita al usuario su nombre, edad y si tiene carnet de conducir.

Muestra en pantalla, utilizando una única instrucción de visualización, el siguiente
texto, incluyendo los datos introducidos:

Resumen de datos:

Nombre tiene Edad años y SI/NO tiene carnet de conducir

5.3 Booleano

Un valor booleano o lógico sólo puede tener dos valores: verdadero (true) o falso

(false).

var1 = False

20
PROGRAMACIÓN EN PYTHON

print(type(var1)) # <class 'bool'>

var1 = True
print(type(var1)) # <class 'bool'>
Se utilizan para comprobar si se cumple alguna condición en un determinado
momento. Estos valores en programación tienen una gran importancia porque
sirve para tomar decisiones dentro del programa en función de las condiciones
que se den.

Los operadores de comparación permiten comparar dos datos o variables,

devolviendo como resultado un valor booleano. Los diferentes operadores son:

a, b = 6, 7
resultado = (a == b)
print(resultado, type(resultado)) # False <class 'bool'>
print(a == b) # False
print(a < b) # True
print(a > b) # False
print(a <= b) # True
print(a >= b) # False
print(a != b) # True
print(a is b) # False
print(a is not b) # True
La principal diferencia entre las expresiones x == y y x is y es que x ==y compara
si los valores de x e y son iguales (igualdad), mientras que x is y compara si x e y
apuntan al mismo objeto en la memoria (identidad).

Las expresiones in y not in, comprueban si un valor está incluido en un conjunto.

21
PROGRAMACIÓN EN PYTHON

a = 6
b = [2,4,6,8]
print(a in b) # True
print(a not in b) # False
Los operadores de comparación no permiten ciertas operaciones entre datos de
diferente tipo.

a = 6
b = 'Hola'
print(a == b) # False
print(a < b) # TypeError: '<' not supported between
# instances of 'int' and 'str'
El operador or (|) permite realizar varias comparaciones al mismo tiempo.
Devuelve el resultado de True si se cumple cualquiera de las comparaciones.
Devuelve el valor false sólo en el caso de que todas las comparaciones sean
falsas.

a, b = 5, 7
print((a > b) | (a < 0) or (a > 3)) # True
print((a > b) or (a < 0) | (a > 8)) # False
El operador and (&) permite realizar varias comparaciones al mismo tiempo.
Devuelve el valor false si no se cumple cualquiera de las comparaciones.
Devuelve el resultado de True en el caso de que todas las comparaciones sean
ciertas
a, b = 5, 7
print((a < b) & (a > 0) and (a < 3)) # False
print((a < b) and (a > 0) & (a > 3)) # True
Ejercicio 9. Evalúa cada una de las siguientes expresiones indicando cuál es el
resultado y el porqué del mismo. Utiliza las siguientes variables:

a, b, c = 5, 7, 3
x, y, z = -2, 0, 10
texto = 'python'

1. (a < b) and (b > c)

2. (a == 5) and (b == 7)
3. (a != c) and (c > b)
4. not (a < b)
5. (x < y) and (y < z)
6. (a > 0) and (b < 10) or (c < 0)
7. (a < 10) or (b == 7) and (c == 3)
22
PROGRAMACIÓN EN PYTHON

8. not (x > 0) and not (a > 0)

9. (x < 0) or (y > 0)
10. (a > c) and not (b == 7)
11. (a < b) and (b > z) and (z > a)
12. (x < 0) and (y == 0) and (z > 0)
13. (a > 4) or (b < 6) or (c == 3)
14. (a != b) and (b != c) and (a != c)
15. not (a < b) and (b > c) and (a > c)
16. ("p" in texto) and ("y" in texto)
17. ("P" in texto) or ("p" not in texto)
18. ("x" not in texto) and ("n" in texto)
19. ("py" in texto) and not ("PY" in texto)
20. ("g" in texto) and ("o" in texto) and ("h" in texto)

5.4 Listas

Una lista es una colección ordenada de elementos, ya que mantienen el orden en

el que los elementos han sido introducidos a la misma. Dichos elementos pueden
ser de cualquier tipo: numérico, texto, booleano, …, e incluso listas.

Se definen entre corchetes y los elementos se separan por comas.

numeros = [1,2,3,4,5]
frutas = ['pera', 'manzana', 'ciruela', 'naranja']
lista_ejemplo = [15, 'pera', ['Zaragoza', 'Huesca', 'Teruel']]
lista_vacia = [] # Lista vacía
Una vez creada una lista, se puede acceder a sus elementos mediante un índice,
el cual indica la posición del elemento en la lista. El índice empieza a contar
desde cero.

frutas = ['pera', 'manzana', 'ciruela', 'naranja']

print(f'El primer elemento es: {frutas[0]}') # pera
print(f'El segundo elemento es: {frutas[1]}') # manzana
print(f'El tercer elemento es: {frutas[2]}') # ciruela
print(f'El cuarto elemento es: {frutas[3]}') # naranja
Si se desea empezar a contar desde el final de la lista, se inicia el conteo desde el
valor -1.

frutas = ['pera', 'manzana', 'ciruela', 'naranja']

print(f'El último elemento es: {frutas[-1]}') # naranja
print(f'El penúltimo elemento es: {frutas[-2]}') # ciruela

23
PROGRAMACIÓN EN PYTHON

Python permite asignar valores a múltiples variables en una sola línea, siguiendo
la sintaxis: variable1, variable2, … = lista.

mi_lista = [10, "Hola", True, 3.14]

entero, texto, booleano, decimal = mi_lista
print(mi_lista[0]) # 10
print(mi_lista[1]) # Hola
print(mi_lista[2]) # True
print(mi_lista[3]) # 3.14
Una lista es mutable, ya que sus elementos se pueden modificar.

frutas = ['pera', 'manzana', 'ciruela', 'naranja']

frutas[0] = 'mandarina'
print(frutas) # ['mandarina', 'manzana', 'ciruela', 'naranja']
También es posible modificar varios elementos al mismo tiempo.

numeros = [18, 35, 9, 47, 73]

numeros[0:2] = [62, 58, 13]
print(numeros) # [62, 58, 13, 9, 47, 73]
La función len() permite conocer la longitud o número de elementos que posee.

frutas = ['pera', 'manzana', 'ciruela', 'naranja']

print(len(frutas)) # 4
En Python se puede agregar elementos a una lista utilizando el método
append(). Este método inserta un nuevo elemento en la última posición.

frutas = ['pera', 'manzana', 'ciruela', 'naranja']

[Link]('melocotón')
print(frutas) # ['pera', 'manzana', 'ciruela', 'naranja',
'melocotón']
print(len(frutas)) # 5
El método insert(posición, elemento) introduce un nuevo elemento en una
posición de la lista.

frutas = ['apple', 'banana', 'cherry']

[Link](1, "pera")
print(frutas) # ['apple', 'pera', 'banana', 'cherry']
El método extend() permite concatenar dos listas. También es posible obtener el
mismo resultado utilizando el operador de concatenación “+”.

frutas = ['apple', 'banana', 'cherry']

numeros = [1,2,3,4,5,6]
print(frutas + numeros)
[Link](numeros) # ['apple', 'banana', 'cherry', 1, 2, 3, 4, 5,
6]

24
PROGRAMACIÓN EN PYTHON

print(frutas) # ['apple', 'banana', 'cherry', 1, 2, 3, 4, 5, 6]

El método remove(nombre_elemento) elimina un elemento determinado de la
lista.

frutas = ['pera', 'manzana', 'ciruela', 'naranja', 'melocoton']

[Link]('manzana')
print(frutas) # ['pera', 'ciruela', 'naranja', 'melocotón']
La palabra reservada “del” elimina de la lista el elemento que ocupa una
determinada posición.

frutas = ['pera', 'manzana', 'ciruela', 'naranja', 'melocoton']

del frutas[1]
print(frutas) # ['pera', 'ciruela', 'naranja', 'melocotón']
El método pop() realiza dos operaciones al mismo tiempo, elimina una
determinada posición de la lista y, si se desea, devuelve el elemento que fue
eliminado. En caso de no indicar la posición, elimina la última.

frutas = ['pera', 'manzana', 'ciruela', 'naranja', 'melocoton']

[Link](2) # Elimina la posición 2 de la lista
print(frutas) # ['pera', 'manzana', 'naranja', 'melocoton']

x = [Link](2)
print(x) # naranja
print(frutas) # ['pera', 'manzana', 'melocoton']

[Link]()
print(frutas) # ['pera', 'manzana']
Ejercicio 10. Crea una lista de temperaturas con valores [18, 21, 19, 23, 20, 22].
1. Muestra por pantalla la temperatura del tercer día.
2. Modifica el valor del primer día a 17.
3. Agrega al final una nueva temperatura de 24 grados.
4. Muestra la lista completa y la cantidad total de elementos.

Ejercicio 11. Crea una lista con los platos: ['ensalada', 'paella', 'pasta', 'pollo
asado', 'flan'].
1. Cambia el plato 'pasta' por 'lasaña'.
2. Elimina el postre 'flan' usando el método remove().
3. Agrega 'fruta' al final con append().
4. Muestra el menú actualizado.

Ejercicio 12. Crea una lista que contenga cinco películas que hayas visto
recientemente.

25
PROGRAMACIÓN EN PYTHON

1. Muestra la primera y la última película de la lista.

2. Elimina la segunda película usando del.
3. Inserta una nueva película en la segunda posición.
4. Muestra la lista final y cuántas películas contiene.

Ejercicio 13. Crea una lista con los artículos: ['pan', 'leche', 'huevos'].
1. Agrega 'aceite' y 'arroz' a la lista.
2. Quita el primer elemento con el método pop().
3. Crea una nueva lista llamada bebidas = ['agua', 'zumo'] y combina ambas en
una sola llamada lista_total.
4. Muestra el contenido de lista_total.

Es posible obtener una sublista de una lista dada utilizando la siguiente sintaxis:
lista[inicio: final-1: paso]
lista = [0,1,2,3,4,5,6,7,8,9]
print(lista[3:7:1]) # [3, 4, 5, 6]
print(lista[1:8:2]) # [1, 3, 5, 7]
print(lista[:7:1]) # [0, 1, 2, 3, 4, 5, 6]
print(lista[3::2]) # [3, 5, 7, 9]
print(lista[3:9:]) # [3, 4, 5, 6, 7, 8]
print(lista[6:2:-1]) # [6, 5, 4, 3]
print(lista[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] INVERSA
El método sort() permite ordenar los elementos modificando la lista original.
Por defecto, el orden es de menor a mayor o en orden alfabético.

numeros = [18, 35, 9, 47, 73]

[Link]()
print(numeros) # [9, 18, 35, 47, 73]

frutas = ['pera', 'manzana', 'pomelo', 'ciruela', 'naranja']

[Link]()
print(frutas) # ['ciruela', 'manzana', 'naranja', 'pera', 'pomelo']

ejemplo = ['pera', 'manzana', 35, 'ciruela', 47]

[Link]()
print(ejemplo) # TypeError: '<' not supported between instances of
'int' and 'str'
Para conseguir el orden inverso, es necesario añadir la expresión “reverse =
True”.

numeros = [18, 35, 9, 47, 73]

[Link](reverse = True)
print(numeros) # [73, 47, 35, 18, 9]

26
PROGRAMACIÓN EN PYTHON

La función sorted() ordena los elementos de una lista pero sin modificar el
orden original. Por defecto, el orden es de menor a mayor o en orden alfabético.
Añadiendo la expresión “reverse = True” se obtiene el orden inverso.

numeros = [18, 35, 9, 47, 73]

print(sorted(numeros)) # [9, 18, 35, 47, 73]
print(sorted(numeros, reverse = True)) # [73, 47, 35, 18, 9]
print(numeros) # [18, 35, 9, 47, 73]
El método reverse() invierte el orden de la lista, modificando el orden original de
la lista.

numeros = [1, 2, 3, 4, 5, 6]
[Link]()
print(numeros) # [6, 5, 4, 3, 2, 1]

frutas = ['pera', 'manzana', 'pomelo', 'ciruela', 'naranja']

[Link]()
print(frutas) # ['naranja', 'ciruela', 'pomelo', 'manzana', 'pera']
Las listas pueden contener diferentes tipos de elementos, incluyendo otras listas.
De este modo, se pueden crear estructuras más complejas y jerárquicas con listas
anidadas.

lista_anidada = [[1,2,3],[4,5,6],[7,8,9]]
lista_anidada = [
[1,2,3],
[4,5,6],
[7,8,9]
]
Python permite acceder a cada uno de los elementos de las listas y sublistas
utilizando la siguiente notación de índices:

clase = [["Juan", 12, "A"],["María", 16, "B"],["Pedro", 15, "C"],

["Luisa", 17, "D"]]
print(clase[1][2]) # B
print(clase[0][1]) # 12
print(clase[2][0]) # Pedro
print(clase[3][-1]) # D
La función list() devuelve una lista que contiene cada uno de los caracteres de
una cadena de texto.

texto = "Hola clase"

var = list(texto)
print(var) # ['H', 'o', 'l', 'a', ' ', 'c', 'l', 'a', 's', 'e']

27
PROGRAMACIÓN EN PYTHON

La función set() elimina todos los elementos repetidos de una lista. Esta función
no modifica la lista original. Su resultado es una estructura llamada “set”, por lo
que será necesario convertirla en lista con la función list().

numeros = [1, 8, 5, 3, 1, 9, 7, 1, 3, 12, 7, 9]

print(set(numeros)) # {1, 3, 5, 7, 8, 9, 12}
print(sorted(list(set(numeros)))) # [1, 3, 5, 7, 8, 9, 12]
print(numeros) # [1, 8, 5, 3, 1, 9, 7, 1, 3, 12, 7, 9]

temperaturas = ["Café", "Té", "Chocolate", "Refresco", "Agua",

"Café", "Té"]
print(set(temperaturas)) # {'Refresco', 'Café', 'Agua', 'Chocolate',
'Té'}
print(sorted(list(set(temperaturas)))) # ['Agua', 'Café',
'Chocolate', 'Refresco', 'Té']
La función reversed() genera una copia de los elementos de una lista en orden
inverso, sin modificar el contenido de la lista original. Para poder utilizar la copia
creada, es necesario convertir la copia generada en una lista, por medio de la
función list().

lista = [1,3,8,4,1,5,7,1,9,7,4]
print(reversed(lista)) # <list_reverseiterator object at
0x000002206402B910>
print(list(reversed(lista))) # [4, 7, 9, 1, 7, 5, 1, 4, 8, 3, 1]
print(lista) # [1, 3, 8, 4, 1, 5, 7, 1, 9, 7, 4]
La palabra reservada “in” permite conocer si un elemento está en una lista.

frutas = ['pera', 'manzana', 'ciruela', 'naranja', 'melocoton']

buscar = 'manzana' in frutas
print(buscar) # True
Hay una serie de funciones (max(), min(), sum()) que permiten operar
directamente con los elementos numéricos de una lista.

numeros = [3, 41, 12, 9, 74, 15]

print(max(numeros)) # 74
print(min(numeros)) # 3
print(sum(numeros)) # 154
El método count() permite contar el número de veces que se repite una
secuencia dentro de una cadena. Esta herramienta sigue la sintaxis
[Link](cadena, inicio, fin), siendo “inicio” y “fin” argumentos no necesarios.

var = "En un lugar de la Mancha de cuyo nombre no quiero acordarme"

print([Link]('a')) # 6
print([Link]('ar')) # 2

28
PROGRAMACIÓN EN PYTHON

print([Link]('a', 10, 30)) # 3

Este método también se puede aplicar a listas, para conocer el número de veces
que aparece un determinado elemento.

var = [1, 3, 5, 1, 6, 1, 8]
print([Link](1)) # 3
La función index() permite conocer la posición de un determinado elemento
dentro de una lista.

fruits = ['apple', 'banana', 'cherry', 'kiwi', 'mango', 'orange']

print([Link]("cherry")) # 2
La función range() genera una secuencia de números que comienzan, por
defecto, en 0 y terminan en el número que se pasa como argumento menos 1.
Esta función asociada con la función list() permite obtener, de forma cómoda,
una lista de un conjunto de números.

print(list(range(7))) # [0, 1, 2, 3, 4, 5, 6]
print(list(range(3))) # [0, 1, 2]
La función range() admite hasta 3 argumentos, separados por comas, donde el
primero es el inicio de la secuencia, el segundo es el final y el tercero indica el
salto deseado entre números. range(inicio, fin, salto)

print(list(range(5,12,1))) # [5, 6, 7, 8, 9, 10, 11]

print(list(range(5,12,2))) # [5, 7, 9, 11]
print(list(range(1,16,4))) # [1, 5, 9, 13]
print(list(range(12,6,-1))) # [12, 11, 10, 9, 8, 7]
print(list(range(12,6,-2))) # [12, 10, 8]

Ejercicio 14. Crea una lista con los números del 0 al 20. Muestra por pantalla:
1. Los números del 5 al 15.
2. Los números pares, utilizando el paso adecuado.
3. Los últimos 5 números de la lista en orden inverso.

Ejercicio 15. Dada una lista conteniendo, al menos, 5 frutas (melón, manzana,
plátano, uva, pera, fresa, …), muestra por pantalla:
1. La lista ordenada alfabéticamente
2. La lista en orden invertido
3. Comprueba si “naranja” está incluido en la lista.
4. Indica en qué posición se encuentra “pera”

29
PROGRAMACIÓN EN PYTHON

Ejercicio 16. Se dispone de la siguiente lista de alumnos:

Nombre Edad Grupo
Laura 17 B
Andrés 18 A
Clara 16 C
Sergio 17 B
Tomando los anteriores datos, crea una lista formada por elementos de tipo lista
que contienen el nombre, la edad y el grupo de un conjunto de alumnos. (Laura
Crea una lista con los números del 0 al 20. Muestra por pantalla:

1. La edad de Andrés
2. El grupo de Laura
3. El nombre del último alumno de la lista
4. Crea una nueva lista sólo con las edades de todos los alumnos
5. Obtén el valor medio de las edades incluidas en la nueva lista

Ejercicio 17. Dada la siguiente lista de calificaciones de una clase:

8 – 5 – 10 – 7 – 6 – 9 – 4 – 10 – 6 – 7 - 5
1. Muestra la nota más alta, más baja y la nota media de la clase.
2. Cuenta cuántas veces aparece la nota 10
3. Elimina las notas repetidas utilizando dos métodos diferentes y muestra la
lista resultante.
4. Ordena la sublista creada anteriormente de menor a mayor e invierte su
orden. Muestra los dos pasos.

5.5 Tuplas

Las tuplas son una estructura de datos en Python que permiten almacenar una
colección de valores ordenados y sin modificaciones. A diferencia de una
lista, las tuplas son inmutables, lo que significa que una vez que se crea una
tupla, no se pueden agregar, eliminar o modificar elementos en ella. Esta
característica, las hace más eficientes en términos de memoria que las listas y
que Python no necesita reservar espacio adicional para futuras modificaciones en
los elementos de la tupla.

Para declarar una tupla se delimita el conjunto de elementos por paréntesis y se

separan los elementos por comas. Python permite crear un tupla vacía.

mi_tupla = (10, "Hola", True, 3.14)

print(mi_tupla) # (10, 'Hola', True, 3.14)

30
PROGRAMACIÓN EN PYTHON

print(type(mi_tupla)) # <class 'tuple'>

tupla_vacia = ()
print(tupla_vacia) # ()
Aunque no es recomendable, la flexibiidad de este lenguaje, permite crear tuplas
sin utilizar el paréntesis como delimitador de elementos.

var = 3, 5, 7
print(var) # (3, 5, 7)
Una tupla de un solo elemento sólo será reconocida como tal si termina en una “,”.
En caso contrario, Python la reconoce como otro tipo de dato.

tupla1= (7)
print(tupla1, type(tupla1)) # 7 <class 'int'>

tupla2= (7,)
print(tupla2, type(tupla2)) # (7,) <class 'tuple'>

tupla1= (7, 5)
print(tupla1, type(tupla1)) # (7, 5) <class 'tuple'>
Una característica de las tuplas es que permiten asignar valores a múltiples
variables en una sola línea, siguiendo la sintaxis: variable1, variable2, … = tupla.

mi_tupla = (10, "Hola", True, 3.14)

entero, texto, booleano, decimal = mi_tupla
print(entero) # 10
print(texto) # Hola
print(booleano) # True
print(decimal) # 3.14
Al igual que en las listas, es posible acceder a cada uno de los elementos
mediante un índice. Al primer elemento le corresponde el índice 0.

mi_tupla = (10, "Hola", True, 3.14)

print(mi_tupla[0]) # 10
print(mi_tupla[1]) # Hola
print(mi_tupla[3]) # 3.14
La notación slice, permite obtener partes de una tupla:

var = (10, "Hola", True, 3.14, "Enero", "Primavera")

print(var[1:3]) # ('Hola', True)
print(var[2:5]) # (True, 3.14, 'Enero')
print(var[:3]) # (10, 'Hola', True)
print(var[1:]) # ('Hola', True, 3.14, 'Enero', 'Primavera')
Python permite eliminar una tupla utilizando la función del().

var = (10, "Hola", True, 3.14, "Enero", "Primavera")

31
PROGRAMACIÓN EN PYTHON

del(var)
print(var) # NameError: name 'var' is not defined.
Una tupla puede contener diferentes tipos de variables, incluida una tupla
anidada.

mi_tupla = (10, "Hola", True, (3, 5 ,7))

El acceso a los elementos anidados, se realiza del mismo modo que para las
listas.

clase = (("Juan", 12, "A"),("María", 16, "B"),("Pedro", 15, "C"),

("Luisa", 17, "D"))
print(clase[1][2]) # B
print(clase[0][1]) # 12
print(clase[2][0]) # Pedro
print(clase[3][-1]) # D
Las tuplas son tipos de datos inmutables, por lo que para modificar una tupla
original será necesario crear una nueva tupla.

tupla_original = (1, 2, 3, 4, 5)
tupla_nueva = tupla_original + (6,)
print(tupla_nueva) # (1, 2, 3, 4, 5, 6)

mes = ("Enero", "Febrero", "Marzo", "Abril", "Mayo")

mes1 = mes[:3]
print(mes1) # ('Enero', 'Febrero', 'Marzo')

mes2 = mes[1:5]
print(mes2) # ('Febrero', 'Marzo', 'Abril', 'Mayo')
Es posible convertir una lista en tupla utilizando la función tuple().

lista = [1, 2, 3]
tupla = tuple(lista)
print(type(tupla)) #<class 'tuple'>
print(tupla) #(1, 2, 3)
Del mismo modo, la función list() permite la conversión de tupla a lista.

numeros = (18, 35, 9, 47, 73)

var = list(numeros)
print(var) # [18, 35, 9, 47, 73]
Al igual que en las listas, Python permite utilizar diversas funciones y métodos con
las tuplas. En este caso cualquier herramienta que modifique el valor original de la
tupla no será admitida. El editor nos enviará un mensaje de error.

32
PROGRAMACIÓN EN PYTHON

 La función len() permite conocer la longitud o número de elementos que

posee.

frutas = ('pera', 'manzana', 'ciruela', 'naranja')

print(len(frutas)) # 4
 La palabra reservada “in” permite conocer si un elemento está en una
lista.

frutas = ('pera', 'manzana', 'ciruela', 'naranja', 'melocoton')

buscar = 'manzana' in frutas
print(buscar) # True
Hay una serie de funciones que permiten operar directamente con los
elementos numéricos de una lista.

numeros = (3, 41, 12, 9, 74, 15)

print(max(numeros)) # 74
print(min(numeros)) # 3
 print(sum(numeros)) # 154
 El método count() permite contar el número de veces que se repite una
elemento en un tupla.

var = (1, 3, 5, 1, 6, 1, 8)
print([Link](1)) # 3
 La función index() permite conocer la posición de un determinado
elemento dentro de una tupla.

fruits = ('apple', 'banana', 'cherry', 'kiwi', 'mango', 'orange')

print([Link]("cherry")) # 2
 La función sorted() ordena los elementos de una tupla pero sin modificar
el orden original. Por defecto, el orden es de menor a mayor o en orden
alfabético. Añadiendo la expresión “reverse = True” se obtiene el orden
inverso.

numeros = (18, 35, 9, 47, 73)

print(sorted(numeros)) # [9, 18, 35, 47, 73]
print(sorted(numeros, reverse = True)) # [73, 47, 35, 18, 9]
print(numeros) # (18, 35, 9, 47, 73)
El uso de las tuplas suele caer en errores típicos como:

tupla = ("Primavera", "Verano", "Otoño")

tupla[0] = "Enero" # TypeError: 'tuple' object does not support item
assignment
[Link](4) # AttributeError: 'tuple' object has no attribute
'append'

33
PROGRAMACIÓN EN PYTHON

tupla1 = ("Febrero")
tupla2 = ("Febrero",)
print(tupla1, type(tupla1)) # Febrero <class 'str'>
print(tupla2, type(tupla2)) # ('Febrero',) <class 'tuple'>
Ejercicio 18.
1. Crea una tupla con las puntuaciones: 87, 92, 75, 98, 91.
2. Muestra cuántas series incluye la tupla.
3. Muestra la primera y la última serie.
4. Crea una tupla csólo con las tres primeras series.
5. Muestra si la serie “Arcane” está incluida en la tupla.

Ejercicio 19.
1. Crea una tupla con las siguientes series de streaming: The boys, Loki, One
Piece, Breaking Bad, Arcane.
2. Muestra la puntuación más alta y la más baja.
3. Calcula la suma total de las puntuaciones.
4. Muestra el número de elementos de la tupla.
5. Muestra qué índice le corresponde a la puntuación 98.

Ejercicio 20.
1. Crea una tupla con los siguientes ingredientes para elaborar una pizza:
queso, tomate, pepperoni, aceitunas, queso, bacon.
2. Muestra el número total de ingredientes
3. Muestra los ingredientes desde el segundo hasta el cuarto.
4. Muestra si el ingrediente “piña” forma parte de la pizza.
5. Muestra cuántas veces aparece el ingrediente “queso”.

Ejercicio 21.
1. Crea una tupla con los tiempos (en segundos) de los 5 pilotos más rápidos
en una carrera: 92.5, 88.3, 95.7, 90.1, 87.6.
2. Obtén una nueva tupla con los tiempos ordenados de menor a mayor y otra
con el orden inverso.
3. Muestra el mejor y el peor tiempo.
4. Muestra los tres mejores tiempos
5. Crea una nueva tupla con un nuevo tiempo de 89.9 al final

5.6 Diccionarios

34
PROGRAMACIÓN EN PYTHON

Son estructuras de datos en Python que se utilizan para almacenar y organizar

información. Contiene una colección de elementos, donde cada elemento está
formado por un par llave-valor (key-value). La llave se utiliza como referencia
para acceder al valor del elemento.

En términos de sintáxis, los diccionarios se definen utilizando llaves { } como

delimitador. Los elementos están separados por comas y se utiliza el símbolo “:”
para diferenciar la llave y el valor de cada elemento.

personas = {'Emilio': 31, 'Pedro': 25, 'María': 42}

print (personas) # {'Emilio': 31, 'Sara': 25, 'María': 42}
En este caso, las llaves o keys (Emilio, Pedro, María) son las palabras clave y los
valores (31, 25, 42) son las edades correspondientes a las personas.

También es posible usar el constructor dict() para crear un diccionario.

personas = dict(Emilio = 31, Sara = 25, María = 42)

print(personas) # {'Emilio': 31, 'Sara': 25, 'María': 42}
datos = dict(Nombre = 'Sara', Edad = 27, DNI = '15246221N')
print(datos) # {'Nombre': 'Sara', 'Edad': 27, 'DNI': '15246221N'}
ordinales = dict(Uno = 'primero', Dos = 'Segundo', Tres = 'Tercero')
print(ordinales) # {'Uno': 'primero', 'Dos': 'Segundo', 'Tres':
'Tercero'}
Una clave tiene que ser única en un diccionario; no se permiten duplicados. Sin
embargo, en caso de claves duplicadas, en lugar de dar un error, Python tomará
como válida la última instancia de la clave y simplemente ignorará el primer par
llave-valor.

dulce = {'a1': 'tarta', 'a2':'galleta', 'a1': 'helado'}

print(dulce['a1']) # helado
Los elementos de un diccionario no tienen índice, por lo que para obtener el valor
de un elemento se debe de acceder a través de su clave. La clave permite tipos
de datos inmutables, como números, cadenas, booleanos, tuplas, … pero no
listas.

personas = {'Emilio': 31, 'Pedro': 25, 'María': 42}

print(personas['Emilio']) # 31
print(personas['Pedro']) # 25
print(personas['María']) # 42
También es posible utilizar la función get() para acceder al valor de un elemento.

personas = {'Emilio': 31, 'Pedro': 25, 'María': 42}

35
PROGRAMACIÓN EN PYTHON

print([Link]('Emilio')) # 31
print([Link]('Pedro')) # 25
print([Link]('María')) # 42
Para modificar el valor de un elemento, se accede con su clave y se le asigna un
nuevo valor.

personas = {'Emilio': 31, 'Pedro': 25, 'María': 42}

personas['Emilio'] = 'Hola'
print(personas) # {'Emilio': 'Hola', 'Pedro': 25, 'María': 42}
Para agregar un nuevo elemento al diccionario se nombra una nueva clave,
diferente a cualquiera ya existente en el diccionario, y se le asigna un valor.

personas = {'Emilio': 31, 'Pedro': 25, 'María': 42}

personas['Antonio'] = 53
print(personas) # {'Emilio': 31, 'Pedro': 25, 'María': 42, 'Antonio':
53}
Python permite borrar una clave y su valor asociado utilizando la función del().

personas = {'Emilio': 31, 'Pedro': 25, 'María': 42, 'Antonio': 53}

del(personas['Pedro'])
print(personas) # {'Emilio': 31, 'María': 42, 'Antonio': 53}
El método clear() elimina todos los elementos de un diccionario, obteniendo así
un diccionario vacío.

numeros = {1: 'Ome', 2: 'Two', 3: 'Three', 4: 'Four'}

print(numeros) # {1: 'Ome', 2: 'Two', 3: 'Three', 4: 'Four'}
[Link]()
print(numeros) # {}
La función len() devuelve el número de pares clave-valor contenidos en el
diccionario.

personas = {'Emilio': 31, 'Pedro': 25, 'María': 42, 'Antonio': 53}

print(len(personas)) # 4
El operador in indica si una clave pertenece a un diccionario.

personas = {'Emilio': 31, 'Pedro': 25, 'María': 42, 'Antonio': 53}

print('Pedro' in personas) # True
print('Andrés' in personas) # False
El método values(), en combinación con la función list(), devuelve una lista con
todos los valores del diccionario.

personas = {'Emilio': 31, 'Pedro': 25, 'María': 42, 'Antonio': 53}

valores= list([Link]())
print(valores) # [31, 25, 42, 53]

36
PROGRAMACIÓN EN PYTHON

Del mismo modo, El método keys(), en combinación con la función list(),

devuelve una lista con todas las claves del diccionario.

personas = {'Emilio': 31, 'Pedro': 25, 'María': 42, 'Antonio': 53}

valores= list([Link]())
print(valores) # ['Emilio', 'Pedro', 'María', 'Antonio']
Ejercicio 22.
En una pequeña tienda de videojuegos se lleva el registro del precio de
algunas consolas:
Videojuego Precio (€)
PS5 546
Xbox Serie X 499
Nintendo Switch 299
1. Crea un diccionario con los nombres de las consolas y sus precios.
2. Añade al diccionario un nuevo artículo llamado “Steam Deck” con precio
459€. Muestra el diccionario.
3. Modifica el precio de la Nintendo Switch para que sea 315€. Muestra el
diccionario.
4. Borra el par clave-valor “Xbox Series X”. Muestra el diccionario
5. Muestra cuantos elementos contiene el diccionario

Ejercicio 23.
En la base de datos de una agencia secreta se guardan las edades de un
grupo de superhéroes:

Superhéroe Iron Man Spider-Man Hulk

Edad 48 17 40
1. Crea un diccionario que contenga los nombres y edades de los superhéroes
2. Utiliza una función para obtener la edad de Iron Man. Muestra la edad.
3. Añade el siguiente superhéroe al diccionario: ‘Black Widow”, 34 años.
Muestra el diccionario.
4. Utiliza un método para mostrar una lista con los nombres de los
superhéroes.
5. Utiliza un método para mostrar una lista con las edades de los superhéroes.
6. Utiliza un método para borrar todos los elementos del diccionario. Muestra el
diccionario.

Ejercicio 24.

37
PROGRAMACIÓN EN PYTHON

En un torneo de videojuegos, los puntos obtenidos por cada jugador se

almacenan en la siguiente tabla:

Jugador Player1 Player2 Player3

Puntos 1200 900 1430
1. Crea un diccionario que contenga los jugadores y los puntos obtenidos.
2. Modifica la puntuación de player2 a 1020 puntos. Muestra el diccionario.
3. Añade un nuevo jugador “Player4” con 1100 puntos. Muestra el diccionario.
4. Utiliza un método para mostrar una lista con todas las puntuaciones.
5. Muestra si ‘Player3’ está incluido en el diccionario.

Ejercicio 25.
Un restaurante tiene el siguiente listado de pedidos:

Pedido Hamburguesa Refresco Patatas

Cantidad 6 8 5
1. Crea un diccionario que contenga los productos y la cantidad pedida.
2. Añade al diccionario un nuevo pedido 3 Helados. Muestra el diccionario.
3. Elimina el producto “Refresco”. Muestra el diccionario.
[Link] el número de pedidos pendientes.

6. CONDICIONALES
Las estructuras condicionales permiten condicionar la ejecución del código a
ciertas circunstancias.
6.1 if, if-else, if-elif-else

La estructura básica de un condicional en Python es:

if condición:
instrucción
la sentencia if debe de terminar en el carácter “:” y el bloque de código a ejecutar
debe de estar indentado (probablemente la indentación se produzca
automáticamente al pulsar la tecla enter después del carácter “:”.

La condición es una expresión lógica que debe ser evaluada con el resultado de
verdadero o falso. Si la condición se cumple (verdadero) la instrucción se
ejecutará. Si la condición no se cumple (falso) el programa sale de la estructura
condicional y sigue con la siguiente instrucción.

38
PROGRAMACIÓN EN PYTHON

nota = float(input("Introduce la nota del examen: "))

if nota >= 5:
print('SUPERADO')
print('La ejecución del programa continúa')
Todo el código indentado, incluido después del carácter “:” de la sentencia if, se
ejecutará si la condición se cumple. En el siguiente ejemplo, la última instrucción
print se ejecutará siempre, ya que, al no estar indentada, está fuera de la
estructura if.

nota = float(input("Introduce la nota del examen: "))

if nota >= 5:
print('SUPERADO')
print (f'Nota: {nota}')
print('La ejecución del programa continúa')
Se pueden combinar varias condiciones entre if y el carácter “:”

numero = int(input("Introduce la número entero de 1 a 99: "))

if (numero > 5) and (numero < 15): # if 5 <= numero <= 15:
print("Número mayor que 5 y menor que 15")
Si se requiere que el programa haga algo diferente en caso de que no se cumpla
la condición, Python dispone de la estructura if – else.

if condición1:
instrucción1
else:
instrucción2
Si la evaluación de la condición1 es verdadera, se ejecuta el bloque de
instrucciones1 y el programa sale de la estructura if-else. Si la evaluación de la
condición1 es falsa, se ejecuta el bloque de instrucción 2 y el programa sale de la
estructura if-else.

En los siguientes ejemplos, la estructura if-else orienta la ejecución de las

instrucciones dependiendo del valor de la variable.

edad = 16
if edad >= 18:
print("Eres mayor de edad.")
else:
print("Eres menor de edad.")

x = 6
if (x % 2) == 0:
print("Es par")

39
PROGRAMACIÓN EN PYTHON

else:
print("Es impar")
En muchos casos, aparecerán varias condiciones diferentes y para cada una de
ellas será necesario un código distinto. Como solución a estas situaciones, se
incluye el término elif en la estructura condicional. El término else se ejecuta en
caso de que el resto de las condiciones no se cumplan.

if condicion1:
instruccion1
elif condicion2:
instruccion2
elif condicion3:
instruccion3
else:
instrucciónN
En el siguiente ejemplo se consideran varias condiciones con sus
correspondientes instrucciones. Como último elemento está else, el cual se
ejecutará sólo si ninguna de las anteriores es verdadera.

x = 5
if x == 5:
print("Es 5")
elif x == 6:
print("Es 6")
elif x == 7:
print("Es 7")
else:
print("Es otro")
Algo no recomendable pero posible, es escribir el bloque de código situado dentro
del if en la misma línea, justo a continuación del carácter “:”.

a = 8
if a > 5:
print("Es > 5")

if a > 5: print("Es > 5")

Si el bloque de código tiene más de una línea, se pueden poner todas en la
misma línea separándolas con el carácter “;”.

a = 8
if a > 5:
print("Es > 5")
print("Dentro del if")

40
PROGRAMACIÓN EN PYTHON

if a > 5: print("Es > 5"); print("Dentro del if")

Python no permite un bloque if vacío, por lo que mostrará un error de sintaxis.

if a > 5: #IndentationError: expected an indented block after 'if'

statement
En caso de tener una estructura if sin contenido, tal vez porque sea una tarea
pendiente de implementar en el futuro, es necesario incluir la palabra pass. Al
ejecutar el código, saltará la instrucción if vacía.

a = 7
if a > 5:
pass
Al evaluar una sentencia en una estructura if, existen valores que son
considerados “false” por el compilador de Python. Estos son:

 valor entero 0
 valor decimal 0,0
 Tupla vacía ( )
 Lista vacía [ ]
 Diccionario vacío { }

if a == 0: # a = 0 --> 66; a != 0 --> 77

print("66")
else:
print("77")

if a: # a = 0 --> 77; a != 0 --> 66

print("66")
else:
print("77")

Ejercicio 26.
Crea una variable que almacene una contraseña de tipo carácter. Solicita al
usuario que introduzca la contraseña y muestra un mensaje en pantalla
indicando si dicha contraseña es correcta o no. La contraseña no debe de
tener en cuenta mayúsculas o minúsculas a la hora de la validación.

Ejercicio 27.
41
PROGRAMACIÓN EN PYTHON

Escribir un programa que pida al usuario dos números, dividendo y divisor, con
o sin decimales, y muestre por pantalla su división con 3 decimales. Si el
divisor es cero el programa debe mostrar un error.

Ejercicio 28.
El pago de un impuesto del ayuntamiento está condicionado a ser mayor de 16
años y tener unos ingresos superiores a 1000€ mensuales. Escribir un script
que solicite al usuario su edad y sus ingresos mensuales. Con estos datos se
debe de mostrar un mensaje que indique al usuario está exento del pago o
debe tributar.

Ejercicio 29.
Los alumnos de 2ª ESO se han dividido en dos grupos, A y B según su género
y su nombre. Al grupo A pertenecen las mujeres cuyo nombre sea anterior a la
letra J y por los hombres cuyo nombre sea posterior a la letra N. El grupo B
está formado por el resto de los alumnos. Solicita al usuario que indique su
nombre y si es hombre o mujer. De acuerdo a su respuesta, el programa debe
de mostrar por pantalla el grupo al que pertenece.

Ejercicio 30.
La comunidad de Aragón establece los siguientes tramos impositivos (los
tramos incluyen el valor inferior y no alcanzan el valor superior):

0
12.450 20.200 35.200
Renta (€) 12.45 >=50.000
20.200 35.200 50.000
0
Tipo impositivo
19% 24% 30% 37% 39%
(%)
Desarrolla un script que solicite al usuario su renta anual y le indique el tipo
impositivo que le corresponde y la cantidad a tributar. Cantidad = (Renta *
Tipo) / 100.

Ejercicio 31.
Un parque de atracciones cobra a los usuarios un precio de entrada
dependiendo de su edad:

Menor
Edad (años) 4 - 18 18 - 45 45 - 60 60 y más
4
Entrada (€) Gratis 5 15 30 8

42
PROGRAMACIÓN EN PYTHON

(Los rangos de edad incluyen el menor valor, pero no el mayor)

Sobre el precio obtenido, se realiza un descuento de un 10% si el usuario

presenta un vale de descuento.

El programa debe pedir al usuario su edad y si tiene vale de descuento. Con

estos datos, debe de indicar al usuario el precio de la entrada.

Ejercicio 32.
Una pizzería ofrece a sus clientes Pizza Vegetal o Pizza Carne. Los
ingredientes para cada tipo de pizza aparecen a continuación.
 Ingredientes vegetal: Espárragos, Aceitunas.
 Ingredientes carne: Salami, Jamón, Salchichas.
Escribir un programa que de la bienvenida al usuario y le solicite el tipo de
pizza que desea, siguiendo el siguiente formato:
Bienvenido a Pizzería X
Tipos de pizza:
1. Vegetal
2. Carne
Indica el número de opción elegida:
En función de su respuesta el programa mostrará un menú con los ingredientes
disponibles para que el usuario elija. Solo se puede elegir un ingrediente,
además de la mozzarella y el tomate que están en todas las pizzas. Supón que
el cliente elige la opción 1 (Vegetal)

Pizza Vegetal. Elegir un ingrediente:

1. Espárragos
2. Aceitunas
Indica el número de opción elegida:
Al final se debe mostrar por pantalla si la pizza elegida es Vegetal o Carne y
todos los ingredientes que lleva siguiendo el formato:

Ingredientes de Pizza Vegetal:

1. Mozzarella
2. Tomate
3. xxxxx
El programa debe enviar un mensaje de error en caso de que el cliente
introduzca una opción no disponible.

Ejercicio 33.

43
PROGRAMACIÓN EN PYTHON

Dado un número de DNI sin letra, calcula la letra que le corresponde. Para ello,
divide el número del DNI entre 23 y obtén su resto. Con el valor obtenido, extrae
la letra de la siguiente tabla:

El programa debe de solicitar al usuario que introduzca su DNI sin letra y, una vez
calculada la letra debe de enviar el mensaje:

Tu DNI con letra es: XXXXXXXXX

Ejercicio 34.
Modifica el programa del ejercicio anterior para detectar que el dato introducido
tenga 8 caracteres numéricos y enviar dos mensajes de error, uno en caso de que
el usuario introduzca más o menos de 8 dígitos y otro en caso de que se
introduzca algún dígito no numérico.

6.2 try – except

Al solicitar una entrada de usuario es posible que no se introduzca el tipo de dato

que estamos esperando, por lo que el intérprete de Python detiene la ejecución
del programa y muestra un mensaje de error.

entrada = input("introduce un entero: ") # ab

numero = int(entrada) # ValueError: invalid literal for int() with
base 10: 'ab'
print(f'El número introducido es: {numero}')
Existe una estructura de ejecución condicional incorporada en Python, Try-
Except, que evita la aparición de este tipo de mensajes inesperados. Si durante
la ejecución del bloque Try aparece algún mensaje de error del compilador, el
programa salta directamente al bloque Except y ejecuta su contenido.

entrada = input("introduce un entero: ") # ab

try:
numero = int(entrada)
print(f'El número introducido es: {numero}')
except:

44
PROGRAMACIÓN EN PYTHON

print('Dato no válido')

Ejercicio 35.
Desarrolla el ejercicio 34 utilizando la estructura try-except.

6.3 match

Es una alternativa al uso de estructuras if-elif-else. Veamos el siguiente ejemplo

para entender su funcionamiento.

dia = 4
match dia:
case 1:
print("Lunes")
case 2:
print("Martes")
case 3:
print("Miércoles")
case 4:
print("Jueves") #Jueves
case 5:
print("Viernes")
case 6:
print("Sábado")
case 7:
print("Domingo")
case _:
print("Dato no válido")
La sentencia match evalúa el valor de la variable y lo compara con cada uno de
los valores especificados en los bloques case. En caso de encontrar una
coincidencia, ejecuta el código correspondiente y sale de la estructura. En otro
caso, ejecuta el último bloque (case _:) y sale de la estructura.

En ejemplo anterior, la variable a comparar es dia. Al ejecutar el código, la salida

mostrará el resultado Jueves.

En cada case se pueden establecer múltiples condiciones, separadas por el

símbolo ”|”:

mes = 4
match mes:
case 12 | 1 | 2:
print("Invierno")
case 3 | 4 | 5:
print("Primavera") # Primavera

45
PROGRAMACIÓN EN PYTHON

case 6 | 7 | 8:
print("Verano")
case 9 | 10 | 11:
print("Otoño")
case _:
print("Error")
Al ejecutar el código, se buscará una coincidencia entre el valor de la variable
mes y las opciones case definidas en el script. En el primer bloque case se
especifica que, si el valor de la variable mes es 12, 1 o 2, la salida será “Invierno”.
Como el valor de la variable mes es 4, el primer bloque case será obviado y se
ejecutará la instrucción (o bloque de instrucciones) del segundo case, mostrando
la salida “Primavera”.

En el siguiente ejemplo, se utiliza una tupla para indicar las coordenadas de

diferentes objetos en un plano.

coordenada = (0, 1)
match coordenada:
case (0, 0):
print("Coordenada origen")
case (3, 0):
print(f"Coordenada objeto 1")
case (0, 1):
print(f"Coordenada objeto 2")
case (3, 5):
print(f"Coordenada objeto 3")
case _:
print("Error")
En este caso se busca la coincidencia de los 2 valores almacenados en la tupla.

Python permite añadir una una estructura if después de la condición de un bloque

case, para especificar con más detalle el proceso de selección.

mes = 5
dia = 2
match dia:
case 1 if mes == 4:
print("Es lunes en abril")
case 1 if mes == 5:
print("Es lunes en mayo")
case 2 if mes == 4:
print("Es martes en abril")
case 2 if mes == 5:
print("Es martes en mayo")
case _:

46
PROGRAMACIÓN EN PYTHON

print("No hay coincidencia")

Ejercicio 36.
Realiza una aplicación, utilizando la estructura match, que solicite al usuario un
color e indique el rango de longitud de onda en el que se encuentra, según la
siguiente tabla. Admite datos en mayúscula y minúscula.

Longitud Longitud Longitud

Color Color Color
(nm) (nm) (nm)
<400 Ultravioleta 461-510 Azul 576-615 Naranja
400-440 Morado 511-555 Verde 616-700 Rojo
441-460 Violeta 556-575 Amarillo >700 Infrarrojo

Ejercicio 37.
Desarrolla una aplicación que solicite al usuario 2 números, enteros o decimales,
y una operación aritmética, y obtenga el resultado de la misma. Las operaciones
posibles serán suma, resta, multiplicación y división. Se verificará la división por
cero. Se considera que el usuario introduce los datos numéricos sin error.

EJEMPLO 1 EJEMPLO 2
Introduce el primer número: 27.15 Introduce el primer número: 236
Introduce el segundo número: 13 Introduce el segundo número: 5.24
Introduce la operación (+, -, *, /): + Introduce la operación (+, -, *, /): /
El resultado de 27.15 + 13 es 40.15 El resultado de 236 / 5.24 es
45.038167938931295
EJEMPLO 3 EJEMPLO 4
Introduce el primer número: 236 Introduce el primer número: 57
Introduce el segundo número: 0 Introduce el segundo número: 3
Introduce la operación (+, -, *, /): / Introduce la operación (+, -, *, /): 85
ERROR. No se puede dividir por cero Operación no válida

Ejercicio 38.
Mejora el ejercicio 36 verificando que el usuario introduce datos válidos. Además,
se deben de limitar los decimales de salida en la división a un máximo de 3,
eliminando los decimales con valor cero a la derecha.

EJEMPLO 1 EJEMPLO 2
Introduce el primer número: 27.15 Introduce el primer número: 236
Introduce el segundo número: 13 Introduce el segundo número: 5.24
Introduce la operación (+, -, *, /): + Introduce la operación (+, -, *, /): /
El resultado de 27.15 + 13 es 40.15 El resultado de 236 / 5.24 es 45.038
EJEMPLO 3 EJEMPLO 4
Introduce el primer número: 10 Introduce el primer número: 57
Introduce el segundo número: 2 Introduce el segundo número: 3
Introduce la operación (+, -, *, /): / Introduce la operación (+, -, *, /): 85

47
PROGRAMACIÓN EN PYTHON

El resultado de 10 / 2 es 5 Operación no válida

EJEMPLO 5 EJEMPLO 6
Introduce el primer número: 236 Introduce el primer número: A
Introduce el segundo número: 0 Introduce el segundo número: 3
Introduce la operación (+, -, *, /): / Introduce la operación (+, -, *, /): +
ERROR. No se puede dividir por cero Sólo se admiten números enteros o
decimales

Ejercicio 39.
Realiza una aplicación para la gestión de reservas en un hotel. El usuario tendrá
que indicar el tipo de habitación y el número de noches que desea alojarse. La
aplicación le confirmará la reserva y el precio a pagar limitado a 2 decimales. El
programa debe de verificar los datos introducidos por el cliente y enviar mensajes
de error si corresponde.

EJEMPLO 1 EJEMPLO 2
RESERVA DE HOTEL RESERVA DE HOTEL
Tipo de habitación: Tipo de habitación:
1. Simple (50€/noche) 1. Simple (50€/noche)
2. Doble (80€/noche) 2. Doble (80€/noche)
3. Suite (150€/noche) 3. Suite (150€/noche)
Indica el tipo de habitación (1, 2 o 3): Indica el tipo de habitación (1, 2 o 3): 1
1 10% descuento para estancias iguales o
10% descuento para estancias iguales superiores a 6 noches
o superiores a 6 noches 20% descuento para estancias iguales o
20% descuento para estancias iguales superiores a 11 noches
o superiores a 11 noches selecciones número de noches (entre 1 y
selecciones número de noches (entre 30): 11
1 y 30): 6 Usted ha seleccionado:
Usted ha seleccionado: Tipo de habitación: Simple
Tipo de habitación: Simple Número noches: 11
Número noches: 6 Precio: 440.0€
Precio: 270.0€
EJEMPLO 3 EJEMPLO 4
RESERVA DE HOTEL RESERVA DE HOTEL
Tipo de habitación: Tipo de habitación:
1. Simple (50€/noche) 1. Simple (50€/noche)
2. Doble (80€/noche) 2. Doble (80€/noche)
3. Suite (150€/noche) 3. Suite (150€/noche)
Indica el tipo de habitación (1, 2 o 3): Indica el tipo de habitación (1, 2 o 3): 3
a 10% descuento para estancias iguales o
Tipo de habitación no admitido superiores a 6 noches
20% descuento para estancias iguales o
superiores a 11 noches
selecciones número de noches (entre 1 y
30): 35
Debe de alojarse un número de noches
entre 1 y 30

Ejercicio 40.
48
PROGRAMACIÓN EN PYTHON

Un número NIE (Número de Identificación de Extranjero) sigue la siguiente estructura: A1234567B.

 La primera letra (A) puede contener los siguientes valores: X, Y, Z.
 7 caracteres numéricos
 Letra final de control (B).

Para el cálculo de la letra final de control se siguen los siguientes pasos:

 Se sustituye la primera letra (A) por uno de los siguientes valores: X  0, Y  1, Z  2
 El valor anterior unido a los otros 7 caracteres numéricos da lugar a un número de 8
dígitos. Ejemplos: X1234567  01234567, Y1234567  11234567, Z1234567 
21234567.
 El número de 8 dígitos obtenido se divide entre 23 y se extrae su resto.
 El valor resultante del resto está asociado a una letra siguiente tabla. Dicha letra
corresponde con el último carácter de control.

El programa debe de solicitar al usuario que introduzca su NIE (con mayúsculas o minúsculas) sin
letra final y, una vez calculado el carácter final de control debe de enviar el mensaje:

Tu NIE con letra es: XXXXXXXXX

EJEMPLO 1 EJEMPLO 2
Introduce tu número NIE sin incluir la Introduce tu número NIE sin incluir la
letra final (X1234567): X1234567 letra final (X1234567): x1234567
Tu NIE con letra es: X1234567L Tu NIE con letra es: X1234567L
EJEMPLO 3 EJEMPLO 4
Introduce tu número NIE sin incluir la Introduce tu número NIE sin incluir la
letra final (X1234567): X1234 letra final (X1234567): P1234567
DATO NO VÁLIDO. Debes de DATO NO VÁLIDO. La primera letra debe
introducir 8 dígitos (1 letra y 7 de ser X o Y o Z.
números).
EJEMPLO 5 EJEMPLOS NIE VÁLIDOS PARA
PROBAR
Introduce tu número NIE sin incluir la X1111111G, Y1231231D, Z9876543A,
letra final (X1234567): X12PF567 Y1122334V,
X9988776Z
DATO NO VÁLIDO. Los 7 últimos
caracteres deben de ser números.

7. BUCLES

49
PROGRAMACIÓN EN PYTHON

Los bucles permiten repetir un conjunto de instrucciones varias veces sin

necesidad de escribir el mismo código una y otra vez.

7.1 While

La palabra reservada “While” permite ejecutar una porción de código repetidas

veces hasta que se cumpla una determinada condición.

La estructura evalúa inicialmente si la condición que le sigue es verdadera o falsa.

Si es verdadera, ejecuta el bloque de código. Si es falsa sale de la estructura y el
programa continúa con el resto de instrucciones.

a = 0
while a < 3:
print(a)
a += 1
# 0
# 1
# 2
El programa imprime en pantalla el valor de la variable “a” mientras se cumpla la
condición de que la variable sea menor que 3.

Python permite escribir el bucle en una sola línea, separando las instrucciones del
bucle con un símbolo “;”.

a = 0
while a < 3: print(a); a += 1
Este tipo de bucles no tiene definidas de antemano el número de iteraciones que
se van a producir, ya que depende del resultado de evaluar la condición, por lo
que es necesario asegurar que su uso no llevará a bucles infinitos.

Se puede utilizar la estructura While para eliminar los elementos de una lista uno
a uno hasta que esté vacía:

x = ["Uno", "Dos", "Tres"]

while x:
[Link](0)
print(x)
#['Dos', 'Tres']
#['Tres']
#[]

50
PROGRAMACIÓN EN PYTHON

Las iteraciones se repiten mientras la condición a evaluar sea verdadera. En el

caso de que el valor de la condición sea 0 o lista vacía, se considera falsa y las
iteraciones se detienen.

La sentencia While se puede combinar con la cláusula else al final de la

estructura:

x = 5
while x > 0:
x -=1
print(x) # 4,3,2,1,0
else:
print("El bucle ha finalizado")
El bucle While se ejecuta mientras la condición ·”x > 0“ sea verdadera (True). La
cláusula “else” se ejecutará cuando la evaluación de la condición While sea falsa
(False).

La palabra reservada break finaliza la ejecución de un bucle.

x = 5
while True:
x -= 1
print(x) #4, 3, 2, 1, 0
if x == 0:
break
El bucle se repite, mostrando el valor de la variable x, hasta que su valor de x es
0, momento en el que la condición if se cumple y se ejecuta del bucle mediante
“break”.

Es posible introducir una estructura While dentro de otra. Este tipo de

construcciones, permite obtener todas las combinaciones entre dos números.

i = 0 # 0 0
j = 0 # 0 1
while i < 3: # 0 2
while j < 3: # 1 0
print(i,j) # 1 1
j += 1 # 1 2
i += 1 # 2 0
j = 0 # 2 1
# 2 2
El comando ‘print’, por defecto, introduce un salto de línea al finalizar su
ejecución. Es posible modificar esa sintaxis añadiendo un parámetro más a la

51
PROGRAMACIÓN EN PYTHON

instrucción, de forma que establezca el comportamiento de ‘print’ al finalizar su

ejecución.

i = 1
while i < 9:
# print(i)
print(i, end = ' ') # 1 2 3 4 5 6 7 8
i += 1
Las estructuras de iteración permiten repetir una pregunta hasta que el usuario
introduzca una respuesta válida.

respuesta = input('Elige Blanco o Negro (B o N): ').upper()

while respuesta != 'B' and respuesta != 'N':
print('Respuesta no válida')
respuesta = input('Elige Blanco o negro (B o N): ').upper()
match respuesta:
case 'B':
print(f'Has elegido Blanco')
case 'N':
print(f'Has elegido Negro')
Introduciendo un contador de iteraciones se limita las veces que el usuario puede
responder a la pregunta.

contador = 1
respuesta = input('Elige Blanco o Negro (B o N): ').upper()
while respuesta != 'B' and respuesta != 'N' and contador < 3:
print('Respuesta no válida')
respuesta = input('Elige Blanco o negro (B o N): ').upper()
contador += 1
match respuesta:
case 'B':
print(f'Has elegido Blanco')
case 'N':
print(f'Has elegido Negro')
case _:
print(f'Has superado el número de intentos')

En caso de que los datos a introducir sean numéricos y deban ser tratados como
tal posteriormente, se puede plantear el siguiente script para controlar la validez
de los datos introducidos

contador = 0
while contador < 3:
numero = input('Introduce un número entre 1 y 10: ')
try:

52
PROGRAMACIÓN EN PYTHON

numero = int(numero)
if 1 <= numero <= 10:
print(f'Has introducido el número {numero}')
break
else:
contador += 1
print('DATO NO VALIDO. Debes de introducir un número entre 1
y 10')
except:
contador += 1
print('DATO NO VALIDO. Debes de introducir un valor numérico')
else:
print('Superado número máximo de intentos')

Ejercicio 41.
Solicita al usuario una palabra (por ejemplo, Python) y, utilizando una estructura
While, muestra la siguiente secuencia:
P
Py
Pyt
Pyth
Pytho
Python

Ejercicio 42.
En matemáticas, la sucesión de Fibonacci es una sucesión infinita de números
naturales, donde el siguiente es calculado sumando los dos anteriores. Partiendo
de los números 0 y 1, la sucesión quedaría:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, …

Utilizando una estructura While, crea un script que solicite al usuario el número de
elementos de la sucesión de Fibonacci a mostrar y cree una lista con dichos
números. El número a mostrar estará en el rango entre 3 y 30. La aplicación
debe de ser segura ante datos no válidos del usuario.

EJEMPLO 1 EJEMPLO 2
Introduce el número de elementos de la lista Introduce el número de elementos de la lista (entre
(entre 3 y 30): 7 3 y 30): 53
[0, 1, 1, 2, 3, 5, 8] El número debe de ser entre 3 y 30
EJEMPLO 3 EJEMPLO 4
Introduce el número de elementos de la lista Introduce el número de elementos de la lista (entre
(entre 3 y 30): 1 3 y 30): PP
El número debe de ser entre 3 y 30 Debes de introducir un valor numérico entero

53
PROGRAMACIÓN EN PYTHON

Ejercicio 43.
Utilizando una estructura While, realiza una aplicación que muestre el siguiente
dibujo:

*
***
*****
*******
*********
***********
*************
***************
Ejercicio 44.
Mejora el ejercicio 40 solicitando al usuario el número de filas de la figura, el cual
no debe de ser superior a 10.

La aplicación debe de enviar un mensaje al usuario en caso de que haya

introducido un número de filas superior a 10 y otro mensaje en caso de que el
dato introducido no sea numérico.

EJEMPLO 1 EJEMPLO 2
Introduce el número de filas entre 1 y 10 : 8 Introduce el número de filas entre 1 y 10 : PP
Se genera el dibujo Debes de introducir un valor numérico
EJEMPLO 3 EJEMPLO 4
Introduce el número de filas entre 1 y 10 : 13 Introduce el número de filas entre 1 y 10 : 0
Debes de introducir un valor entre 1 y 10 Debes de introducir un valor entre 1 y 10

7.1 For

El bucle For permite repetir una acción un número definido de veces. Esto se
logra utilizando un objeto iterable y realizando una acción sobre cada elemento
existente dentro del objeto.

numeros = [1, 2, 3, 4, 5]
for num in numeros:
print(num, end = ' ') # 1 2 3 4 5

54
PROGRAMACIÓN EN PYTHON

La variable ‘num’ toma el valor de cada uno de los elementos de la lista ‘numeros’
y ejecuta un conjunto de instrucciones en cada iteración. El bucle finaliza cuando
se recorren todos los elementos de números.

En esta estructura, el número de repeticiones está definido y no existe una

condición a evaluar, sino un elemento iterable que define el número de veces que
se repetirá el código.

No es necesario definir una variable que vaya variando para finalizar el bucle.

La estructura ‘for’ permite recorrer una parte del objeto iterable y realizar las
iteraciones en sentido inverso.

numeros = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)

for i in numeros[15: 1: -2]:
print(i, end = ' ') # 15 13 11 9 7 5 3
Python considera una cadena como un elemento iterable, por lo que un objeto
iterador, puede desplazarse por cada uno de sus caracteres.

for i in "Python":
print(i, end = ', ') # P, y, t, h, o, n,
print('\b\b', end=' ') # P, y, t, h, o, n - \b retrocede el cursor
una posición y la borra.

texto = "Python"
for i in texto[::-1]:
print(i, end = ' ') # n o h t y P

texto = "Python"
for i in texto[::2]:
print(i, end = ' ') # P t o

La función range(), vista en un apartado anterior, genera un conjunto de números

que permiten ser iterados por la variable del bucle for.

for i in range(1, 11):

print(f'2 x {i} = {2 * i}')
# 2 x 1 = 2
# 2 x 2 = 4
# 2 x 3 = 6
# 2 x 4 = 8
# 2 x 5 = 10
# 2 x 6 = 12
# 2 x 7 = 14
# 2 x 8 = 16

55
PROGRAMACIÓN EN PYTHON

# 2 x 9 = 18
# 2 x 10 = 20

palabras = ['milano', 'avestruz', 'lechuza']

for w in palabras:
print(w, len(w))
# milano 6
# avestruz 8
# lechuza 7
Un caso especial de bucle for se da al recorrer los elementos de un diccionario.
Dado que un diccionario está compuesto por pares clave/valor, hay distintas
formas de iterar sobre ellas

 Recorrer las claves del diccionario

valores = {'A': 4, 'E': 3, 'I': 1, 'O': 0}

for k in valores:
print(k, end = ' ') # A E I O
 Iterar sobre los valores del diccionario

valores = {'A': 4, 'E': 3, 'I': 1, 'O': 0}

for v in [Link]():
print(v, end = ' ') # 4 3 1 0)
 Iterar a la vez sobre la clave y el valor de cada uno de los elementos del
diccionario.

valores = {'A': 4, 'E': 3, 'I': 1, 'O': 0}

for k, v in [Link]():
print(f'k = {k}, v = {v}')
#print('k =', k, ', v =', v)
# k = A, v = 4
# k = E, v = 3
# k = I, v = 1
# k = O, v = 0
La función enumerate() permite obtener dos datos en cada iteración: el índice y el
valor del elemento.

lista = ['Manzana', 'Pera', 'Plátano', 'Fresa']

for i, elemento in enumerate(lista):
print(i, elemento)
# 0 Manzana
# 1 Pera
# 2 Plátano
# 3 Fresa

56
PROGRAMACIÓN EN PYTHON

Python permite la anidación de bucles for, de forma que se itera un elemento que
tiene a su vez otro elemento iterable.

lista = [[56, 34, 1], [12, 4, 5], [9, 4, 3]]

for i in lista:
print(i, end = ' ')
# [56, 34, 1] [12, 4, 5] [9, 4, 3]

lista = [[56, 34, 1], [12, 4, 5], [9, 4, 3]]

for i in lista:
for j in i:
print(j, end = ' ')
# 56 34 1 12 4 5 9 4 3

Es posible alterar la iteración de un bucle for en Python mediante el uso de las

sentencias ‘break’ y ‘continue’.

Break se utiliza para finalizar el bucle, mientras que continue salta al siguiente
paso de la iteración, ignorando todas las sentencias que le siguen y forman parte
del bucle. Por tanto,

coleccion = [2, 4, 5, 7, 8, 9, 3, 4]
for e in coleccion:
if e == 7:
break
print(e, end = ' ') # 2 4 5

for e in coleccion:
if e == 7:
continue
print(e, end = ' ') # 2 4 5 8 9 3 4

Python ofrece una estructura adicional de bucle for en la que incluye la sentencia
else.

for x in range(6):
print(x, end = ' ')
else:
print("La secuencia ha terminado")
# 0 1 2 3 4 5 La secuencia ha terminado

La sentencia else se ejecuta una vez finalizadas las iteraciones del bucle for,
siempre y cuando en dichas iteraciones no se ejecute una instrucción break.

for x in range(6):
print(x, end = ' ')
if x == 5:

57
PROGRAMACIÓN EN PYTHON

break
else:
print("La secuencia ha terminado")
# 0 1 2 3 4

La función zip() recibe como entrada un conjunto de listas, dando como resultado
un conjunto de tuplas, donde cada tupla contiene los elementos con el mismo
número de índice. Es necesario combinar las funciones zip() y list() para obtener
un dato de salida en formato de lista.

a = [1, 2, 3]
b = ["Uno", "Dos", "Tres"]
c = ["One", "Two", "Three"]
d = zip(a, b, c)
print(list(d)) # [(1, 'Uno', 'One'), (2, 'Dos', 'Two'), (3, 'Tres',
'Three')]

En caso de que todas las listas no contengan la misma cantidad de datos, la lista
con menor número de elementos marcará el conjunto de tuplas creado.

a = [1, 2]
b = ["Uno", "Dos", "Tres"]
c = ["One", "Two", "Three"]
d = zip(a, b, c)
print(list(d)) # [(1, 'Uno', 'One'), (2, 'Dos', 'Two')]

El uso de zip() en estructuras for, permite recorrer dos o más listas en paralelo en
una única iteración.

nombres = ["Ana", "Pedro", "Roberto", "Elisa"]

edades = [25, 30, 76, 12]
for nombre, edad in zip(nombres, edades):
print(f"{nombre} tiene {edad} años")
# Ana tiene 25 años
# Pedro tiene 30 años
# Roberto tiene 76 años
# Elisa tiene 12 años

Las variables ‘nombre’ y ‘edad’ toman los datos de las listas ‘nombres’ y ‘edades’
respectivamente, tomando los valores de los elementos con el mismo índice en
cada iteración.

Ejercicio 45.
Desarrolla un programa que solicite un número entero mayor que cero y muestre
sus divisores. Verificar datos de entrada de usuario.

58
PROGRAMACIÓN EN PYTHON

EJEMPLO 1 EJEMPLO 2
Escriba un número entero mayor que cero : 36 Escriba un número entero mayor que cero : -12
¡¡ERROR!! Sólo se admiten números enteros
Los divisores de 36 son: 1 2 3 4 6 9 12 18 36
positivos.
EJEMPLO 3 EJEMPLO 4
Escriba un número entero mayor que 1: -3 Escriba un número entero mayor que 1: FF
¡¡ERROR!! Sólo se admiten números enteros
¡¡ERROR!! Sólo se admiten datos numéricos.
mayores que 1.

Ejercicio 46.
Escribe un script que solicite un número entero mayor que 1 e indique si el
número es primo o no. Verificar datos de entrada de usuario.

Un número es primo si es divisible por 1 y por sí mismo

EJEMPLO 1 EJEMPLO 2
Escriba un número entero mayor que 1: 15 Escriba un número entero mayor que 1 : 23
15 no es un número primo. 23 es un número primo.
EJEMPLO 3
Escriba un número entero mayor que 1: FF
¡¡ERROR!! Sólo se admiten datos numéricos.

Ejercicio 47.
Escribe un script que solicite un número entero no negativo y calcule su factorial.
Verificar datos de entrada de usuario. La rutina se repite hasta que alguno de los
datos de entrada sea ‘FIN’ o ‘fin’.

El factorial de un número (n!) es el producto de todos los números enteros

positivos desde 1 hasta dicho número. 5! = 1*2*3*4*5 = 120.

Excepción -> 0! = 1

Ejercicio 48.
Desarrolla un script que solicite dos números enteros y escriba los números pares
e impares que hay entre ellos. Verificar datos de entrada de usuario. La rutina se
repite hasta que alguno de los datos de entrada sea ‘FIN’ o ‘fin’.

EJEMPLO 1 EJEMPLO 2
Escriba un número entero no negativo: 5 Escriba un número entero no negativo: 0
El factorial de 5 (5!) es 120 El factorial de 0 (0!) es 1

59
PROGRAMACIÓN EN PYTHON

EJEMPLO 3 EJEMPLO 4
Escriba un número entero no negativo: -3 Escriba un número entero no negativo: pepe
¡¡ERROR!! Sólo se admiten números enteros no
¡¡ERROR!! Debe de introducir un dato numérico.
negativos.

60