Як я можу зробити максимально «досконалим» підклас дикту ? Кінцевою метою є створення простого диктанту, в якому клавіші є малі.

Здавалося б, має бути якийсь крихітний набір примітивів, які я можу перекрити, щоб зробити цю роботу, але згідно з усіма моїми дослідженнями та спробами, схоже, це не так:

• Якщо я перекрию __getitem__/__setitem__ , то get/ setне працювати. Як змусити їх працювати? Невже мені не потрібно їх реалізовувати окремо?

• Чи заважаю соління працювати, і мені потрібно застосовувати __setstate__тощо?

• Чи потрібноreprupdate__init__ мені , і ?

• Чи повинен я просто використовувати мутаційну карту (здається, не слід використовувати UserDict або DictMixin)? Якщо так, то як? Документи не зовсім освічуючі.

Ось мій перший погляд на це, get()не працює, і, без сумніву, є багато інших незначних проблем:

class arbitrary_dict(dict):
    """A dictionary that applies an arbitrary key-altering function
       before accessing the keys."""

    def __keytransform__(self, key):
        return key

    # Overridden methods. List from 
    # /programming/2390827/how-to-properly-subclass-dict

    def __init__(self, *args, **kwargs):
        self.update(*args, **kwargs)

    # Note: I'm using dict directly, since super(dict, self) doesn't work.
    # I'm not sure why, perhaps dict is not a new-style class.

    def __getitem__(self, key):
        return dict.__getitem__(self, self.__keytransform__(key))

    def __setitem__(self, key, value):
        return dict.__setitem__(self, self.__keytransform__(key), value)

    def __delitem__(self, key):
        return dict.__delitem__(self, self.__keytransform__(key))

    def __contains__(self, key):
        return dict.__contains__(self, self.__keytransform__(key))


class lcdict(arbitrary_dict):
    def __keytransform__(self, key):
        return str(key).lower()

Ви можете написати об'єкт, який веде себе dictдосить легко за допомогою модуля ABC s (Анотація базових класів) collections.abc. Він навіть говорить вам, якщо ви пропустили метод, тому нижче наведена мінімальна версія, яка закриває ABC.

from collections.abc import MutableMapping


class TransformedDict(MutableMapping):
    """A dictionary that applies an arbitrary key-altering
       function before accessing the keys"""

    def __init__(self, *args, **kwargs):
        self.store = dict()
        self.update(dict(*args, **kwargs))  # use the free update to set keys

    def __getitem__(self, key):
        return self.store[self.__keytransform__(key)]

    def __setitem__(self, key, value):
        self.store[self.__keytransform__(key)] = value

    def __delitem__(self, key):
        del self.store[self.__keytransform__(key)]

    def __iter__(self):
        return iter(self.store)

    def __len__(self):
        return len(self.store)

    def __keytransform__(self, key):
        return key

Ви отримуєте кілька безкоштовних методів від ABC:

class MyTransformedDict(TransformedDict):

    def __keytransform__(self, key):
        return key.lower()


s = MyTransformedDict([('Test', 'test')])

assert s.get('TEST') is s['test']   # free get
assert 'TeSt' in s                  # free __contains__
                                    # free setdefault, __eq__, and so on

import pickle
# works too since we just use a normal dict
assert pickle.loads(pickle.dumps(s)) == s

Я б не підклас dict(або інші вбудовані) безпосередньо. Це часто не має сенсу, адже те, що ви насправді хочете зробити, це реалізувати інтерфейсdict . І саме для цього є ABC.

Як я можу зробити максимально «досконалим» підклас дикту?

Кінцевою метою є створення простого диктанту, в якому клавіші є малі.

• Якщо я перекрию __getitem__/ __setitem__, то get / set не працює. Як змусити їх працювати? Невже мені не потрібно їх реалізовувати окремо?

• Чи заважаю соління працювати, і мені потрібно застосовувати __setstate__тощо?

• Чи потрібно мені перевидання, оновлення та __init__?

• Чи повинен я просто використовувати mutablemapping(здається, один не повинен використовувати UserDict або DictMixin)? Якщо так, то як? Документи не зовсім освічуючі.

Прийнята відповідь була б моїм першим підходом, але оскільки в ній є деякі питання, і оскільки ніхто не звертався до альтернативи, насправді підкласу a dict, я збираюся це зробити тут.

Що не так у прийнятій відповіді?

Це здається мені досить простим запитом:

