Introducción a Python_S01

November 7, 2024

1 INTRODUCCIÓN
1.1 Los lenguajes de programación
Un lenguaje de programación es un conjunto limitado de palabras y símbolos que representan
procedimientos, cálculos, decisiones y operaciones que se pueden ejecutar en una computadora.
Los lenguajes de programación se pueden clasificar en:

1.1.1 Lenguajes de Bajo Nivel

Lenguajes directamente relacionados con las instrucciones que ejecuta el procesador.
• Lenguaje Máquina: utiliza instrucciones en forma de cadenas de números binarios (ceros
y unos) reconocibles directamente por el procesador.
Ejemplo de instrucción del procesador x86: 1011 0000 0110 0001
Esto mueve el número hexadecimal 61 al registro AL del procesador.
• Lenguaje Ensamblador: utiliza mnemotécnicos para representar instrucciones y direc-
ciones simbólicas.
Ejemplo: MOV AL , 61h
Ventajas: mayor adaptación al equipo, máxima velocidad con mínimo uso de memoria.
Inconvenientes: mayor dificultad en la programación y comprensión de los programas.

1.1.2 Lenguajes de Alto Nivel

Lenguajes que utilizan un repertorio de instrucciones complejas siguiendo unas estrictas reglas
gramaticales (sintaxis del lenguaje).
No existe relación directa entre estas instrucciones y las que ejecuta el procesador.
Ejemplos: Basic, C, C++, Python, Java, etc.

1.2 Compiladores e Intérpretes

1.2.1 Lenguajes Compilados
La ejecución de programas escritos en un lenguaje compilado requiere la traducción previa de todo
el código fuente a código máquina (Código objeto).
La herramienta que utilizamos para dicha traducción se llama Compilador. El programa desarrol-
lado nunca se ejecuta mientras haya errores en el código fuente.

1
 1.2.2 Lenguajes Interpretados
La ejecución de programas escritos en un lenguaje interpretado requiere solamente la traducción a
código máquina de la instrucción que se va a ejecutar en ese momento.
La herramienta que utilizados para la traducción/ejecución se llama Interprete.
El programa desarrollado puede ejecutarse aunque haya errores en el código fuente. Solo se detecta
el error cuando se ejecuta la instrucción errónea.

1.3 Estilos de programación

Python permite tres modos o estilos de programación (paradigmas):

1.3.1 Programación imperativa

Conjunto de instrucciones que se ejecutan una tras otra (pasos de ejecución) de forma secuencial.
En la ejecución de estas instrucciones se van cambiando los valores de las variables y, dependiendo
de estos valores, se modifica el flujo de control de la ejecución del programa.

[1]: n = int(input("Número: "))

factorial = 1
while n > 1:
factorial = factorial * n
n = n - 1 # n -= 1
print("Factorial =", factorial)

2
 Número: 4
Factorial = 24

1.3.2 Programación funcional

El código es una secuencia de declaración de funciones.
No existen asignación de variables, las funciones se llaman entre ellas y las repeticiones de instruc-
ciones se sustituyen por recursividad (cuando una función se llama a si misma).

[2]: def doble(x):

return x+x

def triple(x):
return doble(x)+x

def factorial_recursivo(n):
if n>1:
return n*factorial_recursivo(n-1)
else:
return 1

print(f'El doble de 4 es {doble(4)}')

print(f'El triple de 4 es {triple(4)}')
print(f'El factorial de 4 es {factorial_recursivo(4)}')

El doble de 4 es 8
El triple de 4 es 12
El factorial de 4 es 24

1.3.3 Programación orientada a objetos

El código se organiza en unidades denominadas clases, de las cuales se crean objetos que se rela-
cionan entre sí para conseguir un objetivo.
Forma de programación más cercana a la realidad donde cada elemento persona/cosa (objetos)
con sus características que lo identifica (atributos) son capaces de realizar determinadas acciones
(métodos).

[3]: class Persona:

# Atributos
nombre = "Pedro"

# Métodos
def saludo(self):
print("Hola", [Link])

def cambiaNombre(self,nuevo):
[Link] = nuevo

3
 persona = Persona()
[Link]()

Hola Pedro

[4]: [Link] = "Javier"

[Link]()

Hola Javier

1.4 El lenguaje Python

Python es un lenguaje de programación de alto nivel multiparadigma y de propósito general creado
por Guido van Rossum en 1990.
Actualmente el lenguaje lo desarrollan y mantiene la “Python Software Foundation”
([Link])
• Es de código abierto (certificado por la OSI).
• Es interpretable y compilable.
• Es fácil de aprender gracias a que su sintaxis es bastante legible para los humanos.
• Es fácilmente extensible e integrable en otros lenguajes (C, java).
• Mantenido por una gran comunidad de desarrolladores y hay multitud de recursos para su
aprendizaje.

1.4.1 Modos de ejecución

Interpretado en la consola de Python El usuario introduce una
instrucción y el interprete la ejecuta. Similar a una calculadora.

1.4.2 Interpretado en fichero

El usuario crea un fichero de texto con una secuencia de instrucciones (programa) y
el interperte ejecuta de forma secuencial todas las instrucciones contenidas en el fichero.

4
El entorno de programación Para escribir y ejecutar código en Python instalaremos el in-
terprete y el entorno de desarrollo (IDLE) que descargaremos de la página de la fundación:
[Link]
Ejecutando el IDLE de Python entramos en la consola (shell) donde podremos ejecutar instrucciones
de manera interactiva.
Desde el Shell podremos lanzar el Editor que nos permitirá crear y ejecutar el fichero o (módulo)
con la extensión “.py”. Este fichero contendrá las líneas de código de nuestro programa.
Manual completo del IDLE de Python: [Link]

2 TIPOS DE DATOS SIMPLES

• Números (numbers): 0, -1, 3.1415
• Cadenas (strings): 'Hola', "Adiós"
• Booleanos (boolean): True, False
Estos datos son inmutables, es decir, su valor es constante y no puede cambiar.
La clase a la que pertenece un dato (objeto) se obtiene con la función type().

2.1 NÚMEROS (clases int y float)

Secuencia de dígitos que representan números.
Pueden incluir el - para negativos, el . para decimales y la e para expresar potencias de 10 en
notación científica.
Pueden ser enteros (clase int) o reales (clase float).
x = 5 # int
y = 3.14 # float

2.1.1 Operadores aritméticos con números

2 + 3 # Suma
5 - 2 # Resta
2 * 3 # Producto
7 / 2 # Cociente
2 ** 4 # Potencia
7 // 2 # Cociente división entera
7 % 2 # Resto división entera

5
 2.1.2 Orden de prioridad de evaluación
Funciones predefinidas > Potencias > Productos y cocientes > Sumas y restas
Se puede saltar el orden de evaluación utilizando paréntesis ( ).

2.1.3 Operadores lógicos con números

Devuelven un valor lógico o booleano True/False:
== (igual que) != (distinto de)
< (menor que) > (mayor que)
<= (menor o igual que) >= (mayor oigual que)

[5]: print( type(4.5) , type(-1) , type(4e5) )

