Funciones - css-umar/Programacion GitHub Wiki

Funciones

  1. Las funciones agrupan algoritmos (expresiones y sentencias).
  2. Sólo se ejecutan cuando son llamadas, es decir, cuando se hace una referencia a ella.
  3. Para llamar una función, simplemente se le llama por su nombre.
  4. Cuando una función, haga un retorno de datos, estos, pueden ser asignadaos a una variable.
  5. En Python se define una función mediante la instrucción def.

Sintaxis para función sin parámetros

def nombre_funcion():
    expresion_1
    expresion_2
    expresion_3
    expresion_n

Sintaxis para función con parámetros

def nombre_funcion(parametro_1, parametro_2,...,parametro_3):
    expresion_1
    expresion_2
    expresion_3
    expresion_n
    return expresion

_Los parametro son variables(locales) que pueden ser utilizados dentro de la misma función.

Parámetros: Son las variables listadas entre paréntesis en la definición de la función.

Argumento: Es el valor que se envía a la función cuando se llama.

Ejemplo de función sin parámetros

"""
Esta función solamente tiene la expresión print "¿Qué pex?" y no requiere de parámetros
"""
def saludo():    # saludo es el nombre de la función 
    print "¿Qué pex?"    # Las expresiones irán identadas por cuatro espacios
"""
Las funciones sólo se ejecutan cuando son llamadas, es decir, cuando se hace una referencia a ella
"""
saludo()  # Con esta expresión se está llamando a la función saludo, la cual no requiere parámetros.
¿Qué pex?

"""
Esta función hace un retorno de datos.
La instrucción "return" sirve para indicar que devuelva datos, en este caso, la frase "¿Qué pex?"
"""
def saludo2():    
    return "¿Qué pex?"    
hola = saludo2()    # En la variable hola se guarda los datos que devuelve la función saludo2()
print hola    # Aquí se está mostrando los datos que contiene la variable hola
¿Qué pex?

Ejemplo de función con parámetros

"""
Esta función realiza la suma de dos numeros, para lo cual requiere de los parámetros a y b;
donde a y b, son los dos numeros a sumar; la suma de a más b se almancena en la variable resultado,
la cual posteriormente se regresa al usuario mediante la instrucción return.
"""
def suma(a,b):
    resultado = a + b    # "resultado" es una variable local para uso exclusivo de la función
    return resultado
"""
Al llamar a una función que requiere de parámetros, si el usuario no se los proporciona,
Python mostrará un error.
"""
suma()
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-58-3d1cf805e4d2> in <module>()
      3 Python mostrará un error.
      4 """
----> 5 suma()


TypeError: suma() takes exactly 2 arguments (0 given)

"""
Con esta expresión se está llamando a la función suma, los argumentos para los parámetros a y b 
son 2 y 2 respectivamente.
Al llamar a una función, siempre se le deben pasar sus argumentos en el mismo orden 
en el que fueron definidos los parámetros.
"""
suma(2,2)
4

# Otra forma
a, b = 5, 5
suma(a,b)
10

"""
Aquí los datos que devuelve la función suma se almacena en la variable respuesta
"""
respuesta = suma(a,b)
print respuesta   # Aqui se muestra lo que contiene la variable respuesta
10

"""
No se puede acceder a variables locales, fuera de la función.
"""
def division(dividendo, divisor):
    cociente = dividendo/divisor    # cociente es una variable local y es de uso exclusivo de la función 
    return cociente
dividendo, divisor = 10, 2
division(dividendo, divisor)     # se llama a la función división
5

"""
Cuando se intenta acceder a una variable local fuera de la función, python mostrará un error
"""
print cociente 
---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-65-63bf85abac24> in <module>()
      2 Cuando se intenta acceder a una variable local fuera de la función, python mostrará un error
      3 """
----> 4 print cociente


NameError: name 'cociente' is not defined

Argumentos por omisión

En Python se puede asignar argumentos por defecto a los parámetros de las funciones.

