Python Valores Padrão e Argumentos Nomeados

Na aula Parâmetros e Argumentos, cada parâmetro era obrigatório: faltou um argumento, TypeError. Mas na vida real muita coisa tem um "de sempre". Quem pede "um pão de queijo" não precisa dizer "quantidade: um". Nesta aula, os parâmetros ganham um valor padrão, usado quando a chamada não diz nada, e as chamadas ganham nomes: pedido("Café", quantidade=2), que deixam claro o que é cada valor.

A ideia: "o de sempre"

O Seu Joaquim chega à padaria e diz só: "um café". A atendente já sabe o resto: copo médio, com açúcar. É o padrão. Se um dia ele quiser diferente, ele avisa: "um café, sem açúcar". Ele não precisa repetir tudo; diz só o que muda, e diz pelo nome ("sem açúcar"), sem precisar seguir uma ordem.

1. O valor padrão

def pedido(produto, quantidade=1):
    print(f"{quantidade} x {produto}")


pedido("Bolo de milho")
pedido("Pão francês", 10)

$ python3 pedido.py
1 x Bolo de milho
10 x Pão francês

produto

Parâmetro obrigatório, como na aula anterior: toda chamada tem de preenchê-lo.

quantidade=1

Parâmetro com valor padrão (também se diz "opcional"). Se a chamada não mandar nada para ele, o Python usa o 1.

pedido("Bolo de milho")

Só um argumento: produto = "Bolo de milho" e quantidade fica com o padrão, 1.

pedido("Pão francês", 10)

Dois argumentos: o 10 substitui o padrão.

O valor padrão também funciona com texto:

def saudar(nome, saudacao="Bom dia"):
    print(f"{saudacao}, {nome}!")


saudar("Ana")
saudar("Bruno", "Boa noite")

$ python3 saudar.py
Bom dia, Ana!
Boa noite, Bruno!

def pedido(produto, quantidade):
    print(f"{quantidade} x {produto}")


pedido("Pão francês", 10)
pedido("Bolo de milho")

def pedido(produto, quantidade=1):
    print(f"{quantidade} x {produto}")


pedido("Pão francês", 10)
pedido("Bolo de milho")

2. Argumentos nomeados

Na chamada, você pode dizer a qual parâmetro vai cada valor, escrevendo nome_do_parametro=valor. Com nomes, a ordem não importa mais:

def pedido(produto, quantidade=1):
    print(f"{quantidade} x {produto}")


pedido(produto="Café", quantidade=2)
pedido(quantidade=3, produto="Pão de queijo")
pedido("Leite", quantidade=4)

$ python3 nomeados.py
2 x Café
3 x Pão de queijo
4 x Leite

• Na primeira chamada, os dois argumentos têm nome.
• Na segunda, estão na ordem "errada", e mesmo assim deu certo: o Python não olha a posição, olha o nome. Lembra do 30 tem Ana anos. da aula anterior? Com nomes, isso não acontece.
• Na terceira, o primeiro vai pela posição e o segundo pelo nome. É o jeito mais comum: o que é óbvio vai pela posição, o que precisa de explicação vai com nome.

Em inglês, argumento nomeado é keyword argument ("argumento por palavra-chave"); o comum, pela posição, é positional argument. As mensagens de erro usam esses dois nomes.

Pulando um parâmetro opcional

O nome é a única saída quando há vários parâmetros opcionais e você quer mudar só o último:

def cartao(nome, mensagem="Parabéns", assinatura="Padaria Pão Quente"):
    print(f"{mensagem}, {nome}!")
    print(f"   Um abraço, {assinatura}")


cartao("Ana")
cartao("Bruno", "Feliz Natal")
cartao("Carla", assinatura="Tia Rosa")

$ python3 cartao.py
Parabéns, Ana!
   Um abraço, Padaria Pão Quente
Feliz Natal, Bruno!
   Um abraço, Padaria Pão Quente
Parabéns, Carla!
   Um abraço, Tia Rosa

No cartão da Carla, a mensagem ficou com o padrão ("Parabéns") e só a assinatura mudou. Pela posição, isso seria impossível: o segundo valor sempre cairia na mensagem.

Você já usou isso: sep e end

O print é uma função com parâmetros de valor padrão: sep=" " (o que vai entre os valores) e end="\n" (o que vai no fim, uma quebra de linha). Na aula As Opções sep e end, você os mudou com argumentos nomeados:

print("Ana", "Bruno", "Carla")
print("Ana", "Bruno", "Carla", sep=" - ")
print("sem pular linha", end="")
print(" (continuou na mesma linha)")

$ python3 print_sep.py
Ana Bruno Carla
Ana - Bruno - Carla
sem pular linha (continuou na mesma linha)

3. As regras de ordem

Duas regras, uma no def e uma na chamada:

Faz sentido: se um parâmetro opcional viesse antes de um obrigatório, o Python não teria como saber se o primeiro valor da chamada é o opcional ou o obrigatório. As mensagens de quando essas regras são quebradas estão em Quando dá errado.

4. A armadilha: lista como valor padrão

A Ana quer uma função que comece uma lista de compras nova para cada pessoa. Parece razoável usar uma lista vazia como padrão:

def nova_lista(item, compras=[]):
    compras.append(item)
    return compras


