1

2
Principios de Python 5

Listas en Python 14

Tuplas de Python 24

Conjuntos en Python 31

Diccionarios de Python 42

Matrices
55

Funciones
59

3
4
 Principios de Python
¿Qué es? y ¿Por qué escoger Python?
Python es un lenguaje de programación multiplataforma y de código abierto que puede
utilizarse tanto para desarrollo web, creación de software y procesamiento de datos, entre
muchos otros propósitos. Esta versatilidad y facilidad para aprenderlo lo han convertido en
el lenguaje de programación más popular en el mundo, según el índice de popularidad de
programación.

Te dejamos 5 razones para aprender Python:

5
Además de lo antes mencionado, puedes echar una mirada a empresas mundiales que
utilizan Python:

Python es también usado para fines muy diversos como son los siguientes:

• Desarrollo Web: Existen frameworks como Django, Pyramid, Flask o Bottle que
permiten desarrollar páginas web a todos los niveles.
• Ciencia y Educación: Debido a su sintaxis tan sencilla, es una herramienta perfecta
para enseñar conceptos de programación a todos los niveles. En lo relativo a ciencia
y cálculo numérico, existen gran cantidad de librerías como SciPy o Pandas.
• Desarrollo de Interfaces Gráficos: Gran cantidad de los programas que utilizamos
tienen un interfaz gráfico que facilita su uso. Python también puede ser usado para
desarrollar GUIs con librerías como Kivy o pyqt.
• Desarrollo Software: También es usado como soporte para desarrolladores, como
para testing.

6
 • Machine Learning: En los últimos años ha crecido el número de implementaciones
en Python de librerías de aprendizaje automático como Keras, TensorFlow, PyTorch
o sklearn.
• Visualización de Datos: Existen varias librerías muy usadas para mostrar datos en
gráficas, como matplotlib, seaborn o plotly.
• Finanzas y Trading: Gracias a librerías como QuantLib o qtpylib y a su facilidad de
uso, es cada vez más usado en estos sectores.

De hecho, a día de hoy prácticamente cualquier API, librería o servicio que existe en el
mundo tiene una versión para Python, bien sea de manera nativa o a través de un wrapper.

Sintaxis básica

Variables
Las variables son uno de los componentes básicos en cualquier programa. Una variable es
una forma de identificar un dato que se encuentra almacenado en la memoria del
ordenador. Ejemplos:

# Guardamos en la variable suma el resultado de 1+2

suma = 1 + 2

# Guardamos en la variable edad, la edad de una persona

edad = 25

#Guardamos en la variable texto, un texto específico

texto = "Hola mundo!"

7
Como hemos visto para asignarle un valor a una variable lo hacemos por medio del símbolo
de igualdad =, la variable del lado izquierdo y el valor a asignar al lado derecho del símbolo.

Tipos de datos
En cualquier lenguaje de programación de alto nivel se manejan tipos de datos. Los tipos de
datos definen un conjunto de valores que tienen una serie de características y propiedades
determinadas.

En Python, todo valor que pueda ser asignado a una variable tiene asociado un tipo de dato.
Como ya te he mencionado alguna vez, en Python todo es un objeto. Así que los tipos de
datos serían las clases (donde se definen las propiedades y qué se puede hacer con ellas) y
las variables serían las instancias (objetos) de los tipos de datos. No te preocupes si no
entiendes qué es una clase o un objeto, lo veremos en otro tutorial.

En definitiva, un tipo de dato establece qué valores puede tomar una variable y qué
operaciones se pueden realizar sobre la misma.

Los tipos de datos en Python son:

Enteros

Numéricos Reales

Básicos Alfanuméricos String

Lógicos o
Tipos

Booleanos

Listas, tuplas

Estructurados Diccionarios
Set
Conjuntos
FrozenSet

8
Condicional IF
Evalúa básicamente una operación lógica, es decir una expresión que dé como resultado
verdadero o falso y ejecuta siempre y cuando el resultado sea verdadero.

# Ejemplo IF
a=7
b=5
if (a > 5): print("La variable a es mayor a la variable b")

Podemos utilizar else para tener la capacidad de ejecutar código en caso de que el resultado
lógico sea falso.

# Ejemplo IF-ELSE

9
a=7
b = 10
if (a > 5):
print("La variable a es mayor a la variable b")
else:
print("La variable a no es mayor a la variable b")

Su diagrama de flujo es el siguiente:

10
Control de flujo while
El uso principal de la sentencia while es ejecutar repetidamente un bloque de código
mientras se cumpla una condición.

La estructura de esta sentencia while es la siguiente:

while condición:
# bloque de código

Es decir, mientras condición se evalúe a True, se ejecutarán las instrucciones y sentencias

de bloque de código.

Veamos un ejemplo:

numero = 0
while numero <= 10:
print(f'{numero * 3}')
numero += 1
print('Fin')

El script anterior se inicializa una variable en 0 luego aparece la sentencia while. Esta
sentencia comprueba que el valor de la variable numero sea menor o igual a 10, mientras
esa evaluación resulte VERDADERO, se muestra en pantalla el resultado de multiplicar
número x 3, luego se incrementa el valor de numero en 1.

Control de flujo for

El bucle for se utiliza para recorrer los elementos de un objeto iterable (lista, tupla,
conjunto, diccionario, …) y ejecutar un bloque de código. En cada paso de la iteración se

11
tiene en cuenta a un único elemento del objeto iterable, sobre el cuál se pueden aplicar una
serie de operaciones.

Imaginemos que tenemos una lista de números y queremos mostrarlos por consola. El
código podría ser así:

nums = [4, 78, 9, 84]

for n in nums:
print(n)
# Resultado
#4
#78
#9
#84

No te preocupes si no comprendes bien el concepto de iterable, eso lo veremos más

adelante en este mismo curso, lo importante es anotar que el bucle for será útil con este
tipo de objetos.

Datos estructurados en Python

Antes de arrancar con los datos estructurados es importante partir del concepto básico de
Python: Dato simple.

Podemos definir un dato simple como aquel que permite que una variable pueda
almacenarlo como un único valor de ese único tipo. Presta atención a “valor”, “valor único”
y “único tipo”. Pues no podrá ser un dato simple un conjunto de valores (por ser más de un
valor y por qué pueden ser de diferente tipo).

12
Ejemplos de datos simples asignados a una variable son:

a=2
edad = 25
x = 3.16

Dicho lo anterior, los datos estructurados en Python son aquellos que permiten que una
variable pueda almacenarlos como más de un valor, dato o tipo de dato. Como puede ser
un conjunto de números, una cadena de caracteres, letras, listas, secuencias, etc.

Ejemplo de datos estructurados son:

I = [1,2,3]

Tipos de datos estructurados en Python son:

Estructurados

Listas, tuplas

Diccionarios
Set
Conjuntos
FrozenSet

13
 Listas en Python
Las listas en Python son un tipo de datos que permite almacenar datos de cualquier tipo.
Son mutables (permiten ser modificado una vez creados) y dinámicas, lo cual es la principal
diferencia con los conjuntos y las tuplas.

Propiedades de las listas

Algunas de las propiedades de las listas son:

• Son ordenadas, mantienen el orden en el que han sido definidas.

