Python 2025: Tutorial Completo

11 de febrero del 2021

1. Resumen

Vamos a hacer una breve introducción a Python, explicando los tipos de datos que tenemos, los operadores, el uso de funciones y de clases. Además, veremos cómo usar los objetos iterables, cómo usar módulos, etc.

2. Tipos de datos de Python

Existen 7 tipos de datos en Python

De tipo texto: str
Numéricos: int, float, complex
Secuencias: list, tuple, range
Mapping: dict
Sets: set, frozenset
Booleanos: bool
Binarios: bytes, bytearray, memoryview

Podemos obtener el tipo de dato mediante la función type()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		type(5.)
	
	Copied

>_ Output

			
				float

Python es un lenguaje de tipado dinámico, es decir, puedes tener una variable de un tipo y luego asignarle otro tipo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 5
type(a)
	
	Copied

>_ Output

int

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 'MaximoFN'
type(a)
	
	Copied

>_ Output

str

Python tipa las variables por ti, pero si las quieres tipear tú se puede hacer

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		b = int(5.1)
type(b), b
	
	Copied

>_ Output

			
				(int, 5)

Aunque b se ha inicializado como 5.1, es decir, debería ser de tipo float, al tiparlo nosotros a tipo int, vemos que es de tipo int y además su valor es 5

2.1. Strings

Los strings son cadenas de caracteres, estas se pueden definir con doble comilla " o comilla simple '

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = "MaximoFN"
string
	
	Copied

>_ Output

			
				'MaximoFN'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
string
	
	Copied

>_ Output

			
				'MaximoFN'

Para escribir un string muy largo y no tener una fila que ocupe mucho espacio, se puede introducir en varias líneas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = """Este es un ejemplo de
como estoy introduciendo un string
en varias lineas"""
string
	
	Copied

>_ Output

			
				'Este es un ejemplo de
