Parâmetros de Função em Python

Introdução

Neste laboratório, exploraremos como definir e usar funções com parâmetros em Python. As funções se tornam muito mais poderosas quando podem aceitar entradas, o que as torna dinâmicas e reutilizáveis.

Abordaremos vários tipos de parâmetros de função, incluindo parâmetros posicionais, valores padrão (default values), argumentos de palavra-chave (keyword arguments) e argumentos de comprimento variável (variable-length arguments). Através de exemplos práticos, você aprenderá a criar funções flexíveis que podem lidar com uma variedade de entradas.

Definir Funções com Parâmetros Posicionais

Parâmetros nos permitem passar dados para uma função, tornando seu comportamento adaptável com base na entrada que ela recebe. Vamos começar com o tipo mais comum: parâmetros posicionais. Os argumentos passados para uma função são atribuídos a esses parâmetros com base na sua ordem.

Primeiro, localize o arquivo positional_params.py no explorador de arquivos no lado esquerdo do WebIDE e abra-o.

Agora, vamos definir uma função chamada hello que aceita um parâmetro, name. Adicione o seguinte código ao arquivo positional_params.py:

def hello(name):
    print(f'Hello, {name}!')

hello('John')
hello('Alice')

Neste código, name é um parâmetro, que atua como um espaço reservado (placeholder) na definição da função. Quando chamamos a função, como em hello('John'), o valor 'John' é um argumento que é atribuído ao parâmetro name.

Para executar o script, abra um novo terminal no WebIDE clicando em Terminal -> New Terminal no menu superior. Em seguida, execute o seguinte comando:

python3 ~/project/positional_params.py

Você verá a seguinte saída, mostrando que a função produziu resultados diferentes para argumentos diferentes:

Hello, John!
Hello, Alice!

Se uma função for definida com parâmetros posicionais, você deve fornecer um argumento correspondente para cada um deles ao chamá-la. Esquecer de fazer isso resultará em um erro.

Usar Valores de Parâmetro Padrão

É frequentemente útil fornecer um valor padrão (default value) para um parâmetro. Se um argumento para esse parâmetro não for fornecido durante a chamada da função, o valor padrão será usado. Isso torna o parâmetro opcional.

Vamos ver o que acontece quando chamamos uma função sem um argumento obrigatório. Abra o arquivo default_params.py e adicione o seguinte código:

def hello(name):
    print(f'Hello, {name}!')

hello()

Salve o arquivo e execute-o no terminal:

python3 ~/project/default_params.py

Isso produzirá um TypeError porque a função hello esperava um argumento, mas não recebeu nenhum.

Traceback (most recent call last):
  File "/home/labex/project/default_params.py", line 4, in <module>
    hello()
TypeError: hello() missing 1 required positional argument: 'name'

Para corrigir isso, podemos atribuir um valor padrão ao parâmetro name. Modifique o arquivo default_params.py substituindo seu conteúdo pelo código a seguir:

def hello(name="World"):
    print(f'Hello, {name}!')

hello()
hello("Jobs")

Agora, execute o script novamente:

python3 ~/project/default_params.py

A saída será:

Hello, World!
Hello, Jobs!

A primeira chamada usa o valor padrão "World", enquanto a segunda chamada usa o argumento fornecido "Jobs".

Regra Importante: Em uma definição de função, todos os parâmetros sem valores padrão devem vir antes de quaisquer parâmetros com valores padrão. Por exemplo, def func(a, b="default") está correto, mas def func(a="default", b) causará um SyntaxError.

Passar Argumentos Usando Palavras-Chave

Ao chamar uma função, você pode nomear explicitamente os parâmetros para os quais está fornecendo argumentos. Estes são chamados de argumentos de palavra-chave (keyword arguments). Sua principal vantagem é que a ordem não importa, o que pode tornar seu código mais legível.

Abra o arquivo keyword_args.py e adicione o seguinte código:

def person(name, age):
    print(f"{name} is {age} years old.")

## Chamada com argumentos de palavra-chave - a ordem não importa
person(name="Zhang San", age=25)
person(age=50, name="Li Si")

Salve o arquivo e execute-o no terminal:

python3 ~/project/keyword_args.py

Você verá que ambas as chamadas funcionam corretamente, independentemente da ordem dos argumentos:

Zhang San is 25 years old.
Li Si is 50 years old.

Você também pode misturar argumentos posicionais e argumentos de palavra-chave em uma única chamada de função. No entanto, você deve seguir uma regra: todos os argumentos posicionais devem vir antes de quaisquer argumentos de palavra-chave.

Agora, substitua o conteúdo de keyword_args.py pelo seguinte para ver essa regra em ação:

def person(name, age):
    print(f"{name} is {age} years old.")

## Esta é uma mistura válida de argumentos posicionais e de palavra-chave
person("Wang Wu", age=26)

## Isso causaria um SyntaxError: positional argument follows keyword argument
## person(age=28, "Zhao Liu")