• Pueden ser formadas por tipos arbitrarios, múltiples tipos de datos en una sola lista.
• Pueden ser indexadas con [i].
• Se pueden anidar, es decir, meter una lista dentro de otra.
• Son mutables, ya que sus elementos pueden ser modificados.
• Son dinámicas, ya que se pueden añadir o eliminar elementos.

Creando listas
Las listas en Python son uno de los tipos o estructuras de datos más versátiles del lenguaje,
ya que permiten almacenar un conjunto arbitrario de datos. Es decir, podemos guardar en

14
ellas prácticamente lo que sea. Si has tenido contacto con otros lenguajes de programación,
se podría decir que las listas son similares a los arreglos (arrays).

Ejemplo de lista:

lista = [1,2,3,4]

También se puede crear usando list y pasando un objeto iterable (es decir una clase que
puede ser iterada)

lista = list("1234")

Una lista se crea con corchetes [ ] separando sus elementos con comas ,. Una gran ventaja
es que podemos almacenar tipos de datos distintos.

lista = [1,"Hola mundo!", 3.67, [1,2,3]]

En el caso anterior creamos una lista con un elemento entero, uno de tipo string, uno de tipo
decimal y el último elemento es una lista, sí una lista dentro de otra lista.

Acceso y modificación de listas

Si tenemos una lista con 3 elementos almacenados en ella, podemos acceder a los datos
usando corchetes y un índice, que va desde 0 a n-1 siendo n el tamaño de la lista (para
nuestro ejemplo n = 3). Ejemplo:

a = [90, "Python", 3.87]

print(a[0]) #Imprimirá el primer valor de la lista
print(a[1]) #Imprimirá el segundo valor de la lista
print(a[2]) #Imprimirá el tercer valor, y en nuestro caso el último valor

15
Otra forma de acceder al último elemento es utilizando el índice [-1]

a = [90, "Python", 3.87]

print(a[-1]) #3.87

De la misma manera, al igual que con [-1] accedemos al último elemento, para acceder al
penúltimo podríamos utilizar el índice [-2]

a = [90, "Python", 3.87]

print(a[-1]) #3.87
print(a[-2]) #Python

Para modificar un elemento de la lista, basta con asignar con el operador igual (=) el nuevo
valor.

a[2] = 1
print(a) #[90, 'Python', 1]

También podemos tener listas anidadas, es decir, una lista como elemento de otra lista. Para
acceder a sus elementos solo tenemos que usar los corchetes [ ] tantas veces como niveles
de anidado tengamos. Ejemplo:

x = [1, 2, 3, ['p', 'q', [5, 6, 7]]]

print(x[3][0]) #p
print(x[3][2][0]) #5
print(x[3][2][2]) #7

16
Otra forma de acceder a listas es creando sublistas más pequeñas que parten de la más
grande. Para ello debemos usar los dos puntos (:) entre corchetes, indicando a la izquierda
el valor de inicio y a la izquierda el valor final que no está incluido. Por tanto [0:2] creará una
lista con elementos [0] y [1] de la lista original. Ejemplo:

l = [1, 2, 3, 4, 5, 6]
print(l[0:2]) #[1, 2]
print(l[2:6]) #[3, 4, 5, 6]

De esta misma manera podemos modificar múltiples valores de la lista de la siguiente forma:

l = [1, 2, 3, 4, 5, 6]
l[0:3] = [0, 0, 0]
print(l) #[0, 0, 0, 4, 5, 6]

Podemos utilizar el operador + para poder concatenar listas. Ejemplos:

#Ejemplo 1
l = [1, 2, 3]
l += [4, 5]
print(l) #[1, 2, 3, 4, 5]

#Ejemplo 2
lista1 = [1,2,3,4,5]
lista2 = [6,7,8,9,10]
lista3 = lista1 + lista2
print(lista3) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

17
Por otro lado, el operador * repite el contenido de una lista n veces. Ejemplo:

lista1 = [1,2,3]
lista2 = lista1*3
print(lista2) #[1, 2, 3, 1, 2, 3, 1, 2, 3]

Una funcionalidad muy interesante de las listas de Python, es que podemos asignar una lista
con n elementos a n variables en una sola línea de código. Ejemplo:

l = [1, 2, 3]
x, y, z = l
print(x, y, z) #1 2 3
Eliminando elementos de una lista
Para eliminar elementos de una lista podemos hacerlo de diferentes maneras como
veremos a continuación:

• Utilizando la función del: Su sintaxis es del(lista[i]) realiza el eliminado de la

información en base a la posición.
• Utilizando la propiedad remove de la lista: Su sintaxis es lista.remove(elemento)
realiza el eliminado de la información en base al primer valor que encuentra del
elemento.

Ejemplo de cómo eliminar elementos de una lista:

lista = [1,2,3,4,5]
del lista[1]
print(lista) #[1,3,4,5]
lista.remove(4)
print(lista) #[1,3,5]

18
Recorrer/Iterar una lista
En Python es fácil iterar una lista, de hecho, es mucho más sencillo que en cualquier otro
lenguaje de programación. Se utiliza el bucle for para recorrer los elementos de la lista
utilizando la siguiente estructura.

colores = ['azul', 'blanco', 'negro']

for color in colores:
print(color)
#azul
#blanco
#negro

Si necesitamos acompañar del índice del elemento el valor de la lista, lo hacemos de la

siguiente manera:

colores = ['azul', 'blanco', 'negro']

for index, color in enumerate(colores):
print(index, color)
#0 azul
#1 blanco
#2 negro
Ahora bien, también podemos iterar con dos listas a la vez, lo hacemos de la siguiente
manera:

lista1 = [1, 2, 3]
lista2 = ["Jazz", "Rock", "Djent"]
for l1, l2 in zip(lista1, lista2):
print(l1, l2)

19
#5 Jazz
#9 Rock
#10 Djent

Otra forma de iterar con elementos obteniendo la longitud de la lista sería:

lista1 = [5, 9, 10]

for i in range(0, len(lista)):
print(lista1[i])
#5
#9
#10

Métodos de las listas en Python

Los métodos disponibles para los objetos de tipos lista son:

Método Descripción
append() Añade un nuevo elemento al final de la lista.
extend() Añade un grupo de elementos (iterables) al final de la lista.

insert(indice, Inserta un elemento en una posición concreta de la lista.

elemento)
remove(elemento) Elimina la primera ocurrencia del elemento en la lista.

pop([i]) Obtiene y elimina el elemento de la lista en la posición i. Si no

se especifica, obtiene y elimina el último elemento.

20
 clear() Borra todos los elementos de la lista.
index(elemento) Obtiene el índice de la primera ocurrencia del elemento en la
lista. Si el elemento no se encuentra, se lanza la
excepción ValueError.
count(elemento) Devuelve el número de ocurrencias del elemento en la lista.

sort() Ordena los elementos de la lista utilizando el operador <.

reverse() Obtiene los elementos de la lista en orden inverso.

copy() Devuelve una copia poco profunda de la lista.

Ejemplos de los métodos de listas en Python

# Ejemplo append(obj)
l = [1, 2]
l.append(3)
print(l) #[1, 2, 3]

#Ejemplo extend(<iterable>)
l = [1, 2]
l.extend([3, 4])
print(l) #[1, 2, 3, 4]