print( 2+3 , 5*-2 , 5/2 , 5//2 , 5%2 , (2+3)**2 )
print( 3==3 , 3.1<=3 , -1!=1 )

<class 'float'> <class 'int'> <class 'float'>

5 -10 2.5 2 1 25
True False True

2.2 CADENAS (clase str)

Secuencia de caracteres alfanuméricos que representan un texto. Se escriben entre comillas sencillas
' o dobles ".
Ejemplos de cadenas: 'Python' "123" 'True' 'A'
Cadena vacía: '' ""
Cadena con un espacio: ' ' " "
Cambio o salto de línea: '\n' "\n"
Tabulador: '\t' "\t"

2.2.1 Acceso a los elementos de una cadena

Cada carácter tiene asociado un índice que permite acceder a él.
c = "Python"
# Cadena " P y t h o n "
# Índice positivo 0 1 2 3 4 5
# Índice negativo -6 -5 -4 -3 -2 -1
c[i] : Devuelve el carácter de la cadena c con el índice i. El índice del primer carácter de la
cadena es 0. Se pueden utilizar índices negativos para recorrer la cadena del final al principio. El
índice del último carácter de la cadena es -1.
c[i:j] : Devuelve la subcadena de c desde el carácter con el índice i hasta el carácter con el índice
j-1.
c[i:j:k] : Devuelve la subcadena de c desde el carácter con el índice i hasta el carácter con el
índice j-1 con saltos de k caracteres.

6
[6]: c = 'Universidad Miguel Hernandez'
print(c[2])
print(c[3:7])
print(c[Link])

i
vers
nvr

2.2.2 Operaciones con cadenas

c1 + c2 : Devuelve la cadena resultado de concatenar las cadenas c1 y c2.
c * n : Devuelve la cadena resultado de concatenar n copias de la cadena c.
c1 in c2 : Devuelve True si c1 es una cadena contenida en c2 y False en caso contrario.
c1 not in c2 : Devuelve True si c1 es una cadena no contenida en c2 y False en caso contrario.
c1 == c2 : Devuelve True si la cadena c1 es igual que la cadena c2 y False en caso contrario.
Distingue entre mayúsculas y minúsculas.
c1 > c2 : Devuelve True si la cadena c1 sucede a la cadena c2 y False en caso contrario.
c1 < c2 : Devuelve True si la cadena c1 antecede a la cadena c2 y False en caso contrario.
c1 >= c2 : Devuelve True si la cadena c1 sucede o es igual a la cadena c2 y False en caso contrario.
c1 <= c2 : Devuelve True si la cadena c1 antecede o es igual a la cadena c2 y False en caso
contrario.
c1 != c2 : Devuelve True si la cadena c1 es distinta de la cadena c2 y False en caso contrario.
Utilizan el orden establecido en el código ASCII.

[7]: print( 'Me gusta ' + 'Python' )

print( 'Python' * 3 )
print( 'y' in 'Python' )
print( 'Tho' not in 'Python' )
print( 'Python' == 'Python' )
print( 'Python' < 'Python' )
print( 'a' > 'Z' )
print( 'A' >= 'Z' )
print( '' < 'Python' )

Me gusta Python
PythonPythonPython
True
True
True
False
True
False
True

7
 2.2.3 Funciones con cadenas
len(c) : Devuelve el número de caracteres de la cadena c.
min(c) : Devuelve el carácter menor de la cadena c.
max(c) : Devuelve el carácter mayor de la cadena c.
[Link]() : Devuelve la cadena con los mismos caracteres que la cadena c pero en mayúsculas.
[Link]() : Devuelve la cadena con los mismos caracteres que la cadena c pero en minúsculas.
[Link]() : Devuelve la cadena con los mismos caracteres que la cadena c con el primer carácter
en mayúsculas y el resto en minúsculas.
[Link](subcadena) : Busca subcadena en la cadena c. Devuelve la posición en la cadena c del
primer carácter de la subcadena . Si no la encuentra devuelve -1.
[Link](c1,c2) : Devuelve la cadena reemplazando las subcadenas c1 por c2.
[Link](delimitador) : Devuelve la lista formada por las subcadenas que resultan de partir la
cadena c usando como delimitador la cadena delimitador. Si no se especifica el delimitador utiliza
por defecto el espacio en blanco ' '.

[8]: print( len('Python') )

print( min('Python') )
print( max('Python') )
print( 'Python'.upper() )
print( 'A,B,C'.split(',') )
print( 'I love Python'.split() )

6
P
y
PYTHON
['A', 'B', 'C']
['I', 'love', 'Python']

2.2.4 Cadenas formateadas

f'cadena' : La cadena formateada es un tipo de cadena que permite insertar en ellas datos números
o cadenas de caracteres. Se utilizan las llaves { } (marcadores de posición) para señalar el lugar
de inserción y dentro de ellas se indica:
• d dato a insertar.
• n espacio reservado para representar el dato en formato cadena.
• Alineación del dato dentro del espacio reservado (< izquierda, ^ centro y > derecha).
• m número de decimales para datos de tipo float.
Sintaxis de los marcadores de posición:
{d} : Inserta el dato completo sin espacio adicional.
{d:n} : Reserva n caracteres e inserta el dato alineado izquierda (cadenas) y derecha (números).

8
 {d:<n} : Reserva n caracteres e inserta el dato (entero/real/cadena) alineado izquierda.
{d:^n} : Reserva n caracteres e inserta el dato (entero/real/cadena) alineado centro.
{d:>n} : Reserva n caracteres e inserta el dato (entero/real/cadena) alineado derecha.
{d:[Link]} : Reserva n caracteres e inserta el número real con m cifras decimales alineado derecha.
{d:<[Link]} : Reserva n caracteres e inserta el número real con m cifras decimales alineado izquierda.
{d:^[Link]} : Reserva n caracteres e inserta el número real con m cifras decimales alineado centro.
{d:>[Link]} : Reserva n caracteres e inserta el número real con m cifras decimales alineado derecha

[9]: print( f'Texto {45} Texto' )

print( f'Texto {45:6} Texto' )
print( f'Texto {45:>6} Texto' )
print( f'Texto {45:^6} Texto' )
print( f'Texto {45:<6} Texto' )
print( f'Texto {3.1416:6.2f}' )
print( f'Texto {3.1416:<6.2f} Texto' )
print( f'Texto {"Hola":^6} Texto' ) # Si la cadena principal se contiene con␣
↪comillas simples ' ', otras cadenas en su interior deberán contenerse entre␣

↪comillas dobles " ".

print( f"Texto {'Hola':^6} Texto" ) # Si la cadena principal se contiene con␣

↪comillas dobles " ", otras cadenas en su interior deberán contenerse entre␣

↪comillas simples ' '.

Texto 45 Texto
Texto 45 Texto
Texto 45 Texto
Texto 45 Texto
Texto 45 Texto
Texto 3.14
Texto 3.14 Texto
Texto Hola Texto
Texto Hola Texto

2.3 DATOS LÓGICOS o BOOLEANOS (clase bool)

Contiene únicamente dos elementos True y False que representan los valores lógicos verdadero y
falso respectivamente.
False tiene asociado el valor 0 y True tiene asociado el valor 1.

2.3.1 Operaciones con valores lógicos

Operadores lógicos:
== (igual que) > (mayor) < (menor)
>= (mayor o igual) <= (menor o igual) != (distinto de)
not b (negación) : Devuelve True si el dato booleano b es False y False en caso contrario.

9
 b1 and b2 : Devuelve True si los datos booleanos b1 y b2 son True y False‘ en caso contrario.
b1 or b2 : Devuelve True si alguno de los datos booleanos b1 o b2 son True, y False en caso
contrario.

x y not x x and y x or y
False False True False False
False True True False True
True False False False True
True True False True True

Tabla de verdad

2.4 Conversión de datos primitivos simples

Las siguientes funciones convierten un dato de un tipo en otro, siempre y cuando la conversión sea
posible:
int() : convierte a entero.
float() : convierte a real.
str() : convierte a cadena.
bool() : convierte a lógico.

[10]: print( int(2.3) ) # Convierte 2.3 a entero (2)

print( int('12') ) # Convierte la cadena '12' a entero (12)
print( int(True) ) # Convierte el valor lógico True a entero (1)

print( float(3) ) # Convierte 3 a real (3.0)

print( float('3.4') ) # Convierte la cadena '3.4' a real (3.4)
print( float(True) ) # Convierte el valor lógico True a real (1.0)

print( str(3) ) # Convierte el entero 3 a cadena ('3')

print( str(3.14) ) # Convierte el real 3.14 a cadena ('3.14')
print( str(True) ) # Convierte el valor lógico True a cadena ('True')

print( bool(0) ) # Convierte 0 a valor lógico (False)

print( bool('') ) # Convierte cadena vacía a valor lógico (False)
print( bool('Hola') ) # Convierte la cadena 'Hola' a valor lógico (True)

2
12
1
3.0
3.4
1.0
3

10
 3.14
True
False
False
True

2.5 NONE (clase NoneType)

None es un tipo especial en Python que representa la ausencia de valor o un valor nulo. Es un
objeto único de la clase NoneType.
Características de None:
• Representa ausencia de valor: Se utiliza para indicar que una variable no tiene un valor
asignado o para representar la ausencia de un valor.
• Objeto único: Solo existe un objeto None en Python, por lo que se recomienda utilizar el
operador is para comparaciones.
• Valor predeterminado: Las funciones que no devuelven explícitamente un valor retornan
None por defecto.
Consideraciones:
• No se pueden realizar operaciones aritméticas o de concatenación con None.
• Evita usar == o != para comparar con None; es más seguro y eficiente utilizar is o is not.

[11]: x = None
if x is None:
print("x no tiene un valor asignado")

if not x:
print("x es None o False")

print(x is None) # Devuelve True si x es None

print(x is not None) # Devuelve True si x es None

x no tiene un valor asignado

x es None o False
True
False

3 TIPOS DE DATOS COMPUESTOS - CONTENEDORES

• Listas : Colecciones ordenadas y mutables de elementos.
• Tuplas : Colecciones ordenadas e inmutables de elementos.
• Conjuntos : Colecciones no ordenadas de elementos únicos.
• Diccionarios : Colecciones de pares clave-valor.
• Rangos (range): Secuencia inmutable de números enteros en sucesión aritmética.

3.1 LISTAS (clase list)

Una lista es una secuencias ordenadas de objetos de distintos tipos.

11
 Se construyen poniendo los elementos entre corchetes [ ] separados por comas ,:
[ objeto1 , objeto2 , … , objetoN ]
Se caracterizan por:
• Tienen orden.
• Pueden contener elementos de distintos tipos.
• Son mutables, pueden alterarse durante la ejecución de un programa.
list(c) : Crea una lista con los elementos de la secuencia o colección c. Se pueden indicar
los elementos separados por comas, mediante una cadena, o mediante una colección de elementos
iterable.

[12]: print( [] )
print( type([]) )
print( [1, "dos", True] )
print( [1, [2, 3], 4] )

print( list() )
print( list((1, 2, 3)) )
print( list("Python") )

[]
<class 'list'>
[1, 'dos', True]
[1, [2, 3], 4]
[]
[1, 2, 3]
['P', 'y', 't', 'h', 'o', 'n']

3.1.1 Acceso a los elementos de una lista

Se utilizan los mismos operadores de acceso que para cadenas de caracteres.
lista[i] : Devuelve el elemento de lista con el índice i. El índice del primer elemento de lista es
0.
lista[i:j] : Devuelve la sublista desde el elemento con el índice i hasta el elemento con índice
j-1.
lista[i:j:k] : Devuelve la sublista desde el elemento i hasta el elemento j-1, tomando elementos
cada k.

[13]: lista = [0,1,2,3,4,5,6,7]

print( lista )
print( lista[2] )
print( lista[0:5] )
print( lista[::2] )
print( lista[-[Link]-1] )

12
 [0, 1, 2, 3, 4, 5, 6, 7]
2
[0, 1, 2, 3, 4]
[0, 2, 4, 6]
[7, 6, 5]

3.1.2 Operaciones que no modifican una lista

print(*lista) : Imprime los elementos de una lista desempaquetados, es decir, sin los corchetes
y usando el separador por defecto ' '.
len(lista) : Devuelve el número de elementos de lista.
min(lista) : Devuelve el mínimo elemento de lista (siempre que los datos sean comparables).
max(lista) : Devuelve el máximo elemento de lista (siempre que los datos sean comparables).
sum(lista) : Devuelve la suma de los elementos de lista (siempre que los datos se puedan sumar).
dato in lista : Devuelve True si dato pertenece a lista y False en caso contrario.
[Link](dato) : Devuelve la posición que ocupa en lista el primer elemento con valor dato.
[Link](dato) : Devuelve el número de veces que el valor dato está contenido en lista.
all(lista) : Devuelve True si todos los elementos de lista son True y False en caso contrario.
any(lista) : Devuelve True si algún elemento de lista es True y False en caso contrario.
lista1 + lista2 : Crea una nueva lista concatenando los elementos de lista1 y lista2.
map(f,lista) : Devuelve un objeto iterable con los resultados de aplicar la función f a los elementos
de la lista. Para obtener una nueva lista aplicaremos al resultado la función list().

[14]: a = [1, 2, 2, 3]

# Imprimir la lista con corchetes

print("Lista con corchetes:", a)

# Imprimir la lista desempaquetada

print("Lista desempaquetada:", *a)

# Obtener la longitud de la lista

print("Longitud de la lista:", len(a))

# Obtener el elemento máximo de la lista

print("Máximo elemento de la lista:", max(a))

# Sumar los elementos de la lista

print("Suma de los elementos de la lista:", sum(a))

# Verificar si un elemento está en la lista

print("¿El elemento 3 está en la lista?:", 3 in a)

13
 # Obtener la posición del primer elemento con valor 2
print("Posición del primer elemento con valor 2:", [Link](2))

# Contar cuántas veces aparece el valor 2

print("Número de veces que aparece el valor 2:", [Link](2))

# Verificar si todos los elementos son True

print("¿Todos los elementos son True?:", all(a))

# Verificar si algún elemento es True

print("¿Algún elemento es True de la lista [0, False, 3 < 2]?:", any([0, False,␣
↪3 < 2]))

# Concatenar dos listas

print("Concatenación de [1, 2, 3] y [6, 7, 8]:", [1, 2, 3] + [6, 7, 8])

# Aplicar una función a cada elemento de la lista (ejemplo: cuadrado de cada␣

↪número)