Як я можу зробити максимально «досконалим» підклас дикту? Кінцевою метою є створення простого диктанту, в якому клавіші є малі.

Прийнята відповідь насправді не є підкласом dict, і тест на це не вдається:

>>> isinstance(MyTransformedDict([('Test', 'test')]), dict)
False

В ідеалі будь-який код перевірки типу буде тестуванням інтерфейсу, який ми очікуємо, або абстрактного базового класу, але якщо наші об’єкти даних переходять у функції, які тестуються, dict- і ми не можемо "виправити" ці функції, цей код не вдасться.

Інші вигадки, які можна зробити:

• Прийнятий відповідь також відсутній Метод класу: fromkeys.

• Прийнята відповідь також є зайвою __dict__- тому займаючи більше місця в пам'яті:

  >>> s.foo = 'bar'
  >>> s.__dict__
  {'foo': 'bar', 'store': {'test': 'test'}}
  

Фактично підкласифікація dict

Ми можемо повторно використовувати методи викладання шляхом успадкування. Все, що нам потрібно зробити, - це створити інтерфейсний шар, який гарантує, що ключі передаються в дикт у малій формі, якщо вони є рядками.

Якщо я перекрию __getitem__/ __setitem__, то get / set не працює. Як змусити їх працювати? Невже мені не потрібно їх реалізовувати окремо?

Що ж, їх реалізація окремо є недоліком цього підходу та перевагою використання MutableMapping(див. Прийняту відповідь), але насправді це не так вже й багато роботи.

Спочатку давайте визначимо різницю між Python 2 та 3, створимо синглтон ( _RaiseKeyError), щоб переконатися, що ми знаємо, чи насправді отримуємо аргумент dict.pop, і створимо функцію, щоб переконатися, що наші рядкові клавіші є малі:

from itertools import chain
try:              # Python 2
    str_base = basestring
    items = 'iteritems'
except NameError: # Python 3
    str_base = str, bytes, bytearray
    items = 'items'

_RaiseKeyError = object() # singleton for no-default behavior

def ensure_lower(maybe_str):
    """dict keys can be any hashable object - only call lower if str"""
    return maybe_str.lower() if isinstance(maybe_str, str_base) else maybe_str

Тепер ми реалізуємо - я використовую superз повними аргументами, щоб цей код працював для Python 2 і 3:

class LowerDict(dict):  # dicts take a mapping or iterable as their optional first argument
    __slots__ = () # no __dict__ - that would be redundant
    @staticmethod # because this doesn't make sense as a global function.
    def _process_args(mapping=(), **kwargs):
        if hasattr(mapping, items):
            mapping = getattr(mapping, items)()
        return ((ensure_lower(k), v) for k, v in chain(mapping, getattr(kwargs, items)()))
    def __init__(self, mapping=(), **kwargs):
        super(LowerDict, self).__init__(self._process_args(mapping, **kwargs))
    def __getitem__(self, k):
        return super(LowerDict, self).__getitem__(ensure_lower(k))
    def __setitem__(self, k, v):
        return super(LowerDict, self).__setitem__(ensure_lower(k), v)
    def __delitem__(self, k):
        return super(LowerDict, self).__delitem__(ensure_lower(k))
    def get(self, k, default=None):
        return super(LowerDict, self).get(ensure_lower(k), default)
    def setdefault(self, k, default=None):
        return super(LowerDict, self).setdefault(ensure_lower(k), default)
    def pop(self, k, v=_RaiseKeyError):
        if v is _RaiseKeyError:
            return super(LowerDict, self).pop(ensure_lower(k))
        return super(LowerDict, self).pop(ensure_lower(k), v)
    def update(self, mapping=(), **kwargs):
        super(LowerDict, self).update(self._process_args(mapping, **kwargs))
    def __contains__(self, k):
        return super(LowerDict, self).__contains__(ensure_lower(k))
    def copy(self): # don't delegate w/ super - dict.copy() -> dict :(
        return type(self)(self)
    @classmethod
    def fromkeys(cls, keys, v=None):
        return super(LowerDict, cls).fromkeys((ensure_lower(k) for k in keys), v)
    def __repr__(self):
        return '{0}({1})'.format(type(self).__name__, super(LowerDict, self).__repr__())

Ми використовуємо майже шаблонний підхід для будь-якого методу або спеціального методу , який посилається на ключ, але в іншому, у спадок, ми отримуємо методи: len, clear, items, keys, popitem, і valuesбезкоштовно. Хоча для цього потрібна ретельна думка, щоб вийти правильно, банально бачити, що це працює.