#Ejemplo de insert
l = [1, 3]
l.insert(1, 2)

21
print(l) #[1, 2, 3]

#Ejemplo de remove
l = [1, 2, 3]
l.remove(3)
print(l) #[1, 2]

#Ejemplo de pop
l = [1, 2, 3]
l.pop()
print(l) #[1, 2]

#Ejemplo de clear
l=[1,2,3]
l.clear()
print('Lista despues de clear(): ', l)
#Lista después de clear(): []

#Ejemplo de index
animales = ['gato', 'perro', 'conejo','caballo']
index = animales.index('perro')
print(index) # 1

#Ejemplo de count
numeros = [2,3,5,2,11,2,7]
count2 = numeros.count(2)

22
print('El número 2 se repite ', count2, ' veces')
#El número 2 se repite 3 veces

#Ejemplo de sort
l = [3, 1, 2]
l.sort()
print(l) #[1, 2, 3]

#Otra forma de usar sort

#con la palabra reverse ordena de mayor a menor
l = [3, 1, 2]
l.sort(reverse=True)
print(l) #[3, 2, 1]

#Ejemplo de reverse
l = [1, 2, 3]
l.reverse()
print(l) #[3, 2, 1]

#Ejemplo de copy
lista1 = [1,2,3,4]
copia = lista1.copy()
print('La lista copiada queda ', copia)
# La lista copiada queda [1, 2, 3, 4]

23
 Tuplas de Python
La clase de tuplas en Python es uno de los tipos
de datos más singulares del lenguaje. Pertenece
a la categoría de tipos secuenciales y, a
diferencia del tipo lista, las tuplas son un tipo de
secuencias inmutables. Esto quiere decir que una
tupla no puede ser modificada (no se pueden añadir ni eliminar elementos de una tupla).

¿Qué es una tupla?

La clase tuple en Python es un tipo contenedor, compuesto, que en un principio se pensó
para almacenar grupos de elementos heterogéneos, aunque también puede contener
elementos homogéneos.

Junto a la clase list y rango, es uno de los tipos de secuencia en Python, con la particularidad
de que son inmutables. Esto último quiere decir que su contenido NO puede modificarse
después de haber sido creada.

En general, para crear una tupla en Python simplemente hay que definir una secuencia de
elementos separados por comas.

Por ejemplo, para crear una tupla con los números del 1 al 5 se haría del siguiente modo:

numeros = 1, 2, 3, 4, 5

Como hemos mencionados, la clase tuple también puede almacenar elementos de distinto
tipo:

elementos = 3, 'a', 8, 7.2, 'hola'

24
Incluso puede contener otros elementos compuestos y objetos, como listas, otras tuplas,
etc.

tup = 1, ['a', 'e', 'i', 'o', 'u'], 8.9, 'hola'

Creando tuplas
Existen diferentes formas de crear una tupla en Python a continuación, se mencionan:

• Para crear una tupla vacía, usa paréntesis () o el constructor de la clase tuple() sin
parámetros.
• Para crear una tupla con un único elemento: elem ó (elem, ). Observa que siempre
se añade una coma.
• Para crear una tupla de varios elementos, separarlos con comas: a,b,c O (a,b,c).
• Las tuplas también se pueden crear usando el constructor de la clase, tuple(iterable).
En este caso, el constructor crea una tupla cuyos elementos son los mismos y están
en el mismo orden que los ítems del iterable. El objeto iterable puede ser una
secuencia, un contenedor que soporte la iteración o un objeto iterador.

Ejemplos de creación de tuplas:

#Creando tuplas
tupla = (1, 2, 3)
print(tupla) #(1, 2, 3)

#También pueden declararse sin (), separando por , todos sus elementos.
tupla = 1, 2, 3
print(type(tupla)) #<class 'tuple'>
print(tupla) #(1, 2, 3)

25
Acceso a elementos de una tupla
Para acceder a los elementos de una tupla, similar a las listas, se utilizan los índices. Un
índice es un número entero que indica la posición de un elemento en una tupla. El primer
elemento de una tupla siempre comienza con el índice 0.

Por ejemplo, en una tupla con 3 elementos, los índices de cada uno de los ítems serían 0, 1
y 2.

tupla = ('a', 'b', 'c')

print(tupla[0]) #a
print(tupla[1]) #b
print(tupla[2]) #c

Si se intenta acceder a un índice que está fuera del rango de la tupla, el intérprete lanzará
la excepción IndexError. De igual modo, si se utiliza un índice que no es un número entero,
se lanzará la excepción TypeError.

Al igual que ocurre con las listas (y todos los tipos secuenciales), está permitido usar índices
negativos para acceder a los elementos de una tupla. En este caso, el índice -1 hace

26
referencia al último elemento de la secuencia, el -2 al penúltimo y así, sucesivamente.
Ejemplo:

bebidas = ('agua', 'café', 'batido', 'sorbete')

print(bebidas[-1]) #sorbete
print(bebidas[-3]) #café

También es posible acceder a un subconjunto de elementos de una tupla utilizando el

operador [:]. Algunos ejemplos a continuación:

vocales = 'a', 'e', 'i', 'o', 'u'

print(vocales[2:3]) # Elementos desde el índice 2 hasta el índice 3-1
# ('i',)
print(vocales[2:4]) # Elementos desde el 2 hasta el índice 4-1
#('i', 'o')
print(vocales[:]) # Todos los elementos
#('a', 'e', 'i', 'o', 'u')
print(vocales[1:]) # Elementos desde el índice 1
#('e', 'i', 'o', 'u')
print(vocales[:3]) # Elementos hasta el índice 3-1
#('a', 'e', 'i')

Otra forma es indicar un salto entre los elementos con el operador [::]. Algunos ejemplos a
continuación:

pares = 2, 4, 6, 8, 10, 12, 14

print(pares[::2]) # Acceso a los elementos de 2 en 2

27
#(2, 6, 10, 14)
print(pares[1:5:2]) # Elementos del índice 1 al 4 de 2 en 2
#(4, 8)
print(pares[1:6:3]) # Elementos del índice 1 al 5 de 3 en 3
#(4, 10)

También se le puede asignar el valor de una tupla con N elementos a N variables

l = (1, 2, 3)
x, y, z = l
print(x, y, z) #1 2 3

Aunque tal vez no tenga mucho sentido a nivel práctico, es posible crear una tupla de un
solo elemento. Para ellos debes de usar, antes del paréntesis, porque de lo contrario (2)
seria interpretado como un int en el siguiente ejemplo:

tupla = (2,)
print(type(tupla)) #<class 'tuple'>

Recorrer/Iterar una tupla

Igual que con las listas, para poder recorrer los elementos de una tupla podemos utilizar el
bucle for. Para recorrer una tupla utilice la siguiente estructura:

colores = 'Azul', 'Blanco', 'Negro'

for color in colores:
print(color)
#Azul

28
#Blanco
#Negro

Como cualquier tipo secuencia, para conocer la longitud de una tupla en Python se hace uso
de la función len(). Esta función devuelve el número de elementos de una tupla:

vocales = 'a', 'e', 'i', 'o', 'u'

print(len(vocales)) # 5

Modificar una tupla en Python

