Criar suas funções é a chave para a sucesso. Vamos ver algumas das opções de parâmetros de entrada de uma função e em outro post vamos falar em criar seus módulos (Conjunto de funções).
Comente suas funções com docstrings
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
def saudacao(): """ Exibe a saudação "olá mundo" no console. Esta função é um exemplo simples de saudação que demonstra como estruturar uma docstring apropriada seguindo as convenções do Python. Parâmetros ---------- None Esta função não recebe parâmetros. Retorna ------- None Esta função não retorna valor, apenas imprime no console. Exemplos -------- >>> saudacao() olá mundo Notas ----- - A saída é impressa diretamente no stdout - Não há tratamento de erros pois a função é trivial """ print("olá mundo") |
Para acessar a informação help() das suas funções em Python, você precisa adicionar docstrings (documentação inline) ao seu código. Após as configurações docstrings no prompt de comando tente usar help(saudacao) para ter acesso ao help da sua função.
O exemplo acima é uma função que não tem parâmetros de entrada, apenas imprime uma informação. Ao comentar suas funções com aspas triplas você poderá consulta-las em help() e poderá gerar a documentação com pydoc.
Valor Default
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
def saudacao(nome="Mundo"): """ Exibe uma saudação personalizada no console. Esta função imprime uma mensagem de "olá" seguida pelo nome fornecido como parâmetro. Se nenhum nome for especificado, utiliza "Mundo" como valor padrão. Parâmetros ---------- nome : str, optional O nome da pessoa a ser saudada (padrão é "Mundo"). O valor pode ser qualquer string válida. Retorna ------- None Esta função não retorna valor, apenas imprime no console. Exemplos -------- >>> saudacao() olá Mundo ! >>> saudacao("João") olá João ! >>> saudacao("Maria") olá Maria ! >>> saudacao("Python") olá Python ! Notas ----- - A saudação segue o formato: "olá {nome} !" - Há um espaço antes do ponto de exclamação conforme implementado """ print(f"olá {nome} !") |
No exemplo acima nome é um campo não obrigatório que caso não seja informado será atribuído o valor default “Mundo” e imprime o resultado.
Definindo Tipo no parâmetro de entrada
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
from typing import List # RUIM - sem type hints def media_alunos(alunos, notas): # O que é 'alunos'? Lista? Dicionário? # O que é 'notas'? O que retorna? total = sum(notas) return total / len(notas) # BOM - com type hints def media_alunos(alunos: List[str], notas: List[float]) -> float: """ Calcula a média das notas dos alunos. Args: alunos: Lista com nomes dos alunos notas: Lista com as notas correspondentes Returns: Média aritmética das notas """ if not notas: return 0.0 return sum(notas) / len(notas) |
Type hints não são obrigatórios (Python continua dinâmico), mas são altamente recomendados para:
-
Projetos de médio/grande porte
-
Código que será mantido por outras pessoas
-
Bibliotecas e APIs públicas
-
Times de desenvolvimento
-
Prevenção de bugs antes do runtime
Contudo em pequenos ou médios projetos não é interessante o uso de type hints.
Retornando o valor
|
1 2 3 4 5 6 7 8 9 10 11 12 |
def soma(a:float, b:float): """ soma function ====================== add two numbers float Parameters:a(float), b(float) Return:float """ resultado = a + b return resultado retorno_da_funcao = soma(2,3) print(retorno_da_funcao) |
No exemplo acima a função retornou 5, pois usamos o método return, também definimos que os parâmetros de entrada devem ser do tipo float;
Passando um parâmetro obrigatório e outro opcional em uma função
|
1 2 3 4 |
def potencia(base, expoente=2): return base ** expoente print(potencia(2)) print(potencia(2,5)) |
Passando número arbitrários de parâmetros
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
def saudacao(*nomes): """ saudacao function ====================== Print the greeting to the World Parameters:nomes(list) default:"Mundo" """ resultado = "Olá" for nome in nomes: resultado += ", "+nome resultado += " !" print(resultado) help(saudacao) saudacao() saudacao("Mundo") saudacao("Paulo","Suely","Geraldo") saudacao("Maria","Elô","Chico","Severino","Diogo") |
Passando um Dicionário
|
1 2 3 4 5 6 7 8 |
def minha_funcao(**kwargs): for key, value in kwargs.items(): print(f'{key} = {value}') minha_funcao(nome='Paula',sobrenome='Soarez',endereco='Rua Ipanema', numero='0') nome = Paula sobrenome = Soarez endereco = Rua Ipanema numero = 0 |
Dicionário é um tipo de dado mais complexo que farei um post separadamente. A princípio você deve saber que ele existe, e nele temos campos com propriedades chave e valor.
Retornando um Dicionário
|
1 2 3 4 5 |
def retorna_dicionario(**kwargs): return dict(kwargs) dicionario = retorna_dicionario(nome='Paula',sobrenome='Soarez',endereco='Rua Ipanema', numero='0') print(dicionario) print(dicionario['endereco']) |
Passando uma Função para outra Função
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
def aplicar_operacao(numero, operacao): """ Aplica uma operação passada como argumento a um número. :param numero: O número sobre o qual a operação será aplicada. :param operacao: Uma função que realiza a operação. """ return operacao(numero) # Funções que serão passadas como argumento def dobrar(x): return x * 2 def quadrado(x): return x ** 2 # Exemplo de uso resultado1 = aplicar_operacao(5, dobrar) # Chama a função dobrar(5) resultado2 = aplicar_operacao(3, quadrado) # Chama a função quadrado(3) print(f"Dobrar 5: {resultado1}") # Saída: Dobrar 5: 10 print(f"Quadrado de 3: {resultado2}") # Saída: Quadrado de 3: 9 |