ana = nova_lista("arroz")
bruno = nova_lista("café")
print("Ana:", ana)
print("Bruno:", bruno)

$ python3 mutavel.py
Ana: ['arroz', 'café']                             « o café do Bruno foi parar na lista da Ana
Bruno: ['arroz', 'café']

As duas pessoas ficaram com a mesma lista. O arroz da Ana apareceu na lista do Bruno, e o café do Bruno na da Ana. Nenhum erro, só um resultado errado, daqueles que dão muito trabalho para achar.

Por que acontece

O valor padrão é criado uma vez só: no momento em que o Python passa pelo def, e não a cada chamada. A lista [] do padrão é sempre a mesma lista, guardada junto com a função. Cada chamada sem o segundo argumento usa essa mesma lista, e o append (aula Adicionando Itens) vai acumulando nela. Dá para ver isso acontecendo:

def nova_lista(item, compras=[]):
    print("A lista padrão antes:", compras)
    compras.append(item)
    return compras


nova_lista("arroz")
nova_lista("café")
nova_lista("feijão")
print(nova_lista.__defaults__)

$ python3 mutavel_por_que.py
A lista padrão antes: []
A lista padrão antes: ['arroz']
A lista padrão antes: ['arroz', 'café']
(['arroz', 'café', 'feijão'],)

A cada chamada, a lista "vazia" do padrão chega com os itens das chamadas anteriores. A última linha espia os valores padrão guardados na função (__defaults__): lá está a lista, com os três itens. Com números e textos isso não acontece, porque eles não podem ser modificados por dentro, como a lista pode com o append (aula Mutável × Imutável).

O jeito certo: None como padrão

def nova_lista(item, compras=None):
    if compras is None:
        compras = []
    compras.append(item)
    return compras


ana = nova_lista("arroz")
bruno = nova_lista("café")
print("Ana:", ana)
print("Bruno:", bruno)
print(nova_lista("feijão", ana))

$ python3 mutavel_none.py
Ana: ['arroz']
Bruno: ['café']
['arroz', 'feijão']

compras=None

O padrão agora é None, "nada" (aula O Valor None), que não pode ser modificado.

if compras is None:

"Se não mandaram lista nenhuma…" (o is é o jeito certo de comparar com None, aula is e in).

compras = []

…cria uma lista vazia nova, agora, dentro desta chamada. Cada chamada ganha a sua.

nova_lista("feijão", ana)

Quem quiser continuar uma lista existente ainda pode passá-la.

Formas diferentes de chamar a mesma função

Com def pedido(produto, quantidade=1):, as chamadas abaixo pedem 2 cafés:

E quando o valor é o padrão (1 café), o mais simples é não escrever nada: pedido("Café").

Quando dá errado

def pedido(quantidade=1, produto):
    print(f"{quantidade} x {produto}")


pedido("Café")

$ python3 ordem_def.py
  File "/home/ana/ordem_def.py", line 1
    def pedido(quantidade=1, produto):
                             ^^^^^^^
SyntaxError: parameter without a default follows parameter with a default

def pedido(produto, quantidade=1):
    print(f"{quantidade} x {produto}")


pedido(produto="Café", 2)

$ python3 posicional_depois.py
  File "/home/ana/posicional_depois.py", line 5
    pedido(produto="Café", 2)
                            ^
SyntaxError: positional argument follows keyword argument

def pedido(produto, quantidade=1):
    print(f"{quantidade} x {produto}")


pedido("Café", quantidad=2)

$ python3 nome_errado.py
Traceback (most recent call last):
  File "/home/ana/nome_errado.py", line 5, in <module>
    pedido("Café", quantidad=2)
    ~~~~~~^^^^^^^^^^^^^^^^^^^^^
TypeError: pedido() got an unexpected keyword argument 'quantidad'. Did you mean 'quantidade'?

def pedido(produto, quantidade=1):
    print(f"{quantidade} x {produto}")


pedido("Café", produto="Leite")

$ python3 repetido.py
Traceback (most recent call last):
  File "/home/ana/repetido.py", line 5, in <module>
    pedido("Café", produto="Leite")
    ~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: pedido() got multiple values for argument 'produto'

Referência rápida

Exercícios

Missão final: uma lista para cada um

def nova_lista(item, compras=[]):
    compras.append(item)
    return compras


ana = nova_lista("arroz")
bruno = nova_lista("café")
print("Ana:", ana)
print("Bruno:", bruno)

def nova_lista(item, compras=None):
    if compras is None:
        compras = []
    compras.append(item)
    return compras


ana = nova_lista("arroz")
bruno = nova_lista("café")
print("Ana:", ana)
print("Bruno:", bruno)

Resumo

• def f(a, b=10): dá a b um valor padrão: se a chamada não disser nada, vale o 10.
• Argumentos nomeados (f(a=1, b=5)) dizem a qual parâmetro vai cada valor; a ordem deixa de importar, e dá para pular parâmetros opcionais.
• No def: obrigatórios antes dos opcionais. Na chamada: posicionais antes dos nomeados.
• O sep e o end do print são parâmetros com valor padrão.
• O valor padrão é criado uma vez, no def. Por isso nunca use lista ou dicionário como padrão: use None e crie o valor dentro da função.
• * e / no def obrigam a passar com nome ou pela posição; você vai vê-los na documentação.