Como mencionamos al inicio de este tema, las tuplas son objetos inmutables, es decir no
podemos cambiarlas, sin embargo, las tuplas pueden contener objetos u otros elementos
de tipo secuencia, por ejemplo: una lista. Esos objetos, SI son mutables, sí se pueden
modificar:

tupla = (1, ['a', 'b'], 'hola', 8.2)

print(tupla)
#(1, ['a', 'b'], 'hola', 8.2)
tupla[1].append('c') # tupla[1] hace referencia a la lista
print(tupla)
#(1, ['a', 'b', 'c'], 'hola', 8.2)

29
Métodos de las tuplas en Python
Estos son los métodos definidos para los tipos tuplas:

Método Descripción
index(elemento) Obtiene el índice de la primera ocurrencia del elemento en la
tupla. Si el elemento no se encuentra, se lanza la
excepción ValueError.
count(elemento) Devuelve el número de ocurrencias del elemento en la tupla.

#Ejemplo count
t = '1','1','1','3','4'
print(t.count('1')) #3

#Ejemplo index
x = '7','7','7','3','5'
print(x.index('5')) #4

30
 Conjuntos en Python
El tipo set en Python es la clase utilizada por el lenguaje para representar los conjuntos. Un
conjunto es una colección desordenada de elementos únicos, es decir, que no se repiten.

Creando conjuntos en Pyhthon

Ya hemos mencionado que el tipo set en Python es utilizado para trabajar con conjunto de
elementos. La principal característica de este tipo de datos es que es una colección cuyos
elementos no guardan ningún orden y que además son únicos.

Estas características hacen que los principales usos de esta clase sean conocer si un
elemento pertenece o no a una colección y eliminar duplicados de un tipo secuencial (list,
tuple o str).

Además, esta clase también implementa las típicas operaciones matemáticas sobre
conjuntos: unión, intersección, diferencia, …

Para crear un conjunto, basta con encerrar una serie de elementos entre llaves { }, o bien
usar el constructor de la clase set() y pasarle como argumento un objeto iterable (como una
lista, una tupla o una cadena).

31
# Crea un conjunto con una serie de elementos entre llaves
# Los elementos repetidos se eliminan
c = {1, 3, 2, 9, 3, 1}
print(c)
#{1, 2, 3, 9}

# Crea un conjunto a partir de un string

# Los caracteres repetidos se eliminan
a = set('Hola Pythonista')
print(a)
#{'a', 'H', 'h', 'y', 'n', 's', 'P', 't', ' ', 'i', 'l', 'o'}

# Crea un conjunto a partir de una lista

# Los elementos repetidos de la lista se eliminan
unicos = set([3, 5, 6, 1, 5])
print(unicos)
#{1, 3, 5, 6}

Para crear un conjunto vacío, simplemente llama al contructor set() sin parámetros.

NOTA: El uso de las llaves vacías {} NO crea un conjunto vacío, sino un diccionario vacío. Usa
set() si quieres crear un conjunto sin elementos.

IMPORTANTE: Los elementos que se pueden añadir a un conjunto deben ser de tipo
hashable. Un objeto es hashable si tiene un valor de hash que no cambia durante todo su

32
ciclo de vida. En principio, los objetos que son instancias de clases definidas por el usuario
son hashables. También lo son la mayoría de tipos inmutables definidos por Python.

En realidad, en Python existen dos clases para representar conjuntos: set y frozenset. La
principal diferencia es que set es mutable, por lo que después de ser creado, se pueden
añadir y/o eliminar elementos del conjunto, como veremos en secciones posteriores. Por
su parte, frozenset es inmutable y su contenido no puede ser modificado una vez que ha
sido inicializado.

Para crear un conjunto de tipo frozenset, se usa el constructor de la clase frozenset():

f = frozenset([3, 5, 6, 1, 5])
print(f)
#frozenset({1, 3, 5, 6})

Accediendo a elementos de un conjunto

Dado que los conjuntos son colecciones desordenadas, en ellos no se guarda la posición en
la que son insertados los elementos como ocurre en los tipos list o tuples. Es por ello que
no se pueden acceder a los elementos a través de un índice.

Sin embargo, sí se puede acceder y/o recorrer todos los elementos de un conjunto usando
un bucle for:

mi_conjunto = {1, 3, 2, 9, 3, 1}
for e in mi_conjunto:
print(e)
#1
#2
#3
#9

33
Como cualquier otra colección, usar la función len() para obtener el número de elementos
contenidos en un conjunto:

mi_conjunto = set([1, 2, 5, 3, 1, 5])

print(len(mi_conjunto))
#4

Con los conjuntos también se puede usar el operador de pertenencia in para comprobar si
un elemento está contenido, o no, en un conjunto:

mi_conjunto = set([1, 2, 5, 3, 1, 5])

print(1 in mi_conjunto)
#True

print(6 in mi_conjunto)
#False

print(2 not in mi_conjunto)

#False

Añadir elementos a un conjunto (set) en Python

Para añadir un elemento a un conjunto se utiliza el método add(). También existe el método
update(), que puede tomar como argumento una lista, tupla, string, conjunto o cualquier
objeto de tipo iterable.

mi_conjunto = {1,3,2,9,3,1}
print(mi_conjunto)

34
#{1, 2, 3, 9}

#Añadir el elemento 7 al conjunto

mi_conjunto.add(7)
print(mi_conjunto)
#{1, 2, 3, 7, 9}

#Añade los elementos 5,3,4 y 6

#Los elementos repetidos no se añadiran al conjunto
mi_conjunto.update([5,3,4,6])
print(mi_conjunto)
#{1, 2, 3, 4, 5, 6, 7, 9}

Eliminar elementos de un conjunto en Python

La clase set ofrece cuatro métodos para eliminar elementos de un conjunto. Son: discard(),
remove(), pop() y clear(). A continuación, vamos a explicar qué hace cada uno de ellos.

discard(elemento) y remove(elemento) eliminan elemento del conjunto. La única diferencia

es que si elemento no existe, discard() no hace nada mientras que remove() lanza la
excepción KeyError.

Pop() es un tanto peculiar. Este método devuelve un elemento aleatorio del conjunto y lo
elimina del mismo. Si el conjunto está vacío, lanza una excepción KeyError.

Finalmente, clear() elimina todos los elementos contenidos en el conjunto.

mi_conjunto = {1, 3, 2, 9, 3, 1, 6, 4, 5}
print(mi_conjunto)

35
#{1, 2, 3, 4, 5, 6, 9}

#Elimina el elemento 1 con remove()

mi_conjunto.remove(1)
print(mi_conjunto)
#{2, 3, 4, 5, 6, 9}

#Elimina el elemento 4 con discard()

mi_conjunto.discard(4)
print(mi_conjunto)
#{2, 3, 5, 6, 9}

#Trata de eliminar el elemento 7 (no existe) con discard()

mi_conjunto.discard(7)
print(mi_conjunto)
#No hace nada

#Obtiene y elimina un elemento aleatorio con pop()

mi_conjunto.pop()

36
print(mi_conjunto)
#{3, 5, 6, 9}

#Elimina todos los elementos del conjunto

mi_conjunto.clear()
print(mi_conjunto)
#set()

Operaciones sobre conjuntos en Python

Tal y como se adelantó al comiendo de este tema, uno de los principales usos del tipo set
es utilizarlo en operaciones del álgebra de conjuntos: unión, intersección, diferencia,
diferencia simétrica, etc.

