Funções em Python: como chamar e escrever funções

Argumentos padrão

Argumentos padrão recebem um valor default se nenhum valor for passado na chamada da função. Você atribui esse valor usando o operador de atribuição =, como no exemplo a seguir:

Argumentos obrigatórios

Como o nome sugere, argumentos obrigatórios de uma UDF são aqueles que precisam estar presentes. Eles devem ser passados na chamada da função e exatamente na ordem correta, como no exemplo a seguir:

Você precisa de argumentos que mapeiem para os parâmetros a e b para chamar a função sem erros. Se você inverter a e b, o resultado não muda — mas mudaria se você alterasse plus() para o seguinte:

Argumentos nomeados (keyword)

Se quiser garantir que está passando os parâmetros na ordem certa, use argumentos nomeados na chamada da função. Com eles, você identifica os argumentos pelo nome do parâmetro. Vamos pegar o exemplo acima para deixar mais claro:

Note que, ao usar argumentos nomeados, você também pode inverter a ordem dos parâmetros e ainda obter o mesmo resultado ao executar a função:

Número variável de argumentos

Em casos em que você não sabe o número exato de argumentos a passar para a função, use a seguinte sintaxe com *args:

O asterisco (*) é colocado antes do nome da variável que guarda os valores de todos os argumentos não nomeados. Note que você também poderia ter passado *varint, *var_int_args ou qualquer outro nome para a função plus().

Dica: tente substituir *args por outro nome que inclua o asterisco. Você vai ver que o código acima continua funcionando!

Perceba que a função acima usa a função embutida do Python sum() para somar todos os argumentos passados para plus(). 

Variáveis globais vs. locais

Em geral, variáveis definidas dentro do corpo de uma função têm escopo local, e as definidas fora têm escopo global. Isso significa que variáveis locais são definidas dentro do bloco da função e só podem ser acessadas lá dentro, enquanto variáveis globais podem ser acessadas por todas as funções do seu script:

Você verá que receberá um NameError dizendo que name 'total' is not defined ao tentar imprimir a variável local total, definida dentro do corpo da função. Já a variável init pode ser exibida sem problemas.

Parâmetros apenas posicionais e apenas nomeados

Desde o Python 3.8, você pode ter mais controle sobre como os argumentos devem ser passados usando dois marcadores especiais na assinatura da função: / e *. Tudo que vem antes de / só pode ser passado por posição; tudo que vem depois de * só pode ser passado por nome (keyword).

def greet(name, /, greeting="Hello", *, punctuation="!"):
    print(f"{greeting} {name}{punctuation}")

 Veja como isso funciona na chamada:

greet("Alice")                          # funciona
greet("Alice", greeting="Hi")           # funciona
greet("Alice", "Hi", punctuation="?")   # funciona

greet(name="Alice")                     # TypeError: name é apenas posicional
greet("Alice", "Hi", "?")               # TypeError: punctuation é apenas nomeado

Por que você iria querer isso? Dois motivos principais.

Apenas posicionais permitem renomear parâmetros no futuro sem quebrar o código de ninguém — como ninguém pode usar o nome do parâmetro como keyword, você é livre para mudá-lo.

Apenas nomeados forçam quem chama a ser explícito sobre o que está passando, o que deixa as chamadas mais legíveis quando há várias opções ou flags.

Em resumo, é uma forma limpa de reforçar a intenção.

Funções anônimas em Python

Funções anônimas também são chamadas de funções lambda em Python porque, em vez de declará-las com a palavra-chave padrão def, você usa lambda.

No bloco do DataCamp Light acima, lambda x: x*2 é a função anônima ou lambda. x é o argumento e x*2 é a expressão/instrução que é avaliada e retornada. O especial dessa função é que ela não tem nome, diferente dos exemplos que você viu na primeira parte deste tutorial. Se você escrevesse a função acima como uma UDF, ficaria assim:

def double(x):
  return x*2

Vamos considerar outro exemplo de função lambda com dois argumentos:

Você usa funções anônimas quando precisa de uma função sem nome por um curto período e criada em tempo de execução. Contextos típicos são quando você trabalha com filter(), map() e reduce():

A função filter() filtra, como o nome sugere, a lista de entrada original my_list com base no critério >10. Já com map(), você aplica uma função a todos os itens da lista my_list. Neste caso, multiplica todos os elementos por 2.

Note que a função reduce() faz parte da biblioteca functools. Você a aplica cumulativamente aos itens da lista my_list, da esquerda para a direita, reduzindo a sequência a um único valor — 55, neste caso.

Usando main() como função em Python

Se você tem experiência com outras linguagens como Java, sabe que a função main é necessária para executar o programa. Como você viu nos exemplos acima, isso não é obrigatório em Python. No entanto, incluir uma função main() no seu programa pode ser útil para estruturar o código de forma lógica — os componentes mais importantes ficam contidos dentro dessa função.

Você pode definir uma função main() e chamá-la exatamente como fez com as outras funções acima:

Porém, do jeito que está, o código da sua função main() será executado quando você a importar como módulo. Para evitar isso, chame a função main() quando __name__ == '__main__'.

Isso significa que o bloco de código acima fica assim:

Nota: além de __main__, existe também a função __init__, que inicializa uma instância de classe ou objeto. Em termos simples, ela age como um construtor/inicializador e é chamada automaticamente quando você cria uma nova instância de uma classe. Com essa função, o objeto recém-criado é atribuído ao parâmetro self, que você viu anteriormente neste tutorial. Veja o exemplo:

class Dog:
    """A simple Dog class.

    Args:
        legs: Number of legs so that the dog can walk.
        color: The color of the fur.
    """

    def __init__(self, legs: int, color: str) -> None:
        self.legs = legs
        self.color = color

    def bark(self) -> str:
        return "bark" * 2

if __name__ == "__main__":
    dog = Dog(4, "brown")
    print(dog.bark())