print("Lista con cada elemento al cuadrado:", list(map(lambda x: x**2, a)))

Lista con corchetes: [1, 2, 2, 3]

Lista desempaquetada: 1 2 2 3
Longitud de la lista: 4
Máximo elemento de la lista: 3
Suma de los elementos de la lista: 8
¿El elemento 3 está en la lista?: True
Posición del primer elemento con valor 2: 1
Número de veces que aparece el valor 2: 2
¿Todos los elementos son True?: True
¿Algún elemento es True de la lista [0, False, 3 < 2]?: False
Concatenación de [1, 2, 3] y [6, 7, 8]: [1, 2, 3, 6, 7, 8]
Lista con cada elemento al cuadrado: [1, 4, 4, 9]

[15]: def el_doble(x):

return x*x

lista = [1, 2, 4, 8, 16]

list(map(el_doble, lista))

[15]: [1, 4, 16, 64, 256]

3.1.3 Operaciones que modifican una lista

[Link](dato) : Añade dato al final de lista.
[Link](indice, dato) : Inserta dato en la posición indice de lista y desplaza los elementos
una posición a partir de la posición indice.

14
 [Link](dato) : Elimina el primer elemento con valor dato de lista y desplaza los que están
por detrás de él una posición hacia delante.
[Link]([indice]) : Devuelve el dato en la posición indice y lo elimina de lista, desplazando
los elementos por detrás de él una posición hacia delante.
[Link]() : Ordena los elementos de lista de acuerdo al orden predefinido, siempre que los
elementos sean comparables.
[Link]() : invierte el orden de los elementos de lista.