Podemos realizar esta álgebra tanto con operadores cómo con métodos

A = {1,2,3,4,5}
B ={4,5,6,7,8}

37
print('Unión =', A | B)
print('Intersección =', A & B)
print('Diferencia =', A - B)
print('Diferencia sim =', A ^ B)
print()

#Unión = {1, 2, 3, 4, 5, 6, 7, 8}
#Intersección = {4, 5}
#Diferencia = {1, 2, 3}
#Diferencia sim = {1, 2, 3, 6, 7, 8}

Inclusión de conjuntos en Python

#Dado un conjunto A y un conjunto B
A = {1,2}
B = {1,2,3,4}

Dado un conjunto A, subcolección del conjunto B o igual a este, sus elementos son un
subconjunto B. Es decir, A es un subconjunto de B y B es un super conjunto de A.

En Python se utiliza el operador <= para comprobar si un conjunto A es subconjunto B y el

operador >= para comprobar si el conjunto A es superconjunto de B.

print(A <= B) #True

print(A >= B) #False

38
Conjuntos disjuntos en Python
Dos conjuntos A y B son disjuntos si no tienen elementos en común, es decir, la intersección
de A y B es el conjunto vacío.

En Python se utiliza el método isdisjoint() de la case set para comprobar si un conjunto es

disjunto del otro.

A = {1, 2}
B = {1,2,3,4}
print(A.isdisjoint(B)) #False

A = {1,2}
B = {3,4}
print(A.isdisjoint(B)) #True

Igualdad de conjuntos en Python

En Python dos conjuntos son iguales si y solo si todos los elementos de un conjunto están
contenidos en el otro. Esto quiere decir que cada uno es un subconjunto del otro.

A = {1, 2}
B = {1, 2}
print(id(A)) #2090910437376
print(id(B)) #2090910437600
print(A == B) #True

39
Métodos de la clase set en Python
La clase set tiene una gran cantidad de métodos, la mayoría los hemos cubierto en esta
clase, pero dejaremos el listado completo a continuación:

Método Descripción
add(e) Añade un elemento al conjunto.
clear() Elimina todos los elementos del
conjunto.
copy() Devuelve una copia superficial del
conjunto.
difference(iterable) Devuelve la diferencia del conjunto
con el iterable como un conjunto
nuevo.
difference_update(iterable) Actualiza el conjunto tras realizar la
diferencia con el iterable.
discard(e) Elimina, si existe, el elemento del
conjunto.
intersection(iterable) Devuelve la intersección del
conjunto con el iterable como un
conjunto nuevo.
intersection_update(iterable) Actualiza el conjunto tras realizar la
intersección con el iterable.
isdisjoint(iterable) Devuelve True si dos conjuntos son
disjuntos.
issubset(iterable) Devuelve True si el conjunto es
subconjunto del iterable.

40
issuperset(iterable) Devuelve True si el conjunto es
superconjunto del iterable.
pop() Obtiene y elimina un elemento de
forma aleatoria del conjunto.
remove(e) Elimina el elemento del conjunto. Si
no existe lanza un error.
symmetric_difference(iterable) Devuelve la diferencia simétrica del
conjunto con el iterable como un
conjunto nuevo.
symmetric_difference_update(iterable) Actualiza el conjunto tras realizar la
diferencia simétrica con el iterable.
union(iterable) Devuelve la unión del conjunto con
el iterable como un conjunto nuevo.
update(iterable) Actualiza el conjunto tras realizar la
unión con el iterable.

41
 Diccionarios de Python
El tema de diccionarios de Python es, junto con el tema de listas, uno de los más
importantes del lenguaje.

Vamos a descubrir todo a detalle de la clase dict de Python para que pueda sacarles partido
a todas sus funcionalidades.

¿Qué es el tipo dict en Python?

La clase dict de Python es un tipo
mapa que asocia claves a valores. A
diferencia de los tipos secuenciales
(list, tuple, rango o str), que son
indexados por un índice numérico,
los diccionarios son indexados por
claves. Estas claves siempre deben
ser de tipo inmutable, concretamente un tipo hashable.

Piensa siempre en un diccionario como un contenedor de pares clave: valor, en el que la

clave puede ser de cualquier tipo hashable y es única en el diccionario que la contiene.

Las principales operaciones que se suelen realizar con los diccionarios son almacenar un
valor asociado a una clave y recuperar un valor a partir de una clave. Esta es la esencia de
los diccionarios y es aquí donde son realmente importantes. En un diccionario, el acceso a

42
un elemento a partir de una clave es una operación realmente rápida, eficaz y que consume
pocos recursos si lo comparamos con cómo lo haríamos con otros tipos de datos.

Propiedades de los diccionarios en Python

Alguna de las propiedades de los diccionarios en Python son las siguientes:

• Son dinámicos, pueden crecer o decrecer, se pueden añadir o eliminar elementos.

• Son indexados, los elementos del diccionario son accesibles a través del key.
• Son anidados, un diccionario puede contener a otro diccionario en su campo value.
• Son ordenados, preserva el orden en que se insertan los pares clave:valor.

Creando diccionarios en Python

En Python hay varias formas de crear un diccionario. Las veremos todas a continuación:

La más simple es encerrar una secuencia de pares clave:valor separados por comas entre
llaves {}

diccionario = {1: 'hola', 89:'Pythonista', 'a':'b', 'c': 27}

print(diccionario)
#{1: 'hola', 89: 'Pythonista', 'a': 'b', 'c': 27}

En el diccionario anterior, los enteros 1,89 y las cadenas ‘a’ y ‘c’ son las claves. Como ves, se
pueden mezclar claves y valores de distinto tipo sin problema.

Para crear un diccionario vacío, simplemente asigna a una variable el valor {}.

También se puede usar el constructor de la clase dict() de varias maneras:

• Sin parámetros. Esto creará un diccionario vacío

• Con pares clave: valor encerrados entre llaves

43
 • Con argumentos con nombre. El nombre del argumento será la clave en el
diccionario. En este caso, las claves solo pueden ser identificadores válidos y
mantienen el orden en el que se indican. No se podría, por ejemplo, tener números
enteros como claves.
• Pasando un iterable. En este caso, cada elemento de iterable debe ser también un
iterable con solo dos elementos. El primero se toma como clave del diccionario y el
segundo como valor. Si la clave aparece varias veces, el valor que prevalece es el
último.

Ejemplos

# 1. Pares clave: valor encerrados entre llaves

dict1 = {'uno': 1, 'dos': 2, 'tres': 3}
print(dict1) #{'uno': 1, 'dos': 2, 'tres': 3}

# 2. Argumentos con nombre

dict2 = dict(uno=1, dos=2, tres=3)
print(dict2) #{'uno': 1, 'dos': 2, 'tres': 3}

# 3. Pares clave: valor encerrados entre llaves

dict3 = dict({'uno':1, 'dos': 2, 'tres':3})
print(dict3) #{'uno': 1, 'dos': 2, 'tres': 3}

# 4. Iterable que contiene iterables con dos elementos

dict4 = dict([('uno', 1), ('dos', 2), ('tres', 3)])
print(dict4) #{'uno': 1, 'dos': 2, 'tres': 3}