como estoy introduciendo un string
en varias lineas'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = '''Este es un ejemplo de
como estoy introduciendo un string
en varias lineas'''
string
	
	Copied

>_ Output

			
				'Este es un ejemplo de
como estoy introduciendo un string
en varias lineas'

Sin embargo, vemos que en medio ha metido el carácter del salto de línea. Si usamos la función print() veremos cómo ya no aparece

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string)
	
	Copied

>_ Output

			
				Este es un ejemplo de
como estoy introduciendo un string
en varias lineas

Como hemos dicho, los strings son cadenas de caracteres, por lo que podemos navegar e iterar a través de ellos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(10):
  # Se indica a la función print que cuando imprima no termine con un salto de 
  # linea para escribir todo en la misma linea
  print(string[i], end='')
	
	Copied

>_ Output

			
				Este es un

Podemos obtener la longitud de nuestro string mediante la función len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(string)
	
	Copied

>_ Output

Chequear si hay algún string determinado dentro del nuestro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'ejemplo' in string
	
	Copied

>_ Output

			
				True

Los strings tienen ciertos atributos útiles, como poner todo en mayúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.upper())
	
	Copied

>_ Output

			
				ESTE ES UN EJEMPLO DE
COMO ESTOY INTRODUCIENDO UN STRING
EN VARIAS LINEAS

Todo en minúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.lower())
	
	Copied

>_ Output

			
				este es un ejemplo de
como estoy introduciendo un string
en varias lineas

Reemplazar caracteres

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.replace('o', '@'))
	
	Copied

>_ Output

			
				Este es un ejempl@ de
c@m@ est@y intr@duciend@ un string
en varias lineas

Obtener todas las palabras

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(string.split())
	
	Copied

>_ Output

			
				['Este', 'es', 'un', 'ejemplo', 'de', 'como', 'estoy', 'introduciendo', 'un', 'string', 'en', 'varias', 'lineas']

Puedes ver todos los métodos de los strings en este enlace

Otra cosa útil que se puede hacer con los strings es concatenarlos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string1 = 'Maximo'
string2 = 'FN'
string1 + string2
	
	Copied

>_ Output

			
				'MaximoFN'

Antes explicamos que el carácter \n correspondía a un salto de línea, este carácter especial corresponde a una serie de caracteres especiales llamados Escape Characters. Veamos otros

Si declaramos un string con doble comilla y queremos añadir una doble comilla dentro del string usamos el escape character \"

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print("Este es el blog de "MaximoFN"")
	
	Copied

>_ Output

			
				Este es el blog de "MaximoFN"

Lo mismo con la comilla simple, añadimos \'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de 'MaximoFN'')
	
	Copied

>_ Output

			
				Este es el blog de 'MaximoFN'

Ahora tenemos el problema de si queremos añadir el carácter \ ya que como hemos visto es un escape character, así que lo solucionamos poniendo doble barra (backslash) \

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \\MaximoFN\\')
	
	Copied

>_ Output

			
				Este es el blog de \MaximoFN\

Ya vimos antes el escape character de nueva línea \n

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \nMaximoFN')
	
	Copied

>_ Output

			
				Este es el blog de
MaximoFN

Si queremos escribir desde el inicio de línea añadimos \r

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Esto no se imprimirá \rEste es el blog de MaximoFN')
	
	Copied

>_ Output

			
				Este es el blog de MaximoFN

Si queremos añadir un espacio grande (sangría) usamos \t

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \tMaximoFN')
	
	Copied

>_ Output

			
				Este es el blog de 	MaximoFN

Podemos borrar un carácter con \b

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('Este es el blog de \bMaximoFN')
	
	Copied

>_ Output

			
				Este es el blog deMaximoFN

Podemos añadir el código ASCII en octal mediante \ooo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('\115\141\170\151\155\157\106\116')
	
	Copied

>_ Output

			
				MaximoFN

O añadir el código ASCII en hexadecimal mediante \xhh

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('\x4d\x61\x78\x69\x6d\x6f\x46\x4e')
	
	Copied

>_ Output

			
				MaximoFN

Por último, podemos convertir otro tipo de dato en un string

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5
print(type (n))
string = str(n)
print(type(string))
	
	Copied

>_ Output

			
				&lt;class 'int'&gt;
&lt;class 'str'&gt;

2.2. Números

2.2.1. Enteros

Números de tipo entero

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5
n, type(n)
	
	Copied

>_ Output

			
				(5, int)

2.2.2. Float

Números de tipo coma flotante

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5.1
n, type(n)
	
	Copied

>_ Output

			
				(5.1, float)

2.2.3. Complejos

Números complejos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 3 + 5j
n, type(n)
	
	Copied

>_ Output

			
				((3+5j), complex)

2.2.4. Conversión

Se puede convertir entre tipos de números

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5
n = float(n)
n, type(n)
	
	Copied

>_ Output

			
				(5.0, float)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5.1
n = complex(n)
n, type(n)
	
	Copied

>_ Output

			
				((5.1+0j), complex)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		n = 5.1
n = int(n)
n, type(n)
	
	Copied

>_ Output

			
				(5, int)

No se puede convertir un número complex a tipo int o tipo float

2.3. Secuencias

2.3.1. Listas

Las listas guardan múltiples ítems en una variable. Se declaran mediante los símbolos [], con los ítems separados por comas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ['item0', 'item1', 'item2', 'item3', 'item4', 'item5']
lista
	
	Copied

>_ Output

			
				['item0', 'item1', 'item2', 'item3', 'item4', 'item5']

Podemos obtener la longitud de una lista mediante la función len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(lista)
	
	Copied

>_ Output

Las listas pueden tener ítems de distintos tipos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ['item0', 1, True, 5.3, "item4", 5, 6.6]
lista
	
	Copied

>_ Output

			
				['item0', 1, True, 5.3, 'item4', 5, 6.6]

En Python se empieza a contar desde la posición 0, es decir, si queremos obtener el primer elemento de la lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[0]
	
	Copied

>_ Output

			
				'item0'

Pero una de las cosas potentes de Python es que si queremos acceder a la última posición podemos usar índices negativos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[-1]
	
	Copied

>_ Output

6.6

Si en vez de la última posición de la lista queremos la penúltima

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[-2]
	
	Copied

>_ Output

Si solo queremos un rango de valores, por ejemplo, del segundo al quinto ítem accedemos mediante [2:5]

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[2:5]
	
	Copied

>_ Output

			
				[True, 5.3, 'item4']

Si se omite el primer número del rango significa que queremos desde el primer ítem de la lista hasta el ítem indicado, es decir, si queremos desde el primer ítem hasta el quinto usamos [:5]

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[:5]
	
	Copied

>_ Output

			
				['item0', 1, True, 5.3, 'item4']

Si se omite el último número del rango, significa que queremos desde el ítem indicado hasta el último. Es decir, si queremos desde el tercer ítem hasta el último, usamos [3:]

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[3:]
	
	Copied

>_ Output

			
				[5.3, 'item4', 5, 6.6]

Podemos escoger el rango de ítems también con números negativos, es decir, si queremos desde el antepenúltimo hasta el penúltimo usamos [-3:-1]. Esto es útil cuando se tiene listas que no se sabe su longitud, pero se sabe que se quiere un rango de valores del final, porque por ejemplo, la lista se ha creado con medidas que se van tomando y se quiere saber las últimas medias

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[-3:-1]
	
	Copied

>_ Output

			
				['item4', 5]

Se puede comprobar si un ítem está en la lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'item4' in lista
	
	Copied

>_ Output

			
				True

2.3.1.1. Editar listas

Las listas en Python son dinámicas, es decir, se pueden modificar. Por ejemplo se puede modificar el tercer ítem

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[2] = False
lista
	
	Copied

>_ Output

			
				['item0', 1, False, 5.3, 'item4', 5, 6.6]

También se puede modificar un rango de valores

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista[1:4] = [1.1, True, 3]
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6]

Se pueden agregar valores al final de la lista mediante el método append()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.append('item7')
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6, 'item7']

O podemos insertar un valor en una posición determinada mediante el método insert()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.insert(2, 'insert')
lista
	
	Copied

>_ Output

			
				['item0', 1.1, 'insert', True, 3, 'item4', 5, 6.6, 'item7']

Se pueden unir listas mediante el método extend()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista2 = ['item8', 'item9']
lista.extend(lista2)
lista
	
	Copied

>_ Output

			
				['item0', 1.1, 'insert', True, 3, 'item4', 5, 6.6, 'item7', 'item8', 'item9']

No es necesario extender la lista mediante otra lista, se puede hacer mediante otro tipo de dato iterable de Python (tuplas, sets, diccionarios, etc)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item10', 'item11')
lista.extend(tupla)
lista
	
	Copied

>_ Output

			
				['item0',
1.1,
'insert',
True,
3,
'item4',
5,
6.6,
'item7',
'item8',
'item9',
'item10',
'item11']

Podemos eliminar una posición determinada mediante el método pop()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.pop(2)
lista
	
	Copied

>_ Output

			
				['item0',
1.1,
True,
3,
'item4',
5,
6.6,
'item7',
'item8',
'item9',
'item10',
'item11']

Si no se especifica el índice, se elimina el último ítem

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.pop()
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6, 'item7', 'item8', 'item9', 'item10']

O se puede eliminar un item sabiendo su valor mediante el método remove()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.remove('item7')
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 3, 'item4', 5, 6.6, 'item8', 'item9', 'item10']

Con la función del() se puede eliminar también un ítem de la posición indicada

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del lista[3]
lista
	
	Copied

>_ Output

			
				['item0', 1.1, True, 'item4', 5, 6.6, 'item8', 'item9', 'item10']

Si no se indica el índice se elimina la lista completa

Con el método clear() dejo la lista vacía

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista.clear()
lista
	
	Copied

>_ Output

[]

Se puede obtener la cantidad de ítems con un valor determinado mediante el método count()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 4, 6, 5, 7, 8, 5, 3, 1, 5]
lista.count(5)
	
	Copied

>_ Output

También se puede obtener el primer índice de un ítem con un valor determinado mediante el método index()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 4, 6, 5, 7, 8, 5, 3, 1, 5]
lista.index(5)
	
	Copied

>_ Output

2.3.1.2. List comprehension

Podemos operar a través de la lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []
 
# Iteramos por todos los items de la lista
for x in fruits:
  # Si el item contiene el caracter "a" lo añadimos a newlist
  if "a" in x:
    newlist.append(x)
 
newlist
	
	Copied

>_ Output

			
				['apple', 'banana', 'mango']

Otras de las cosas potentes de Python son las list comprehensions, que permiten hacer todo en una sola línea y que el código quede más compacto

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
 
newlist = [x for x in fruits if "a" in x]
 
newlist
	
	Copied

>_ Output

			
				['apple', 'banana', 'mango']

La sintaxis es la siguiente:

newlist = [expression for item in iterable if condition == True]

Se puede aprovechar para realizar operaciones en la lista original

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		newlist = [x.upper() for x in fruits if "a" in x]
newlist
	
	Copied

>_ Output

			
				['APPLE', 'BANANA', 'MANGO']

2.3.1.3. Ordenar listas

Para ordenar listas usamos el método sort()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.sort()
lista
	
	Copied

>_ Output

			
				[3, 4, 5, 5, 6, 8, 9]

También nos las ordena alfabéticamente

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["orange", "mango", "kiwi", "pineapple", "banana"]
lista.sort()
lista
	
	Copied

>_ Output

			
				['banana', 'kiwi', 'mango', 'orange', 'pineapple']

A la hora de ordenar alfabéticamente, distingue entre mayúsculas y minúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["orange", "mango", "kiwi", "Pineapple", "banana"]
lista.sort()
lista
	
	Copied

>_ Output

			
				['Pineapple', 'banana', 'kiwi', 'mango', 'orange']

Se pueden ordenar en orden descendente mediante el atributo reverse = True

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.sort(reverse = True)
lista
	
	Copied

>_ Output

			
				[9, 8, 6, 5, 5, 4, 3]

Se pueden ordenar de la manera que queramos mediante el atributo key

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def myfunc(n):
  # devuelve el valor absoluto de n - 50
  return abs(n - 50)
 
lista = [100, 50, 65, 82, 23]
lista.sort(key = myfunc)
lista
	
	Copied

>_ Output

			
				[50, 65, 23, 82, 100]

Se puede aprovechar esto para que, por ejemplo, a la hora de ordenar no distinga entre mayúsculas y minúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["orange", "mango", "kiwi", "Pineapple", "banana"]
lista.sort(key = str.lower)
lista
	
	Copied

>_ Output

			
				['banana', 'kiwi', 'mango', 'orange', 'Pineapple']

Se puede invertir la lista mediante el método reverse

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [5, 8, 3, 4, 9, 5, 6]
lista.reverse()
lista
	
	Copied

>_ Output

			
				[6, 5, 9, 4, 3, 8, 5]

2.3.1.4. Copiar listas

No se pueden copiar listas mediante lista1 = lista2, ya que si se modifica lista1 también se modifica lista2

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = lista1
lista1[0] = True
lista2
	
	Copied

>_ Output

			
				[True, 8, 3, 4, 9, 5, 6]

Por lo que hay que usar el método copy()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = lista1.copy()
lista1[0] = True
lista2
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6]

Ó hay que usar el constructor de listas list()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = list(lista1)
lista1[0] = True
lista2
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6]

2.3.1.5. Concatenar listas

Se pueden concatenar listas mediante el operador +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = ['a', 'b', 'c']
lista = lista1 + lista2
lista
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6, 'a', 'b', 'c']

O mediante el método extend

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = [5, 8, 3, 4, 9, 5, 6]
lista2 = ['a', 'b', 'c']
lista1.extend(lista2)
lista1
	
	Copied

>_ Output

			
				[5, 8, 3, 4, 9, 5, 6, 'a', 'b', 'c']

Otra forma de concatenar es repetir la tupla X veces mediante el operador *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista1 = ['a', 'b', 'c']
lista2 = lista1 * 3
lista2
	
	Copied

>_ Output

			
				['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

2.3.2. Tuplas

Las tuplas son similares a las listas, guardan múltiples ítems en una variable, pueden contener ítems de distintos tipos, pero no se pueden modificar ni reordenar. Se definen mediante (), con los ítems separados por comas

Al no poderse modificar, hace que las tuplas se ejecuten un poco más rápido que las listas, por lo que si no necesitas modificar los datos, es mejor utilizar tuplas en vez de listas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0', 1, True, 3.3, 'item4', True)
tupla
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'item4', True)

Se puede obtener su longitud mediante la función len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len (tupla)
	
	Copied

>_ Output

Para crear tuplas con un único elemento es necesario añadir una coma

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0',)
tupla, type(tupla)
	
	Copied

>_ Output

			
				(('item0',), tuple)

Para acceder a un elemento de la tupla se procede igual que con las listas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0', 1, True, 3.3, 'item4', True)
print(tupla[0])
print(tupla[-1])
print(tupla[2:4])
print(tupla[-4:-2])
	
	Copied

>_ Output

			
				item0
True
(True, 3.3)
(True, 3.3)

Podemos comprobar si hay un item en la tupla

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'item4' in tupla
	
	Copied

>_ Output

			
				True

2.3.2.1. Modificar tuplas

Aunque las tuplas no son modificables, se pueden modificar convirtiéndolas a listas, modificando la lista y después volver a convertirla en una tupla

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = list(tupla)
lista[4] = 'ITEM4'
tupla = tuple(lista)
tupla
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'ITEM4', True)

Al convertirla a lista, podemos hacer todas las modificaciones vistas en las listas

Lo que sí se puede es eliminar la tupla completa

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del tupla
 
if 'tupla' not in locals():
  print("tupla eliminada")
	
	Copied

>_ Output

			
				tupla eliminada

2.3.2.2. Desempaquetar tuplas

Cuando creamos tuplas, en realidad estamos empaquetando datos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('item0', 1, True, 3.3, 'item4', True)
tupla
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'item4', True)

pero podemos desempaquetarlos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		item0, item1, item2, item3, item4, item5 = tupla
item0, item1, item2, item3, item4, item5
	
	Copied

>_ Output

			
				('item0', 1, True, 3.3, 'item4', True)

Si queremos sacar menos datos que la longitud de la tupla añadimos un *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		item0, item1, item2, *item3 = tupla
item0, item1, item2, item3
	
	Copied

>_ Output

			
				('item0', 1, True, [3.3, 'item4', True])

Se puede poner el asterisco * en otra parte si por ejemplo lo que queremos es el último ítem

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		item0, item1, *item2, item5 = tupla
item0, item1, item2, item5
	
	Copied

>_ Output

			
				('item0', 1, [True, 3.3, 'item4'], True)

2.3.2.3. Concatenar tuplas

Se pueden concatenar tuplas mediante el operador +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla1 = ("a", "b" , "c")
tupla2 = (1, 2, 3)
 
tupla3 = tupla1 + tupla2
tupla3
	
	Copied

>_ Output

			
				('a', 'b', 'c', 1, 2, 3)

Otra forma de concatenar es repetir la tupla X veces mediante el operador *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla1 = ("a", "b" , "c")
 
tupla2 = tupla1 * 3
tupla2
	
	Copied

>_ Output

			
				('a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c')

2.3.2.4. Métodos de las tuplas

Las tuplas tienen dos métodos, el primero es el método count() que devuelve el número de veces que aparece un ítem dentro de la tupla

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (5, 4, 6, 5, 7, 8, 5, 3, 1, 5)
tupla.count(5)
	
	Copied

>_ Output

Otro método es index() que devuelve la primera posición de un ítem dentro de la tupla

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (5, 4, 6, 5, 7, 8, 5, 3, 1, 5)
tupla.index(5)
	
	Copied

>_ Output

2.3.3. Range

Con range() podemos crear una secuencia de números, comenzando desde 0 (de forma predeterminada), se incrementa en 1 (de forma predeterminada) y se detiene antes de un número especificado

range(start, stop, step)

Por ejemplo, si queremos una secuencia de 0 a 5 (sin incluir el 5)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(5):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				0 1 2 3 4

Si por ejemplo no queremos que empiece en 0

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(2, 5):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				2 3 4

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(-2, 5):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				-2 -1 0 1 2 3 4

Por último, si no queremos que se incremente en 1, si por ejemplo queremos una secuencia de números pares.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in range(0, 10, 2):
  print(f'{i} ', end='')
	
	Copied

>_ Output

			
				0 2 4 6 8

2.4. Diccionarios

Los diccionarios se usan para guardar datos en pares key:value. Son modificables, no ordenados y no permiten duplicidades. Se definen mediante los símbolos {}. Admiten ítems de distintos tipos de datos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "colors": ["red", "white", "blue"]
}
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford',
'model': 'Mustang',
'year': 1964,
'colors': ['red', 'white', 'blue']}

Como se ha dicho no permiten duplicidades

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "year": 2000,
  "colors": ["red", "white", "blue"]
}
diccionario["year"]
	
	Copied

>_ Output

Se puede obtener su longitud mediante la función len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(diccionario)
	
	Copied

>_ Output

Como se puede ver la longitud es 4 y no 5, ya que year lo cuenta solo una vez

2.4.1. Acceder a los items

Para acceder a un elemento lo podemos hacer a través de su key

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario["model"]
	
	Copied

>_ Output

			
				'Mustang'

También se puede acceder mediante el método get

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.get("model")
	
	Copied

>_ Output

			
				'Mustang'

Para saber todas las keys de los diccionarios se puede usar el método keys()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.keys()
	
	Copied

>_ Output

			
				dict_keys(['brand', 'model', 'year', 'colors'])

Se puede usar una variable para apuntar a las keys del diccionario, con lo que llamándola una vez es necesario

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se declara una vez la variable que apunta a las keys
x = diccionario.keys()
print(x)
 
# Se añade una nueva key
diccionario["color"] = "white"
 
# Se consulta la variable que apunta a las key
print(x)
	
	Copied

>_ Output

			
				dict_keys(['brand', 'model', 'year'])
dict_keys(['brand', 'model', 'year', 'color'])

Para obtener los valores del diccionario se puede usar el método values()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.values()
	
	Copied

>_ Output

			
				dict_values(['Ford', 'Mustang', 1964, 'white'])

Se puede usar una variable para apuntar a los valuess del diccionario, con lo que llamándola una vez es necesario

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se declara una vez la variable que apunta a los values
x = diccionario.values()
print(x)
 
# Se modifica un value
diccionario["year"] = 2020
 
# Se consulta la variable que apunta a los values
print(x)
	
	Copied

>_ Output

			
				dict_values(['Ford', 'Mustang', 1964])
dict_values(['Ford', 'Mustang', 2020])

Si lo que se quiere son los items enteros, es decir keys y values hay que usar el método items()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario.items()
	
	Copied

>_ Output

			
				dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 2020)])

Se puede usar una variable para apuntar a los items del diccionario, con lo que llamándola una vez es necesario

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se declara una vez la variable que apunta a los items
x = diccionario.items()
print(x)
 
# Se modifica un value
diccionario["year"] = 2020
 
# Se consulta la variable que apunta a los items
print(x)
	
	Copied

>_ Output

			
				dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)])
dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 2020)])

Se puede comprobar si una key existe en el diccionario

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		"model" in diccionario
	
	Copied

>_ Output

			
				True

2.4.2. Modificar los ítems

Se puede modificar un item accediendo a él directamente

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se modifica un item
diccionario["year"] = 2020
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 2020}

O se puede modificar mediante el método update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se modifica un item
diccionario.update({"year": 2020})
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 2020}

2.4.3. Añadir ítems

Se puede añadir un item agregándolo de esta manera:

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
 
# Se modifica un item
diccionario["colour"] = "blue"
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'colour': 'blue'}

Ó se puede agregar mediante el método update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se modifica un item
diccionario.update({"colour": "blue"})
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'colour': 'blue'}

2.4.4. Eliminar items

Se puede eliminar un item con una key específica mediante el método pop()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina un item
diccionario.pop("model")
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'year': 1964}

O se puede eliminar un item con una key específica mediante del indicando el nombre de la key entre los símbolos []

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina un item
del diccionario["model"]
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'year': 1964}

Se elimina el diccionario entero si se usa del y no se especifica la key de un item

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina un item
del diccionario
 
if 'diccionario' not in locals():
  print("diccionario eliminado")
	
	Copied

>_ Output

			
				diccionario eliminado

Si lo que se quiere es eliminar el último item introducido se puede usar el método popitem()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
 
# Se elimina el último item introducido
diccionario.popitem()
 
diccionario
	
	Copied

>_ Output

			
				{'brand': 'Ford', 'model': 'Mustang'}

Si se quiere limpiar el diccionario hay que usar el método clear()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario.clear()
diccionario
	
	Copied

>_ Output

{}

2.4.5. Copiar diccionarios

No se pueden copiar diccionarios mediante diccionario1 = diccionario2, ya que si se modifica diccionario1 también se modifica diccionario2

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario1 = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario2 = diccionario1
diccionario1["year"] = 2000
diccionario2["year"]
	
	Copied

>_ Output

Por lo que hay que usar el método copy()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario1 = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario2 = diccionario1.copy()
diccionario1["year"] = 2000
diccionario2["year"]
	
	Copied

>_ Output

Ó hay que usar el constructor de diccionarios `dict()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario1 = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
diccionario2 = dict(diccionario1)
diccionario1["year"] = 2000
diccionario2["year"]
	
	Copied

>_ Output

2.4.6. Diccionarios anidados

Los diccionarios pueden tener itemss de cualquier tipo de dato, incluso otros diccionarios. A este tipo de diccionarios se les denomina diccionarios nested

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario_nested = {
  "child1" : {
    "name" : "Emil",
    "year" : 2004
  },
  "child2" : {
    "name" : "Tobias",
    "year" : 2007
  },
  "child3" : {
    "name" : "Linus",
    "year" : 2011
  }
}
diccionario_nested
	
	Copied

>_ Output

			
				{'child1': {'name': 'Emil', 'year': 2004},
'child2': {'name': 'Tobias', 'year': 2007},
'child3': {'name': 'Linus', 'year': 2011}}

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		child1 = {
  "name" : "Emil",
  "year" : 2004
}
child2 = {
  "name" : "Tobias",
  "year" : 2007
}
child3 = {
  "name" : "Linus",
  "year" : 2011
}
 
diccionario_nested = {
  "child1" : child1,
  "child2" : child2,
  "child3" : child3
}
 
diccionario_nested
	
	Copied

>_ Output

			
				{'child1': {'name': 'Emil', 'year': 2004},
'child2': {'name': 'Tobias', 'year': 2007},
'child3': {'name': 'Linus', 'year': 2011}}

2.4.7. Métodos de los diccionarios

Estos son los métodos que se pueden usar en los diccionarios

2.4.8. Dictionary comprehension

Igual que podíamos hacer list comprehensions mediante la sintaxis

list_comprehension = [expression for item in iterable if condition == True]

Podemos hacer dictionaries comprehensions mediante la siguiente sintaxis

dictionary_comprehension = {key_expression: value_expression for item in iterable if condition == True}

Veamos un ejemplo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		dictionary_comprehension = {x: x**2 for x in (2, 4, 6) if x &gt; 2}
dictionary_comprehension
	
	Copied

>_ Output

			
				{4: 16, 6: 36}

2.5. Sets

2.5.1. Set

Los sets se utilizan en Python para guardar un conjunto de items en una sola variable. Se pueden guardar items de distintos tipos. Son no ordenados y no tienen índice.

Se diferencian de las listas en que no tienen ni orden ni índice.

Se declaran mediante los símbolos {}

Como set es una palabra reservada en Python creamos un set con el nombre set_

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6}
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 'item0', 'item4'}

No puede haber ítems duplicados, si encuentra algún ítem duplicado se queda solo con uno

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6, 'item0'}
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 'item0', 'item4'}

Se puede obtener la longitud del set mediante la función len()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		len(set_)
	
	Copied

>_ Output

Como se puede ver la longitud del set es 6 y no 7, ya que se queda con un solo 'item0'

Se puede comprobar si un item se encuentra en el set

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		'item4' in set_
	
	Copied

>_ Output

			
				True

2.5.1.1. Añadir ítems

Se puede añadir un elemento al set mediante el método add()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.add(8.8)
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 8.8, 'item0', 'item4'}

Se puede agregar otro set mediante el método `update()'

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set2 = {"item5", "item6", 7}
set_.update(set2)
set_
	
	Copied

>_ Output

			
				{1, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5', 'item6'}

También se pueden añadir items de tipos de datos iterables de Python

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ["item9", 10, 11.2]
set_.update(lista)
set_
	
	Copied

>_ Output

			
				{1, 10, 11.2, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5', 'item6', 'item9'}

2.5.1.2. Eliminar ítems

Se puede eliminar un ítem determinado mediante el método remove()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.remove('item9')
set_
	
	Copied

>_ Output

			
				{1, 10, 11.2, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5', 'item6'}

O mediante el método discard()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.discard('item6')
set_
	
	Copied

>_ Output

			
				{1, 10, 11.2, 5, 5.3, 6.6, 7, 8.8, 'item0', 'item4', 'item5'}

Mediante el método pop() se puede eliminar el último item, pero como los sets no son ordenados no hay manera de saber cuál es el último item. El método pop() devuelve el item eliminado

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(f"set antes de pop(): {set_}")
eliminado = set_.pop()
print(f"Se ha eliminado {eliminado}")
	
	Copied

>_ Output

			
				set antes de pop(): {1, 5, 5.3, 6.6, 8.8, 7, 10, 11.2, 'item5', 'item0', 'item4'}
Se ha eliminado 1

Mediante el método clear() se puede vaciar el conjunto

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_.clear()
set_
	
	Copied

>_ Output

			
				set()

Por último, con del se puede eliminar el set

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del set_
 
if 'set_' not in locals():
  print("set eliminado")
	
	Copied

>_ Output

			
				set eliminado

2.5.1.3. Unir ítems

Una forma de unir sets es mediante el método union()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
set3
	
	Copied

>_ Output

			
				{1, 2, 3, 'a', 'b', 'c'}

Otra forma es mediante el método update(), pero de esta manera se añade un set en otro, no se crea uno nuevo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}
set1.update(set2)
set1
	
	Copied

>_ Output

			
				{1, 2, 3, 'a', 'b', 'c'}

Estos métodos de unión eliminan los duplicados, pero si queremos obtener los elementos duplicados en dos sets usamos el método intersection()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set3 = set1.intersection(set2)
set3
	
	Copied

>_ Output

			
				{'apple'}

Si queremos obtener los elementos duplicados en dos sets, pero sin crear un set nuevo, usamos el método intersection_update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set1.intersection_update(set2)
set1
	
	Copied

>_ Output

			
				{'apple'}

Ahora al revés, si queremos quedarnos con los no duplicados usamos el método symmetric_difference().

La diferencia entre esto y la unión entre dos sets es que en la unión se queda con todos los ítems, pero los que están duplicados solo los coge una vez. Ahora nos quedamos con los que no están duplicados

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set3 = set1.symmetric_difference(set2)
set3
	
	Copied

>_ Output

			
				{'banana', 'cherry', 'google', 'microsoft'}

Si queremos quedarnos con los no duplicados sin crear un nuevo set usamos el método symmetric_difference_update()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set1 = {"apple", "banana", "cherry"}
set2 = {"google", "microsoft", "apple"}
 
set1.symmetric_difference_update(set2)
set1
	
	Copied

>_ Output

			
				{'banana', 'cherry', 'google', 'microsoft'}

2.5.1.4. Métodos de los sets

Estos son los métodos que se pueden usar en los sets

2.5.2. FrozenSet

Los frozensets son como los sets pero con la salvedad de que son inmutables, al igual que las tuplas son como las lists pero inmutables. Por lo que no podremos añadir o eliminar items

2.6. Booleanos

Hay solo dos booleanos en Python: True y False

Mediante la función bool() se puede evaluar si cualquier cosa es True o False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(bool("Hello"))
print(bool(15))
print(bool(0))
	
	Copied

>_ Output

			
				True
True
False

2.6.1. Otros tipos de datos True y False

Los siguientes datos son True:

Cualquier string que no esté vacío
Cualquier número excepto el 0
Cualquier lista, tupla, diccionario o set que no esté vacío

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(bool("Hola"))
print(bool(""))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print(bool(3))
print(bool(0))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [1, 2, 3]
print(bool(lista))
 
lista = []
print(bool(lista))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = (1, 2, 3)
print(bool(tupla))
 
tupla = ()
print(bool(tupla))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "colors": ["red", "white", "blue"]
}
print(bool(diccionario))
 
diccionario.clear()
print(bool(diccionario))
	
	Copied

>_ Output

			
				True
False

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'item0', 1, 5.3, "item4", 5, 6.6}
print(bool(set_))
 
set_.clear()
print(bool(set_))
	
	Copied

>_ Output

			
				True
False

2.7. Binarios

2.7.1. Bytes

El tipo bytes es una secuencia inmutable de bytes. Solo admiten caracteres ASCII. También se pueden representar los bytes mediante números enteros cuyos valores deben cumplir 0 <= x < 256

Para crear un tipo byte debemos introducir antes el carácter b

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte = b"MaximoFN"
byte
	
	Copied

>_ Output

			
				b'MaximoFN'

También se pueden crear mediante su constructor bytes()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte = bytes(10)
byte
	
	Copied

>_ Output

b''

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte = bytes(range(10))
byte
	
	Copied

>_ Output

			
				b'	'

Se pueden concatenar bytes mediante el operador +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte1 = b'DeepMax'
byte2 = b'FN'
byte3 = byte1 + byte2
byte3
	
	Copied

>_ Output

			
				b'DeepMaxFN'

Ó mediante la repetición con el operador *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte1 = b'MaximoFN '
byte2 = byte1 * 3
byte2
	
	Copied

>_ Output

			
				b'MaximoFN MaximoFN MaximoFN '

Podemos comprobar si un carácter está dentro de la cadena

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		b'D' in byte1
	
	Copied

>_ Output

			
				False

Estos son los métodos que se pueden usar en los bytes

2.7.2. Bytearray

Los bytearrays son iguales que los bytes solo que son mutables

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte_array = bytearray(b'MaximoFN')
byte_array
	
	Copied

>_ Output

			
				bytearray(b'MaximoFN')

2.7.3. MemoryView

Los objetos memoryview permiten que el código Python acceda a los datos internos de un objeto que admite el protocolo de buffer sin realizar copias.

La función memoryview() permite el acceso directo de lectura y escritura a los datos orientados a bytes de un objeto sin necesidad de copiarlos primero. Eso puede generar grandes ganancias de rendimiento cuando se opera con objetos grandes, ya que no crea una copia al cortar.

Protocolo de búfer, puede crear otro objeto de acceso para modificar los datos grandes sin copiarlos. Esto hace que el programa utilice menos memoria y aumente la velocidad de ejecución.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		byte_array = bytearray('XYZ', 'utf-8')
print(f'Antes de acceder a la memoria: {byte_array}')
 
mem_view = memoryview(byte_array)
 
mem_view[2]= 74
print(f'Después de acceder a la memoria: {byte_array}')
	
	Copied

>_ Output

			
				Antes de acceder a la memoria: bytearray(b'XYZ')
Después de acceder a la memoria: bytearray(b'XYJ')

3. Operadores

3.1. Operadores aritméticos

Operador suma +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 + 5
	
	Copied

>_ Output

Operador resta -

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 - 5
	
	Copied

>_ Output

-2

Operador multiplicación *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 * 5
	
	Copied

>_ Output

Operador división /

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 / 5
	
	Copied

>_ Output

0.6

Operador módulo %. Devuelve el resto de una división

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		25 % 2
	
	Copied

>_ Output

Operador exponente **

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		5 ** 2
	
	Copied

>_ Output

Operador división entera //

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		25 // 2
	
	Copied

>_ Output

3.2. Operadores de comparación

Operador es igual ==

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		1 == 1
	
	Copied

>_ Output

			
				True

Operador es diferente !=

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		1 != 2
	
	Copied

>_ Output

			
				True

Operador es mayor que >

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 &gt; 2
	
	Copied

>_ Output

			
				True

Operador es menor que <

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		2 &lt; 3
	
	Copied

>_ Output

			
				True

Operador es mayor o igual que >=

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 &gt;= 3
	
	Copied

>_ Output

			
				True

Operador es menor o igual que <=

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 &lt;= 3
	
	Copied

>_ Output

			
				True

3.3. Operadores lógicos

Operador and

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		True and True
	
	Copied

>_ Output

			
				True

Operador or

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		True or False
	
	Copied

>_ Output

			
				True

Operador not

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		not False
	
	Copied

>_ Output

			
				True

3.4. Operadores de identidad

Operador is

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		5.3 is 5.3
	
	Copied

>_ Output

			
				True

Operador is not

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		5.3 is not 5
	
	Copied

>_ Output

			
				True

3.5. Operadores de pertenencia

Operador in

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = ["apple", "banana"]
 
"banana" in x
	
	Copied

>_ Output

			
				True

Operador not in

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = ["apple", "banana"]
 
"orange" not in x
	
	Copied

>_ Output

			
				True

3.6. Operadores bit a bit

Operador AND &

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
c = a &amp; b; # 12 = 0000 1100
c
	
	Copied

>_ Output

Operador OR |

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
c = a | b; # 61 = 0011 1101
c
	
	Copied

>_ Output

Operador XOR ^

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
c = a ^ b; # 49 = 0011 0001
c
	
	Copied

>_ Output

Operador NOT ~

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
 
c = ~a; # -61 = 1100 0011
c
	
	Copied

>_ Output

-61

Operador desplazamiento hacia la izquierda <<

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
 
c = a &lt;&lt; 2; # 240 = 1111 0000
c
	
	Copied

>_ Output

Operador desplazamiento hacia la derecha >>

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
 
c = a &gt;&gt; 2; # 15 = 0000 1111
c
	
	Copied

>_ Output

3.7. Operadores de asignación

Operador `=

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 5
a
	
	Copied

>_ Output

Operador +=. x += y es equivalente a x = x + y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a += 5
a
	
	Copied

>_ Output

Operador -=. x -= y es equivalente a `x = x - y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a -= 5
a
	
	Copied

>_ Output

Operador *=. x *= y es equivalente a `x = x * y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a *= 3
a
	
	Copied

>_ Output

Operador /=. x /= y es equivalente a `x = x / y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a /= 3
a
	
	Copied

>_ Output

5.0

Operador %=. x %= y es equivalente a `x = x % y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 25
a %= 2
a
	
	Copied

>_ Output

Operador //=. x //= y es equivalente a `x = x // y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 25
a //= 2
a
	
	Copied

>_ Output

Operador **=. x **= y es equivalente a `x = x ** y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 5
a **= 2
a
	
	Copied

>_ Output

Operador &=. x &= y es equivalente a `x = x & y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
a &amp;= b; # 12 = 0000 1100
a
	
	Copied

>_ Output

Operador |=. x |= y es equivalente a x = x | y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
a |= b; # 61 = 0011 1101
a
	
	Copied

>_ Output

Operador ^=. x ^= y es equivalente a `x = x ^ y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
b = 13 # 13 = 0000 1101 
 
a ^= b; # 49 = 0011 0001
a
	
	Copied

>_ Output

Operador >>=. x >>= y es equivalente a `x = x >> y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
 
a &lt;&lt;= 2; # 240 = 1111 0000
a
	
	Copied

>_ Output

Operador <<=. x <<= y es equivalente a x = x << y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 60 # 60 = 0011 1100 
 
a &gt;&gt;= 2; # 15 = 0000 1111
a
	
	Copied

>_ Output

4. Control de flujo

Para poder utilizar las herramientas de control de flujo es necesario añadir la sentencia, dos puntos : y en una nueva línea escribir el código con indentación.

A diferencia de otros lenguajes, Python necesita la indentación (añadir un espacio en blanco) para definir el código de dentro de una herramienta de control de flujo

4.1. If

Mediante if podemos crear condicionales

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		if len('MaximoFN') == 8:
  print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

Si queremos crear más de una condición podemos usar elif

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		if len('MaximoFN') &lt; 8:
  print('MaximoFN tiene menos de 8 caracteres')
elif len('MaximoFN') == 8:
  print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

Si lo que queremos es que se ejecute algo en caso de que no se cumpla ninguna de las condiciones indicadas, podemos usar else

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		if len('MaximoFN') &lt; 8:
  print('MaximoFN tiene menos de 8 caracteres')
elif len('MaximoFN') &gt; 8:
  print('MaximoFN tiene más de 8 caracteres')
else:
  print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

Si queremos escribir todo en una sola línea

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		if len('MaximoFN') == 8: print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

Igual, si queremos escribir todo en una línea, pero con varias condiciones

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		print('MaximoFN tiene menos de 8 caracteres') if len('MaximoFN') &lt; 8 else print('MaximoFN tiene más de 8 caracteres') if len('MaximoFN') &gt; 8 else print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

Si por ejemplo queremos hacer la estructura del if pero no queremos, de momento, codificar una de las condiciones, podemos usar pass

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		if len('MaximoFN') &lt; 8:
  print('MaximoFN tiene menos de 8 caracteres')
elif len('MaximoFN') &gt; 8:
  pass
else:
  print('MaximoFN tiene 8 caracteres')
	
	Copied

>_ Output

			
				MaximoFN tiene 8 caracteres

4.2. While

El bucle while se ejecuta mientras la condición sea True

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		i = 0
string = 'MaximoFN'
while len(string) &gt; i:
  print(string[i], end='')
  i += 1
	
	Copied

>_ Output

			
				MaximoFN

Si queremos que el bucle pare por alguna condición usamos break

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		i = 0
string = 'MaximoFN'
while len(string) &gt; i:
  if string[i] == 'F':
    break
  print(string[i], end='')
  i += 1
	
	Copied

>_ Output

			
				Maximo

Si queremos que una de las iteraciones no se ejecute por alguna razón usamos continue

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		i = 0
string = 'Maximo FN'
while len(string) &gt; i:
  if string[i] == ' ':
    i += 1
    continue
  print(string[i], end='')
  i += 1
	
	Copied

>_ Output

			
				MaximoFN

Mediante else se puede ejecutar un bloque de código si la condición del while no es True

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		i = 0
string = 'MaximoFN'
 
while len(string) &gt; i:
  print(string[i], end='')
  i += 1
else:
  print("
Se ha terminado el while")
	
	Copied

>_ Output

			
				MaximoFN
Se ha terminado el while

4.3. For

El bucle for se usa para ejecutar código mientras se itera por una secuencia, esta secuencia puede ser cualquier elemento iterable de Python (string, lista, tupla, range, diccionario, set)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
 
for x in string:
  print(x, end='')
	
	Copied

>_ Output

			
				MaximoFN

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = ['M', 'a', 'x', 'i', 'm', 'o', 'F', 'N']
 
for x in lista:
  print(x, end='')
	
	Copied

>_ Output

			
				MaximoFN

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ('M', 'a', 'x', 'i', 'm', 'o', 'F', 'N')
 
for x in tupla:
  print(x, end='')
	
	Copied

>_ Output

			
				MaximoFN

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
 
for i in range(len(string)):
  print(string[i], end='')
	
	Copied

>_ Output

			
				MaximoFN

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		diccionario = {
  "letra1": "M",
  "letra2": "a",
  "letra3": "x",
  "letra4": "i",
  "letra5": "m",
  "letra6": "o",
  "letra7": "F",
  "letra8": "N",
}
 
for x in diccionario.values():
  print(x, end='')
	
	Copied

>_ Output

			
				MaximoFN

También se puede iterar por los sets, pero como son elementos no ordenados, no tendremos control del orden de ejecución

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		set_ = {'M', 'a', 'x', 'i', 'm', 'o', 'F', 'N'}
 
for x in set_:
  print(x, end='')
	
	Copied

>_ Output

			
				NximoaMF

Si queremos que el bucle pare por alguna condición usamos break

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
 
for x in string:
  if x == 'F':
    break
  print(x, end='')
	
	Copied

>_ Output

			
				Maximo

Si queremos que una de las iteraciones no se ejecute por alguna razón usamos continue

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'Maximo FN'
 
for x in string:
  if x == ' ':
    continue
  print(x, end='')
	
	Copied

>_ Output

			
				MaximoFN

Mediante else se puede ejecutar un bloque de código si la condición del while no es True

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
 
for x in string:
  print(x, end='')
else:
  print("
Se ha terminado el for")
	
	Copied

>_ Output

			
				MaximoFN
Se ha terminado el for

Si por ejemplo queremos hacer la estructura del for pero no queremos, de momento, codificar su interior podemos usar pass

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = 'MaximoFN'
for x in string:
  pass
print('Interior del for no codificado')
	
	Copied

>_ Output

			
				Interior del for no codificado

5. Funciones

Una función es una porción de código que se puede ejecutar tantas veces como quieras. Se le puede pasar argumentos y puede devolver datos como resultado

Para definir una función se comienza con la palabra reservada def, seguido del nombre de la función, paréntesis (), dos puntos : y a continuación en una nueva línea indentado el código de la función

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  print('MaximoFN')
	
	Copied

Para llamar a la función solo es necesario escribir su nombre

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		funcion()
	
	Copied

>_ Output

			
				MaximoFN

A las funciones se les pueden pasar todos los argumentos que se quiera, dentro de los paréntesis y separados por comas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(string1, string2):
  print(string1 + ' ' + string2)
 
funcion("Hola", "MaximoFN")
	
	Copied

>_ Output

			
				Hola MaximoFN

Cuando se llama a la función hay que pasarle el mismo número de argumentos que se han declarado, si se pasan más o menos obtendríamos un error.

Si no sabemos los argumentos que va a recibir la función se puede usar *args, es decir, poniendo un * antes de los argumentos se indica que el número de argumentos es libre.

Al hacer esto, se le pasa una tupla (recordemos que es inmutable) con los argumentos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(*argumentos):
  numero_argumentos = len(argumentos)
 
  for i in range(numero_argumentos):
    print(argumentos[i], end=' ')
 
funcion("funcion", "con", "varios", "argumentos", "sin", "especificar", "cuantos")
	
	Copied

>_ Output

			
				funcion con varios argumentos sin especificar cuantos

En caso de no saber el orden de los argumentos de una función, podemos indicar el argumento que le queremos pasar indicándole su nombre

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento1, argumento2, argumento3):
  print(argumento1 + ' '+ argumento2 + ' ' + argumento3)
 
funcion(argumento3 = "MaximoFN", argumento1 = "Blog", argumento2 = "de")
	
	Copied

>_ Output

			
				Blog de MaximoFN

En caso de querer pasar los argumentos con su nombre, pero en caso de no saber cuántos argumentos se van a pasar se puede usar **kwargs. En este caso se le pasará un diccionario con los argumentos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(**kargumentos):
  print("Autor del blog: " + kargumentos["autor"])
 
funcion(blog = "Blog", pertenencia = "de", autor = "MaximoFN")
	
	Copied

>_ Output

			
				Autor del blog: MaximoFN

Si queremos que algún argumento tenga un valor por defecto lo podemos indicar entre los paréntesis de la función. De esta manera, si a la hora de llamar a la función no se pasa dicho argumento, este en la función tendrá el valor por defecto

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento1, argumento2, argumento3 = "MaximoFN"):
  print(argumento1 + ' '+ argumento2 + ' ' + argumento3)
 
funcion("Blog", "de")
	
	Copied

>_ Output

			
				Blog de MaximoFN

Se puede pasar cualquier tipo de dato como argumento. Por ejemplo, si se pasa una lista como argumento, dentro de la función, dicho argumento será tratado como una lista

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento):
  longitud_lista = len(argumento)
 
  for i in range(longitud_lista):
    print(argumento[i], end=' ')
 
funcion(["Blog", "de", "MaximoFN"])
	
	Copied

>_ Output

			
				Blog de MaximoFN

Las funciones pueden devolver datos, esto se hace mediante la palabra reservada return

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento):
  longitud_lista = len(argumento)
  string = ""
 
  for i in range(longitud_lista):
    string = string + argumento[i] + ' '
 
  return string
 
print(funcion(["Blog", "de", "MaximoFN"]))
	
	Copied

>_ Output

			
				Blog de MaximoFN

Pueden devolver más de un dato

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento):
  longitud_lista = len(argumento)
  string0 = argumento[0]
  string1 = argumento[1]
  string2 = argumento[2]
 
  return string0, string1, string2
 
dato0, dato1, dato2 = funcion(["Blog", "de", "MaximoFN"])
 
print(dato0 + ' ' + dato1 + ' ' + dato2)
	
	Copied

>_ Output

			
				Blog de MaximoFN

Si uno de los datos devueltos no nos interesa, podemos pasar de él mediante `_

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion(argumento):
  longitud_lista = len(argumento)
  string0 = argumento[0]
  string1 = argumento[1]
  string2 = argumento[2]
 
  return string0, string1, string2
 
_, _, dato_de_interes = funcion(["Blog", "de", "MaximoFN"])
 
print(dato_de_interes)
	
	Copied

>_ Output

			
				MaximoFN

Si por ejemplo queremos hacer la estructura de la función pero no queremos, de momento, codificar el interior podemos usar pass

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  pass
 
funcion()
	
	Copied

Una función puede llamarse a sí misma, a esto se le llama recursión o recursividad de la función.

Por ejemplo podemos usar esta cualidad para calcular el factorial de un número

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def factorial(n):
  if n == 0 or n == 1:
    return 1
  else:
    return n * factorial(n-1)
 
factorial(5)
	
	Copied

>_ Output

5.1. Built in functions

Hay una serie de funciones ya definidas en Python que se pueden usar, como por ejemplo la función abs(), que devuelve el valor absoluto

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		abs(-5)
	
	Copied

>_ Output

A continuación se muestra una lista de estas funciones

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import builtins
 
dir(builtins)
	
	Copied

>_ Output

			
				['ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'BlockingIOError',
'BrokenPipeError',
'BufferError',
'BytesWarning',
'ChildProcessError',
'ConnectionAbortedError',
'ConnectionError',
'ConnectionRefusedError',
'ConnectionResetError',
'DeprecationWarning',
'EOFError',
'Ellipsis',
'EnvironmentError',
'Exception',
'False',
'FileExistsError',
...
'slice',
'sorted',
'staticmethod',
'str',
'sum',
'super',
'tuple',
'type',
'vars',
'zip']

5.2. Documentación de una función

Se puede añadir una explicación de una función que creemos mediante un comentario al inicio de la función, de esta manera cuando llamemos a la built in function help() nos mostrará dicha explicación.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  "Esta es la explicación de la función"
 
  None
 
help(funcion)
	
	Copied

>_ Output

			
				Help on function funcion in module __main__:
funcion()
    Esta es la explicación de la función

Otra opción para ver la explicación de la función es usar el método __doc__ de la función

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		funcion.__doc__
	
	Copied

>_ Output

			
				'Esta es la explicación de la función'

5.3. Decoradores

Los decoradores son una funcionalidad de Python que permiten añadir características nuevas a una función

Se crea una función decoradora que tiene como parámetro otra función. Entonces la función decoradora añade la característica nueva a la función que recibe

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def decorador(parametro_funcion):
  """Agrega barritas arriba y abajo de la funcion"""
 
  def envoltorio():
    """Aplica las barritas al texto"""
 
    print("==================")
    parametro_funcion()
    print("==================")
      
  return envoltorio
 
def funcion():
  print("MaximoFN")
 
funcion_envoltorio = decorador(funcion)
 
print('Función sin decoradores: ')
funcion()
 
print('
Función con decoradores: ')
funcion_envoltorio()
	
	Copied

>_ Output

			
				Función sin decoradores:
MaximoFN
Función con decoradores:
==================
MaximoFN
==================

Pero otra manera más potente de usar los decoradores es mediante el uso de @ y el nombre del decorador antes de la función.

Es decir, primero se define el decorador y a continuación se llama a una función con el decorador definido

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def decorador2(parametro_funcion2):
  """Agrega barritas arriba y abajo de la funcion"""
 
  def envoltorio2():
    """Aplica las barritas al texto"""
 
    print("==================")
    parametro_funcion2()
    print("==================")
      
  return envoltorio2
 
@decorador2
def funcion2():
  print("MaximoFN")
 
print('Función con decoradores: ')
funcion2()
	
	Copied

>_ Output

			
				Función con decoradores:
==================
MaximoFN
==================

5.4. `*args` y `**kwargs`

*args y **kwargs son argumentos opcionales que se pueden usar al definir una función en Python. La sintaxis es la siguiente:

def mi_funcion(arg1, arg2, *args, **kwargs):
          # código de la función aquí

5.4.1. `*args`

*args se usa para enviar un número variable de argumentos a una función. Al usar *args, puedes enviar una cantidad variable de argumentos a la función sin tener que especificar el número exacto de argumentos que necesita la función. Los argumentos se reciben en la función como una tupla.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def saludo(saludo, *nombres):
    for nombre in nombres:
        print(f"{saludo}, {nombre}")
 
saludo("Hola", "Alicia", "Roberto", "Carlos")
	
	Copied

>_ Output

			
				Hola, Alicia
Hola, Roberto
Hola, Carlos

5.4.2. `**kwargs`

**kwargs se usa de la misma manera, pero para enviar un número variable de argumentos con palabras clave (keyword arguments) a una función. Al usar **kwargs, puedes enviar una cantidad variable de argumentos a la función y especificar el valor de cada argumento usando su nombre. Los argumentos se reciben en la función como un diccionario.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def saludo(saludo, **personas):
    for key, value in personas.items():
        print(f"{saludo} {key}, tu edad es {value} años")
 
saludo("Hola", Juan=22, Maria=32, Pedro=25)
	
	Copied

>_ Output

			
				Hola Juan, tu edad es 22 años
Hola Maria, tu edad es 32 años
Hola Pedro, tu edad es 25 años

6. Funciones adicionales

6.1. Funciones lambda

Una función *lambda* es una pequeña función anónima.

Una función *lambda* puede tomar cualquier número de argumentos, pero solo puede tener una expresión.

Las funciones *lambda* se definen de la siguiente manera:

lambda arguments : expression

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = lambda a : a + 10
print(x(5))
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = lambda a, b, c : a + b + c
print(x(5, 6, 2))
	
	Copied

>_ Output

El poder de *lambda* se muestra mejor cuando las usa como una función anónima dentro de otra función.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(f"mydoubler: {mydoubler(11)}")
print(f"mytripler: {mytripler(11)}")
	
	Copied

>_ Output

			
				mydoubler: 22
mytripler: 33

6.2. Función `map`

La función map permite aplicar a cada elemento de una estructura iterable una función

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [1, 2, 3]
 
def funcion_mas_1(valor):
  return valor + 1
 
lista_modificada = list(map(funcion_mas_1, lista))
lista_modificada
	
	Copied

>_ Output

			
				[2, 3, 4]

Esto es equivalente a usar list comprehension

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista_modificada = [funcion_mas_1(x) for x in lista]
lista_modificada
	
	Copied

>_ Output

			
				[2, 3, 4]

6.3. Función `filter`

La función filter permite seleccionar los elementos de una estructura iterable que cumplan con una condición

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista = [1, 2, 3, 4, 5, 6, 7]
 
def esPar(valor):
  return valor % 2 == 0
 
lista_filtrada = list(filter(esPar, lista))
lista_filtrada
	
	Copied

>_ Output

			
				[2, 4, 6]

Esto es equivalente a usar list comprehension

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		lista_filtrada = [x for x in lista if esPar(x)]
lista_filtrada
	
	Copied

>_ Output

			
				[2, 4, 6]

6.4. Función `reduce`

La función reduce permite realizar tareas acumulativas sobre estructuras iterables

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		from functools import reduce
 
lista = [1, 22, 33]
 
def acumular(valor, acumulador):
  print(f'valor = {valor}, acumulador = {acumulador}, acumulacion = {valor + acumulador}')
  return valor + acumulador
 
acumulacion = reduce(acumular, lista)
print(f'
acumulacion = {acumulacion}')
	
	Copied

>_ Output

			
				valor = 1, acumulador = 22, acumulacion = 23
valor = 23, acumulador = 33, acumulacion = 56
acumulacion = 56

6.5. Función `zip`

Con la función zip se puede combinar varias estructuras iterables en una sola, es decir permite agrupar varios elementos de las estructuras *A_x* en una sola estructura *B*. La estructura *B* está formada por tuplas de los elementos de las estructuras *A_x*

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		nombres = ["Manolo", "Andres", "Fernando"]
altura = [181, 178, 180]
 
my_zip = list(zip(nombres, altura))
my_zip
	
	Copied

>_ Output

			
				[('Manolo', 181), ('Andres', 178), ('Fernando', 180)]

6.5. Generadores

Supongamos que queremos iterar sobre una secuencia de números, pero de una manera especial que no nos ofrece ningún tipo de bucle. Esto lo podemos solucionar con los generadores. Para poder hacer esto, la función generadora no tiene que devolver el valor con return, sino con yield para que sepa que tiene que seguir iterando

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def iterador_custom(N):
    for i in range (N):
        if i % 3 == 0:
            yield i
 
generador = iterador_custom(20)
for i in generador:
    print(i)
	
	Copied

>_ Output

Acabamos de hacer un iterador por números múltiplos de 3

6.6. High order functions

Podemos crear funciones que reciben otras funciones como parámetros, de manera que la función que recibe otra función como parámetro se llama función de orden superior (high order function). Veamos un ejemplo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def increment(x):
    return x + 1
 
def hof(f, x):
    return 2*f(x)
 
print(hof(increment, 3))
	
	Copied

>_ Output

7. Clases y objetos

Python es un lenguaje de programación orientado a objetos. Casi todo en Python es un objeto, con sus atributos y métodos.

Una clase es como un constructor de objetos o un "plano" para crear objetos.

Para crear una clase se usa la palabra reservada class

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Clase:
  variable = 'MaximoFN'
	
	Copied

Una vez creada la clase, se puede crear un objeto de dicha clase

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		objeto = Clase()
Clase.variable
	
	Copied

>_ Output

			
				'MaximoFN'

Normalmente las clases tienen una función inicial, que se ejecuta cuando se crea un objeto de la clase. Esta función se denomina *dunder init* y se escribe __init__(). A la función *dunder init* se le tiene que pasar siempre la variable self, que indica la propia clase, y a continuación, las variables que se quiera pasar

Con esta función se suelen inicializar las variables de las clases, o se ejecuta el código que se necesita cuando se crea un objeto de la clase

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Persona:
  def __init__(self, nombre, edad):
    self.nombre = nombre
    self.edad = edad
 
objeto_persona = Persona("Miguel", 36)
 
print(objeto_persona.nombre)
print(objeto_persona.edad)
	
	Copied

>_ Output

			
				Miguel
36

Además de la función inicial *dunder init*, se pueden crear más funciones. A estas funciones se les llama *métodos* de la clase. A estos *métodos* siempre hay que pasarles la variable self

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Persona:
  def __init__(self, nombre, edad):
    self.nombre = nombre
    self.edad = edad
 
  def saludar(self):
    print(f'Hola mi nombre es {self.nombre} y tengo {self.edad} años')
 
objeto_persona = Persona("Miguel", 36)
 
objeto_persona.saludar()
	
	Copied

>_ Output

			
				Hola mi nombre es Miguel y tengo 36 años

La variable self no tiene por qué ser llamada self, puede tener cualquier nombre, pero dentro de cada clase tiene que ser siempre el mismo. Pero por convenio se suele usar self

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Persona:
  def __init__(yo_mismo, nombre, edad):
    yo_mismo.nombre = nombre
    yo_mismo.edad = edad
 
  def saludar(yo_mismo):
    print(f'Hola mi nombre es {yo_mismo.nombre} y tengo {yo_mismo.edad} años')
 
objeto_persona = Persona("Miguel", 36)
 
objeto_persona.saludar()
	
	Copied

>_ Output

			
				Hola mi nombre es Miguel y tengo 36 años

Se pueden modificar las variables de los objetos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		objeto_persona.nombre = 'Marta'
objeto_persona.saludar()
	
	Copied

>_ Output

			
				Hola mi nombre es Marta y tengo 36 años

Incluso eliminarlas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del objeto_persona.nombre
	
	Copied

También se puede eliminar el objeto entero

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		del objeto_persona
	
	Copied

Si por ejemplo queremos hacer la estructura de la clase pero no queremos, de momento, codificar el interior podemos usar pass

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Persona:
  pass
 
objeto_persona = Persona()
	
	Copied

7.1. Herencia

La herencia nos permite definir una clase que herede todos los métodos y propiedades de otra clase.

La **clase padre** es la clase de la que se hereda, también llamada **clase base**.

La **clase hija** es la clase que hereda de otra clase, también llamada **clase derivada**.

Creamos una clase padre

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Persona:
  def __init__(self, nombre, apellido):
    self.nombre = nombre
    self.apellido = apellido
 
  def imprimir_nombre(self):
    print(f'Me llamo {self.nombre} {self.apellido}')
 
objeto_padre = Persona("Laura", "Perez")
objeto_padre.imprimir_nombre()
	
	Copied

>_ Output

			
				Me llamo Laura Perez

Para crear la clase hija hay que indicar entre paréntesis, a la hora de declarar la clase, de qué clase hereda

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Estudiante(Persona):
  pass
	
	Copied

Y al momento de crear el objeto de la clase hija, se le pasan los parámetros que la clase padre necesita

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		objeto_hijo = Estudiante("Mariano", "Sanz")
objeto_hijo.imprimir_nombre()
	
	Copied

>_ Output

			
				Me llamo Mariano Sanz

Hasta ahora la clase hija ha heredado las funciones de la clase padre, pero podemos modificarlas reescribiéndolas. Por ejemplo reescribiendo la función *dunder init*.

Si se reescribe la función *dunder init*, si queremos que se llame a la función *dunder init* de la clase padre hay que llamarla.

Para esto hay dos maneras, una es mediante el nombre de la clase padre. En este caso, hay que pasarle la variable self.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Estudiante(Persona):
  def __init__(self, nombre, apellido):
    Persona.__init__(self, nombre, apellido)
 
objeto_hijo = Estudiante("Mariano", "Sanz")
objeto_hijo.imprimir_nombre()
	
	Copied

>_ Output

			
				Me llamo Mariano Sanz

Otra forma es mediante super(), en este caso no hace falta pasarle la variable self

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Estudiante(Persona):
  def __init__(self, nombre, apellido):
    super().__init__(nombre, apellido)
 
objeto_hijo = Estudiante("Mariano", "Sanz")
objeto_hijo.imprimir_nombre()
	
	Copied

>_ Output

			
				Me llamo Mariano Sanz

Al modificar las funciones se puede agregar código nuevo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Estudiante(Persona):
  def __init__(self, nombre, apellido, curso):
    Persona.__init__(self, nombre, apellido)
    self.curso = curso
 
  def imprimir_nombre(self):
    Persona.imprimir_nombre(self)
    print(f'Estoy en el curso número {self.curso}')
 
objeto_hijo = Estudiante("Mariano", "Sanz", 4)
objeto_hijo.imprimir_nombre()
	
	Copied

>_ Output

			
				Me llamo Mariano Sanz
Estoy en el curso número 4

Por último, se pueden agregar nuevos métodos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Estudiante(Persona):
  def __init__(self, nombre, apellido, curso):
    Persona.__init__(self, nombre, apellido)
    self.curso = curso
 
  def imprimir_nombre(self):
    Persona.imprimir_nombre(self)
    print(f'Estoy en el curso número {self.curso}')
 
  def imprimir_estudiante(self):
    print(f"Soy un estudiante del curso número {self.curso}")
 
objeto_hijo = Estudiante("Mariano", "Sanz", 4)
objeto_hijo.imprimir_nombre()
objeto_hijo.imprimir_estudiante()
	
	Copied

>_ Output

			
				Me llamo Mariano Sanz
Estoy en el curso número 4
Soy un estudiante del curso número 4

7.2. Sobrecarga de operadores

Podemos definir operaciones básicas, como la suma, entre varios objetos de una clase. Por ejemplo, si tenemos una clase que representa un vector, podemos definir la suma y la multiplicación entre objetos de dicha clase

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __mul__(self, other):
        return Vector(self.x * other.x, self.y * other.y)
    
    def __str__(self):
        return f"Vector ({self.x}, {self.y})"
 
v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2) # Vector (4, 6)
print(v1 * v2) # Vector (3, 8)
	
	Copied

>_ Output

			
				Vector (4, 6)
Vector (3, 8)

Todas las posibles sobrecargas de operadores son:

__add__(self, other): sobrecarga el operador de suma (+).
__sub__(self, other): sobrecarga el operador de resta (-).
__mul__(self, other): sobrecarga el operador de multiplicación (*).
__truediv__(self, other): sobrecarga el operador de división (/).
__floordiv__(self, other): sobrecarga el operador de división de redondeo (//).
__mod__(self, other): sobrecarga el operador de módulo (%).
__divmod__(self, other): sobrecarga la función divmod().
__pow__(self, other): sobrecarga el operador de potencia (**).
__lshift__(self, other): sobrecarga el operador de desplazamiento a la izquierda (<<).
__rshift__(self, other): sobrecarga el operador de desplazamiento a la derecha (>>).
__and__(self, other): sobrecarga el operador de and (&).
__or__(self, other): sobrecarga el operador de or (|).
__xor__(self, other): sobrecarga el operador de xor (^).
__lt__(self, other): sobrecarga el operador de comparación menor que (<).
__le__(self, other): sobrecarga el operador de comparación menor o igual que (<=).
__eq__(self, other): sobrecarga el operador de comparación igual a (==).
__ne__(self, other): sobrecarga el operador de comparación diferente a (!=).
__gt__(self, other): sobrecarga el operador de comparación mayor que (>).
__ge__(self, other): sobrecarga el operador de comparación mayor o igual que (>=).
__neg__(self): sobrecarga el operador de negación (-).
__pos__(self): sobrecarga el operador de posición (+).
__abs__(self): sobrecarga la función abs().
__invert__(self): sobrecarga el operador de inversión (~).
__complex__(self): sobrecarga la función complex().
__int__(self): sobrecarga la función int().
__float__(self): sobrecarga la función float().

7.3. Iteradores personalizados

Como hemos visto en el apartado 2 (Tipos de datos de Python), existen algunos tipos de datos sobre los que se puede iterar. Pero podemos hacernos nuestra propia clase iterable, siempre que tenga las funciones __len__ y __getitem__

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class custonIterator:
    def __init__(self, n):
        self.items = [i for i in range(n)]
    
    def __len__(self):
        return len(self.items)
    
    def __getitem__(self, index):
        return self.items[index]
 
iterator = custonIterator(10)
print(len(iterator)) # 10
print(iterator[0]) # 0
print(iterator[1]) # 1
	
	Copied

>_ Output

Ahora podemos iterar con el objeto de nuestra clase con bucles for, por ejemplo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		for i in iterator:
    print(i, end=" ") # 0 1 2 3 4 5 6 7 8 9
	
	Copied

>_ Output

			
				0 1 2 3 4 5 6 7 8 9

7.4. Llamada a objetos como funciones

Nos puede interesar llamar a un objeto de una función como si fuera una clase. Esto se puede conseguir agregando la función __call__ a la clase

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class potencia:
    def __init__(self, base):
        self.base = base
    
    def __call__(self, potencia):
        return self.base ** potencia
    
potencia_cuadrado = potencia(2)
print(potencia_cuadrado(3)) # 8
	
	Copied

>_ Output

7.5. Atributos y funciones privados

Cuando creamos una clase, podemos hacer que algunos atributos o funciones sean privados y no se pueda acceder desde fuera de la clase, para ello hay que añadir __ antes del atributo o método

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Privados:
    def __init__(self):
        self.publico = "Soy público"
        self.__privado = "Soy privado"
    
    def getPrivado(self):
        return self.__privado
    
    def setPrivado(self, valor):
        self.__privado = valor
    
    def __funcion_privada(self):
        return "Soy una función privada"
    
    def funcion_publica(self):
        return self.__funcion_privada()
 
privados = Privados()
 
print("Acceso al atributo publico: ", end="")
try:
    print(f"{privados.publico}")
except:
    print("	No se puede acceder al atributo privado")
print("Acceso al atributo privado: ", end="")
try:
    print(f"{privados.__privado}")
except:
    print("	No se puede acceder al atributo privado")
print("Acceso al atributo privado mediante el accesor: ", end="")
try:
    print(f"{privados.getPrivado()}")
except:
    print("	No se puede acceder al atributo privado mediante el accesor")
print("Llamada a la función privada: ", end="")
try:
    print(f"{privados.__funcion_privada()}")
except:
    print("	No se puede llamar a la función privada")
print("Llamada a la función pública: ", end="")
try:
    print(f"{privados.funcion_publica()}")
except:
    print("	No se puede llamar a la función pública")
	
	Copied

>_ Output

			
				Acceso al atributo publico: Soy público
Acceso al atributo privado: 	No se puede acceder al atributo privado
Acceso al atributo privado mediante el accesor: Soy privado
Llamada a la función privada: 	No se puede llamar a la función privada
Llamada a la función pública: Soy una función privada

8. Iteradores

Un iterador es un objeto que contiene un número contable de valores.

Un iterador es un objeto sobre el que se puede iterar, lo que significa que puede recorrer todos los elementos.

Técnicamente, en Python, un iterador es un objeto que implementa el protocolo del iterador, que consta de los métodos __iter__() y __next__().

Las listas, tuplas, diccionarios y conjuntos son todos objetos iterables. Son contenedores iterables de los que se puede obtener un iterador.

Todos estos objetos tienen un método iter() que se usa para obtener un iterador:

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ("manzana", "plátano", "cereza")
iterable = iter(tupla)
 
print(next(iterable))
print(next(iterable))
print(next(iterable))
	
	Copied

>_ Output

			
				manzana
plátano
cereza

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = "plátano"
iterable = iter(string)
 
print(next(iterable), end=' ')
print(next(iterable), end=' ')
print(next(iterable), end=' ')
print(next(iterable), end=' ')
print(next(iterable), end=' ')
print(next(iterable), end=' ')
print(next(iterable), end=' ')
	
	Copied

>_ Output

			
				p l á t a n o

El bucle for en realidad crea un objeto iterador y ejecuta el método next() en cada iteración.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		tupla = ("manzana", "plátano", "cereza")
 
for x in tupla:
  print(x)
	
	Copied

>_ Output

			
				manzana
plátano
cereza

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = "plátano"
 
for x in string:
  print(x, end=' ')
	
	Copied

>_ Output

			
				p l á t a n o

8.1. Crear un objeto iterador

Para crear un objeto/clase como iterador, hay que implementar los métodos __iter__() y __next__().

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Numeros:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
objeto_iterador = Numeros()
iterador = iter(objeto_iterador)
 
print(next(iterador), end=' ')
print(next(iterador), end=' ')
print(next(iterador), end=' ')
print(next(iterador), end=' ')
print(next(iterador), end=' ')
	
	Copied

>_ Output

			
				1 2 3 4 5

El ejemplo anterior continuaría para siempre si tuviera suficientes llamadas a next(), o si se usara en un bucle for.

Para evitar que la iteración continúe para siempre, podemos usar la declaración StopIteration.

En el método __next__(), podemos agregar una condición de terminación para generar un error si la iteración se realiza un número específico de veces:

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Numeros:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a &lt;= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
objeto_iterador = Numeros()
iterador = iter(objeto_iterador)
 
for x in iterador:
  print(x, end=' ')
	
	Copied

>_ Output

			
				1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

8.2. Iterar obteniendo el índice y el valor

Podemos iterar por un objeto iterable obteniendo en cada iteración su índice y su valor mediante el método enumerate()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string = "MaximoFN"
 
for index, valor in enumerate(string):
  print(f"En la posición {index}, está el caracter {valor}")
	
	Copied

>_ Output

			
				En la posición 0, está el caracter M
En la posición 1, está el caracter a
En la posición 2, está el caracter x
En la posición 3, está el caracter i
En la posición 4, está el caracter m
En la posición 5, está el caracter o
En la posición 6, está el caracter F
En la posición 7, está el caracter N

8.3. Iterar simultáneamente sobre dos objetos iterables

Si tenemos dos objetos iterables, de la misma longitud, podemos iterar por los dos a la vez mediante el método zip()

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		string1 = 'MaximoFN__'
string2 = 'PythonPost'
 
if len(string1) == len(string2):
  for valor1, valor2 in zip(string1, string2):
    print(f"En el primer string hay {valor1}, en el segundo string hay {valor2}")
	
	Copied

>_ Output

			
				En el primer string hay M, en el segundo string hay P
En el primer string hay a, en el segundo string hay y
En el primer string hay x, en el segundo string hay t
En el primer string hay i, en el segundo string hay h
En el primer string hay m, en el segundo string hay o
En el primer string hay o, en el segundo string hay n
En el primer string hay F, en el segundo string hay P
En el primer string hay N, en el segundo string hay o
En el primer string hay _, en el segundo string hay s
En el primer string hay _, en el segundo string hay t

9. Alcance de variables

Una variable solo está disponible dentro de la región en la que se crea. A esto se le llama *alcance*

9.1. Alcance local

Una variable creada dentro de una función pertenece al ámbito local de esa función y solo se puede usar dentro de esa función.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  x = 300
  print(x)
 
funcion()
	
	Copied

>_ Output

La variable x no está disponible fuera de la función, pero está disponible para cualquier función dentro de ella

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  x = 300
  def funcion_interna():
    print(x)
  funcion_interna()
 
funcion()
	
	Copied

>_ Output

9.2. Alcance global

Una variable creada en el cuerpo principal del código Python es una variable global y pertenece al ámbito global.

Las variables globales están disponibles desde cualquier ámbito, global y local.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = 300
 
def funcion():
  print(f'Ámbito local: {x}')
 
funcion()
 
print(f'Ámbito global: {x}')
	
	Copied

>_ Output

			
				Ámbito local: 300
Ámbito global: 300

Si se crean dos variables, una global y otra local, las dos con el mismo nombre, Python las creará como dos variables distintas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = 300
 
def funcion():
  x = 200
  print(f'Variable local: {x}')
 
funcion()
 
print(f'Variable global: {x}')
	
	Copied

>_ Output

			
				Variable local: 200
Variable global: 300

Si se necesita crear una variable global, pero está declarada en el ámbito local, se puede usar la palabra clave global.

La palabra clave global hace que la variable sea global.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def funcion():
  global x
  x = 300
 
funcion()
 
print(f'Variable global: {x}')
	
	Copied

>_ Output

			
				Variable global: 300

Además, el uso de la palabra clave global permite realizar un cambio en una variable global dentro de una función.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		x = 300
 
def funcion():
  global x
  x = 200
 
funcion()
 
print(f'Variable global: {x}')
	
	Copied

>_ Output

			
				Variable global: 200

10. Módulos

Un módulo es un archivo que contiene un conjunto de funciones que desea incluir en su aplicación.

Para crear un módulo, simplemente guarde el código que desea en un archivo con la extensión de archivo .py

Tip: En los cuadernos Jupyter (Colab es un cuaderno Jupyter en línea) si escribimos el carácter ! antes de un comando podremos ejecutar comandos de terminal

Primero vamos a ver en qué directorio estamos, para eso usamos el comando pwd (*print working directory*)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!pwd
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/web/portafolio/posts

Vamos a crear una carpeta para crear nuestros módulos con el comando mkdir (make directory)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!mkdir introduccion_python
	
	Copied

A continuación veamos qué archivos hay en nuestra carpeta. Esto lo haremos mediante el comando ls (*list*)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls introduccion_python
	
	Copied

Vemos que está vacía, creamos un nuevo archivo .py en el que vamos a crear nuestro módulo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile introduccion_python/modulo1.py
 
def funcion_del_modulo(nombre):
  print("Hola, " + nombre)
	
	Copied

>_ Output

			
				Writing introduccion_python/modulo1.py

Volvemos a ver qué archivos hay en nuestra carpeta

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls introduccion_python
	
	Copied

>_ Output

			
				modulo1.py  __pycache__

Vemos que se ha creado un archivo modulo1.py. Ya podemos usarlo

Para usar un módulo externo hay que usar la palabra import. Para usar las funciones del módulo hay que poner primero el nombre del módulo, un . y a continuación el nombre de la función que se quiere usar

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import introduccion_python.modulo1
 
introduccion_python.modulo1.funcion_del_modulo('MaximoFN')
	
	Copied

>_ Output

			
				Hola, MaximoFN

Si queremos que dentro de nuestro código, el módulo tenga un nombre determinado podemos usar la palabra as

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import introduccion_python.modulo1 as mod1
 
mod1.funcion_del_modulo('MaximoFN')
	
	Copied

>_ Output

			
				Hola, MaximoFN

Si el módulo tiene varias funciones, pero solo queremos importar una, podemos hacerlo mediante el uso de las palabras from e import. La forma sería

from <modulo> import <funcion>

En este caso no hace falta indicar el nombre del módulo al llamar a la función

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile introduccion_python/modulo2.py
 
def funcion1_del_modulo(nombre):
  print("Hola, " + nombre + ", funcion 1")
 
def funcion2_del_modulo(nombre):
  print("Hola, " + nombre + ", funcion 2")
 
def funcion3_del_modulo(nombre):
  print("Hola, " + nombre + ", funcion 3")
	
	Copied

>_ Output

			
				Writing introduccion_python/modulo2.py

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		from introduccion_python.modulo2 import funcion2_del_modulo
 
funcion2_del_modulo('MaximoFN')
	
	Copied

>_ Output

			
				Hola, MaximoFN, funcion 2

No solo podemos usar módulos creados por nosotros, sino módulos ya instalados (built-in modules)

Por ejemplo podemos usar el módulo platform

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import platform
 
x = platform.system()
x
	
	Copied

>_ Output

			
				'Linux'

10.1. Entry points: archivos como módulos y no como scripts

Vamos ahora a crear un archivo llamado modulo3.py

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile introduccion_python/modulo3.py
 
print("Hola desde modulo3")
 
def funcion_del_modulo():
  return "Hola desde la función del modulo3"
	
	Copied

>_ Output

			
				Overwriting introduccion_python/modulo3.py

Si ahora importamos modulo3.py para usar la función funcion_del_modulo veamos qué ocurre

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import introduccion_python.modulo3 as mod3
 
print(mod3.funcion_del_modulo())
	
	Copied

>_ Output

			
				Hola desde modulo3
Hola desde la función del modulo3

Vemos que se ha ejecutado el print de modulo3.py, pero no es lo que nosotros queríamos, esto es debido a que al llamarse el archivo modulo3.py Python lo ejecuta como un script

Pero ¿qué ocurre si queremos ejecutar introduccion_python/main.py como un script?

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!python introduccion_python/modulo3.py
	
	Copied

>_ Output

			
				Hola desde modulo3

Vemos que solo se ejecuta el print, pero no la función funcion_del_modulo. Si queremos tener la dualidad de funcionalidad del archivo modulo3.py, es decir, que podamos importarlo desde otro módulo sin que se ejecute como un script y ejecutarlo solo y que se ejecute la función que nosotros queremos, se usa un entry point. Esto es, usar la condición if __name__ == '__main__': y a continuación indicar qué queremos que se ejecute. Veámoslo con un ejemplo, voy a reescribir el archivo modulo3.py

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile introduccion_python/modulo3.py
 
print("Hola desde modulo3")
 
def funcion_del_modulo():
  return "Hola desde la función del modulo3"
 
if __name__ == "__main__":
  funcion_del_modulo()
	
	Copied

>_ Output

			
				Overwriting introduccion_python/modulo3.py

Si ahora llamo a main.py desde otro módulo, ya no se ejecutará el print

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import introduccion_python.modulo3 as mod3
 
print(mod3.funcion_del_modulo())
	
	Copied

>_ Output

			
				Hola desde la función del modulo3

Y si lo ejecuto como un script independiente, se ejecutará la función funcion_del_modulo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!python introduccion_python/modulo3.py
	
	Copied

>_ Output

			
				Hola desde modulo3

11. Paquetes

En Python podemos crearnos nuestros propios paquetes, para ello creamos una carpeta con el nombre del paquete

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!mkdir mi_paquete_de_python
	
	Copied

Creamos ahora dos archivos dentro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!touch mi_paquete_de_python/modulo1.py mi_paquete_de_python/modulo2.py
	
	Copied

Y escribimos en ellos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile mi_paquete_de_python/modulo1.py
 
def funcion1():
  print("Hola desde la función 1 del módulo 1")
 
def funcion2():
    print("Hola desde la función 2 del módulo 1")
	
	Copied

>_ Output

			
				Overwriting mi_paquete_de_python/modulo1.py

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile mi_paquete_de_python/modulo2.py
 
def funcion1():
  print("Hola desde la función 1 del módulo 2")
 
def funcion2():
    print("Hola desde la función 2 del módulo 2")
	
	Copied

>_ Output

			
				Overwriting mi_paquete_de_python/modulo2.py

Ahora podemos llamar a las funciones de nuestro paquete

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		from mi_paquete_de_python import modulo1 as mod1
from mi_paquete_de_python import modulo2 as mod2
 
mod1.funcion1()
mod1.funcion2()
mod2.funcion1()
mod2.funcion2()
	
	Copied

>_ Output

			
				Hola desde la función 1 del módulo 1
Hola desde la función 2 del módulo 1
Hola desde la función 1 del módulo 2
Hola desde la función 2 del módulo 2

Pero qué ocurre si nuestro paquete tiene decenas de archivos con funciones que queremos usar, tendríamos que importar todos los archivos uno a uno. Para evitar esto, se puede crear un archivo __init__.py dentro del paquete donde se haga toda esta importación de archivos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!touch mi_paquete_de_python/__init__.py
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		%%writefile mi_paquete_de_python/__init__.py
 
import modulo1
import modulo2
	
	Copied

>_ Output

			
				Overwriting mi_paquete_de_python/__init__.py

Ahora podemos solamente importar nuestro paquete, que ya internamente se han importado todos los módulos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import mi_paquete_de_python as mi_paquete
 
mi_paquete.modulo1.funcion1()
mi_paquete.modulo1.funcion2()
mi_paquete.modulo2.funcion1()
mi_paquete.modulo2.funcion2()
	
	Copied

>_ Output

			
				Hola desde la función 1 del módulo 1
Hola desde la función 2 del módulo 1
Hola desde la función 1 del módulo 2
Hola desde la función 2 del módulo 2

De esta manera solo tenemos que hacer un import

12. Try... except

Cuando ocurre un error, o una excepción como se llama realmente, Python normalmente lo capturará y generará un mensaje de error.

Estas excepciones se pueden manejar usando las declaraciones try y except

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		try:
  print(variable_no_declarada)
except:
  print("Ha ocurrido una excepción")
	
	Copied

>_ Output

			
				Ha ocurrido una excepción

Dado que el bloque try genera un error, entonces se ejecutará el bloque except

Sin el bloque try, el programa se bloquearía y generaría un error

Se pueden definir tantos bloques de excepción como se desee, por ejemplo, si se quiere ejecutar un bloque de código especial para un tipo de error especial

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		try:
  print(variable_no_declarada)
except NameError:
  print("La variable 'variable_no_declarada' no está definida")
except:
  print("Algo inesperado ha ocurrido")
	
	Copied

>_ Output

			
				La variable 'variable_no_declarada' no está definida

Se puede usar la palabra else para indicar el caso en el que no se haya producido un error

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		try:
  print('MaximoFN')
except NameError:
  print("Ha ocurrido una excepción")
else:
  print('Todo OK')
	
	Copied

>_ Output

			
				MaximoFN
Todo OK

con la palabra finally se ejecutará un código al final haya ocurrido una excepción o no

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		try:
  print(variable_no_declarada)
except:
  print("Ha ocurrido una excepción")
finally:
  print("'try except' finallizado")
	
	Copied

>_ Output

			
				Ha ocurrido una excepción
'try except' finallizado

Esto puede resultar útil para cerrar objetos y limpiar recursos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		class Clase:
  variable = 'MaximoFN'
 
objeto = Clase()
 
try:
  print(Clase.mi_variable)
except:
  print("Ha ocurrido una excepción")
finally:
  del objeto
	
	Copied

>_ Output

			
				Ha ocurrido una excepción

12.1. Crear una excepcion

Como desarrollador de Python, se puede elegir lanzar una excepción si ocurre una condición.

Para lanzar (o generar) una excepción, hay que usar la palabra clave raise

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def division(numerador, denominador):
  if denominador == 0:
    raise Exception("El denominador no puede ser 0")
  
  return numerador/denominador
 
print(division(10, 0))
	
	Copied

>_ Output

			
				---------------------------------------------------------------------------Exception                                 Traceback (most recent call last)&lt;ipython-input-16-33fb6066fa78&gt; in &lt;module&gt;
      5   return numerador/denominador
      6
----&gt; 7 print(division(10, 0))
&lt;ipython-input-16-33fb6066fa78&gt; in division(numerador, denominador)
      1 def division(numerador, denominador):
      2   if denominador == 0:
----&gt; 3     raise Exception("El denominador no puede ser 0")
      4
      5   return numerador/denominador
Exception: El denominador no puede ser 0

Se puede definir qué tipo de error generar y el texto que se mostrará al usuario

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		def division(numerador, denominador):
  if denominador == 0:
    raise TypeError("El denominador no puede ser 0")
  
  return numerador/denominador
 
print(division(10, 0))
	
	Copied

>_ Output

			
				---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)&lt;ipython-input-17-26bfa63ae44c&gt; in &lt;module&gt;
      5   return numerador/denominador
      6
----&gt; 7 print(division(10, 0))
&lt;ipython-input-17-26bfa63ae44c&gt; in division(numerador, denominador)
      1 def division(numerador, denominador):
      2   if denominador == 0:
----&gt; 3     raise TypeError("El denominador no puede ser 0")
      4
      5   return numerador/denominador
TypeError: El denominador no puede ser 0

13. Keywords o palabras reservadas

Durante este post en varias ocasiones han aparecido palabras reservadas de Python o keywords, estas son una serie de palabras reservadas por Python

A continuación se muestra una lista de las keywords

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import keyword
 
keyword.kwlist
	
	Copied

>_ Output

			
				['False',
'None',
'True',
'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']

14. El ZEN de Python

Importando el módulo this podemos leer el zen de Python, es decir, su filosofía o principios

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import this
	
	Copied

>_ Output

			
				The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Seguir leyendo

Deep Research con LangGraph: Crea un Asistente de IA para Investigar Automáticamente

Aprende cómo funcionan las redes neuronales desde cero con un ejemplo práctico de regresión lineal. Tutorial paso a paso que explica neuronas artificiales, inicialización de parámetros, funciones de pérdida y error cuadrático medio (ECM) con código Python.

Elicitación MCP: Implementar Elicitación en Servidores con FastMCP y Python

Aprende a implementar elicitación en servidores MCP (Model Context Protocol) con FastMCP. Tutorial completo paso a paso ...

MCP Durability: Servidor y Cliente con Persistencia para Tareas de Larga Duración

Aprende a crear un servidor y cliente MCP con durabilidad para tareas de larga duración. Tutorial completo sobre Model C...

Últimos posts -->

¿Has visto estos proyectos?

Gymnasia

Horeca chatbot

Naviground

Ver todos los proyectos -->

>_ Disponible para proyectos

¿Tienes un proyecto con IA?

Hablemos.

maximofn@gmail.com

Especialista en Machine Learning e Inteligencia Artificial. Desarrollo soluciones con IA generativa, agentes inteligentes y modelos personalizados.

Escríbeme LinkedIn

¿Quieres ver alguna charla?

Agentes del Mañana: Descifrando los Enigmas de Planificación, UX y Memoria

Los agentes IA, impulsados por LLMs, prometen transformar aplicaciones. Pero, ¿son hoy simples ejecutores o futuros colaboradores inteligentes? Para a...

Crea tu propio Apple intelligence

Aprende a crear un sistema de IA para ejecutar eficientemente en un dispositivo

Últimas charlas -->

¿Quieres mejorar con estos tips?

Buenas prácticas creando agentes con Claude Code

Charla técnica: skills, subagentes, slash commands y MCPs en Claude Code

o1 prompt engineering

Crear mejores prompts para o1 siguiendo un ejemplo

Memory profiler

Ver el uso de memoria de un script

Últimos tips -->

Usa esto en local

Los espacios de Hugging Face nos permite ejecutar modelos con demos muy sencillas, pero ¿qué pasa si la demo se rompe? O si el usuario la elimina? Por ello he creado contenedores docker con algunos espacios interesantes, para poder usarlos de manera local, pase lo que pase. De hecho, es posible que si pinchas en alún botón de ver proyecto te lleve a un espacio que no funciona.