[16]: a = [1, 3]
b = [2, 4, 6]

# Añadir un elemento al final de la lista

[Link](5)
print("Después de append(5):", a)

# Extender la lista con otra lista

[Link]([8, 9])
print("Después de extend([8, 9]):", a)

# Insertar un elemento en la posición 2

[Link](2, 9)
print("Después de insert(2, 9):", a)

# Eliminar el primer elemento con valor 3

[Link](3)
print("Después de remove(3):", a)

# Eliminar y devolver el elemento en la posición 3

popped_element = [Link](3)
print("Después de pop(3):", a)
print("Elemento eliminado con pop(3):", popped_element)

# Ordenar la lista
[Link]()
print("Después de sort():", a)

# Invertir el orden de la lista

[Link]()
print("Después de reverse():", a)

Después de append(5): [1, 3, 5]

Después de extend([8, 9]): [1, 3, 5, 8, 9]
Después de insert(2, 9): [1, 3, 9, 5, 8, 9]
Después de remove(3): [1, 9, 5, 8, 9]
Después de pop(3): [1, 9, 5, 9]
Elemento eliminado con pop(3): 8
Después de sort(): [1, 5, 9, 9]

15
 Después de reverse(): [9, 9, 5, 1]

3.1.4 Copia de listas

Existen dos formas de copiar listas:
• Copia por referencia lista2 = lista1 : Asocia la variable lista1 la misma lista que
tiene asociada la variable lista2, ambas variables apuntan a la misma dirección de memoria.
Cualquier cambio que hagamos a través de lista1 o lista2 afectará a la misma lista.
• Copia por valor lista2 = list(lista1) : Crea una copia de lista2 en una dirección de
memoria diferente y se la asocia a lista1. Las variables apuntan a direcciones de memoria
diferentes que contienen los mismos datos. Cualquier cambio que hagamos a través de lista1
no afectará a lista2 y viceversa.

[17]: # copia por referencia

a = [1, 2, 3]
b = a
print(f'Antes de [Link](2)\tLista {a=}, Lista {b=}')
[Link](2)
print(f'Después de [Link](2)\tLista {a=}, Lista {b=}\n')

# copia por valor

a = [1, 2, 3]
b = list(a)
print(f'Antes de [Link](2)\tLista {a=}, Lista {b=}')
[Link](2)
print(f'Después de [Link](2)\tLista {a=}, Lista {b=}')

Antes de [Link](2) Lista a=[1, 2, 3], Lista b=[1, 2, 3]

Después de [Link](2) Lista a=[1, 3], Lista b=[1, 3]

Antes de [Link](2) Lista a=[1, 2, 3], Lista b=[1, 2, 3]

Después de [Link](2) Lista a=[1, 2, 3], Lista b=[1, 3]

3.2 TUPLAS (clase tuple)

Una tupla es una secuencia ordenada de objetos de distintos tipos.
Se construyen poniendo los elementos entre paréntesis ( ) separados por comas ,.
( objeto1 , objeto2 , … , objetoN )
Se caracterizan por:
• Tienen orden.
• Pueden contener elementos de distintos tipos.
• Son inmutables, no pueden alterarse durante la ejecución de un programa.
tuple(c) : Crea una tupla con los elementos de la secuencia o colección c.

16
[18]: print( () )
print( type(()) )
print( (1, "dos", True) )
print( (1, [2, 3], 4) )
print( (1, (2, 3), 4) )

print( tuple() )
print( tuple((1, 2, 'hola')) )
print( tuple("Python") )
print( tuple([1, 2, 3]) )

()
<class 'tuple'>
(1, 'dos', True)
(1, [2, 3], 4)
(1, (2, 3), 4)
()
(1, 2, 'hola')
('P', 'y', 't', 'h', 'o', 'n')
(1, 2, 3)

3.2.1 Operaciones con tuplas

El acceso a los elementos de una tupla se realiza del mismo modo que en las listas. También se
pueden obtener subtuplas de la misma manera que las sublistas.
Las operaciones de listas que no modifican la lista también son aplicables a las tuplas.

[19]: t = (1, 2, 3, 4, 5, 6)

# Imprimir la tupla
print("Contenido de la tupla:", t)

# Imprimir la tupla desempaquetada

print("Contenido de la tupla desempaquetada:", *t)

# Acceder al tercer elemento

print("Elemento en la posición 2:", t[2])

# Acceder a una porción de la tupla

print("Porción de la tupla t[0:5]:", t[0:5])

# Acceder a elementos en saltos de dos

print("Elementos con saltos de dos t[::2]:", t[::2])

# Acceso inverso desde el final hasta el índice 4 (sin incluir)

print("Acceso inverso t[-[Link]-1]:", t[-[Link]-1])

17
# Longitud de la tupla
print("Longitud de la tupla:", len(t))

# Valor máximo de la tupla

print("Máximo valor en la tupla:", max(t))

# Suma de todos los elementos de la tupla

print("Suma de los elementos de la tupla:", sum(t))

# Verificar si un elemento está en la tupla

print("¿El número 3 está en la tupla?:", 3 in t)

# Obtener la posición del primer elemento con valor 2

print("Posición del primer elemento con valor 2:", [Link](2))

# Contar cuántas veces aparece el valor 2

print("Número de veces que aparece el valor 2:", [Link](2))

# Verificar si todos los elementos son True

print("¿Todos los elementos son True?:", all(t))

# Verificar si algún elemento es True

print("¿Algún elemento es True?:", any([0, False, 3 < 2]))

# Concatenar dos tuplas

print("Concatenación de (1, 2, 3) y (6, 7, 8):", (1, 2, 3) + (6, 7, 8))

Contenido de la tupla: (1, 2, 3, 4, 5, 6)

Contenido de la tupla desempaquetada: 1 2 3 4 5 6
Elemento en la posición 2: 3
Porción de la tupla t[0:5]: (1, 2, 3, 4, 5)
Elementos con saltos de dos t[::2]: (1, 3, 5)
Acceso inverso t[-[Link]-1]: (6,)
Longitud de la tupla: 6
Máximo valor en la tupla: 6
Suma de los elementos de la tupla: 21
¿El número 3 está en la tupla?: True
Posición del primer elemento con valor 2: 1
Número de veces que aparece el valor 2: 1
¿Todos los elementos son True?: True
¿Algún elemento es True?: False
Concatenación de (1, 2, 3) y (6, 7, 8): (1, 2, 3, 6, 7, 8)

3.3 CONJUNTOS (clase set)

Un conjunto es una colección no ordenada de objetos únicos.
Se construyen poniendo los elementos entre llaves { } separados por comas ,:

18
 { objeto1 , objeto2 , … , objetoN }