44
# 5. Diccionario vacio
dict5 = {}
print(dict5) #{}

# 6. Diccionario vacio usando constructor

dict6 = dict()
print(dict6) # {}

Accediendo a elementos de un diccionario

Acceder a un elemento de un diccionario es una de las principales operaciones por las que
existe este tipo de dato. El acceso a un valor se realiza mediante la indexación de la clave.
Para ello, simplemente encierra entre corchetes la clave del elemento d[clave]. En caso de
que la clave no exista, se lanzará la excepción KeyError.

d = {'uno': 1, 'dos':2, 'tres':3}

print(d['dos']) # 2

La clase dist también ofrece el método get(clave[, valor por defecto]). Este método devuelve
el valor correspondiente a la clave clave. En caso de que la clave no exista no lanza ningún

45
error, sino que devuelve el segundo argumento valor por defecto. Si no se proporciona este
argumento, se devuelve el valor None.

d = {'uno': 1, 'dos': 2, 'tres': 3}

print(d.get('uno')) # 1

# Devuelve 4 como valor por defecto si no encuentra la clave

print(d.get('cuatro', 4)) #4

# Devuelve Nonve como valor por defecto si no encuentra la clave

a = d.get('cuatro')
print(a) # None
print(type(a)) # <class 'NoneType'>

Recorrer/Iterar un diccionario
Hay varias formas de recorrer los elementos de un diccionario: recorrer solo las claves, solo
los valores o recorrer a la vez las clave y los valores.

d = {'uno': 1, 'dos': 2, 'tres': 3}

for e in d:
print(e)
# uno
# dos
# tres

# Recorrer las claves del diccionario

for k in d.keys():

46
 print(k)
# uno
# dos
# tres

# Recorrer los valores del diccionario

for v in d.values():
print(v)
#1
#2
#3

#Recorrer los pares clave valor

for i in d.items():
print(i)
#('uno', 1)
#('dos', 2)
#('tres', 3)

Al igual que sucede en otros tipos de contenedores, se puede usar la función de Python len()
para obtener el número de elementos de un diccionario.

d = {'uno': 1, 'dos': 2, 'tres': 3, 'cuatro': 4, 'cinco': 5}

print(len(d)) # 5

47
Al operar con diccionarios, se puede usar el operador de pertenencia in para comprobar si
una clave está contenida, o no, en un diccionario. Esto resulta útil, por ejemplo, para
asegurarnos de que una clave existe antes de intentar eliminarla.

d = {'uno': 1, 'dos': 2, 'tres': 3, 'cuatro': 4, 'cinco': 5}

print('uno' in d) # True
print('seis' in d) # False

# Intenta eliminar una clave 1 si existe

if 1 in d:
del d[1]
print(d) # {'uno': 1, 'dos': 2, 'tres': 3, 'cuatro': 4, 'cinco': 5}

if 'uno' in d:
del d['uno']
print(d) # {'dos': 2, 'tres': 3, 'cuatro': 4, 'cinco': 5}

Agregar elementos a un diccionario

Como hemos mencionado, la clase dict es mutable, por lo que se pueden añadir, modificar
y/o eliminar elementos después de haber creado un objeto de este tipo.

Para añadir un nuevo elemento a un diccionario existente, se usa el operador de asignación

=. A la izquierda del operador aparece el objeto diccionario con la nueva clave entre
corchetes [] y a la derecha el valor que se asocia a dicha clave.

d = {'uno': 1, 'dos': 2, 'tres': 3}

print(d) #{'uno': 1, 'dos': 2, 'tres': 3}

48
# Añade un nuevo elemento
d['cuatro'] = 4
print(d) # {'uno': 1, 'dos': 2, 'tres': 3, 'cuatro': 4}

También existe el método setdefault(clave[, valor]). Este método devuelve el valor de la

clave si ya existe y, en caso contrario, le asigna el valor que se pasa como segundo
argumento. Si no se especifica este segundo argumento, por defecto es None.

d = {'uno': 1, 'dos': 2}
print(d.setdefault('uno', 1.0)) # 1
print(d.setdefault('tres',3)) # 3
print(d.setdefault('cuatro')) #None

Modificar elementos de un diccionario

Anteriormente hemos visto que, para actualizar el valor asociado a una clave, simplemente
se asigna a un nuevo valor a dicha clave del diccionario.

d = {'uno': 1, 'dos': 2}
print(d) # {'uno': 1, 'dos': 2}
d['uno'] = 1.0
print(d) # {'uno': 1.0, 'dos': 2}

49
Eliminar un elemento de un diccionario
En Python existen diversos modos de eliminar un elemento de un diccionario. Son los
siguientes:

• Pop(clave [, valor por defecto]): Si la clave está en el diccionario, elimina el elemento

y devuelve su valor; si no, devuelve el valor por defecto. Si no se proporciona el valor
por defecto y la clave no está en el diccionario, se lanza la excepción KeyError.
• Popitem(): Elimina el último par clave: valor del diccionario y lo devuelte. Si el
diccionario está vacío se lanza la excepción KeyError. (NOTA: En versiones anteriores
a Python 3.7, se elimina/devuelve un par aleatorio, no se garantiza que sea el
último).
• del d[clave]: Elimina el par clave: valor. Si no existe la clave, se lanza la excepción
KeyError.
• clear(): Borra todos los pares clave: valor del diccionario.

d = {'uno': 1, 'dos': 2, 'tres': 3, 'cuatro': 4, 'cinco': 5}

# Elimina un elemento con pop()
print(d.pop('uno'))
#1
print(d)
# {'dos': 2, 'tres': 3, 'cuatro': 4, 'cinco': 5}

50
# Elimina un elemento con popitem()
print(d.popitem())
# ('cinco', 5)
print(d)
# {'dos': 2, 'tres': 3, 'cuatro': 4}

# Elimina un elemento con del

del d['tres']
print(d)
# {'dos': 2, 'cuatro': 4}

# Borra todos los elementos del diccionario

d.clear()
print(d)
# {}

51
Comparar diccionarios
En Python se pueden utilizar el operador de igualdad == para comparar si dos diccionarios
son iguales. Dos diccionarios son iguales si contiene el mismo conjunto de pares clave: valor,
independientemente del orden que tengan.

Otro tipo de comparaciones entre diccionarios no están permitidas. Si se intenta, el

intérprete lanzará el error TypeError.

d1 = {'uno': 1, 'dos': 2}
d2 = {'dos': 2, 'uno': 1}
d3 = {'uno': 1}
print(d1 == d2)
# True
print(d1 == d3)
# False

Diccionarios anidados
Un diccionario puede contener un valor de cualquier tipo, entre ellos, otro diccionario. Este
hecho se conoce como diccionarios anidados.

52
Para acceder al valor de una de las claves de un diccionario interno, se usa el operador de
indexación anidada [clave1][clave2]…

Veámoslo con un ejemplo:

d = {'d1': {'k1': 1, 'k2': 2}, 'd2': {'k1': 3, 'k4': 4}}

print(d['d1']['k1'])
#1
print(d['d2']['k1'])
#3
print(d['d2']['k4'])
#4

Obtener una lista con las claves de un diccionario