(Зауважте, що haskeyце застаріле в Python 2, видалено в Python 3.)

Ось якесь використання:

>>> ld = LowerDict(dict(foo='bar'))
>>> ld['FOO']
'bar'
>>> ld['foo']
'bar'
>>> ld.pop('FoO')
'bar'
>>> ld.setdefault('Foo')
>>> ld
{'foo': None}
>>> ld.get('Bar')
>>> ld.setdefault('Bar')
>>> ld
{'bar': None, 'foo': None}
>>> ld.popitem()
('bar', None)

Чи заважаю соління працювати, і мені потрібно застосовувати __setstate__тощо?

маринування

І соління підкласу Дікт просто чудово:

>>> import pickle
>>> pickle.dumps(ld)
b'\x80\x03c__main__\nLowerDict\nq\x00)\x81q\x01X\x03\x00\x00\x00fooq\x02Ns.'
>>> pickle.loads(pickle.dumps(ld))
{'foo': None}
>>> type(pickle.loads(pickle.dumps(ld)))
<class '__main__.LowerDict'>

__repr__

Чи потрібно мені перевидання, оновлення та __init__?

Ми визначили updateі __init__, але у вас є гарний __repr__за замовчуванням:

>>> ld # without __repr__ defined for the class, we get this
{'foo': None}

Однак добре написати __repr__атрибут для покращення налагоджуваності вашого коду. Ідеальний тест - це eval(repr(obj)) == obj. Якщо це легко зробити для вашого коду, я настійно рекомендую:

>>> ld = LowerDict({})
>>> eval(repr(ld)) == ld
True
>>> ld = LowerDict(dict(a=1, b=2, c=3))
>>> eval(repr(ld)) == ld
True

Розумієте, саме те, що нам потрібно відтворити еквівалентний об’єкт - це те, що може відображатися в наших журналах або в ретракціях:

>>> ld
LowerDict({'a': 1, 'c': 3, 'b': 2})

Висновок

Чи повинен я просто використовувати mutablemapping(здається, один не повинен використовувати UserDict або DictMixin)? Якщо так, то як? Документи не зовсім освічуючі.

Так, це ще кілька рядків коду, але вони мають бути вичерпними. Першим моїм схильністю було б використовувати прийняту відповідь, і якщо з цим виникнуть проблеми, я б тоді подивився на свою відповідь - оскільки це трохи складніше, і немає АВС, яка допомогла б мені правильно встановити інтерфейс.

Передчасна оптимізація потребує більшої складності у пошуку ефективності. MutableMappingпростіше - тому він отримує негайний край, а всі інші рівні. Тим не менш, щоб викласти всі відмінності, давайте порівняємо та порівняємо.

Варто додати, що був поштовх, щоб помістити аналогічний словник у collectionsмодуль, але він був відхилений . Вам, мабуть, слід просто зробити це замість цього:

my_dict[transform(key)]

Це має бути набагато легше для відсвідчення.

Порівнювати і протиставляти

Є 6 функцій інтерфейсу, реалізованих з MutableMapping(який відсутній fromkeys) та 11 з dictпідкласом. Мені не потрібно , щоб реалізувати __iter__або __len__, але замість цього я повинен реалізувати get, setdefault, pop, update, copy, __contains__, і fromkeys- але це досить тривіально, так як я можу використовувати спадкування для більшості з цих реалізацій.

У MutableMappingреалізують деякі речі в Python , який dictреалізує в C - так що я очікував би , що dictпідклас більш продуктивний в деяких випадках.

Ми отримуємо безкоштовно __eq__в обох підходах - обидва з них припускають рівність лише в тому випадку, якщо інший диктант є малі, - але, знову ж таки, я думаю, що dictпідклас порівняється швидше.

Підсумок:

• підкласифікація MutableMappingпростіша з меншими можливостями для помилок, але повільніше, займає більше пам’яті (див. зайвий диктант) і не дає змогиisinstance(x, dict)
• підкласифікація dictшвидша, використовує менше пам'яті та проходить isinstance(x, dict), але вона має більшу складність в реалізації.

Що досконаліше? Це залежить від вашого визначення ідеального.

Мої вимоги були трохи суворішими:

