¿Cómo funcionan las funciones en Python?

Comprender cómo funcionan las funciones en Python es clave para crear código limpio y reutilizable en sus programas. Además, comprender cómo funcionan las funciones de Python ayudará cuando se trabaja con un marco como Django o Flask, ambos escritos en el lenguaje de programación Python. De hecho, este es probablemente uno de los beneficios clave, ya que podrá escanear archivos de origen y mirar varias definiciones de funciones para comprender lo que le ofrece el software. Recuerde que, en términos generales e independientemente del lenguaje de programación, una función tiene el propósito de reducir la duplicación de código, dividir problemas más grandes en problemas más pequeños, aumentar la legibilidad del software, impulsar la reutilización del código y ocultar información.

Ciudadanos de primera clase

Es posible que haya oído hablar del término "ciudadano de primera clase" en los círculos de programación antes. De hecho, la idea de funciones como ciudadanos de primera clase es popular en el mundo de JavaScript. Lo que queremos decir cuando decimos ciudadanos de primera clase es que las funciones están al mismo nivel, por así decirlo, que otros objetos del lenguaje. Como resultado de esto, puede asignar funciones a variables o incluso pasarlas como argumento a otras funciones. Al igual que en JavaScript, esto ayuda a permitir que uno doble el lenguaje a su voluntad. Al igual que PHP tiene muchas funciones que se incluyen como parte del lenguaje, también lo hace Python. Estas son las funciones integradas e incluyen funciones como abs (), dir (), bin (), len () y muchas más. Si desea crear su propia función, puede hacerlo haciendo uso de ladef palabra clave, y veremos esto a continuación.

Crear una función de Python

La mejor forma de aprender es haciendo. Por lo tanto, intentemos crear nuestra propia función en Python y aprendamos qué hace que una, bueno, funcione. Así que consideremos la creación de una función que sume dos números y devuelva la suma. Sí, considérelo el "Hola mundo" de crear una función. Pensándolo bien, comencemos con la función "Hola mundo", ya que ni siquiera necesita aceptar ningún parámetro y la función de adición lo hará.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def hello():
    print('Hello World')
    print('Its me')
    print('I was wondering if after all these years you\'d like to meet')
    print('To go over everything')
    print('They say that time\'s supposed to heal ya')
    print('But I ain\'t done much healing')
 
hello()
 
## function call output ##
# Hello World
# Its me
# I was wondering if after all these years you'd like to meet
# To go over everything
# They say that time's supposed to heal ya
# But I ain't done much healing

¡Vaya! Nos dejamos llevar allí, supongo que Adele tiene una influencia de gran alcance en estos días. En cualquier caso, podemos ver cómo construimos esta primera función. Tenga en cuenta que comenzamos la definición de la función con la defpalabra clave. Si incluso abrió un archivo .py de un repositorio de software Python popular y notó un número incalculable de esa palabra clave, ahora sabe para qué sirve. Es para definir tus funciones. Justo después de la palabra clave def, asignamos un nombre para identificar la función seguido de un paréntesis de apertura y cierre, tal como podría encontrar en otro lenguaje de programación. Después de esto, encontramos los dos puntos :personaje. Esto indica el comienzo del bloque de código de función que albergará la lógica que se ejecutará cuando se realice una llamada a esta función en un momento posterior. Las siguientes líneas parecen simples, ¡pero son importantes! En Python, el espacio en blanco significa algo . Antes de cada llamada a print () hay exactamente cuatro espacios en blanco. Si obtiene su espacio en blanco incorrecto en Python, el compilador arrojará un error. Este es un aspecto un poco controvertido de Python, pero si desea programar en este lenguaje, tendrá que acostumbrarse. Después de definir la función, la llamamos simplemente escribiendo hello()en su propia línea sin espacios. Podemos ver por el resultado, que podemos tener un futuro en el negocio de la música.

A continuación, creemos esa función de adición.

1
2
3
4
5
6
7
8
9
def addEmUp(one, two):
    return one + two
 
result = addEmUp(5,7)
 
print(result)
 
## function call output ##
# 12

Esta función funciona tal y como esperamos. Observe que en la definición de la función, dejamos dos parámetros. Estos representan los dos números que pasaremos a nuestra función que sumará. Luego, simplemente devolvemos el resultado de la primera variable más la segunda variable, representada por return one + two. La salida del programa nos muestra que está funcionando a la perfección. Modifiquemos nuestra función para aceptar la entrada del usuario, ya que será más flexible de esta manera.

1
2
3
4
5
6
7
8
9
10
11
12
def addEmUp():
    one = int(input('What is the first number? '))
    two = int(input('What is the second number? '))
    return one + two
 
result = addEmUp()
 
print(result)
 
# What is the first number? 1234
# What is the second number? 2345
# 3579

