usine d'objet qui génère un objet ou d'une liste d'objets

Question

Je le code suivant:

def f(cls, value): 
    # cls is a class 
    # value is a string value 
    if cls == str: 
    pass # value is already the right type 
    elif cls == int: 
    value = int(value) 
    elif cls == C1: 
    value = C1(value) 
    elif cls == C2: 
    value = C2(value) 
    elif cls == C3 
    # in this case, we convert the string into a list of objects of class C3 
    value = C3.parse(value) 
    else 
    raise UnknownClass(repr(cls)) 
    return value 

De toute évidence, je suis en train de le remplacer par quelque chose comme:

def f(cls, value) 
    return cls(value) 

Malheureusement, dans certains cas (si cls == C3), l'analyse de l'entrée aboutit à une liste d'objets de cette classe, plutôt qu'à un seul objet. Quelle est la bonne façon de gérer cela? J'ai accès à toutes les classes.

Answer 1

Si la plupart des cas sont mieux gérées en appelant cls, et quelques-uns sont mieux gérées sinon, le plus simple est de choisir ce dernier:

themap = {C3: C3.parse} 
for C in (str, C1, C2): 
    themap[C] = C 

def f(cls, value): 
    wot = themap.get(cls) 
    if wot is None: 
     raise UnknownClass(repr(cls)) 
    return wot(value) 

Notez que l'appel str sur une chaîne est un noop assez rapide, il est donc généralement à éviter absolument le « singulariser » de ce cas spécifique en faveur de la simplicité du code.

Answer 2

Cela dépend de ce que vous feriez avec la liste. Ceci est la façon la plus simple:

obj = cls (valeur)

si le type (obj) == Liste:

handle_list (obj)

retour obj