def potenciacion(base, exponente=2):
    return base**exponente    # Recuerda que para elevar un número a una potencia se usa **
potenciacion(2)
4

"""
También es posible llamar a una función, pasándole los argumentos esperados, como pares 
de claves=valor:
"""
potenciacion(base=2, exponente=3)
8

"""
Si se transfieren los argumentos por medio de pares claves=valor, no importa el orden en el que
se hace. 
"""
potenciacion(exponente=4,base=2)
16

Parámetros arbitrarios

Es posible que una función espere recibir un número arbitrario de parámetros. Estos parámetros, llegarán a la función en forma de tupla.

Sintaxis para función con parámetros arbitrarios

def nombre_funcion(argumento_1, argumento_2,...,*argumento_arbitrario):
    expresion_1
    expresion_2
    expresion_3
    expresion_n
    return expresion

Los parámetros arbitrarios, se anteceden con un asterisco y siempre deben suceder a los fijos.

"""
La función func requiere de parámetros fijos y de arbitrarios, con print se está accediendo
a los parámetros fijos. Mientras que con el ciclo for se acceden a los parámetros arbitrarios
"""

def func(parametro_fijo, *parametro_arbitrario):
    print parametro_fijo
    for i in parametro_arbitrario:
        print i
    
# Imprime el argumento fijo  y arbitrarios 
func("Parametro fijo","Parametro arbitrario 1","...","Parametro arbitrario n")   
Parametro fijo
Parametro arbitrario 1
...
Parametro arbitrario n

"""
Ahora con números y cadena de texto
"""
func(1,"dos",3,4,5,6,7,8,"nueve")
1
dos
3
4
5
6
7
8
nueve

"""
Otra forma es utilizar listas, como en el siguiente ejemplo 
"""

def funcion(parametro_fijo, lista):
    print parametro_fijo
    for i in lista:
        print i   
lista_argumentos = [2,3,4,5,6,7,8,9]

funcion(1,lista_argumentos)
1
2
3
4
5
6
7
8
9

funcion(1,[2,3,4,5,6,7,8,9])
1
2
3
4
5
6
7
8
9

Empaquetado de argumentos

También es posible empaquetar los argumentos en una lista o tupla. Como ejemplo vamos a retomar la función potenciacion que previamente ya fue creada. Esta funcion requiere de dos parametro, la base y el exponente.

"""
Para empaquetar los argumentos vamos a utilizar una lista, a la cual vamos a llamar datos:
"""
datos = [2,3]    # Lista con los argumentos
"""
Para desempaquetar los argumentos en la función, al nombre de la lista se le debe 
anteponer un asterisco(*)
"""
potenciacion(*datos)
8

"""
Comparando los métodos...
Empaquetado de argumentos y Clave=Valor, ambos métodos arrojan resultados similares
"""
potenciacion(base=2, exponente=3)
8

"""
Cuando los argumentos están contenidos en un diccionario, se deberán pasar a la función con el 
nombre del diccionario precedido de dos asteriscos (**).
"""
datos_dic = {"base":2, "exponente":3}    # Diccionario con los argumentos
potenciacion(**datos_dic)
8

Funciones anónimas (lambda)

Caracteristicas de la función lambda:

  • Puede tomar varios parámetros, pero solamente puede regresar una expresión o resultado.
  • Se puden usar dentro de otras funciones.
  • No es necesario declarar un return, siempre devuelven una sola expresión.
  • Se usan cuando se requiere una función para un periodo de tiempo corto.

Sintaxis para la función lambda

nombre_funcion = lambda parametro_1, parametro_2,...,parametro_n: expresión

"""
Retomando la función "suma" creada previamente, la cual realiza la suma de dos (a y b) números reales
cualesquiera:

def suma(a,b):
    resultado = a + b  
    return resultado

Utilizando función lambda queda de la forma siguiente...
"""

suma = lambda a, b: a + b
"""
Llamando a la función suma creada con lambda.
"""
suma(2,2)
4



              


           
⚠️ **GitHub.com Fallback** ⚠️