Your method violates the Single Responsibility Principle. Consider splitting it like this:
def positionExtractor(alist):
return tuple(alist[0:3])
def velocityExtractor(alist):
velocity = tuple(alist[3:6])
return velocity + (np.sqrt(sum(x**2 for x in velocity)),)
def forcesExtractor(alist):
forces = tuple(alist[6:9])
return forces + (np.sqrt(sum(x**2 for x in forces)),)
You can put them in a dictionary:
extractors = {
'position' : positionExtractor,
'velocity' : velocityExtractor,
'forces' : forcesExtractor}
and use:
result = extractors[quantity](alist)
Here is an example with inheritance. It seems to be over-engineering for such a simple task though:
import numpy as np
class Extractor:
def extract(self, alist):
raise NotImplementedError()
class IndexRangeExtractor(Extractor):
def __init__(self, fromIndex, toIndex):
self.fromIndex = fromIndex
self.toIndex = toIndex
def extract(self, alist):
return tuple(alist[self.fromIndex:self.toIndex])
class EuclideanDistanceExtractorDecorator(Extractor):
def __init__(self, innerExtractor):
self.innerExtractor = innerExtractor
def extract(self, alist):
innerResult = self.innerExtractor.extract(alist)
distance = np.sqrt(sum(x**2 for x in innerResult))
return innerResult + (distance,)
#...
class ExtractorFactory:
def __init__(self):
self.extractors = {
'position':IndexRangeExtractor(0, 3),
'velocity':EuclideanDistanceExtractorDecorator(
IndexRangeExtractor(3, 6)),
'forces':EuclideanDistanceExtractorDecorator(
IndexRangeExtractor(6, 9))}
def createExtractor(self, quantity):
return self.extractors[quantity]
alist = [1,2,3,4,5,6,7,8,9]
ef = ExtractorFactory()
e1 = ef.createExtractor('position')
e2 = ef.createExtractor('velocity')
e3 = ef.createExtractor('forces')
print e1.extract(alist)
print e2.extract(alist)
print e3.extract(alist)