Definir e chamar funções

Dar um nome a um bloco de código

Uma função é um bloco de código com nome que você pode executar de novo e de novo. Você a define uma vez com def, um nome, parênteses e dois-pontos; o bloco recuado embaixo é o corpo. return devolve um valor a quem chamou a função. Chamá-la é escrever seu nome com parênteses e os valores com que trabalhar.

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

print(gross_value(184.25, 200))  # 36850.0

Parâmetros e argumentos

Os nomes entre os parênteses do def são os parâmetros: espaços reservados para as entradas. Os valores que você passa ao chamar são os argumentos e preenchem os parâmetros em ordem. Se você os trocar, o resultado muda. Passar um número errado de argumentos é um erro. Cada chamada recebe sua própria cópia dos 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 não é print

print mostra algo na tela para uma pessoa. return entrega um valor ao código que chamou para que ele continue trabalhando com ele. Uma função sem return devolve None, que significa «nada». Funções que calculam devem devolver; o código que as chama decide se imprime.

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

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

Funções pequenas que se apoiam umas nas outras

Uma função pode chamar outras, então você constrói comportamentos grandes com peças pequenas e testáveis. Dê a cada função um só trabalho e um nome que o diga. A docstring, uma string logo abaixo do def, explica-a ao próximo leitor. Defina uma função antes de a linha que a chama executar.

# 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 vários valores

return a, b devolve os dois valores de uma vez, como uma tupla: um par ordenado escrito com vírgulas (as tuplas terão em breve seu próprio tópico). Quem chamou pode nomear as partes na hora. Dividir uma ordem de 1.000 ações em 3 fatias com // e % devolve o tamanho de cada fatia e o 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

• Um trabalho por função e um nome que diga o que ela devolve.
• Calcular e return; deixar quem chama imprimir.
• Adicionar uma docstring que diga o que entra e o que sai.

A seguir: argumentos de função e valores padrão, para chamar funções com nomes, valores opcionais e qualquer número de argumentos.

Lab: o que é avaliado

• Definir uma função que avalie uma posição com gross_value25 pts
• Cobrar uma comissão com mínimo usando commission25 pts
• Montar o custo real a partir de duas funções com net_cost25 pts
• Devolver dois valores de uma vez com split_fill25 pts