Execute o script novamente. A chamada válida será executada como esperado.

python3 ~/project/keyword_args.py

Saída esperada:

Wang Wu is 26 years old.

Lidar com um Número Variável de Argumentos

As funções Python podem ser projetadas para aceitar um número variável de argumentos. Isso é útil quando você não sabe de antemão quantos argumentos serão passados para sua função.

Argumentos Posicionais Variáveis (*args)

Ao colocar um asterisco * antes do nome de um parâmetro, você pode coletar um número arbitrário de argumentos posicionais em uma tupla (tuple). O nome args é uma convenção, mas você pode usar qualquer nome de parâmetro válido.

Argumentos de Palavra-Chave Variáveis (**kwargs)

Ao colocar um asterisco duplo ** antes do nome de um parâmetro, você pode coletar um número arbitrário de argumentos de palavra-chave em um dicionário (dictionary). O nome kwargs também é uma convenção.

Vamos combinar esses conceitos. Abra o arquivo variable_args.py e adicione o seguinte código:

## Usando *args para somar um número variável de valores
def calculate_sum(*numbers):
    print(f"Arguments received as a tuple: {numbers}")
    total = sum(numbers)
    print(f"Sum: {total}\n")

## Usando **kwargs para capturar informações extras de perfil
def person_profile(name, age, **other_info):
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"Other Info: {other_info}\n")

## Chamando as funções
calculate_sum(1, 2, 3)
calculate_sum(10, 20, 30, 40, 50)

person_profile('Wang Wu', 26, gender="Male", job="Writer")
person_profile('Zhao Liu', 28, city="Beijing", status="Active")

Execute o script a partir do terminal:

python3 ~/project/variable_args.py

A saída mostra que numbers é uma tupla e other_info é um dicionário:

Arguments received as a tuple: (1, 2, 3)
Sum: 6

Arguments received as a tuple: (10, 20, 30, 40, 50)
Sum: 150

Name: Wang Wu
Age: 26
Other Info: {'gender': 'Male', 'job': 'Writer'}

Name: Zhao Liu
Age: 28
Other Info: {'city': 'Beijing', 'status': 'Active'}

Explorar Tipos de Parâmetros Especiais

O Python permite que você restrinja como os argumentos podem ser passados para uma função, tornando a assinatura da sua função mais clara e menos ambígua. Você pode especificar parâmetros como somente posicionais (positional-only) ou somente de palavra-chave (keyword-only).

Parâmetros Somente Posicionais (/)

Para especificar que os parâmetros só podem ser passados por posição, coloque-os antes de uma barra (/) na definição da função.

Parâmetros Somente de Palavra-Chave (*)

Para especificar que os parâmetros só podem ser passados por palavra-chave, coloque-os após um asterisco (*). Se o * não for seguido por um nome de parâmetro, isso significa que todos os parâmetros subsequentes devem ser somente de palavra-chave.

Vamos ver como combinar esses tipos. Abra o arquivo special_params.py e adicione o seguinte código. Este exemplo define uma função com parâmetros somente posicionais, padrão e somente de palavra-chave.

def school_info(name, /, standard_param, *, city):
    print(f'Positional-Only (name): {name}')
    print(f'Standard (standard_param): {standard_param}')
    print(f'Keyword-Only (city): {city}')
    print('---')

## Nesta função:
## - `name` deve ser passado por posição.
## - `standard_param` pode ser passado por posição ou palavra-chave.
## - `city` deve ser passado por palavra-chave.

## Chamadas válidas
school_info("Peking University", "PKU", city="Beijing")
school_info("Tsinghua University", standard_param="THU", city="Beijing")

## Exemplos de chamadas inválidas (comentadas para evitar erros)
## school_info(name="Zhejiang University", "ZJU", city="Hangzhou")  ## TypeError: name is positional-only
## school_info("Fudan University", "FDU", "Shanghai")               ## TypeError: city is keyword-only

Execute o script para ver o resultado das chamadas válidas:

python3 ~/project/special_params.py

A saída será:

Positional-Only (name): Peking University
Standard (standard_param): PKU
Keyword-Only (city): Beijing
---
Positional-Only (name): Tsinghua University
Standard (standard_param): THU
Keyword-Only (city): Beijing
---

Esta sintaxe ajuda a criar funções robustas e auto-documentadas, reduzindo a ambiguidade sobre como elas devem ser chamadas.

Resumo

Neste laboratório, você aprendeu os fundamentos do uso de parâmetros em funções Python. Cobrimos como definir e chamar funções com parâmetros posicionais, como tornar os parâmetros opcionais fornecendo valores padrão e como usar argumentos de palavra-chave (keyword arguments) para um código mais legível. Você também explorou como criar funções flexíveis que podem aceitar um número variável de argumentos posicionais (*args) e de palavra-chave (**kwargs). Finalmente, analisamos a sintaxe especial (/ e *) para impor como os argumentos devem ser passados, o que melhora a clareza e a robustez das suas funções.