• Мені довелося зберегти інформацію про регістр (рядки - це шляхи до файлів, що відображаються користувачеві, але це програма для Windows, тому внутрішньо всі операції повинні бути нечутливими до регістру)
• Мені потрібно було ключі , щоб бути якомога менше (це дійсно зробити різницю в продуктивності пам'яті, відрубану 110 мб з 370). Це означало, що кешування малої версії клавіш - це не варіант.
• Мені потрібно було створити структуру даних, щоб бути якомога швидшим (знову змінив продуктивність, швидкість цього разу). Довелося їхати з вбудованим

Моя початкова думка полягала в тому, щоб замінити наш незграбний клас Path на нечутливий підклас однокласового підрозділу - але:

• виявилося важко отримати це право - див .: Клас струн нечутливий до випадку в python
• виявляється, що чітке керування клавішами dict робить код багатослівним і безладним - і схильним до помилок (структури передаються туди-сюди, і незрозуміло, чи є вони екземплярами CIStr як ключі / елементи, легко забути плюс, some_dict[CIstr(path)]це некрасиво)

Тож мені довелося нарешті записати цей випадок, нечутливий до справи. Завдяки коду від @AaronHall, який було зроблено в 10 разів простіше.

class CIstr(unicode):
    """See https://stackoverflow.com/a/43122305/281545, especially for inlines"""
    __slots__ = () # does make a difference in memory performance

    #--Hash/Compare
    def __hash__(self):
        return hash(self.lower())
    def __eq__(self, other):
        if isinstance(other, CIstr):
            return self.lower() == other.lower()
        return NotImplemented
    def __ne__(self, other):
        if isinstance(other, CIstr):
            return self.lower() != other.lower()
        return NotImplemented
    def __lt__(self, other):
        if isinstance(other, CIstr):
            return self.lower() < other.lower()
        return NotImplemented
    def __ge__(self, other):
        if isinstance(other, CIstr):
            return self.lower() >= other.lower()
        return NotImplemented
    def __gt__(self, other):
        if isinstance(other, CIstr):
            return self.lower() > other.lower()
        return NotImplemented
    def __le__(self, other):
        if isinstance(other, CIstr):
            return self.lower() <= other.lower()
        return NotImplemented
    #--repr
    def __repr__(self):
        return '{0}({1})'.format(type(self).__name__,
                                 super(CIstr, self).__repr__())

def _ci_str(maybe_str):
    """dict keys can be any hashable object - only call CIstr if str"""
    return CIstr(maybe_str) if isinstance(maybe_str, basestring) else maybe_str

class LowerDict(dict):
    """Dictionary that transforms its keys to CIstr instances.
    Adapted from: https://stackoverflow.com/a/39375731/281545
    """
    __slots__ = () # no __dict__ - that would be redundant

    @staticmethod # because this doesn't make sense as a global function.
    def _process_args(mapping=(), **kwargs):
        if hasattr(mapping, 'iteritems'):
            mapping = getattr(mapping, 'iteritems')()
        return ((_ci_str(k), v) for k, v in
                chain(mapping, getattr(kwargs, 'iteritems')()))
    def __init__(self, mapping=(), **kwargs):
        # dicts take a mapping or iterable as their optional first argument
        super(LowerDict, self).__init__(self._process_args(mapping, **kwargs))
    def __getitem__(self, k):
        return super(LowerDict, self).__getitem__(_ci_str(k))
    def __setitem__(self, k, v):
        return super(LowerDict, self).__setitem__(_ci_str(k), v)
    def __delitem__(self, k):
        return super(LowerDict, self).__delitem__(_ci_str(k))
    def copy(self): # don't delegate w/ super - dict.copy() -> dict :(
        return type(self)(self)
    def get(self, k, default=None):
        return super(LowerDict, self).get(_ci_str(k), default)
    def setdefault(self, k, default=None):
        return super(LowerDict, self).setdefault(_ci_str(k), default)
    __no_default = object()
    def pop(self, k, v=__no_default):
        if v is LowerDict.__no_default:
            # super will raise KeyError if no default and key does not exist
            return super(LowerDict, self).pop(_ci_str(k))
        return super(LowerDict, self).pop(_ci_str(k), v)
    def update(self, mapping=(), **kwargs):
        super(LowerDict, self).update(self._process_args(mapping, **kwargs))
    def __contains__(self, k):
        return super(LowerDict, self).__contains__(_ci_str(k))
    @classmethod
    def fromkeys(cls, keys, v=None):
        return super(LowerDict, cls).fromkeys((_ci_str(k) for k in keys), v)
    def __repr__(self):
        return '{0}({1})'.format(type(self).__name__,
                                 super(LowerDict, self).__repr__())

Імпліцит проти явного все ще залишається проблемою, але як тільки пил осідає, перейменування атрибутів / змінних, щоб почати з ci (і великий жирний коментар doc, що пояснює, що ci означає невідчутне до випадку), я думаю, що це ідеальне рішення - оскільки читачі коду повинні бути повністю усвідомленим, що ми маємо справу з нечутливими до обліку структурами даних. Це, сподіваємось, виправить деякі важкі для відтворення помилки, які, як я підозрюю, звелися до чутливості випадку.

Коментарі / виправлення вітаємо :)

