<jupyter_start><jupyter_text>[![imagenes](imagenes/pythonista.png)](https://pythonista.mx)  Funciones.Las funciones en Python son objetos que pueden ser ejecutados al ser invocados y que realizan ciertas operaciones que fueron asignadas al momento de ser definidas.```{, , ..., )```Donde:* `````` es el nombre de una función.* `````` es un objeto que se ingresa como argumento.   Características de las funciones.* Las funciones pueden aceptar argumentos que serán asignados a los parámetros definidos en dichas funciones. Es necesario que para cada parámetro definido en una función se ingrese un argumento.* Cada  función tiene su propio ámbito.* Las funciones siempre regresan un objeto como resultado de su ejecución. Si no se indica lo contrario, las funciones regresan ```None```. **Ejemplos:** * La siguiente celda ejecutará la función ```dir()``` sin ingresar argumentos. El resultado será el contenido del espacio de nombres del intérprete.<jupyter_code>dir()<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará la función ```len()``` ingresando el objeto ```"Hola, Mundo."``` como argumento. El resultado es ```12```.<jupyter_code>len("Hola, mundo.")<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```print()```, ingresando al objeto ```"Hola, Mundo."``` como argumento. * La función ```print()``` despliega un mensaje ```Hola, Mundo.``` en la salida estándar del intérprete, pero en realidad regresa ```None```.<jupyter_code>print("Hola, mundo.")<jupyter_output><empty_output><jupyter_text>* La siguiente celda asignará el nombre ```resultado``` al objeto que regrese la función ```print()```.<jupyter_code>resultado = print("Hola, mundo.")<jupyter_output><empty_output><jupyter_text>* La siguiente celda deplegará el objeto ligado al nombre ```resultado```, el cual es ```None```.<jupyter_code>print(resultado)<jupyter_output><empty_output><jupyter_text>Definición de una función.Python permite definir funciones utilizando generalmente la siguiente sintaxis:```def (, , ... , ):    ```Donde:* `````` es el nombre de una función.* `````` es el nombre de un parámetro, el cual recibirá un argumento. **Nota:** Posteriormente se estudiarán las *funciones lambda*, las cuales permiten definir funciones de una manera distinta a la presentada aquÍ.   Ejemplo: Definición de una función mínima.  La declaración ```pass```.La declaración ```pass``` no realiza ninguna acción, pero evita que se genere un error de indentación al crear una función vacía. La siguiente celda define a la función ```nada()```, la cual aún cuando es sintácticamente correcta, no realiza ningun tipo de acción.<jupyter_code>def nada():
    pass<jupyter_output><empty_output><jupyter_text>* Al invocar a la función ```nada()```, dicha funci;on es ejecutada, pero no realiza ninguna operación.<jupyter_code>nada()<jupyter_output><empty_output><jupyter_text>Ejemplo: La función ```saludo()```.* La siguiente celda deifne a la función ```saludo()```, la cual desplegará el texto ```Hola``` al ser invocada.<jupyter_code>def saludo():
    print('Hola')<jupyter_output><empty_output><jupyter_text>* Al ejecutar la funcion ```saludo()```, se desplegará ```Hola```.<jupyter_code>saludo()<jupyter_output><empty_output><jupyter_text>Las funciones son objetos.En Python, las funciones son objetos de primer orden. Es decir, que cuentan con atributos y métodos bien defindos al ser creadas. **Ejemplo:** * La siguiente celda cointiene a una expresión que refiere al nombre ```saludo``` (sin los paréntesis), lo que regresará al objeto ligado a dicho nombre y el cual es ```<function __main__.saludo()```.<jupyter_code>saludo<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la funcion ```type()```, ingresando el nombre ```saludo``` como argumento. El resutado será ```function```.<jupyter_code>type(saludo)<jupyter_output><empty_output><jupyter_text>* Al ejecutar la función ```dir()``` ingresando el nombre ```saludo``` como argumento, el resultado es el contenido de dicho objeto.<jupyter_code>dir(saludo)<jupyter_output><empty_output><jupyter_text>Introspección en las funciones.Python puede generar documentación a partir del código y los elementos de un objeto y particularmente de los comentarios de estilo docstring.El primer comentario usando docstring justo debajo de ```def``` se utiliza como parte de la documentación de la función. **Ejemplo:** * La siguiente celda define a la función ```saludo()```, incluyendo una *docstring* descriptiva.<jupyter_code>def saludo():
    '''Imprime un mensaje de texto.'''
    print( 'Hola')<jupyter_output><empty_output><jupyter_text>* Al ejecutar la función ```help()``` ingresando al nombre ```saludo``` como argumento, la descripción de dicho objeto incluye el texto de la *docstring* insertada después la definición.<jupyter_code>help(saludo)<jupyter_output><empty_output><jupyter_text>Ámbitos.El intérprete de Python cuenta con un espacio de nombres en el que se ligan los objetos mediante la asignación de un nombre. Del mismo modo, las funciones crean su propio espacio de nombres, el cual deja de existir tan pronto como la función invocada concluye su ejecución.A estos espacios de nombres diferenciados se les conoce como ámbitos y evita que objetos definidos con nombres idénticos dentro de una función sobrescriban el espacio de nombres del intérprete. **Ejemplo:** * La siguiente celda creará al objeto ```"Hola"``` con nombre ```objeto``` en el espacio de nombres del intérprete.<jupyter_code>objeto = "Hola"
objeto<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará la función ```dir()``` sin argumentos, la cuaL regresará un objeto de tipo ```list``` que contiene a todos los nombres definido en el espacio de nombres del intérprete,  incluyendo a ```'objeto'```.<jupyter_code>dir()<jupyter_output><empty_output><jupyter_text>* La siguiente celda definirá a la funcion ```mifuncion()```, en la que:    * Se define de forma local al objeto ```2``` con nombre ```objeto```.    * Se despliega el contenido de ```objeto```.<jupyter_code>def mifuncion():
    objeto = 2
    print(objeto)<jupyter_output><empty_output><jupyter_text>* Al ejecutar la función ```mifuncion()```, se utilizará la referencia al nombre ```objeto``` correpsondiente a ```2```<jupyter_code>mifuncion()<jupyter_output><empty_output><jupyter_text>* El objeto ```"Hola"``` sigue ligado al nombre ```objeto``` en el ámbito global.<jupyter_code>objeto<jupyter_output><empty_output><jupyter_text>Ámbito global.El espacio de nombres del intérprete de Python corresponde al ámbito global.  La función ```globals()```.La función ```globals()``` regresa el contenido del espacio de nombres del ámbito global como un objeto de tipo ```dict```.Cuando se invoca la función ```dir()``` sin argumentos desde el intérprete, ésta regresa un objeto de tipo ```list``` con el listado de nombres del ámbito global.  Ámbitos locales.Cada función genera su propio espacio de nombres cada vez que es invocada. Cada uno de estos espacios de nombres es un ámbito local.**Nota:** Los parámetros definidos en una función pertencen al ámbito local.  La función ```locals()```.La función ```locals()``` regresa el contenido del espacio de nombres del ámbito local como un objeto de tipo ```dict```. Cuando se invoca la función ```dir()``` sin argumentos desde una función, ésta regresa un objeto de tipo ```list``` con el listado de nombres del ámbito local. **Ejemplo:** * Se definirá la función ```ambitos()```, la cual desplegará:   * El contenido de su ámbito local mediante ```locals()``` y ```dir()```.   * El espacio de nombres del ámbito global con ```globals()```.<jupyter_code>def ambitos():
    lista = [1, 2, 3]
    nulo = None
    print('Espacio de nombres en el ámbito local:')
    print('%s\n%s\n' %(locals(), dir()))
    print('----------------')
    print('Espacio de nombres en el ámbito global:')
    print(globals())
ambitos()<jupyter_output><empty_output><jupyter_text>* La siguiente celda se ejecutará la función ```dir()``` desde el intérprete.<jupyter_code>dir()<jupyter_output><empty_output><jupyter_text>Búsqueda de nombres entre ámbitos.Cuando se invoca a una función y se hace una referencia a un nombre, el intérprete primeramente busca una coincidencia dentro del ámbito local y posteriormente en el ámbito global. En caso de no encontrarla, se generará un error de tipo ```NameError```. **Ejemplo:** * Se creará la función ```trino()```, haciendo referencia al nombre ```ave```, pero no se definirá en el ámbito global ni en el local.<jupyter_code>def trino():
    print(ave * 3)<jupyter_output><empty_output><jupyter_text>* El nombre ```ave``` no ha sido definido en el ámbito global. * La siguiente celda tratará de buscar el nombre ```ave``` en el ámbito local. Al no encotrarlo, se generará un error de tipo ```NameError```.<jupyter_code>ave<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará la función ```trino``` y en vista de que el nombre ```ave```no existe en el ámbito global ni tampoco en el ámbito local de la función, se desencadenará un error de tipo ```NameError```.<jupyter_code>trino()<jupyter_output><empty_output><jupyter_text>* La siguiente celda definirá al objeto ```'pio'```con el nombre ```ave```en el ámbito global.<jupyter_code>ave = 'pio'<jupyter_output><empty_output><jupyter_text>* Al ejecutar a la función ```trino``` ésta se jecutará correctamente ya que el nombre ```ave``` existe en el ámbito global.<jupyter_code>trino()<jupyter_output><empty_output><jupyter_text>**Ejemplo:*** Se creará la función ```multiplica()```, definiendo en el ámbito local de la función a un objeto de tipo ```int``` con el nombre ```factor``` y hará una referencia dicho nombre.<jupyter_code>def multiplica():
    factor = 12
    print(factor * 5)<jupyter_output><empty_output><jupyter_text>* Se invocará a la función ```multiplica()```.<jupyter_code>multiplica()<jupyter_output><empty_output><jupyter_text>* Se definirá a un objeto de tipo ```str``` con el nombre ```factor``` en el ámbito global.<jupyter_code>factor = "factor"<jupyter_output><empty_output><jupyter_text>* Se invocará nuevamente a la función ```multiplica()```. Esta función utilizará al objeto con nombre ```factor``` de su ámbito local.<jupyter_code>multiplica()<jupyter_output><empty_output><jupyter_text>Definiendo nombres en el ámbito global con la palabra reservada ```global```.Es posible que una función pueda ligar un objeto al espacio de nombres del ámbito global mediante el uso de la expresión ```global``` con la siguiente sintaxis.```global  = ```Donde:* `````` es el nombre que se quiere añadir al ámbito global.* `````` es un objeto ligado a ``````. **Ejemplo:** * La siguiente celda define en el ámbito global al nombre ```minombre``` ligado al objeto ```'Juan'```.<jupyter_code>minombre = "Juan"<jupyter_output><empty_output><jupyter_text>* La función ```nombre_global()``` definirá de forma global al objeto ```"Hola"``` con nombre ```minombre```.<jupyter_code>def nombre_global():
    global minombre
    minombre = "Hola"<jupyter_output><empty_output><jupyter_text>* Al ejecutar la función ```nombre_global()```, el nombre ```minombre``` será sustituído por el objeto ```"Hola"```.<jupyter_code>nombre_global()
minombre<jupyter_output><empty_output><jupyter_text>Argumentos y parámetros.  Argumentos.Las funciones permiten aceptar datos al ser invocadas. A estos datos que se ingresan se les denomina argumentos. ```(, , ...  )```Donde: * `````` es el nombre de una función existente.* `````` es cualquier tipo de objeto.  Parámetros.Al ser definidas, las funciones permiten asignar nombres en el ámbito local capaces de recibir argumentos. A estos nombres se les conocen como parámetros. ```def (, , ...  ):   ...   ...```Donde: * `````` es el nombre de la función a definir.* `````` es un nombre al que se le asignará un argumento.En Python el número de argumentos ingresados debe corresponder al número de parámetros que se definen. En caso de que no se ingresen los argumentos necesarios, se generará un error de tipo ```TypeError```. **Ejemplo:** * La siguiente celda define a la función ```suma()```, la cual a su vez define 2 parámetros:   * ```primero```.   * ```segundo```.<jupyter_code>def suma(primero, segundo):
    '''Despliega la suma de dos objetos'''
    print(primero + segundo)<jupyter_output><empty_output><jupyter_text>* La siguiente celda despelgará la documentación del objeto ```suma```. Es importante hacer notar que en la descripción de la función se indican los argumentos definidos.<jupyter_code>help(suma)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```suma()``` ingresando los argumentos ```12, 5```, de tal forma que:    * Al parámetro  ```primero``` se le asignará el objeto ```12```.    * Al parámetro ```segundo``` se le asignará el objeto ```5```.<jupyter_code>suma(12, 5)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```suma()``` ingresando los argumentos ```'Hola, ',  'Mundo.'```. * El primer argumento corresdponderá al primer parámetro. Es decir:    * Al parámetro ```primero``` se le asignará el objeto ```'Hola, '```.    * Al parámetro ```segundo``` se le asignará el objeto ```'Mundo.'```.<jupyter_code>suma('Hola, ', 'Mundo.')<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```suma()``` sin argumentos. Lo que generará un error de tipo ```TypeError```.<jupyter_code>suma()<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```suma()``` ingresando sólo 1 argumento. Lo que generará un error de tipo ```TypeError```.<jupyter_code>suma('Hola')<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```suma()``` ingresando 3 argumentos. Lo que generará un error de tipo ```TypeError```.<jupyter_code>suma('Hola, ', 'Mundo', '.')<jupyter_output><empty_output><jupyter_text>Parámetros con argumentos por defecto.Es posible asignar valores por defecto a cada parámetro definido en una función mediante el operado de asignación ```=```.* Si a todos los parámetros se les asigna un valor, entonces no es necesario ingresar argumentos al invocar la función, ya que dichos valores serán utilizados. Los argumentos que se ingresen se irán sustituyendo de izquierda a derecha.* Si al definir una función se asignaran argumentos por defecto a sólo algunos parámetros, dichos argumentos se deben de dejar al principio de la sucesión de parámetros. De no ser así, se generará un error de tipo ```SyntaxError```.```def (=, =, ...  =):   ...   ...```Donde: * `````` es el nombre de la función a definir.* `````` es un nombre al que se le asignará un argumento. **Ejemplo:** La función ```suma()``` define los argumentos:* ```primero=1```* ```segundo=3```<jupyter_code>def suma(primero=1, segundo=3):
    '''Despliega la suma de dos objetos'''
    print(primero + segundo)<jupyter_output><empty_output><jupyter_text>* La siguiente celda despelgará la documentación del objeto ```suma```. En la descipción del objeto se indican los parámetros con los argumentos por defecto.<jupyter_code>help(suma)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```suma()``` sin argumentos, por lo que se usarán los valores por defecto.<jupyter_code>suma()<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```suma()``` con un solo argumento igual a ```2```. Este argumento será ligado al parámetro ```primero```.<jupyter_code>suma(2)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```suma()``` con dos argumentos.<jupyter_code>suma(23, 51.4)<jupyter_output><empty_output><jupyter_text>**Ejemplo:** * La siguiente celda tratará de definir a la función ```suma()```, definiendo un parámetro con argumento por defecto al final de la sucesión de parámetros ```segundo=3```.<jupyter_code>def suma(primero, segundo=3):
    '''Despliega la suma de dos objetos'''
    print(primero + segundo)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará función ```suma()``` sin argumentos y se desencadenará un error de tipo ```TyepeError```. Cabe hacer notar que el mensaje de error indica que hace falta solo un argumento.<jupyter_code>suma()<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará función ```suma()``` con un argumento, el cual será ligado al parámetro ```primero```.<jupyter_code>suma(2)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará función ```suma()``` con dos argumentos.<jupyter_code>suma("2", "43")<jupyter_output><empty_output><jupyter_text>* La siguiente celda intentará definir en la función ```suma()``` al argumento ```primero=1``` y al parámetro ```segundo``` sin argumento por defecto. Esto provocará un error de tipo ```SyntaxError```.<jupyter_code>def suma(primero=1, segundo):
    '''Despliega la suma de dos objetos'''
    print(primero + segundo)<jupyter_output><empty_output><jupyter_text>* La siguiente definición de la función ```suma()``` es la adecuada.<jupyter_code>def suma(segundo, primero=1):
    '''Despliega la suma de dos objetos'''
    print(primero + segundo)<jupyter_output><empty_output><jupyter_text>Captura de varios argumentos en un parámetro de tipo ```tuple``` (```*args```).Es posible definir un parámetro que acepte un número indeterminado de argumentos y que éstos queden guardados dentro de un objeto tipo ```tuple```. Para esto, basta preceder al nombre del parámetro con un solo asterisco ```*```.```def (, , ... , *) ```Donde:* `````` son parámetros a los que se les asigna un argumento.* `````` es un parámetro que es capaz de recibir cualquier número de argumentos y corresponde a un objeto de tipo  ```tuple```.El parámetro que recibe más de un argumento debe definirse al final de la lista de parámetros. **Ejemplo:** * La siguiente celda definirá la función ```promedio()```, incluyendo al parámetro ```*muestras```.   * Se despelgará el contenido del parámetro ```muestras```.   * Se realizarán algunas operaciones con las funciones ```sum()``` y ```len()``` usando al parámetro ```muestra```.<jupyter_code>def promedio(*muestras):
    '''Función que calcula el promedio a partir de un parámetro al que se 
    ingresa un número arbitrario de argumentos.'''
    print('Muestras:', muestras)
    '''Calcula el promedio de la muestra correspondiente a 
    todos los parámetros ingresados.'''
    promedio = sum(muestras)/len(muestras)
    print('El promedio de la muestra de %d elementos es %.3f.' %(len(muestras), promedio))<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```promedio()``` con 7 argumentos, los cuales serán asignados como elementos de un objeto de tipo ```tuple``` al parámetro ```muestras``` en el ámbito de la función ```promedio()``` .<jupyter_code>promedio(1, 3, 5, 8, 11, 24, 90, 29)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```promedio()``` con 3 argumentos, los cuales serán asignados como elementos de un objeto de tipo ```tuple``` al parámetro ```muestras``` en el ámbito de la función ```promedio()``` .<jupyter_code>promedio(14, 38, 1)<jupyter_output><empty_output><jupyter_text>**Ejemplo:** * La siguiente celda definirá la función ```promedio()```, incluyendo los parámetros ```titulo, *muestras```.   * Se realizarán algunas operaciones con las funciones ```sum()``` y ```len()``` usando al parámetro ```muestra```.<jupyter_code>def promedio(titulo, *muestras):
    '''Función que calcula el promedio a partir de un parámetro al que se 
    ingresa un número arbitrario de argumentos. El primer argumneto será usado
    como título.'''
    promedio = sum(muestras)/len(muestras)
    print(titulo)
    print('El promedio de la muestra de %d elementos es %.3f.' %(len(muestras), promedio))<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará la función ```promedio()``` ingresando la secuencia de argumentos ```'Conteo de abejas en campo.', 34, 45, 61, 23, 47, 41, 52```.    * Al parámetro ```titulo``` se le asignará el objeto ```'Conteo de abejas en campo.'```.    * Al parámetro ```muestras``` se le asignará el objeto  ```(34, 45, 61, 23, 47, 41, 52)```.<jupyter_code>promedio('Conteo de abejas en campo.', 34, 45, 61, 23, 47, 41, 52)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará la función ```promedio()``` ingresando la secuencia de argumentos ```1, 3, 5, 8, 11, 24, 90, 29```.    * Al parámetro ```titulo``` se le asignará el objeto ```1```.    * Al parámetro ```muestras``` se le asignará el objeto  ```(3, 5, 8, 11, 24, 90, 29)```.<jupyter_code>promedio(1, 3, 5, 8, 11, 24, 90, 29)<jupyter_output><empty_output><jupyter_text>Captura de varios argumentos en un parámetro de tipo ```dict``` (```**kwargs``` ).Es posible definir los parámetros y valores que se ingresan a una función mediante el uso de la sintaxis ```=``` y que estos parámetros queden almacenados en un objeto tipo ```dict```. Para esto, basta preceder al nombre del parámetro con doble asterisco ```**```.```def (, , ... , **) ```Donde:* `````` son parámetros a los que se les asigna un argumento.* `````` es un parámetro que es capaz de recibir cualquier número de argumentos y corresponde a un objeto de tipo  ```dict```. **Ejemplo:** * La función ```superficie()``` define al paramentro ```**dato```.     * Se calculará ```superficie``` dependiendo del valor del elemento ```dato["tipo"]```.     * Se hace referencia a:         * ```dato["base"]``` y ```dato["altura"]``` en caso de que ```dato["tipo"]``` sea ```'Rectángulo'``` o ```'Triángulo'```.         * ```dato["radio"]```  en caso de que ```dato["tipo"]``` sea ```'Círculo'```.      * En caso de que ```dato["tipo"]``` sea distinto a ```'Rectángulo'```, ```'Triángulo'``` o . ```'Círculo'```, ```superficie``` será igual a ```'indefinido'```.<jupyter_code>def superficie(**dato):
    '''Calcula la superficie de una figura geométrica si los parámetros  ingresados
       coinciden.'''
    print("Argumentos: ", dato)
    if dato["tipo"] == "Rectángulo":
        superficie = float(dato["base"]) * float(dato["altura"])
    elif dato["tipo"] == "Triángulo":
        superficie = float(dato["base"]) * float(dato["altura"]) / 2
    elif dato["tipo"] == "Círculo":
        superficie = float(dato["radio"]) ** 2 * 3.14259265
    else:
        print("No puedo calcular la superficie.")
        superficie = "indefinido"
    print("La superficie del %s es %s." % (dato["tipo"].lower(), superficie))<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará la función ```superficie()``` ingresando los argumentos ```base=22```, ```altura=30``` y ```tipo=rectángulo```.* La función ```superficie()``` asignará al parámetro ```dato``` el objeto ```{'base':22, 'altura':30, 'tipo':'Rectángulo'}```.<jupyter_code>superficie(base=22, altura=30, tipo="Rectángulo")<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará la función ```superficie()``` ingresando los argumentos ```tipo="Círculo"``` y ```radio=35```.* La función ```superficie()``` asignará al parámetro ```dato``` el objeto ```{'tipo':'Círculo', 'radio':35}```.<jupyter_code>superficie(tipo="Círculo", radio = 35)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará la función ```superficie()``` ingresando los argumentos ```base=22```, ```altura=30``` y ```tipo="Rombo"```.* La función ```superficie()``` asignará al parámetro ```dato``` el objeto ```{'base':22, 'altura':30, 'tipo':'Rombo'}```.<jupyter_code>superficie(base=22, altura=30, tipo="Rombo")<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará la función ```superficie()``` ingresando los argumentos ```base=22```, ```altura=30``` y ```tipo="Rectángulo", radio=6```.* La función ```superficie()``` asignará al parámetro ```dato``` el objeto ```{'base':22, 'altura':30, 'tipo':'Rectángulo', 'radio':6}```.<jupyter_code>superficie(base=22, altura=30, tipo="Rectángulo", radio=6)<jupyter_output><empty_output><jupyter_text>Funciones que regresan valores y cerraduras.Todas las funciones regresan un valor al finalizar su ejecución al cual se le puede asignar un nombre si se desea conservarlo. Las funciones regresan el valor ```None``` por defecto. **Ejemplo:** * La siguiente celda definirá a la función ```nada()``` la cual no realiza ninguna acción.<jupyter_code>def nada():
    pass<jupyter_output><empty_output><jupyter_text>* La siguiente celda le asignará el nombre ```resultado``` al objeto que regresa la función ```nada()```.<jupyter_code>resultado = nada()<jupyter_output><empty_output><jupyter_text>* La siguiente celda desplegará el objeto ligado a ```resultado```, el cual es ```None```.<jupyter_code>print(resultado)<jupyter_output><empty_output><jupyter_text>La palabra reservada  ```return```.La expresión ```return``` se utiliza para regresar uno o varios objetos específicos a su ámbito superior y acto seguido dar por terminada la ejecución de la función de forma similar a ```break```. Pueden incluirse varios ```return``` en una función, pero sólo se ejecutará la primera que se encuentre. La sintaxis es la siguiente:```return , , ...,  ```Donde:* `````` puede ser cualquier objeto de Python.En el caso de que ```return``` regrese una secuencia de objetos, estos estarán contenidos en un objeto de tipo ```tuple```. **Ejemplo:** * La siguiente celda define a la función ```regresapromedio()```, la cual regresará el resultado de varias expresiones que usan el parámetro ```muestras```.<jupyter_code>def regresapromedio(*muestras):
    return len(muestras), sum(muestras) / len(muestras)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```regresapromedio()``` ingresando ```1, 3, 5, 8, 11, 24, 90, 29``` como argumentos. La función regresará ```(8, 21.375)```.<jupyter_code>regresapromedio(1, 3, 5, 8, 11, 24, 90, 29)<jupyter_output><empty_output><jupyter_text>* La siguiente celda ejecutará a la función ```regresapromedio()``` ingresando ```1, 3, 5, 8, 11, 24, 90, 29``` como argumentos. El objeto que regrese la función será asignado al nombre ```media```.<jupyter_code>media = regresapromedio(1, 3, 5, 8, 11, 24, 90, 29)<jupyter_output><empty_output><jupyter_text>* El nombre ```media``` corresponde al objeto ```(8, 21.375)```.<jupyter_code>media
print('El promedio de la muestra de %d elementos es %.3f.' %(media))<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14346103038309116, 'fraction_numerical': 0.009813172296659747, 'mean_word_length': 6.075033377837116, 'pattern_counts': {'":': 3, '<': 278, '<?xml version=': 0, '>': 277, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '69', 'dir': 'jupyter-structured-clean-dedup', 'id': '36914', 'license': 'MIT', 'n_tokens_mistral': 9478, 'n_tokens_neox': 9393, 'n_words': 2956, 'path': '15_funciones.ipynb', 'repo_name': 'hecrap1/clone_pythonist', 'size': '26495'}