Al ejecutar esta iteración de la función de suma, podemos ver en la salida del programa que se le pidió al usuario que agregara los números. Algo a tener en cuenta es que la función input () incorporada normalmente leerá datos como una cadena. Es por eso que necesitamos envolver la llamada a input () mediante una llamada int (). Esto convierte o convierte los datos de entrada en un número entero. De esta manera, la suma ocurre en sentido numérico y no en sentido de cadena. Veamos qué pasa si no incluimos esta llamada a int ().

1
2
3
4
5
6
7
8
9
10
11
12
def addEmUp():
    one = input('What is the first number? ')
    two = input('What is the second number? ')
    return one + two
 
result = addEmUp()
 
print(result)
 
# What is the first number? 1234
# What is the second number? 2345
# 12342345

Como podemos ver, ¡probablemente ese no sea el resultado que estamos buscando!

Sintaxis de Python

Ahora que tenemos algunas funciones de trabajo para ver, podemos ver cómo se ve la sintaxis general. Sigue este esquema como hemos demostrado.

1
2
3
4
def name-of-function(Parameter(s)):
    statements (function body)
    statements (function body)
    statements (function body)

La función puede aceptar ninguno, uno o muchos parámetros. Como hemos visto, el cuerpo de la función no tiene llaves como delimitadores. El cuerpo simplemente hace uso de la sangría como parte de su definición. Si hay parámetros requeridos, éstos se designan primero. Los parámetros opcionales siempre vienen después de los parámetros requeridos. Dentro de las declaraciones de la función, se puede hacer uso de la palabra clave return para enviar el resultado de la función a la ubicación de la llamada. Cuando usa una declaración de retorno, termina la llamada a la función. Puede haber ocasiones en las que no necesite devolver un valor, sino simplemente detener la ejecución de la función. En este caso, si usa return, simplemente devolverá el valor None. Esto equivale a algo como nulo en otros idiomas.

Especificar parámetros opcionales

Quizás no te guste decir Hola al mundo. Tal vez le gustaría elegir a quién le está diciendo hola. Podemos hacer esto con parámetros opcionales.

1
2
3
4
5
6
7
8
9
10
11
def hello(world='World'):
    print('Hello ' + world)
 
hello()
# Hello World
hello('Jackson')
# Hello Jackson
hello('J Lo')
# Hello J Lo
hello('Rico')
# Hello Rico

En esta iteración de la función hello (), hacemos que la segunda parte del mensaje de saludo sea opcional. Sabemos que es opcional porque, en la definición del parámetro en sí, asignamos la cadena de 'Mundo' al parámetro mundial. Lo que esto dice es que, cuando llama a la función hello (), si no se pasa ningún argumento, a la variable mundial se le asignará automáticamente el valor de 'Mundo'. Si se pasa un valor como argumento, sobrescribirá este valor predeterminado. Vemos esto en acción saludando a Jackson, J Lo y Rico.

Agregar una cadena de documentos a una función de Python

En uno de nuestros tutoriales anteriores, tuvimos un pequeño ejemplo de clasificación alfabética. En esta iteración, lo convertiremos en una función, que por supuesto hace que el código sea reutilizable, al mismo tiempo que agregamos un Docstring, que es casi una forma de documentación para explicar lo que realmente hace una función. Sigue el formato de function_name .__ doc__ y veremos un ejemplo aquí ahora.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def alphabetsorter():
    '''Sorts the alphabet from a dictionary!'''
    alphabet = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7,
                'h': 8, 'i': 9, 'j': 10, 'k': 11, 'l': 12, 'm': 13, 'n': 14,
                'o': 15, 'p': 16, 'q': 17, 'r': 18, 's': 19, 't': 20, 'u': 21,
                'v': 22, 'w': 23, 'x': 24, 'y': 25, 'z': 26}
    for key, value in sorted(alphabet.items()):
        print(key, value)
    print('The docstring of the function alphabetsorter is : ' + alphabetsorter.__doc__)
 
alphabetsorter()
 
# a 1
# b 2
# c 3
# d 4
# e 5
# f 6
# g 7
# h 8
# i 9
# j 10
# k 11
# l 12
# m 13
# n 14
# o 15
# p 16
# q 17
# r 18
# s 19
# t 20
# u 21
# v 22
# w 23
# x 24
# y 25
# z 26
# The docstring of the function alphabetsorter is : Sorts the alphabet from a dictionary!

Cómo devolver más de un valor

Hemos visto que podemos devolver un valor de una función. Sin embargo, hay ocasiones en las que desea devolver muchos valores de una función. Aunque no puede devolver explícitamente varias variables diferentes que representen valores diferentes, puede devolver una lista o diccionario que contenga los valores múltiples que desea devolver. Vemos esto todo el tiempo en otros lenguajes al devolver una matriz de valores o un objeto que tiene muchos valores. En Python, si tuviera que devolver 5 valores enteros diferentes, podría devolver una tupla o lista que contenga estos valores y acceder a ellos de esa manera. Echemos un vistazo a un programa que usa un retorno de valor múltiple ahora.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def multi_value_return(x, y):
    sum = x + y
    modulo = x % y
    product = x * y
    return (sum, modulo, product)
 