Все, що вам доведеться зробити - це

class BatchCollection(dict):
    def __init__(self, *args, **kwargs):
        dict.__init__(*args, **kwargs)

АБО

class BatchCollection(dict):
    def __init__(self, inpt={}):
        super(BatchCollection, self).__init__(inpt)

Зразок використання для мого особистого використання

### EXAMPLE
class BatchCollection(dict):
    def __init__(self, inpt={}):
        dict.__init__(*args, **kwargs)

    def __setitem__(self, key, item):
        if (isinstance(key, tuple) and len(key) == 2
                and isinstance(item, collections.Iterable)):
            # self.__dict__[key] = item
            super(BatchCollection, self).__setitem__(key, item)
        else:
            raise Exception(
                "Valid key should be a tuple (database_name, table_name) "
                "and value should be iterable")

Примітка : перевірено лише в python3

Спробувавши обидві перші дві пропозиції, я зупинився на тінистому зовнішньому маршруті для Python 2.7. Можливо, 3 безпечніше, але для мене:

class MyDict(MutableMapping):
   # ... the few __methods__ that mutablemapping requires
   # and then this monstrosity
   @property
   def __class__(self):
       return dict

яку я справді ненавиджу, але, здається, відповідає моїм потребам, а саме:

• може перекрити **my_dict
  • якщо ви успадковуєте цеdict , це обходить ваш код . Спробуй.
  • це робить номер 2 для мене неприйнятним в будь-який час , оскільки це досить часто в python-коді
• маскарад як isinstance(my_dict, dict)
  • виключає MutableMapping поодинці, тому №1 недостатньо
  • Я щиро рекомендую №1, якщо вам це не потрібно, це просто і передбачувано
• повністю керована поведінка
  • тому я не можу успадкувати від dict

Якщо вам потрібно сказати себе окремо від інших, особисто я використовую щось подібне (хоча рекомендую кращі імена):

def __am_i_me(self):
  return True

@classmethod
def __is_it_me(cls, other):
  try:
    return other.__am_i_me()
  except Exception:
    return False

Поки вам потрібно лише розпізнати себе внутрішньо, таким чином важче випадково зателефонувати __am_i_meчерез зміни імені python (це перейменовано на _MyDict__am_i_meвсе, що дзвонить поза цим класом). Трохи більш приватні, ніж _methods, як на практиці, так і в культурі.

Поки я не маю жодних скарг, окрім серйозно-тінистого вигляду перегляду __class__. Мені буде приємно почути будь-які проблеми, з якими стикаються інші, хоча я не повністю розумію наслідків. Але до цих пір у мене жодних проблем не було, і це дозволило мені перемістити безліч кодів середньої якості у багатьох місцях, не потребуючи жодних змін.

Як доказ: https://repl.it/repls/TraumaticToughCockatoo

В основному: скопіюйте поточний параметр №2 , додайте print 'method_name'рядки до кожного методу, а потім спробуйте це і перегляньте результат:

d = LowerDict()  # prints "init", or whatever your print statement said
print '------'
splatted = dict(**d)  # note that there are no prints here

Ви побачите подібну поведінку для інших сценаріїв. Скажіть, що ваша підробка dict- це обгортка навколо якогось іншого типу даних, тому немає розумного способу зберігання даних у резервній картинці; **your_dictбуде порожнім, незалежно від того, що робить кожен інший метод.

Це працює правильно MutableMapping, але як тільки ви успадковуєте dictйого, це стає неконтрольованим.

Редагувати: як оновлення, це працює без жодного випуску вже майже два роки, на кількох сотнях тисяч (е, може бути, пару мільйонів) рядків складного, застарілого пітона. Тож я дуже задоволений цим :)

Редагувати 2: мабуть, я давно неправильно скопіював це чи щось. @classmethod __class__не працює для isinstanceперевірок - @property __class__робить: https://repl.it/repls/UnitedScientistSequence