Alguns pontos base:
- As chamadas de método Python são "caras" devido à sua natureza interpretada . Em teoria, se o seu código for simples o suficiente, a quebra do código Python terá um impacto negativo além da legibilidade e da reutilização (o que é um grande ganho para os desenvolvedores, não para os usuários ).
- O princípio de responsabilidade única (SRP) mantém o código legível, é mais fácil de testar e manter.
- O projeto tem um tipo especial de experiência em que queremos código legível, testes e desempenho de tempo.
Por exemplo, código como este, que chama vários métodos (x4), é mais lento que o seguinte, que é apenas um.
from operator import add
class Vector:
def __init__(self,list_of_3):
self.coordinates = list_of_3
def move(self,movement):
self.coordinates = list( map(add, self.coordinates, movement))
return self.coordinates
def revert(self):
self.coordinates = self.coordinates[::-1]
return self.coordinates
def get_coordinates(self):
return self.coordinates
## Operation with one vector
vec3 = Vector([1,2,3])
vec3.move([1,1,1])
vec3.revert()
vec3.get_coordinates()Em comparação com isso:
from operator import add
def move_and_revert_and_return(vector,movement):
return list( map(add, vector, movement) )[::-1]
move_and_revert_and_return([1,2,3],[1,1,1])Se eu devo paralelizar algo assim, é bastante objetivo que eu perco o desempenho. Mente que é apenas um exemplo; meu projeto possui várias mini-rotinas com matemática como essa - embora seja muito mais fácil trabalhar com, nossos criadores de perfil não gostam disso.
Como e onde adotamos o SRP sem comprometer o desempenho no Python, pois sua implementação inerente o afeta diretamente?
Existem soluções alternativas, como algum tipo de pré-processador que coloca as coisas em linha para o lançamento?
Ou o Python é simplesmente ruim em lidar com a quebra de código?
4
Possível duplicata de A micro-otimização é importante ao codificar?
—
mosquito
Pelo que vale a pena, seus dois exemplos de código não diferem no número de responsabilidades. O SRP não é um método de contagem de exercícios.
—
Robert Harvey
@RobertHarvey Você está certo, desculpe pelo exemplo ruim e eu editarei um melhor quando tiver tempo. Em qualquer um dos casos, a legibilidade e a manutenção são prejudicadas e, eventualmente, o SRP se decompõe na base de código à medida que reduzimos as classes e seus métodos.
—
Lucasgcb 12/04/19
note que chamadas de função são caros em qualquer idioma , embora compiladores AOT tem o luxo de inlining
—
Eevee
Use uma implementação JITted de python, como PyPy. Deve principalmente corrigir esse problema.
—
Bakuriu 12/04/19