Definir y llamar funciones

Ponerle nombre a un bloque de código

Una función es un bloque de código con nombre que puedes ejecutar una y otra vez. La defines una vez con def, un nombre, paréntesis y dos puntos; el bloque con sangría debajo es el cuerpo. return devuelve un valor a quien llamó a la función. Llamarla es escribir su nombre con paréntesis y los valores con los que trabajar.

def gross_value(price, quantity):
    return price * quantity

print(gross_value(184.25, 200))  # 36850.0

Parámetros y argumentos

Los nombres entre paréntesis de def son los parámetros: marcadores para las entradas. Los valores que pasas al llamar son los argumentos y rellenan los parámetros en orden. Si los intercambias, el resultado cambia. Pasar un número equivocado de argumentos es un error. Cada llamada recibe su propia copia de los parámetros.

# Arguments fill the parameters in order
def spread(bid, ask):
    return ask - bid

print(spread(184.25, 184.5))  # 0.25
print(spread(184.5, 184.25))  # -0.25

return no es print

print muestra algo en pantalla para una persona. return entrega un valor al código que llama para que siga trabajando con él. Una función sin return devuelve None, que significa «nada». Las funciones que calculan deben devolver; el código que las llama decide si imprimir.

# A function with no return gives back None
def show(price):
    print("price", price)

result = show(184.25)   # price 184.25
print(result)           # None

Funciones pequeñas que se apoyan unas en otras

Una función puede llamar a otras, así que construyes comportamientos grandes con piezas pequeñas y comprobables. Dale a cada función un solo trabajo y un nombre que lo diga. La docstring, una cadena justo bajo def, se lo explica al siguiente lector. Define una función antes de que se ejecute la línea que la llama.

# Small functions build bigger ones
def gross_value(price, quantity):
    """Value of a position before costs."""
    return price * quantity


def commission(gross):
    """0.1% of the value, but never less than 1.0."""
    return max(1.0, gross * 0.001)


def net_cost(price, quantity):
    """What the position really costs: value plus commission."""
    gross = gross_value(price, quantity)
    return gross + commission(gross)


print(net_cost(184.25, 200))  # 36886.85

Devolver varios valores

return a, b devuelve ambos valores a la vez, como una tupla: un par ordenado escrito con comas (las tuplas tendrán pronto su propio tema). Quien llama puede ponerles nombre enseguida. Dividir una orden de 1.000 acciones en 3 partes con // y % devuelve el tamaño de cada parte y lo que sobra.

# return several values as a tuple
def split_fill(quantity, slices):
    return quantity // slices, quantity % slices

size, leftover = split_fill(1000, 3)
print(size, leftover)  # 333 1

• Un trabajo por función y un nombre que diga lo que devuelve.
• Calcular y return; que imprima quien llama.
• Añadir una docstring que diga qué entra y qué sale.

A continuación: argumentos de funciones y valores por defecto, para llamar funciones con nombres, valores opcionales y cualquier número de argumentos.

Lab: qué se califica

• Definir una función que valore una posición con gross_value25 pts
• Cobrar una comisión con mínimo usando commission25 pts
• Construir el coste real con dos funciones usando net_cost25 pts
• Devolver dos valores a la vez con split_fill25 pts