[Dúvida] [Python] Como evitar a repetição de parâmetros em várias funções.
Em um código Python, se várias funções recebem os mesmos parâmetros (especialmente se forem muitos), existe alguma boa prática para evitar repetição e melhorar a organização?
Por exemplo nesse código:
def calcular_imposto(valor_bruto, aliquota, deducoes, dependentes, estado):
def calcular_salario_liquido(valor_bruto, aliquota, deducoes, dependentes, estado):
def gerar_holerite(valor_bruto, aliquota, deducoes, dependentes, estado):
Imagine uma dezena ou mais de funções assim, todas com muitos parametros e todos se repetindo por serem usados em todas as funções. Existe alguma forma de evitar a repetição?
Tem algumas opções como usar a lib dataclass para gerar um placeholder para esses valores, então tu conseguiria passar o placeholder ao invês de uma repetição.
from dataclasses import dataclass
@dataclass
class ParametrosFinanceiros:
valor_bruto: float
aliquota: float
deducoes: float
dependentes: int
estado: str
def calcular_imposto(params: ParametrosFinanceiros):
# use params.valor_bruto, params.aliquota, etc.
pass
def calcular_salario_liquido(params: ParametrosFinanceiros):
pass
def gerar_holerite(params: ParametrosFinanceiros):
pass
# Uso
parametros = ParametrosFinanceiros(5000, 0.2, 300, 2, 'SP')
calcular_imposto(parametros)
calcular_salario_liquido(parametros)
gerar_holerite(parametros)
Sem modificar as funções, uma alternativa é colocar todos os valores em uma tupla, e depois usar a sintaxe de unpacking ao chamá-las:
params = (valor_bruto, aliquota, deducoes, dependentes, estado)
calcular_imposto(*params)
calcular_salario_liquido(*params)
gerar_holerite(*params)
Repare no asterisco antes de params, é ele que faz o unpacking: o primeiro elemento da tupla é passado como o primeiro argumento da função, o segundo elemento é passado como o segundo argumento e assim por diante.
Claro que tem outras soluções mais rebuscadas, como criar uma classe que contém todos os valores, aí as funções só recebem a instância da classe. Mas aí precisa avaliar se justifica aumentar a complexidade.
Por exemplo, se não puder mudar as funções, a solução com unpacking me parece mais interessante.
Quando os parâmetros se repetem demais, talvez é uma indicação de que eles pertencem ao escopo de uma classe, inclusive as funções.
Uma solução é a que foi dada pelo KitsuneSemCalda, mas você pode incluir os métodos também:
Assim, as chamadas não precisam mais repetir a expressão "parametros"
(PS: Mudei o nome da classe para CalculosFinanceiros, porque faz mais sentido nesse escopo)
from dataclasses import dataclass
@dataclass
class CalculosFinanceiros:
valor_bruto: float
aliquota: float
deducoes: float
dependentes: int
estado: str
def calcular_imposto(self):
# use self.valor_bruto, self.aliquota, etc.
pass
def calcular_salario_liquido(self):
pass
def gerar_holerite(self):
pass
# Uso
calculos = CalculosFinanceiros(5000, 0.2, 300, 2, 'SP')
calculos.calcular_imposto()
calculos.calcular_salario_liquido()
calculos.gerar_holerite()
Salve Andy!
Não conheço nenhum artifício da linguagem pra omitir esses parâmetros repetidos, mas também acredito que caso exista esse artifício isso só dificultaria a legibilidade do código.
Hoje em dia as IDEs possuem auto-complete, o que facilita bastante. Caso você queira reduzir seu código você pode passar como argumento um dicionário (não é uma boa opção e é mais trabalhoso na hora de chamar a função, mas solucionaria teu problema tendo que passar somente 1 variável)
def sum(nums):
return (nums['a'] + nums['b'])
nums = {'a': 5, 'b': 7}
print(f'Sum of {nums["a"]} and {nums["b"]} is {sum(nums)}')