Complete Python Guide 2025 (2/3): operators, control flow and functions

11 of february of 2021

In the first part we saw Python’s **data types**. In this second chapter we cover **operators**, **flow control** (if, for, while) and **functions**.

Disclaimer: This post has been translated to English using a machine translation model. Please, let me know if you find any mistakes.

📚 **This post is part of the _Complete Python Guide_ series**, divided into three chapters that are read in order:

> * Part 1: Data types

* 👉 **Part 2: Operators, control flow, and functions**

* Part 3: Classes, objects, and advanced topics

3. Operators

3.1. Arithmetic operators

Operator addition +

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 + 5
	
	Copied

>_ Output

Subtraction operator -

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 - 5
	
	Copied

>_ Output

-2

Multiplication operator *

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 * 5
	
	Copied

>_ Output

Division operator /

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 / 5
	
	Copied

>_ Output

0.6

Modulo operator %. Returns the remainder of a division

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		25 % 2
	
	Copied

>_ Output

Exponent operator **

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		5 ** 2
	
	Copied

>_ Output

Integer division operator //

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		25 // 2
	
	Copied

>_ Output

3.2. Comparison operators

Operator is ==

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		1 == 1
	
	Copied

>_ Output

			
				True

Operator is different !=

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		1 != 2
	
	Copied

>_ Output

			
				True

Operator is greater than >

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 &gt; 2
	
	Copied

>_ Output

			
				True

Operator is less than <

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		2 &lt; 3
	
	Copied

>_ Output

			
				True

Operator is greater than or equal to >=

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 &gt;= 3
	
	Copied

>_ Output

			
				True

Operator is less than or equal to <=

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		3 &lt;= 3
	
	Copied

>_ Output

			
				True

3.3. Logical Operators

Operator and

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		True and True
	
	Copied

>_ Output

			
				True

Operator or

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		True or False
	
	Copied

>_ Output

			
				True

Operator not

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		not False
	
	Copied

>_ Output

			
				True

3.4. Identity operators

is operator

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		5.3 is 5.3
	
	Copied

>_ Output

			
				True

Operator is not

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		5.3 is not 5
	
	Copied

>_ Output

			
				True

3.5. Membership operators

in operator

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

>_ Output

			
				True

not in operator

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

>_ Output

			
				True

3.6. Bitwise operators

AND operator &

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

>_ Output

OR operator |

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

>_ Output

XOR operator ^

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

>_ Output

NOT operator ~

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

>_ Output

-61

Left shift operator <<

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

>_ Output

Right shift operator >>

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

>_ Output

3.7. Assignment operators

Operator =

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a = 5
a
	
	Copied

>_ Output

Operator +=. x += y is equivalent to x = x + y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a += 5
a
	
	Copied

>_ Output

Operator -=. x -= y is equivalent to x = x - y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a -= 5
a
	
	Copied

>_ Output

Operator *=. x *= y is equivalent to x = x * y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a *= 3
a
	
	Copied

>_ Output

Operator /=. x /= y is equivalent to x = x / y

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		a /= 3
a
	
	Copied

>_ Output

5.0

Operator %=. x %= y is equivalent to x = x % y

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

>_ Output

Operator //=. x //= y is equivalent to x = x // y

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

>_ Output

Operator **=. x **= y is equivalent to x = x ** y

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

>_ Output

Operator &=. x &= y is equivalent to x = x & y

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

>_ Output

Operator |=. x |= y is equivalent to x = x | y

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

>_ Output

Operator ^=. x ^= y is equivalent to x = x ^ y

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

>_ Output

Operator >>=. x >>= y is equivalent to x = x >> y

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

>_ Output

Operator <<=. x <<= y is equivalent to x = x << y

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

>_ Output

4. Flow Control

To be able to use flow control tools, it is necessary to add the statement, a colon : and on a new line write the code with indentation.

Unlike other languages, Python needs indentation (adding whitespace) to define the code within a control flow tool

4.1. Si

Using if, we can create conditionals

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

>_ Output

			
				MaximoFN tiene 8 caracteres

If we want to create more than one condition, we can use 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

If what we want is for something to run in case none of the indicated conditions are met, we can use 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

If we want to write everything on a single line

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

>_ Output

			
				MaximoFN tiene 8 caracteres

Likewise, if we want to write everything on one line, but with several conditions

	
		
			< >
			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

If, for example, we want to create the structure of the if but do not want, for now, to code one of the conditions, we can use 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. Mientras

The while loop runs while the condition is True

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

>_ Output

			
				MaximoFN

If we want the loop to stop for some condition, we use 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

If we want one of the iterations not to execute for some reason, we use 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

Using else, you can execute a block of code if the while condition is not 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. Para

