Guía completa de Python 2025 (2/3): operadores, control de flujo y funciones

11 de febrero del 2021

En la primera parte vimos los **tipos de datos** de Python. En este segundo capítulo cubrimos los **operadores**, el **control de flujo** (if, for, while) y las **funciones**.

📚 **Esta entrada es parte de la serie _Guía completa de Python_**, dividida en tres capítulos que se leen en orden:

> * Parte 1: Tipos de datos

* 👉 **Parte 2: Operadores, control de flujo y funciones**

* Parte 3: Clases, objetos y temas avanzados

3. Operadores

3.1. Operadores aritméticos

Operador suma +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 + 5
	
	Copied

>_ Output

Operador de resta -

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 - 5
	
	Copied

>_ Output

-2

Operador multiplicación *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 * 5
	
	Copied

>_ Output

Operador de 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 de desplazamiento hacia la izquierda <<

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

>_ Output

Operador de 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 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 quieran, 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, éste 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 permite 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 se 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

---

➡️ **Continúa en la Parte 3: clases, objetos y temas avanzados**, donde darás el salto a la programación orientada a objetos y a los módulos.

Seguir leyendo

Deep Research con LangGraph (3/3): agente Writer e informe final

Tercera y última parte de la serie Deep Research con LangGraph. Implementa el agente Writer que redacta el informe final a partir de la investigación, integra todo el grafo del deep researcher y ejecuta el asistente completo de principio a fin.

Deep Research con LangGraph (2/3): Research Supervisor multiagente

Segunda parte de la serie Deep Research con LangGraph. Construye el Research Supervisor que coordina varios agentes Rese...

Deep Research con LangGraph (1/3): agentes Scope y Researcher

Primera parte de la serie para crear un asistente de investigación con LangGraph. Conoce la arquitectura del sistema y 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.

Flow edit

FLUX.1-RealismLora

token_hmr

Ver todos los contenedores -->

>_ 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 entrenar tu modelo con estos datasets?

short-jokes-dataset

HuggingFace

Dataset de chistes en inglés

Uso: Fine-tuning de modelos de generación de texto humorístico

231K filas 2 columnas 45 MB

Ver en HuggingFace →

opus100

HuggingFace

Dataset con traducciones de inglés a español

Uso: Entrenamiento de modelos de traducción inglés-español

1M filas 2 columnas 210 MB

Ver en HuggingFace →

netflix_titles

HuggingFace

Dataset con películas y series de Netflix

Uso: Análisis de catálogo de Netflix y sistemas de recomendación

8.8K filas 12 columnas 3.5 MB

Ver en HuggingFace →

Ver más datasets -->

3. Operadores

3.1. Operadores aritméticos

3.2. Operadores de comparación

3.3. Operadores lógicos

3.4. Operadores de identidad

3.5. Operadores de pertenencia

3.6. Operadores bit a bit

3.7. Operadores de asignación

4. Control de flujo

4.1. If

4.2. While

4.3. For

5. Funciones

5.1. Built-in functions

5.2. Documentación de una función

5.3. Decoradores

5.4. *args y **kwargs

5.4.1. *args

5.4.2. **kwargs

6. Funciones adicionales

6.1. Funciones *lambda*

6.2. Función map

6.3. Función filter

6.4. Función reduce

6.5. Función zip

6.5. Generadores

6.6. High order functions

Seguir leyendo

Deep Research con LangGraph (3/3): agente Writer e informe final

Deep Research con LangGraph (2/3): Research Supervisor multiagente

Deep Research con LangGraph (1/3): agentes Scope y Researcher

¿Has visto estos proyectos?

¿Tienes un proyecto con IA?

¿Quieres ver alguna charla?

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

Crea tu propio Apple intelligence

¿Quieres mejorar con estos tips?

Buenas prácticas creando agentes con Claude Code

o1 prompt engineering

Memory profiler

Usa esto en local

¿Tienes un proyecto con IA?

¿Quieres entrenar tu modelo con estos datasets?

short-jokes-dataset

opus100

netflix_titles

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

5.4.1. `*args`

5.4.2. `**kwargs`

6.1. Funciones lambda

6.2. Función `map`

6.3. Función `filter`

6.4. Función `reduce`

6.5. Función `zip`