Использует ли тип в качестве словарных ключей, считающихся хорошей практикой в ​​Python?

Question

У меня есть справочная таблица, как это:

lookup = { 
    "<class 'Minority.mixin'>": report_minority, 
    "<class 'Majority.mixin'>": report_majority, 
} 

def report(o): 
    h = lookup[str(type(o))] 
    h() 

Это выглядит неудобно мне как key будет непрочно связан к тому, как type() возвращается и представляет в string в class. Если в один прекрасный день Python изменит свой путь до class типов в string, все эти коды сломаны. Поэтому я хочу получить советы от профессионалов, такой тип ключей считается хорошим или плохим? Благодарю.

Answer 1

Вопрос будет более Почему вы это делаете в первую очередь? Какое преимущество вы думаю используя струны есть?

объекты класса hashable, так что вы можете использовать Minority.mixin и Majority.mixinнепосредственно в качестве ключей. И когда вы это сделаете, вы гарантируете, что ключ всегда тот же самый объект, если ваши классы являются глобальными в своих соответствующих модулях, что делает их одноклассниками вашей программы. Более того, нет никаких шансов на случайную путаницу, когда вы позже реорганизуете свой код для переименования модулей, и вы получите разные типы с таким точным результатом repr().

Так что, если у вас нет конкретной утилиты, в которой вы не можете не использовать, вы не должны использовать представления строк.

(И даже если вы должны были генерировать классы с заводской функцией, использование базового класса и isinstance, вероятно, будет предпочтительным проверять или извлекать базовый класс из MRO).

Так, для USECASE, придерживайтесь:

lookup = { 
    Minority.mixin: report_minority, 
    Majority.mixin: report_majority, 
} 

def report(o): 
    h = lookup[type(o)]) 
    h() 

Далее, если вы убедитесь, что report_minority и report_majority являются функции (а не методы, например), вы можете использовать functools.singledispatch() и обойтись без вашего отображение в целом:

from functools import singledispatch 

@singledispatch 
def report(o): 
    raise ValueError('Unhandled type {}'.format(type(o))) 

@report.register(Minority.mixin) 
def report_minority(o): 
    # handle a Minority instance 

@report.register(Majority.mixin) 
def report_majority(o): 
    # handle a Majority instance 

Обратите внимание, что это не будет работать с методами, как и методы должны принять несколько аргументов для отправки на работу, так как они всегда принимают self.

Одиночные диспетчерские ручки подклассы гораздо лучше, в отличие от вашего str - на основе картографирования или даже прямого сопоставления классов.

Answer 2

Посмотрите на этот сценарий, я не думаю, что это прекрасно, но это работает, и я думаю, что это более элегантно, чем ваше решение:

#!/usr/bin/env python3 

class Person: 
    pass 

def display_person(): 
    print("Person !") 

class Car: 
    pass 

def display_car(): 
    print("Car !") 

lookup = { 
    Person: display_person, 
    Car: display_car 
} 


def report(o): 
    lookup[o.__class__]() 


report(Person()) 
report(Car()) 

Edit: модификация для Python3

Answer 3

Просто удалите str из поиска и из словаря. Таким образом,

lookup = { 
    Minority.mixin : report_minority, 
    Majority.mixin : report_majority, 
} 

def report(o): 
    h = lookup[type(o)] 
    h() 

Это исправляет вашу непосредственную озабоченность и является довольно разумным кодом. Однако, похоже, что отправка по типу - это именно то, для чего OO. Итак, почему бы не сделать эти различные методы функций отчета на объекте o, полученном из его типа? Тогда вы могли бы просто написать:

o.report() 

и правильный вариант был получен из класса.