En ocasiones, es necesario tener almacenado en una lista las claves de un diccionario. Para
ello, simplemente pasa el diccionario como argumento del constructor list(). Esto devolverá
las claves del diccionario en una lista.

d = {'uno': 1, 'dos': 2, 'tres': 3}

print(list(d)) # ['uno', 'dos', 'tres']

53
Listado de métodos de la clase dict
Para finalizar con el tema de diccionarios, vamos a presentar la lista de los métodos que
implementa la clase dict, algunos de ellos los vimos en detalle en los temas anteriores:

Método Descripción
clear() Elimina todos los elementos del diccionario.
copy() Devuelve una copia poco profunda del diccionario.
get(clave[, valor]) Devuelve el valor de la clave. Si no existe, devuelve el
valor valor si se indica y si no, None.
items() Devuelve una vista de los pares clave: valor del diccionario.

keys() Devuelve una vista de las claves del diccionario.

pop(clave[, valor]) Devuelve el valor del elemento cuya clave es clave y elimina
el elemento del diccionario. Si la clave no se encuentra,
devuelve valor si se proporciona. Si la clave no se encuentra
y no se indica valor, lanza la excepción KeyError.
popitem() Devuelve un par (clave, valor) aleatorio del diccionario. Si el
diccionario está vacío, lanza la excepción KeyError.
setdefault(clave[, Si la clave está en el diccionario, devuelve su valor. Si no lo
valor]) está, inserta la clave con el valor valor y lo devuelve (si no se
especifica valor, por defecto es None).
update(iterable) Actualiza el diccionario con los pares clave:
valor del iterable.
values() Devuelve una vista de los valores del diccionario.

54
 Matrices
Las matrices surgen en matemáticas cuando deseamos manejar datos que se pueden
almacenar en forma de vectores pero que además requieren el uso de varios vectores para
manejar información.

¿Qué es una matriz en Python?

Los datos dentro de la matriz tienen un aspecto similar al siguiente:

En el caso de la primera matriz, se muestra una matriz de dimensiones 2x2, donde se

observan 2 filas y 2 columnas. Los datos de esa matriz están representados en forma de
números, donde se observan en las filas uno los valores 2 y 3 y en la fila dos los valores 4 y
5. Si hacemos la lectura por columna, para la columna uno los valores son 2 y 4 y para la
columna dos son 3 y 5.

La matriz de la derecha es ligeramente diferente, es una matriz con dimensión de 2x3, dos
filas y tres columnas. La lectura se puede hacer por filas, para la fila uno (2,3,4) para la fila
dos (5,6,7); o por columnas: columna uno (2,5), columna dos (3,6) y columna tres (4,7).

Las matrices no son una estructura propia de Python. Simplemente, una matriz es una lista
de listas que nosotros interpretamos desde el punto de vista matemático. Es decir la
estructura m = [[1,2],[3,4]] nosotros la interpretamos como la matriz 2x2 cuya primera fila

55
es (1,2) y cuya segunda fila es (3,4), pero esto no deja de ser nada más que una
interpretación.

La dimensión de una matriz es el número de filas x número de columnas. Se dice que la

matriz es de dimensión n x m.

Crear una matriz

Una matriz como:

Se representa como

# Creacion de una matriz 3x3

A = [[1, -2.3, 0], [9.6, -1.5, 4], [5.7, -6.3, 3.1]]

Recorrer/Iterar una matriz

Al igual que las listas, haremos uso del ciclo for para poder recorrer los elementos de una
matriz, con la diferencia y complejidad que debemos de anidar el for dentro de otro ciclo,
de la siguiente manera:

# Creacion de una matriz 3x3

A = [[1, -2.3, 0], [9.6, -1.5, 4], [5.7, -6.3, 3.1]]

56
# Iterar con la matriz
for i in range(len(A)): # Indice de los reglones es i
print(),
for j in range(len(A[i])): # Indice de las columnas j
print(A[i][j], end = '\t' )

#RESULTADO
#1 -2.3 0
#9.6 -1.5 4
#5.7 -6.3 3.1

Acceder y modificar elementos

Para acceder a los elementos de una matriz (entiéndase fila, columna o un elemento
individual) lo podemos hacer de la siguiente manera

# Acceder a un elemento especifico

print(A[1]) #Obtiene la fila con indice 1
print(A[1][1]) #Obtiene el elemento 1,1

#Para obtener la columna

x = 1 #columna que queremos obtener
columna = [fila[x] for fila in A]
print(columna)

57
Para modificar un elemento en una matriz, debemos de asignar al elemento el nuevo valor
de la siguiente manera:

# Modificando un elemento en la matriz

A[1][1] = 3
# Iterar con la matriz
for i in range(len(A)): # Indice de los reglones es i
print(),
for j in range(len(A[i])): # Indice de las columnas j
print(A[i][j], end = '\t' )
print()
# RESULTADO
#1 -2.3 0
# 9.6 3 4
# 5.7 -6.3 3.1

58
 Funciones
Las funciones en Python, como en cualquier otro lenguaje de programación, son estructuras
esenciales de código. Una función es un grupo de instrucciones que constituyen una unidad
lógica del programa y resuelven un problema en concreto.

Que son las funciones en Python

Como habíamos mencionado, las funciones en Python constituyen unidades lógicas de un
programa y tiene dos objetivos:

• Dividir y organizar el código en partes más sencillas.

• Encapsular el código que se repite a lo largo de un programa para ser reutilizado.

Python ya define una serie de conjuntos de funciones que podemos utilizar directamente
en nuestras aplicaciones. Algunas de ellas las hemos visto en lo largo de este curso. Por
ejemplo, la función len(), que obtiene el número de elementos de un objeto contenedor
como una lista, una tupla, un diccionario o un conjunto. También hemos utilizado la función
print(), que muestra por consola un texto.

Sin embargo, como programadores podemos definir nuestras propias funciones para
estructurar nuestro código de manera más legible y para reutilizar aquellas partes que se

59
repiten a lo largo de una aplicación. Esto es una tarea fundamental a medida que va
creciendo el número de líneas en un programa.

La idea la podemos ver en la siguiente imagen:

En principio, un programa es una secuencia ordenada de instrucciones que se ejecutan una

a continuación de otra. Sin embargo, cuando se utilizan funciones, puedes agrupar parte de
esas instrucciones como una unidad más pequeña que ejecuta dichas instrucciones y suele
devolver un resultado.

Definir funciones en Python

Cualquier función tendrá un nombre, unos argumentos de entrada (opcional), un código a
ejecutar y unos parámetros de salida. Al igual que las funciones matemáticas, en
programación nos permiten realizar diferentes operaciones con la entrada, para entregar
una determinada salida que dependerá del código que escribamos dentro.

60
La siguiente imagen muestra el esquema de una función en Python:

Para definir una función en Python se utiliza la palabra reservada def. A continuación, viene
el nombre o identificador de la función que es el que se utiliza para invocarla. Después del
nombre hay que incluir los paréntesis y una lista opcional de parámetros. Por último, la
cabecera o definición de la función termina con dos puntos.

Tras los dos puntos se incluye el cuerpo de la función (con un tabulado generalmente de 4
espacios) que no es más que el conjunto de instrucciones que se encapsulan en dicha
función y que le dan significado.

En último lugar y de manera opcional, se añade la instrucción con la palabra reservada