The for loop is used to execute code while iterating over a sequence; this sequence can be any iterable element in Python (string, list, tuple, range, dictionary, 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

You can also iterate over sets, but since they are unordered elements, we won't have control over the execution order

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

>_ Output

			
				NximoaMF

If we want the loop to stop for some condition, we use break

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

>_ Output

			
				Maximo

If we want one of the iterations not to run for some reason, we use continue

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

>_ Output

			
				MaximoFN

Using else, you can execute a block of code if the condition of the while is not 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

If, for example, we want to create the structure of the for loop but do not want to code its body yet, we can use pass

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

>_ Output

			
				Interior del for no codificado

5. Functions

A function is a portion of code that can be executed as many times as you want. It can be passed arguments and can return data as a result

To define a function, start with the reserved word def, followed by the function name, parentheses (), a colon :, and then on a new line, indented, the function code.

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

To call the function, it is only necessary to write its name

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		funcion()
	
	Copied

>_ Output

			
				MaximoFN

Functions can be passed as many arguments as desired, within the parentheses and separated by commas

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

>_ Output

			
				Hola MaximoFN

When the function is called, the same number of arguments that were declared must be passed to it; if more or fewer are passed, an error would occur.

If we do not know the arguments that the function will receive, we can use *args, that is, by placing a * before the arguments, we indicate that the number of arguments is flexible.

By doing this, a tuple is passed to it (remember that it is immutable) with the arguments

	
		
			< >
			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

In case we do not know the order of a function's arguments, we can specify the argument we want to pass by indicating its name.

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

>_ Output

			
				Blog de MaximoFN

In case you want to pass the arguments by name, but if you do not know how many arguments will be passed, you can use **kwargs. In this case, a dictionary with the arguments will be passed to it.

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

>_ Output

			
				Autor del blog: MaximoFN

If we want any argument to have a default value, we can indicate it between the parentheses of the function. In this way, if when calling the function that argument is not passed, it will have the default value in the function.

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

>_ Output

			
				Blog de MaximoFN

Any type of data can be passed as an argument. For example, if a list is passed as an argument, within the function, that argument will be treated as a list

	
		
			< >
			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

Functions can return data, this is done using the reserved word 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

They can return more than one piece of data

	
		
			< >
			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

If one of the returned data items is not of interest to us, we can skip it using _

	
		
			< >
			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

If, for example, we want to create the structure of the function, but for now we don't want to code the inside, we can use pass

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

A function can call itself; this is called recursion or recursive function behavior.

For example, we can use this property to calculate the factorial of a number

	
		
			< >
			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. Funciones integradas

There are a series of functions already defined in Python that can be used, such as the abs() function, which returns the absolute value

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		abs(-5)
	
	Copied

>_ Output

Below is a list of these functions

	
		
			< >
			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. Function documentation

An explanation of a function we create can be added through a comment at the start of the function; in this way, when we call the built-in function help(), it will show that explanation.

	
		
			< >
			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

Another option to view the function's explanation is to use the function's __doc__ method

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		funcion.__doc__
	
	Copied

>_ Output

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

5.3. Decorators

Decorators are a Python feature that allows new capabilities to be added to a function

A decorator function is created that takes another function as a parameter. Then the decorator function adds the new feature to the function it receives.

	
		
			< >
			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
==================

But a more powerful way to use decorators is by using @ and the decorator’s name before the function.

That is, first the decorator is defined and, then, a function is called with the defined decorator

	
		
			< >
			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` and `**kwargs`

*args and **kwargs are optional arguments that can be used when defining a function in Python. The syntax is as follows:

def my_function(arg1, arg2, *args, **kwargs):
      # function code here

5.4.1. `*args`

*args is used to pass a variable number of arguments to a function. By using *args, you can send a variable amount of arguments to the function without having to specify the exact number of arguments the function needs. The arguments are received in the function as a tuple.

	
		
			< >
			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 is used in the same way, but to send a variable number of keyword arguments (keyword arguments) to a function. By using **kwargs, you can send a variable amount of arguments to the function and specify the value of each argument using its name. The arguments are received in the function as a dictionary.

	
		
			< >
			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. Additional functions

6.1. Lambda functions

A *lambda* function is a small anonymous function.

A *lambda* function can take any number of arguments, but it can only have one expression.

*Lambda* functions are defined as follows:

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

The power of *lambda* is best shown when it is used as an anonymous function within another function.

	
		
			< >
			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. Function `map`

The map function allows you to apply a function to each element of an iterable structure

	
		
			< >
			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]

This is equivalent to using list comprehension

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

>_ Output

			
				[2, 3, 4]

6.3. Function `filter`

The filter function allows selecting the elements of an iterable structure that meet a condition

	
		
			< >
			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]

This is equivalent to using list comprehension

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

>_ Output

			
				[2, 4, 6]

6.4. `reduce` Function

The reduce function allows performing cumulative tasks on iterable structures

	
		
			< >
			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. Function `zip`

With the zip function, several iterable structures can be combined into one, that is, it allows grouping several elements from the *A_x* structures into a single *B* structure. The *B* structure is made up of tuples of the elements of the *A_x* structures

	
		
			< >
			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. Generators

Suppose we want to iterate over a sequence of numbers, but in a special way that no kind of loop offers us. We can solve this with generators. To do this, the generator function does not have to return the value with return, but with yield so that it knows it has to keep iterating

	
		
			< >
			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

We just made an iterator for numbers that are multiples of 3

6.6. Funciones de orden superior

We can create functions that receive other functions as parameters, so that the function that receives another function as a parameter is called a higher-order function. Let’s look at an example

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

>_ Output

---

➡️ **Continue in Part 3: classes, objects, and advanced topics**, where you will make the leap to object-oriented programming and modules.

Continue reading

Deep Research with LangGraph (3/3): the Writer agent and final report

Third and final part of the Deep Research with LangGraph series. Implement the Writer agent that drafts the final report from the research, assemble the full deep researcher graph, and run the complete assistant end to end.

Deep Research with LangGraph (2/3): the multi-agent Research Supervisor

Second part of the Deep Research with LangGraph series. Build the Research Supervisor that coordinates several Researche...

Deep Research with LangGraph (1/3): Scope and Researcher agents

First part of the series on building an AI research assistant with LangGraph. Learn the system architecture and build th...

Last posts -->

Have you seen these projects?

Gymnasia

Horeca chatbot

Naviground

View all projects -->

>_ Available for projects

Do you have an AI project?

Let's talk.

maximofn@gmail.com

Machine Learning and AI specialist. I develop solutions with generative AI, intelligent agents and custom models.

Write me LinkedIn

Do you want to watch any talk?

Tomorrow's Agents: Deciphering the Mysteries of Planning, UX and Memory

AI agents, powered by LLMs, promise to transform applications. But are they simple executors today or future intelligent collaborators? To reach their...

Create your own Apple intelligence

Learn to create an IA system to execute efficiently on a device

Last talks -->

Do you want to improve with these tips?

Best practices building agents with Claude Code

Technical talk: skills, subagents, slash commands and MCPs in Claude Code

o1 prompt engineering

Create better prompts for o1 following an example

Memory profiler

See the memory usage of a script

Last tips -->

Use this locally

Hugging Face spaces allow us to run models with very simple demos, but what if the demo breaks? Or if the user deletes it? That's why I've created docker containers with some interesting spaces, to be able to use them locally, whatever happens. In fact, if you click on any project view button, it may take you to a space that doesn't work.

Flow edit

FLUX.1-RealismLora

token_hmr

View all containers -->

>_ Available for projects

Do you have an AI project?

Let's talk.

maximofn@gmail.com

Machine Learning and AI specialist. I develop solutions with generative AI, intelligent agents and custom models.

Write me LinkedIn

Do you want to train your model with these datasets?

short-jokes-dataset

HuggingFace

Dataset with jokes in English

Use: Fine-tuning text generation models for humor

231K rows 2 columns 45 MB

View on HuggingFace →

opus100

HuggingFace

Dataset with translations from English to Spanish

Use: Training English-Spanish translation models

1M rows 2 columns 210 MB

View on HuggingFace →

netflix_titles

HuggingFace

Dataset with Netflix movies and series

Use: Netflix catalog analysis and recommendation systems

8.8K rows 12 columns 3.5 MB

View on HuggingFace →

View more datasets -->

3. Operators

3.1. Arithmetic operators

3.2. Comparison operators

3.3. Logical Operators

3.4. Identity operators

3.5. Membership operators

3.6. Bitwise operators

3.7. Assignment operators

4. Flow Control

4.1. Si

4.2. Mientras

4.3. Para

5. Functions

5.1. Funciones integradas

5.2. Function documentation

5.3. Decorators

5.4. *args and **kwargs

5.4.1. *args

5.4.2. **kwargs

6. Additional functions

6.1. *Lambda* functions

6.2. Function map

6.3. Function filter

6.4. reduce Function

6.5. Function zip

6.5. Generators

6.6. Funciones de orden superior

Continue reading

Deep Research with LangGraph (3/3): the Writer agent and final report

Deep Research with LangGraph (2/3): the multi-agent Research Supervisor

Deep Research with LangGraph (1/3): Scope and Researcher agents

Have you seen these projects?

Do you have an AI project?

Do you want to watch any talk?

Tomorrow's Agents: Deciphering the Mysteries of Planning, UX and Memory

Create your own Apple intelligence

Do you want to improve with these tips?

Best practices building agents with Claude Code

o1 prompt engineering

Memory profiler

Use this locally

Do you have an AI project?

Do you want to train your model with these datasets?

short-jokes-dataset

opus100

netflix_titles

5.4. `*args` and `**kwargs`

5.4.1. `*args`

5.4.2. `**kwargs`

6.1. Lambda functions

6.2. Function `map`

6.3. Function `filter`

6.4. `reduce` Function

6.5. Function `zip`