Se caracterizan por:
• No tienen orden.
• No se pueden repetir.
• Pueden contener elementos de distintos tipos.
• Son mutables, pueden alterarse durante la ejecución de un programa.
set(c) : Crea un conjunto con los elementos de la secuencia o colección c.

[20]: x = set([0,1,2,4,4,6,'hola','hola',True,False])
y = {0,1,2,4,4,6,'hola','hola',True,False}

print(f'set {x=}')
print(f'set {y=}')

set x={0, 1, 2, 'hola', 4, 6}

set y={0, 1, 2, 'hola', 4, 6}

3.3.1 Operaciones con conjuntos

len(conjunto) : Devuelve el número de elementos de conjunto.
[Link](elemento) : Añade elemento a conjunto.
[Link](elemento) : Elimina elemento de conjunto. Si no existe no elimina nada.
[Link]() : Elimina todos los elementos de conjunto.
[Link]() : Extrae aleatoriamente un elemento de conjunto.
conjunto1 | conjunto2 : Unión conjunto1 y conjunto2 (elimina duplicados). Elementos que están
en conjunto1 o conjunto2.
conjunto1 & conjunto2 : Intersección de conjunto1 y conjunto2. Elementos que están en con-
junto1 y conjunto2.
conjunto1 - conjunto2 : Diferencia de conjunto1 y conjunto2. Elementos de conjunto1 que no
están en conjunto2.
conjunto1 == conjunto2 : True si conjunto1 y conjunto2 tienen los mismos elementos.
[Link](conjunto2) : True si conjunto1 es un subconjunto de conjunto2. Todos los
elementos de conjunto1 están en conjunto2.
conjunto1.symetric_difference(conjunto2) : Diferencia simétrica de conjunto1 – conjunto2.
Elementos de conjunto1 y conjunto2 que solo están en uno de los dos conjuntos y no en la inter-
sección.
[Link](conjunto2) : True si conjunto1 y conjunto2 son disconexos. No com-
parten ningún elemento.

[21]: # Definir el conjunto s

s = {1, 2, 3}

19
 # Añadir un elemento al conjunto
[Link](4)
print("Después de añadir 4:", s)

# Eliminar un elemento específico (si está presente)

[Link](2)
print("Después de descartar 2:", s)

# Eliminar y devolver un elemento arbitrario del conjunto

x = [Link]()
print("Elemento eliminado con pop():", x)
print("Conjunto después de pop():", s)

# Vaciar el conjunto
[Link]()
print("Conjunto después de clear():", s)

Después de añadir 4: {1, 2, 3, 4}

Después de descartar 2: {1, 3, 4}
Elemento eliminado con pop(): 1
Conjunto después de pop(): {3, 4}
Conjunto después de clear(): set()

[22]: # Definir dos conjuntos para operaciones adicionales

s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}

# Unión de s1 y s2
print("Unión de s1 y s2 (s1 | s2):", s1 | s2)

# Intersección de s1 y s2
print("Intersección de s1 y s2 (s1 & s2):", s1 & s2)

# Diferencia de s1 y s2
print("Diferencia de s1 y s2 (s1 - s2):", s1 - s2)

# Comparación de igualdad entre s1 y s2

print("¿s1 es igual a s2?:", s1 == s2)

# Verificar si un conjunto es subconjunto de otro

print("¿{1, 3} es subconjunto de s1?:", {1, 3}.issubset(s1))

# Diferencia simétrica entre s1 y s2

print("Diferencia simétrica entre s1 y s2:", s1.symmetric_difference(s2))

# Verificar si los conjuntos son disjuntos (sin elementos en común)

20
 print("¿s1 y s2 son disjuntos?:", [Link](s2))

Unión de s1 y s2 (s1 | s2): {1, 2, 3, 4, 5, 6, 7, 8}

Intersección de s1 y s2 (s1 & s2): {4, 5}
Diferencia de s1 y s2 (s1 - s2): {1, 2, 3}
¿s1 es igual a s2?: False
¿{1, 3} es subconjunto de s1?: True
Diferencia simétrica entre s1 y s2: {1, 2, 3, 6, 7, 8}
¿s1 y s2 son disjuntos?: False

3.4 DICCIONARIOS (clase dict)

Un diccionario es una colección de pares formados por una clave y un valor asociado a la clave.
Se construyen poniendo los pares entre llaves { } separados por comas ,, y separando la clave del
valor con dos puntos :.
{ clave1 : objeto1 , clave2 : objeto2 , … , claveN : objetoN }
Se caracterizan por:
• No tienen orden.
• Pueden contener elementos de distintos tipos.
• Son mutables, pueden alterarse durante la ejecución de un programa.
• Las claves son únicas, no pueden repetirse en un mismo diccionario, y pueden ser de
cualquier tipo de datos inmutable.

[23]: # Diccionario con elementos de distintos tipos

dic1 = {'nombre': 'Alfredo', 'despacho': 218, 'email': 'asalber@[Link]'}