return para devolver un resultado.

61
Empecemos por la función más sencillas de todas. Una función sin parámetros de entrada
ni parámetros de salida

def di_hola():
print("Hola mundo!")

Cómo utilizar una función

Para usar o invocar a una función, simplemente hay que escribir su nombre como si de una
instrucción más se tratara. Eso sí, pasando los argumentos necesarios según los parámetros
que defina la función.

Hemos declarado o definido la función. El siguiente paso es utilizarla, para ellos solamente
basta con escribir di_hola().

# Para llamar la funcion

di_hola() # Hola mundo!

Vamos a ponerle un poco de complejidad a la función pasando un argumento de entrada.

Ahora si pasamos como entrada un nombre, se imprimirá Hola y el nombre.

def di_hola(nombre):

print("Hola ", nombre)

di_hola("Pepe") # Hola Pepe

62
Python permite pasar argumentos también de otra forma formas, las cuales se listan a
continuación:

• Argumento por posición: estas son las formas más básicas e intuitivas de pasar
parámetros. Si tenemos una función resta() que acepta dos parámetros, se puede
llamar como se muestra a continuación.

def resta(a, b):

return print(a-b)

resta(5,3) # 2

Al tratarse de parámetros posicionales, se interpretará que el primer número es el

a y el segundo la b. El número de parámetros es fijo, por lo que, si intentamos llamar
la función con un solo parámetro, dará error.
• Argumento por nombre: Otra forma de llamar una función, es usando el nombre del
argumento con = y su valor. El siguiente código hace lo mismo que el código anterior,
con la diferencia de que los argumentos no son posicionales.

def resta(a, b):

return print(a-b)

resta(a=5, b=3) # 2

Al indicar en la llamada de la función el orden de la variable y el valor, el orden en el

que los pongamos ya no es importante por lo que podríamos llamarlo así resta(b=3,
a=5).
• Argumentos por defecto: Tal vez queramos tener una función con algún parámetro
opcional, que pueda ser usado o no dependiendo de diferentes circunstancias. Para

63
 ello lo que podemos hacer es asignar un valor por defecto a la función. En el
siguiente caso c valdría cero salvo que se indique lo contrario.

def suma(a, b, c=0):

return print(a+b+c)

suma(5,5,3) # 13

suma(4,3) # 7

• Argumentos de longitud variable: Si declaramos un argumento con * antes de su

nombre, hará que el argumento que se pase sea empaquetado en una tupla de
manera automática. No confundir * con los punteros en otros lenguajes de
programación.

def suma(*numeros):
print(type(numeros))
# <class 'tuple'>
total = 0
for n in numeros:
total += n
return total
print(suma(1,3,5,4)) # 13

Sentencia return
Anteriormente vimos que cuando acaba la última instrucción de una función, el flujo del
programa continúa por la instrucción que sigue a la llamada de dicha función. Hay una

64
excepción: usa la sentencia return. return hace que termine la ejecución de la función
cuando aparece y el programa continúa su flujo normal.

Además, return se puede utilizar para devolver un valor.

La sentencia return es opcional, puede devolver, o no, un valor y esposible que aparezca
más de una vez dentro de una misma función.

En resumen, el uso de la sentencia return permite realizar dos cosas:

• Salir de la función y transferir la ejecución de vuelta a donde se realizó la llamada.

• Devolver uno o varios parámetros, fruto de la ejecución de la función.

Python, a diferencia de otros lenguajes de programación, no tiene procedimientos. Un

procedimiento sería como una función pero que no devuelve ningún valor.

¿Por qué no tiene procedimientos si hemos vistos ejemplos de funciones que no retornan
ningún valor? Porque Python, internamente, devuelve por defecto el valor None cuando en
una función no aparece la sentencia return o esta no devuelve nada.

def saludo(nombre):
print(f'Hola {nombre}')

print(saludo('j2logo'))
#Hola j2logo
#None

Como puedes ver en el ejemplo anterior, el print que envuelve a la función saludo() muestra
None.

65
return que no devuelve ningún valor
La siguiente función muestra por pantalla el cuadrado de un número solo si este es par:

def cuadrado_de_par(numero):
if not numero % 2 == 0:
return
else:
print(numero ** 2)

cuadrado_de_par(8)
#64
cuadrado_de_par(3)

Varios return en una misma función

La función es_par() devuelve TRUE si un número es par y FALSE en caso contrario:

def es_par(numero):
if numero % 2 == 0:
return True
else:
return False

print(es_par(2))
#True
print(es_par(5))
#False

66
Sin embargo, se puede usar otra técnica devolviendo los diferentes resultados/valores en
una lista. Por ejemplo, la función tabla_del() que se muestra a continuación hace esto:

def tabla_del(numero):
resultados = []
for i in range(11):
resultados.append(numero * i)
return resultados

res = tabla_del(3)
print(res)
#[0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]

Paso por referencia

En muchos lenguajes de programación existen los conceptos de paso por valor y por
referencia que aplican a la hora de cómo trata una función a los parámetros que se le pasan
como entrada. Su comportamiento es el siguiente:

• Si usamos un parámetro pasado por valor, se creará una copia local de la variable,
lo que implica que cualquier modificación sobre la misma no tendrá efecto sobre la
original.
• Con una variable pasada como referencia, se actuará directamente sobre la variable
pasada, por lo que las modificaciones afectarán a la variable original.

En Python las cosas son un poco distintas, y el comportamiento estará definido por el tipo
de variable con la que estamos tratando. Veamos un ejemplo de paso por valor.

67
x = 10
def funcion(entrada):
entrada = 0
funcion(x)

print(x) # 10
Iniciamos la x a 10 y se la pasamos a funcion(). Dentro de la función hacemos que la variable
valga 0. Dado que Python trata a los int como pasados por valor, dentro de la función se
crea una copia local de x, por lo que la variable original no es modificada.

No pasa lo mismo si por ejemplo x es una lista como en el siguiente ejemplo. En este caso
Python lo trata como si estuviese pasada por referencia, lo que hace que se modifique la
variable original. La variable original x ha sido modificada.

x = [10, 20, 30]

def funcion(entrada):
entrada.append(40)

funcion(x)
print(x) # [10, 20, 30, 40]

Documentación
Ahora que ya tenemos nuestras propias funciones creadas, es importante pensar en
generar la documentación necesaria en caso de necesitar posteriormente recordar qué
hace o para compartirla con alguno de nuestros colegas. Las funciones pueden ser muy
complejas y leer código ajeno o incluso el propio, mucho tiempo después, puede no ser

68
tarea fácil. Por esto es la importancia de DOCUMENTAR las funciones. Es decir: añadir
indicaciones como comentarios que nos digan cómo son utilizadas y qué hacen.

def mi_funcion_suma(a, b):

"""
Descripción de la función. Como debe ser usada,
que parámetros acepta y que devuelve
"""
return a+b

Para ello debemos usar la triple comilla """ al principio de la función. Se trata de una especie
de comentario que podemos usar para indicar como la función debe ser usada. No se trata
de código, es un simple comentario un tanto especial, conocido como docstring.

Ahora cualquier persona que tenga nuestra función, podrá llamar a la función help() y
obtener la ayuda de cómo debe ser usada.

help(mi_funcion_suma)

69