Funciones en python#
Definiciones#
Las funciones son una porción de código con alcance limitado. Cualquier función tendrá un nombre, unos argumentos de entrada, un código a ejecutar y unos parámetros de salida. Al igual que las funciones matemáticas, en programación nos permiten realizar diferentes operaciones con la entrada, para entregar una determinada salida que dependerá del código que escribamos dentro. Por lo tanto, es totalmente análogo al clásico y=f(x) de las matemáticas.
def nombre_funcion:
codigo
return resultado
def f(x):
return 2*x
y = f(3)
print(y) # 6
6
w=2#por defecto es una variable global
def f(x):
t=5#solo existe en la funcion f
return x*w
z = f(2)
print(z)
4
t
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In[3], line 1
----> 1 t
NameError: name 't' is not defined
Algo que diferencia en cierto modo las funciones en el mundo de la programación, es que no sólo realizan una operación con sus entradas, sino que también parten de los siguientes principios:
El principio de reusabilidad, que nos dice que si por ejemplo tenemos un fragmento de código usado en muchos sitios, la mejor solución sería pasarlo a una función. Esto nos evitaría tener código repetido, y que modificarlo fuera más fácil, ya que bastaría con cambiar la función una vez.
Y el principio de modularidad, que defiende que en vez de escribir largos trozos de código, es mejor crear módulos o funciones que agrupen ciertos fragmentos de código en funcionalidades específicas, haciendo que el código resultante sea más fácil de leer.
Empecemos por la función más sencilla de todas. Una función sin parámetros de entrada ni parámetros de salida.
def di_hola():
print("Hola")
Hemos declarado o definido la función. El siguiente paso es llamarla con di_hola(). Si lo realizamos veremos que se imprime Hola.
di_hola() # Hola
Hola
Vamos a complicar un poco las cosas pasando un argumento de entrada. Ahora si pasamos como entrada un nombre, se imprimirá Hola y el nombre.
def di_hola(nombre):
print("Hola", nombre)
di_hola("Juan")
# Hola Juan
Argumentos posicionales#
Los argumentos por posición o posicionales son la forma más básica e intuitiva de pasar parámetros. Si tenemos una función resta() que acepta dos parámetros, se puede llamar como se muestra a continuación.
def resta(a, b):
return a-b
resta(5, 3) # 2
resta(3, 5) # -2
-2
Al tratarse de parámetros posicionales, se interpretará que el primer número es la a y el segundo la b. El número de parámetros es fijo, por lo que si intentamos llamar a la función con solo uno, dará error.
resta(1)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-8-fdc94298ad94> in <cell line: 1>()
----> 1 resta(1)
TypeError: resta() missing 1 required positional argument: 'b'
Tampoco es posible usar mas argumentos de los que tiene la función definidos, ya que no sabría que hacer con ellos. Por lo tanto si lo intentamos, Python nos dirá que toma 2 posicionales y estamos pasando 3, lo que no es posible.
resta(2,3,5,6)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-9-929e5667680d> in <cell line: 1>()
----> 1 resta(2,3,5,6)
TypeError: resta() takes 2 positional arguments but 4 were given
Argumentos por nombre#
Otra forma de llamar a una función, es usando el nombre del argumento con = y su valor. El siguiente código hace lo mismo que el código anterior, con la diferencia de que los argumentos no son posicionales.
resta(a=3, b=5) # -2
-2
Al indicar en la llamada a la función el nombre de la variable y el valor, el orden ya no importa, y se podría llamar de la siguiente forma.
resta(b=5, a=3) # -2
-2
Como es de esperar, si indicamos un argumento que no ha sido definido como parámetro de entrada, tendremos un error.
resta(b=5, c=3)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-bfe8a70d88a9> in <cell line: 1>()
----> 1 resta(b=5, c=3)
TypeError: resta() got an unexpected keyword argument 'c'
Argumentos por defecto#
Tal vez queramos tener una función con algún parámetro opcional, que pueda ser usado o no dependiendo de diferentes circunstancias. Para ello, lo que podemos hacer es asignar un valor por defecto a la función. En el siguiente caso c valdría cero salvo que se indique lo contrario.
def suma(a, b, c=1):
return a+b+c
suma(5,5,3) # 14
13
Dado que el parámetro c tiene un valor por defecto, la función puede ser llamada sin ese valor.
suma(4,3) # 8
8
Podemos incluso asignar un valor por defecto a todos los parámetros, por lo que se podría llamar a la función sin ningún argumento de entrada.
def suma(a=3, b=5, c=0):
return a+b+c
suma() # 8
8
Las siguientes llamadas a la función también son válidas
#suma(1) # 6
suma(4,5) # 9
#suma(5,3,2) # 10
6
Sentencia return#
El uso de la sentencia return permite realizar dos cosas:
Salir de la función y transferir la ejecución de vuelta a donde se realizó la llamada.
Devolver uno o varios parámetros, fruto de la ejecución de la función.
En lo relativo a lo primero, una vez se llama a return se para la ejecución de la función y se vuelve o retorna al punto donde fue llamada. Es por ello por lo que el código que va después del return no es ejecutado en el siguiente ejemplo.
def mi_funcion():
print("Entra en mi_funcion")
return
print("No llega")
mi_funcion() # Entra en mi_funcion
Entra en mi_funcion
Por ello, sólo llamamos a return una vez hemos acabado de hacer lo que teníamos que hacer en la función.
Por otro lado, se pueden devolver parámetros. Normalmente las funciones son llamadas para realizar unos cálculos en base a una entrada, por lo que es interesante poder devolver ese resultado a quien llamó a la función.
def di_hola():
return "Hola"
di_hola()
# 'Hola'
'Hola'
También es posible devolver mas de una variable, separadas por ,. En el siguiente ejemplo tenemos una función que calcula la suma y media de tres números, y devuelve su resultado.
def suma_y_media(a, b, c):
suma = a+b+c
media = suma/3
return suma, media
x, y = suma_y_media(9, 6, 3)
print(y) # 18
print(x) # 6.0
6.0
18
Ejercicios#
0.Hacer la calculadora, pero cada operacion se debe hacer dentro de una funcion. Por ejemplo:#
def suma(numeros):
codigo
def resta(numeros):
codigo
def multiplicacion(numeros):
codigo
#pedir numeros y operacion a realizar
#invocar solo la funcion que realiza la operacion solicitada
1. Escribir una función que aplique un descuento a un precio y otra que aplique el IVA a un precio. Escribir una tercera función que reciba un diccionario con los precios y porcentajes de una cesta de la compra, y una de las funciones anteriores, y utilice la función pasada para aplicar los descuentos o el IVA a los productos de la cesta y devolver el precio final de la cesta.#
def apply_discount(price, discount):
'''
Función que aplica un descuento a una cantidad.
Parámetros:
price: Es un valor real con el precio al que aplicar el descuento.
discount: Es el porcentaje a descontar.
Devuelve:
El precio final tras aplicar el descuento.
'''
def apply_IVA(price, percentage):
'''
Función que aplica un IVA a una cantidad.
Parámetros:
price: Es un valor real con el precio al que aplicar el IVA.
percentage: Es el porcentaje del IVA a aplicar.
Devuelve:
El precio final tras aplicar el IVA.
'''
def price_basket(basket, function):
'''
Función que calcula el precio de una cesta de la compra una vez aplicada una función a los precios iniciales.
Parámetros:
basket: Es un diccionario formado por pares precio:descuento.
function: Es una función que toma dos valores reales y devuelve otro. Normalmente para aplicar descuentos o IVA.
Devuelve:
El precio final de la cesta de la compra una vez aplicada la función sobre los precios iniciales.
'''
print('El precio de la compra tras aplicar los descuentos es: ', price_basket({1000:20, 500:10, 100:1}, apply_discount))
print('El precio de la compra tras aplicar el IVA es: ', price_basket({1000:20, 500:10, 100:1}, apply_IVA))
2. Escribir una función que reciba una frase y devuelva un diccionario con las palabras que contiene y su longitud.#
def length_words(sentence):
'''
Función que recibe una frase y devuelve un diccionario con las palabras que contiene y su longitud.
Parámetros:
sentence: Es una cadena de caracteres con una frase.
Devuelve:
Un diccionario con pares palabra:longitud donde palabra son las palabras que contiene la frase sentence.
'''
print(length_words('Welcome to Python'))
3. Escribir una función que simule una calculadora científica que permita calcular el seno, coseno, tangente, exponencial y logaritmo neperiano. La función preguntará al usuario el valor y la función a aplicar, y mostrará por pantalla una tabla con los enteros de 1 al valor introducido y el resultado de aplicar la función a esos enteros.#
from math import sin, cos, tan, exp, log
def apply_function(f, n):
'''
Función que aplica una función a los enteros desde 1 hasta n.
Parámetros:
f: Es una función que recibe un número real y devuelve otro.
n: Es un número entero positivo.
Devuelve:
Un diccionario con los pares i:f(i) para cada valor entero i de 1 a n.
'''
def calculator():
'''
Función que aplica una función seleccionada por el usuario (seno, coseno, tangente, exponencial o logarítmo) a la lista de enteros desde 1 hasta n.
Imprime por pantalla una tabla con la secuencia de enteros y el resultado de aplicarles la función introducida.
Parámetros:
f: Es una cadena con la función a aplicar (sin, cos, tan, exp o log).
n: Es un entero positivo.
'''
calculator()
#Librerias básicas de Python
Un módulo o module en Python es un fichero .py que alberga un conjunto de funciones, variables o clases y que puede ser usado por otros módulos. Por ejemplo, podemos definir un módulo llamado mimodulo.py con dos funciones: suma() y resta().
# mimodulo.py
def suma(a, b):
return a + b
def resta(a, b):
return a - b
Una vez definido, dicho módulo puede ser usado o importado en otro fichero, como mostramos a continuación. Usando import podemos importar todo el contenido.
# otromodulo.py
import mimodulo
print(mimodulo.suma(4, 3)) # 7
print(mimodulo.resta(10, 9)) # 1
Numpy#
Numpy (Numerical Python) es una libreria de código abierto de python que se usa para representar arreglos de números. Un ejemplo de arreglo de números son los vectores.
#Operaciones entre listas
[1,2,3,5]+[4,5,6,7]
3*[1,2,3,5]
[1, 2, 3, 5, 1, 2, 3, 5, 1, 2, 3, 5]
Para usar la libreria de Numpy se debe importar al entorno.
import numpy as np
Una forma de definir un NumpyArray o arreglo de Numpy, es mediante una lista.
mi_lista_1=[1,2,3,5]
mi_array_1=np.array(mi_lista_1)
mi_lista_2=[4,5,6,7]
mi_array_2=np.array(mi_lista_2)
mi_array_1+mi_array_2
array([ 5, 7, 9, 12])