# Diccionarios anidados
dic2 = {'nombre_completo': {'nombre': 'Alfredo', 'apellidos': 'Sánchez␣
↪Alberca'}, 'edad': 34}

3.4.1 Acceso a los elementos de un diccionario

diccionario[clave] : devuelve el valor de diccionario asociado a la clave clave. Si en el dic-
cionario no existe esa clave devuelve un error.
[Link](clave, valor) : devuelve el valor de diccionario asociado a la clave clave. Si
la clave no existe en diccionario devuelve valor, y si no se especifica un valor por defecto devuelve
None.

[24]: dic = {'nombre': 'Alfredo', 'despacho': 218, 'email': 'asalber@[Link]'}

print(dic['nombre'] )
#print( dic['despacho1'] ) # Este código devuelve KeyError, ya que␣
↪la clave 'despacho1' no existe en dic.

print( [Link]('email') )
print( [Link]('universidad', 'UMH') )

21
 Alfredo
asalber@[Link]
UMH

3.4.2 Operaciones que no modifican el diccionario

len(diccionario) : Devuelve el número de elementos de diccionario.
min(diccionario) : Devuelve la mínima clave de diccionario (siempre que las claves sean compa-
rables).
max(diccionario) : Devuelve la máxima clave de diccionario (siempre que las claves sean compa-
rables).
sum(diccionario) : Devuelve la suma de las claves de diccionario (siempre que las claves se puedan
sumar).
clave in diccionario : Devuelve True si la clave clave pertenece a diccionario y False en caso
contrario.
[Link]() : Devuelve un iterador sobre las claves de diccionario.
[Link]() : Devuelve un iterador sobre los valores diccionario.
[Link]() : Devuelve un iterador sobre los pares clave-valor de diccionario.

[25]: dic = {'nombre':'Alfredo', 'despacho': 218, 'email':'asalber@[Link]'}

print( len(dic) )
print( min(dic) )
print( [Link]() )
print( [Link]() )
print( [Link]() )

3
despacho
dict_keys(['nombre', 'despacho', 'email'])
dict_values(['Alfredo', 218, 'asalber@[Link]'])
dict_items([('nombre', 'Alfredo'), ('despacho', 218), ('email',
'asalber@[Link]')])

3.4.3 Operaciones que modifican el diccionario

diccionario [clave] = valor : Añade a diccionario el par formado por la clave clave y el valor
valor.
[Link](d2) : Añade los pares del diccionario2 al diccionario1.
diccionario1 | d2
[Link](clave, alternativo) : Devuelve del valor asociado a la clave clave de dic-
cionario y lo elimina de diccionario. Si la clave no está devuelve el valor alternativo.

22
 [Link]()* : Devuelve la *tupla formada por la clave y el valor del último par
añadido a diccionario y lo elimina de diccionario.
del diccionario[clave] : Elimina de diccionario el par con la clave clave.
[Link]() : Elimina todos los pares de diccionario (diccionario vacío).

[26]: dic = {'nombre':'Alfredo','despacho': 218,'email':'asalber@[Link]'}

dic['universidad'] = 'CEU'
print('Tras añadir clave universidad: ', dic)

[Link]('despacho') # Podríamos guardar el valor de la clave 'despacho' (218),␣

↪recogiendo el return de la función: x = [Link]('despacho')

print('Tras eliminar clave despacho: ', dic)

[Link]() # Podríamos guardar la tupla (clave, valor) eliminada del␣

↪diccionario, recogiendo el return de la función: x = [Link]()

print('Tras eliminar la última clave añadida: ', dic)

del dic['email']
print('Tras eliminar la clave \'email\': ', dic)

[Link]()
print('Tras limpiar el diccionario', dic)

Tras añadir clave universidad: {'nombre': 'Alfredo', 'despacho': 218, 'email':

'asalber@[Link]', 'universidad': 'CEU'}
Tras eliminar clave despacho: {'nombre': 'Alfredo', 'email': 'asalber@[Link]',
'universidad': 'CEU'}
Tras eliminar la última clave añadida: {'nombre': 'Alfredo', 'email':
'asalber@[Link]'}
Tras eliminar la clave 'email': {'nombre': 'Alfredo'}
Tras limpiar el diccionario {}

3.4.4 Copia de diccionarios

Existen dos formas de copiar diccionarios:
• Copia por referencia diccionario2 = diccionario1 : Asocia la variable diccionario1 el
mismo diccionario que tiene asociado la variable diccionario2, es decir, ambas variables apun-
tan a la misma dirección de memoria. Cualquier cambio que hagamos a través de diccionario1
o diccionario2 afectará al mismo diccionario.
• Copia por valor diccionario2 = dict(diccionario1) : Crea una copia del diccionario2
en una dirección de memoria diferente y se la asocia a diccionario1. Las variables apuntan
a direcciones de memoria diferentes que contienen los mismos datos. Cualquier cambio que
hagamos a través de diccionario1 no afectará al diccionario de diccionario2 y viceversa.

23
[27]: # copia por referencia
a = {1: 'A', 2: 'B', 3: 'C'}
b = a
print(f'Antes de [Link](2)\tDiccionario {a=}, Diccionario {b=}')
[Link](2)
print(f'Después de [Link](2)\tDiccionario {a=}, \tDiccionario {b=}\n')

# copia por valor

a = {1: 'A', 2: 'B', 3: 'C'}
b = dict(a)
print(f'Antes de [Link](2)\tDiccionario {a=}, Diccionario {b=}')
[Link](2)
print(f'Después de [Link](2)\tDiccionario {a=}, Diccionario {b=}')

Antes de [Link](2) Diccionario a={1: 'A', 2: 'B', 3: 'C'}, Diccionario

b={1: 'A', 2: 'B', 3: 'C'}
Después de [Link](2) Diccionario a={1: 'A', 3: 'C'}, Diccionario
b={1: 'A', 3: 'C'}

Antes de [Link](2) Diccionario a={1: 'A', 2: 'B', 3: 'C'}, Diccionario

b={1: 'A', 2: 'B', 3: 'C'}
Después de [Link](2) Diccionario a={1: 'A', 2: 'B', 3: 'C'}, Diccionario
b={1: 'A', 3: 'C'}

3.5 RANGOS (clase range)

Los datos de tipo rango representan una secuencia inmutable de números enteros en sucesión
aritmética (la diferencia entre dos términos consecutivos es siempre la misma).
range(n) : secuencia creciente de n números enteros consecutivos que empieza en 0 y acaba en
n-1.
range(m,n) : secuencia creciente de n números enteros consecutivos que empieza en m y acaba en
n-1.
range(m,n,p) : secuencia creciente de n números enteros consecutivos que empieza en m y acaba
en n-1, aumentando los valores de p en p. Si p negativo, la secuencia será decreciente.

[28]: # Usamos print(list(range())) en lugar de print(range()) para poder ver

# todos los valores del rango como una lista. Si usamos solo print(range()),
# Python mostrará solo la información del objeto range y no sus valores.

print(list( range(4) ))
print(list( range(4, 8) ))
print(list( range(4, 10, 2) ))
print(list( range(-4, 1) ))
print(list( range(-1, -5, -1) ))
print(list( range(8, 4) )) # No muestra valores ya que m < n y el orden␣
↪es creciente

24
 print(list( range(8, 4, -1) ))

[0, 1, 2, 3]
[4, 5, 6, 7]
[4, 6, 8]
[-4, -3, -2, -1, 0]
[-1, -2, -3, -4]
[]
[8, 7, 6, 5]

3.6 ITERABLES
Un iterable es un objeto que puede ser recorrido elemento a elemento, como listas, tuplas, conjun-
tos, diccionarios, cadenas y rangos. Los iterables son fundamentales en Python, ya que permiten
trabajar con colecciones de datos de forma eficiente.
Los iterables pueden ser utilizados en estructuras cíclicas, funciones y expresiones, permitiendo re-
alizar operaciones comunes como contar elementos, encontrar valores mínimos o máximos, ordenar,
entre otras.

3.6.1 Operaciones comunes con iterables

A continuación, se presentan algunas operaciones y funciones comunes que pueden aplicarse a
iterables:
• print(*iterable) : Imprime los elementos de un iterable.
• len(iterable) : Devuelve el número de elementos del iterable.
• min(iterable) : Devuelve el elemento mínimo del iterable.
• max(iterable) : Devuelve el elemento máximo del iterable.
• sum(iterable) : Devuelve la suma de los elementos del iterable (numéricos).
• sorted(iterable) : Devuelve una lista con los elementos del iterable ordenados.
• dato in iterable : Devuelve True si el dato está en el iterable.
• any(iterable) : Devuelve True si algún elemento del iterable es verdadero.
• all(iterable) : Devuelve True si todos los elementos del iterable son verdaderos.
• [Link](iterable) : Devuelve la cadena resultante de concatenar todos los objetos
del iterable y colocando el separador entre cada par de elementos.
• zip(*iterables) : Agrega elementos de múltiples iterables.
• enumerate(iterable) : Devuelve un objeto enumerado, que contiene pares (índice, ele-
mento).
• map(función, iterable) : Aplica una función a todos los elementos del iterable.
• filter(función, iterable) : Filtra elementos del iterable según una función.

[29]: lista = [3, 1, 4, 1, 5, 9, 2]

print("Lista:", lista)
print("Longitud:", len(lista))
print("Mínimo:", min(lista))
print("Máximo:", max(lista))
print("Suma:", sum(lista))

25
 print("Ordenada:", sorted(lista))
print("¿El 4 está en la lista?", 4 in lista)
print("¿Todos los elementos son mayores que 0?", all(n > 0 for n in lista))
print("¿Algún elemento es igual a 5?", any(n == 5 for n in lista))

Lista: [3, 1, 4, 1, 5, 9, 2]
Longitud: 7
Mínimo: 1
Máximo: 9
Suma: 25
Ordenada: [1, 1, 2, 3, 4, 5, 9]
¿El 4 está en la lista? True
¿Todos los elementos son mayores que 0? True
¿Algún elemento es igual a 5? True

3.6.2 Uso de join() con iterables de cadenas

El método join() permite concatenar elementos de un iterable de cadenas utilizando un separador.
[Link](iterable_de_cadenas)
Donde:
• separador: Es una cadena que se utiliza como delimitador para unir los elementos del
iterable. Puede ser cualquier cadena de caracteres, como un espacio, una coma, un guion,
etc.
• iterable_de_cadenas: Es el conjunto de cadenas que se quieren unir usando el separador.
Puede ser una lista, una tupla, o cualquier iterable que contenga únicamente elementos de
tipo cadena.

[30]: # Uso de join con una lista de cadenas

frutas = ["manzana", "banana", "cereza"]
frase = ", ".join(frutas)
print("Frutas:", frase)

Frutas: manzana, banana, cereza

3.6.3 Funciones de orden superior: map() y filter()

• map(función, iterable) : Aplica una función a cada elemento del iterable y devuelve un
iterador con los resultados.
• filter(función, iterable) : Filtra elementos del iterable que cumplen una condición
definida por una función.

[31]: # Uso de map() para calcular cuadrados

numeros = [1, 2, 3, 4, 5]

cuadrados = list(map(lambda x: x**2, numeros)) # Función anónima (lambda), ver␣

↪más adelante

print("Números:", numeros)

26
 print("Cuadrados:", cuadrados)

Números: [1, 2, 3, 4, 5]
Cuadrados: [1, 4, 9, 16, 25]

[32]: # Uso de filter() para obtener números pares

numeros = range(1, 10)

pares = list(filter(lambda x: x % 2 == 0, numeros))

print("Números pares:", pares)

Números pares: [2, 4, 6, 8]

3.6.4 Funciones zip() y enumerate()

• zip(*iterables) : Combina varios iterables en una serie de tuplas.
• enumerate(iterable, start=0) : Añade un contador a un iterable y lo devuelve en forma
de objeto enumerado. El argumento inicio es opcional, cuyo valor por defecto es 0.

[33]: # Uso de zip() para combinar listas

nombres = ["Ana", "Luis", "Pedro"]
edades = [25, 30, 22]

combinado_lista = list(zip(nombres, edades))

print("Combinado (lista):", combinado_lista)

combinado_dic = dict(zip(nombres, edades))

print("Combinado (diccionario):", combinado_dic)

Combinado (lista): [('Ana', 25), ('Luis', 30), ('Pedro', 22)]

Combinado (diccionario): {'Ana': 25, 'Luis': 30, 'Pedro': 22}

[34]: # Uso de enumerate para obtener índices y valores

nombres = ["Ana", "Luis", "Pedro"]
for indice, nombre in enumerate(nombres, start=1):
print(f"Índice: {indice}, Nombre: {nombre}")

Índice: 1, Nombre: Ana

Índice: 2, Nombre: Luis
Índice: 3, Nombre: Pedro

3.6.5 Comprensiones de listas, tuplas y conjuntos

Las comprensiones son una forma concisa de crear colecciones a partir de iterables existentes.
• Lista comprensión: utiliza corchetes [ ].
[ expresión for elemento in iterable if condición ]
• Tupla comprensión: utiliza tuple( ).
tupla = tuple(expresión for elemento in iterable if condición)

27
 • Conjunto comprensión: utiliza llaves { }.
{ expresión for elemento in iterable if condición }
Donde:
• expresión es el valor o la operación que se aplicará a cada elemento del iterable. Es el
resultado de esta expresión lo que se almacenará en la nueva colección.
• elemento representa cada ítem individual del iterable. Se utiliza en la comprensión como
variable temporal para acceder a cada uno de los valores dentro del iterable.
• iterable es la colección o conjunto de datos sobre el cual se está iterando. Puede ser una
lista, tupla, conjunto, rango, etc., y proporciona los elementos que serán evaluados en la
comprensión.
• condición es una expresión booleana opcional que, de cumplirse (es decir, si evalúa a True),
permite incluir el elemento en la nueva colección. Si la condición no se cumple, el elemento
se omite.

[35]: # Lista de cuadrados de números pares

cuadrados = [n**2 for n in range(10)]
print("Cuadrados:", cuadrados)

# Lista de cuadrados de números pares

cuadrados_pares = [n**2 for n in range(10) if n % 2 == 0]
print("Cuadrados de números pares:", cuadrados_pares)

Cuadrados: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Cuadrados de números pares: [0, 4, 16, 36, 64]

[36]: # Tupla de caracteres en mayúscula

cadena = "python"
tupla_mayus = tuple([Link]() for letra in cadena)

print("Tupla de caracteres en mayúscula:", tupla_mayus)

Tupla de caracteres en mayúscula: ('P', 'Y', 'T', 'H', 'O', 'N')

[37]: # Conjunto de números divisibles por 3

conjunto_div3 = {n for n in range(20) if n % 3 == 0}
print("Conjunto de números divisibles por 3:", conjunto_div3)

Conjunto de números divisibles por 3: {0, 3, 6, 9, 12, 15, 18}

3.6.6 Copia de iterables mutables

Al copiar iterables mutables como listas y diccionarios, es importante distinguir entre copias por
referencia y copias por valor.
En los apartados correspondientes de Listas, Tuplas, Conjuntos y Diccionarios se explica su
uso.

28
 3.6.7 Iteradores (clase iter)
Un iterador es un objeto que permite recorrer un iterable, pero sin almacenar todos los valores en
memoria a la vez. Esto puede resultar muy eficiente cuando trabajamos con grandes conjuntos de
datos. En lugar de crear una lista completa, el iterador va generando cada valor solo cuando hace
falta, ahorrando memoria a cambio de un pequeño coste computacional.
El bucle for en Python utiliza internamente un iterador para recorrer elementos de listas, tuplas, o
cualquier iterable. Podemos convertir cualquier iterable en un iterador usando iter(), y recorrerlo
manualmente con next().

[38]: milista = [4, 8, 15, 16, 23, 42]

iterador = iter(milista)

# Generamos el primer elemento

print(iterador.__next__()) # Salida: 4
print(iterador.__next__()) # Salida: 8

# Otro ejemplo con un rango

iterador = iter(range(4))
print(iterador.__next__()) # Salida: 0
print(iterador.__next__()) # Salida: 1

4
8
0
1

4 VARIABLES
Una variable es el nombre que se utiliza para referirse a un objeto que reside en la memoria.
Cada variable debe tener un nombre único llamado identificador.
A diferencia de otros lenguajes no tienen asociado un tipo y no es necesario declararlas antes de
usarlas (tipado dinámico).
El nombre de la variable debe respetar las siguientes reglas:
• Comienzar siempre por una letra, seguida de otras letras o números.
• No utilizar palabras reservadas del lenguaje: False None True peg_parser and as assert
async await break class continue def del elif else except finally for from global
if import in is lambda nonlocal not or pass raise return try while with yield.
Para asignar un valor a una variable se utiliza el operador =. Este operador permite asignar valores
a mas de una variable con una sola instrucción (asignación múltiple).
• id(variable) : Devuelve la dirección de memoria a la que apunta la variable (donde se
encuentra el objeto).
• del() : Borra una variable.

29
 Por economía del lenguaje, nos tomaremos la licencia de hablar de “guardar un valor en una
variable” en vez de “guardar el valor en un objeto y asociar una variable al objeto”.

[39]: lenguaje = 'Python'

print(f'La dirección de memoria de lenguaje es {id(lenguaje)}.' )

x = 3.14
y = 3 + 2
print(f'{x=}, {y=}')

a1,a2 = 5,2 # Asignación múltiple

print(f'{a1=}, {a2=}')

x,y = y,x # Intercambio de valores

print(f'{x=}, {y=}')

x += 2 # Incremento (equivale a x=x+2)

print(f'{x=}')
x -= 1 # Decremento (equivale a x=x-1)
print(f'{x=}')

x = None # Valor no definido

print(f'{x=}')

del(x) # Eliminar variable x

#print(f'{x=}') # Este código devolverá NameError

La dirección de memoria de lenguaje es 140652108823472.

x=3.14, y=5
a1=5, a2=2
x=5, y=3.14
x=7
x=6
x=None

5 ENTRADA / SALIDA
5.1 LEER DATOS DE TECLADO
Para asignar a una variable un valor introducido por teclado por el usuario se utiliza la instrucción:
input(mensaje) : Muestra la cadena mensaje por la terminal y devuelve una cadena con la
entrada del usuario.
El valor devuelto siempre es una cadena, incluso si el usuario introduce un dato numérico.
Al ejecutarse esta función, el programa se detiene esperando que se escriba algo y se pulse la tecla
INTRO .
Posteriormente, se utilizarán las funciones de conversión de tipo para transformar la cadena

30
 en el tipo de dato deseado.

[40]: nombre = input('Introduce nombre: ')

entrada = input('Introduce edad: ')
edad = int(entrada) # Convertimos la variable entrada (str) a entero (int)

# La conversión se puede hacer directamente:

edad = int(input('Introduce edad: '))

Introduce nombre: Javier

Introduce edad: 33
Introduce edad: 33

5.2 ESCRIBIR DATOS EN PANTALLA

Para mostrar un dato por la terminal se utiliza la instrucción:
print( dato1, ... , sep=' ', end='\n' ) :
• dato1, … : son los datos a imprimir y pueden indicarse tantos como se quieran separados por
comas.
• sep : establece el separador entre los datos, que por defecto es un espacio en blanco ' '.
• end : indica la cadena final de la impresión, que por defecto es un salto de línea \n.
print( *contenedor, ... , sep=' ', end='\n' ) : imprime todos los elementos del contene-
dor (cadena de caracteres, lista, etc.).

[41]: nombre = input('Teclea tu nombre: ')

print('Mi nombre es',nombre)
print('Mi nombre es',nombre,sep='')
print('Mi nombre es',nombre,end='*')
print('Mi nombre es',nombre,sep='\n')
print(f'Mi nombre es {nombre:^10}.')

Teclea tu nombre: Javier

Mi nombre es Javier
Mi nombre esJavier
Mi nombre es Javier*Mi nombre es
Javier
Mi nombre es Javier .

[42]: lista=[1,'hola',2]
print(*lista , sep='-',end='*')
cadena='hola'
print(*cadena , sep='-')

1-hola-2*h-o-l-a

31
 5.3 LEER DATOS DE UN FICHERO DE TEXTO
Para acceder al fichero de texto utilizaremos un objeto de tipo File que apunte o haga referencia
al fichero. Este objeto se obtiene con la función open().

5.3.1 Abrir y leer fichero

open( nombre, 'r' ) : Abre el fichero llamado nombre en modo lectura (el argumento r significa
read) y devuelve un objeto que lo referencia.
Una vez abierto el fichero, se puede leer todo el contenido del fichero o se puede leer línea a línea.
• [Link]( ) : Lee todos los caracteres fasta el final del fichero y los devuelve como
cadena de caracteres.
• [Link]( n ) : Lee n caracteres del fichero y los devuelve como cadena de caracteres.
Si se ha leído antes todo el fichero y se ha alcanzado el final de fichero, devolverá una cadena
vacía.
• [Link]( ) : Lee una línea del fichero y la devuelve como cadena de caracteres.
Si se ha leído antes todo el fichero y se ha alcanzado el final de fichero, devolverá una cadena
vacía.
• [Link]( ) : Lee el fichero completo y devuelve una lista de cadenas de caracteres
donde cada cadena es una línea.

5.3.2 Cerrar fichero

[Link]( ) : Cierra el fichero referenciado por el objeto fichero.
Cuando se termina de trabajar con un fichero conviene cerrarlo. Si no se cierra explícitamente un
fichero, Python intentará cerrarlo cuando estime que ya no se va a usar más.

5.3.3 Abrir y cerrar fichero automáticamente con with

En lugar de abrir un fichero y cerrarlo manualmente, se puede usar la sentencia with. Al usar with,
Python se encarga de cerrar automáticamente el fichero cuando se sale del bloque, lo que hace el
código más seguro y fácil de leer.
La sintaxis es:
with open(nombre, 'r') as f:
contenido = [Link]()

[43]: f = open('ficheros/[Link]', 'r')

print([Link]())
[Link]()

Este es un saludo
que he realizdo
en un fichero de texto

[44]: with open('ficheros/[Link]','r') as f:

print([Link]())

32
 print([Link]())

Este es un saludo

que he realizdo

[45]: with open('ficheros/[Link]','r') as fichero:

print([Link]())

['Este es un saludo\n', 'que he realizdo\n', 'en un fichero de texto\n']

5.4 ESCRIBIR DATOS DE UN FICHERO DE TEXTO

5.4.1 Crear fichero nuevo y escribir datos
open( nombre, 'w' ) : Crea el fichero llamado nombre, lo abre en modo escritura (el argumento
w significa write) y devuelve un objeto que lo referencia.
Si el fichero indicado por la ruta ya existe en el sistema, se reemplazará por el nuevo.
Una vez abierto el fichero, se puede leer todo el contenido del fichero o se puede leer línea a línea.
• [Link]( c ): Escribe la cadena c en el fichero referenciado por fichero.
• [Link]( iterable ) : Toma un iterable de cadenas (como una lista de líneas)
y las escribe en el fichero. Ojo: no añade saltos de línea automáticamente, así que deberás
asegurarte terminar las líneas con \n.

5.4.2 Añadir datos a un fichero existente

open( nombre , 'a' ) : Abre el fichero llamado nombre en modo añadir (el argumento a significa
append) y devuelve un objeto que lo referencia. El nombre puede contener la ruta completa hasta
llegar al fichero. Si el fichero no existe, se creará uno nuevo, y si existe, se se añadirá al existente.
Los métodos de escritura son los mismos que en el apartado anterior: [Link]( c ) y
[Link]( iterable ).

5.4.3 Cerrar fichero

[Link]() : Cierra el fichero referenciado por el objeto fichero.
Cuando se termina de escribir en un fichero hay que cerrarlo.
Si finaliza la ejecución del programa sin cerrar el fichero puede que las ultimas ordenes de escritura
no se ejecuten completamente.
Si no se cierra explícitamente un fichero, Python intentará cerrarlo cuando estime que ya no se va
a usar más.
Mientras esté abierto en modo escritura no se debe abrir por otra aplicación.

33
 5.4.4 Abrir y cerrar fichero automáticamente con with
Del mismo modo que al leer ficheros, en lugar de abrir un fichero y cerrarlo manualmente, se puede
usar la sentencia with.
with open(nombre, 'a') as f:
[Link](c)

[46]: with open("ficheros/fichero_lectura.txt", "w") as fichero:

[Link]("Este es un ejemplo de texto.\n")

[47]: with open("ficheros/fichero_lectura.txt", "a") as fichero:

[Link]("Otra línea que inserto con el método append 'a'.\n")

[48]: lineas = ['Esta es mi linea 1', 'Esta es mi segunda linea\n', 'Esta es mi␣
↪tercera linea\n']

with open("ficheros/fichero_lectura.txt", "a") as fichero:

[Link](lineas)

34