while True:
    x = int(input("What is the first number?: "))
    if x == 0:
        print('Thanks for playing!')
        break
    y = int(input("What is the second number?: "))
    (sum, modulo, product) = multi_value_return(x, y)
    print("Adding these two numbers equals: " + str(sum))
    print("The modulo of these two numbers is: " + str(modulo))
    print("Multiplying these two numbers is: " + str(product))
 
# What is the first number?: 8
# What is the second number?: 7
# Adding these two numbers equals: 15
# The modulo of these two numbers is: 1
# Multiplying these two numbers is: 56
# What is the first number?: 0
# Thanks for playing!

¡Este ejemplo es genial! Primero, definimos una función que toma dos parámetros que son números enteros y calcula la suma, módulo y producto de esos dos números enteros. Ahora, nuestro objetivo es devolver todos los valores resultantes de la función. No podemos hacer algo como devolver suma, devolver módulo, devolver el producto todo en una fila; el programa no funcionará. Entonces, ¿cómo hacemos que esto funcione? ¡La tupla viene al rescate! En lugar de intentar devolver cada valor por sí solo, devolvemos una tupla. Dentro de esa tupla, tenemos el resultado de cada cálculo. Con este enfoque, podemos acceder a los tres valores cuando llamamos a la función en el ciclo while como se muestra arriba.

Cómo funciona el alcance variable en Python

En Python, los nombres de las variables son locales a la función de forma predeterminada. Las variables globales en Python son accesibles tanto dentro como fuera de las funciones. Las variables dentro de funciones solo son accesibles dentro de esas funciones. Las variables y parámetros asignados en una función ocupan el ámbito local . Un alcance es una especie de contenedor de variables. Cuando las variables se asignan fuera de las funciones, ocupan el ámbito global. Solo hay un ámbito global en un programa y se crea al inicializar el programa. Un ámbito local entra en juego cada vez que se llama a una función. Considere estos puntos sobre las variables en Python:

El código en el ámbito global no puede utilizar ninguna variable en un ámbito local.
El código en un ámbito local puede acceder a variables en el ámbito global.
El código de una función anidada puede acceder al ámbito local de la función externa.
Puede usar el mismo nombre para diferentes variables si están en diferentes ámbitos.

1
2
3
4
5
6
7
8
language = 'JavaScript'
 
def variablescope():
    language = 'Python'
    print(language)
 
variablescope() #inside the function language == 'Python'
print(language) #outside the function language == 'JavaScript'

1
2
3
4
5
6
7
8
9
10
11
12
global_language = 'JavaScript'
 
def variablescope():
    private_language = 'Python'
    print(global_language)
 
variablescope()         #JavaScript
                        #the global_language variable can be accessed inside the function
 
print(private_language) #NameError: name 'private_language' is not defined
                        #an error is thrown, unable to access variable defined
                        #inside the function

Podemos ver que el fragmento de código justo arriba arroja un NameError ya que no puede acceder a una variable definida por función en el alcance global. Si necesitamos tener acceso a esa variable, podemos hacerlo simplemente declarando esa variable como global. Así es como podemos hacer eso.

1
2
3
4
5
6
7
8
9
10
11
12
13
global_language = 'JavaScript'
 
def variablescope():
    global private_language
    private_language = 'Python'
    print(global_language)
 
variablescope()         #JavaScript
                        #the global_language variable can be accessed inside the function
 
print(private_language) #Python
                        #we can now access private_language variable outside of the
                        #function since we declared it as global

Cierre en Python

Como hemos aprendido en JavaScript, cuando una función anidada llega fuera de su propio ámbito local para acceder a una variable no global que es parte de una función externa, entonces tenemos el cierre. La función externa, sin embargo, no tiene acceso a las variables de la función interna. Python hace uso de esta construcción, y podemos ver un ejemplo de esto en acción aquí mismo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def outer_function():
    outer_variable = 'I live in the outer function'
 
    def nested_function():
        inner_variable = 'I live in the inner function'
        print('The outer_variable is: ', outer_variable)
        print('The inner_variable is: ', inner_variable)
        print('************')
 
    nested_function()
    print('The outer_variable is: ', outer_variable)
    print('The inner_variable is: ', inner_variable)  # NameError: name 'inner_variable' is not defined
 
 
outer_function()
 
# The outer_variable is:  I live in the outer function
# The inner_variable is:  I live in the inner function
# ************
# The outer_variable is:  I live in the outer function
# NameError: name 'inner_variable' is not defined