Tiveron!

Argumentos….parece assunto bastante trivial, na verdade é, mas podemos nos deparar com algumas situações um pouco mais complexas que o tradicional.
E como eu qualquer outra linguagem decente, python nos dá algumas opções para trabalharmos com argumentos em uma função.

Basicamente temos 2 tipos de argumentos em python, aqueles que são passados diretamente na execução de uma função(chamado de posicional, o mais tradicional)  e aqueles argumentos passados por palavra-chave(que não precisam estar na ordem certa em que são declarados na função).

Argumentos Posicionais

Quando trabalhamos com argumentos posicionais, devemos respeitar a ordem na qual eles foram definidos na função, ou seja, o primeiro argumento passado na execução da função será o primeiro argumento que ela receberá, e assim por diante. Todo argumento posicional é obrigatório.

def foo(arg1, arg2):
    print arg1
    print arg2
 
>>> foo('valor1', 'valor2')
valor 1
valor 2

Argumentos tipo Palavra-chave

Já argumentos definidos por palavras-chave não precisam ser passados na ordem em que foram definidos, basta fazer a associação através de uma palavra-chave. Argumentos por palavra-chave são opcionais, uma vez que podemos pré-definir valores para eles.

def foo(arg1='valor 1', arg2='valor 2'):
    print arg1
    print arg2
 
>>> foo(arg2='novo valor 2')
valor 1
novo valor 2

Note que  na chamada da função só passamos o argumento arg2, isso funciona porque, como já explicado, argumentos por palavra-chave são opcionais. Como a função não recebeu nenhum argumento chamado arg1, o mesmo assumiu seu valor pré-definido(‘valor 1′).

Um pouco dos 2

Podemos também misturar os 2 tipos de argumentos sem problemas, com uma simples regra. Os argumentos posicionais devem sempre vir antes que argumentos por palavra-chave

def foo(arg1, arg2, arg3='valor 3', arg4='valor 4'):
    print arg1
    print arg2
    print arg3
    print arg4
 
>>> foo(valor1, valor2, arg4='novo valor 4')
valor 1
valor 2
valor 3
novo valor 4

Caixa preta

Até agora, em todos os exemplos passados, sabemos exatamente quais argumentos nossa função deve esperar. Mas se por acaso não soubermos os argumentos que nossa função vai receber? Como adequar nosso código para tratar esse tipo de imprevisto?

Para esses casos python nos dá uma grande ajuda =)  Temos 2 coringas para pegarmos os argumentos adicionais:

*arg = pega todos os argumentos posicionais adicionais em uma função
**kwargs = pega todos os argumentos por palavra-chave adicionais em uma função

Lembrando que as palavras ‘arg’ e ‘kwargs’ são apenas uma convenção, o que interessa mesmo são os asteriscos. 1 para posicionais e 2 para palavras-chave.

esses 2 coringas armazenam os argumentos em objetos iteráveis, *args em tuplas e **kwargs em dicionários.

def foo(arg1, *args):
    print arg1
    print args
 
>>> foo('valor 1', 'valor 3', 'valor 4')
valor 1
('valor 3','valor 4')

def foo(arg1, **kargs):
    print arg1
    print kwargs
 
>>> foo('valor 1', arg2='valor 2', arg3='valor 3')
valor 1
{'arg2': 'valor 2', 'arg3': 'valor3'}

def foo(*args **kargs):
    print arg
    print kwargs
 
>>> foo('valor 1', 'valor 2' arg3='valor 3', arg4='valor 4')
('valor 1', 'valor 2')
{'arg2': 'valor 2', 'arg3': 'valor3'}

 
Com isso temos mais flexibilidade para trabalhar os argumentos, mesmo não sabendo quantos e quais argumentos a função irá receber.