Я нахожу более удобным доступ к ключам с ключами как obj.foo вместо obj['foo'], поэтому я написал этот фрагмент:
class AttributeDict(dict):
def __getattr__(self, attr):
return self[attr]
def __setattr__(self, attr, value):
self[attr] = value
Однако я предполагаю, что должна быть какая-то причина, по которой Python не предоставляет эту функциональность из коробки. Какими были бы предостережения и ловушки доступа к ключам ключа таким образом?
Лучший способ сделать это:
class AttrDict(dict):
def __init__(self, *args, **kwargs):
super(AttrDict, self).__init__(*args, **kwargs)
self.__dict__ = self
Некоторые профи:
.keys() работают просто отлично)AttributeError вместо KeyErrorМинусы:
.keys(), будут не работать нормально, если они будут перезаписаны входящими даннымиE1123(unexpected-keyword-arg) и E1103(maybe-no-member)__dict__.__dict__ должен был быть "просто простым dict", поэтому мы можем назначить любой подкласс dict() для внутреннего словаря.AttrDict(), который мы создаем (как мы находимся в __init__).super() __init__(), мы убедились, что он (уже) ведет себя точно так же, как словарь, так как эта функция вызывает весь код экземпляра словаря.Как отмечено в списке "cons", это объединяет пространство имен хранимых ключей (которое может исходить от произвольных и/или ненадежных данных!) с пространством имен встроенных атрибутов dict-метода. Например:
d = AttrDict()
d.update({'items':["jacket", "necktie", "trousers"]})
for k, v in d.items(): # TypeError: 'list' object is not callable
print "Never reached!"
Вы можете иметь все юридические строковые символы как часть ключа, если используете нотацию массива.
Например, obj['!#$%^&*()_']
Из Этот другой вопрос SO есть отличный пример реализации, который упрощает ваш существующий код. Как насчет:
class AttributeDict(dict):
__getattr__ = dict.__getitem__
__setattr__ = dict.__setitem__
Гораздо более краткий и не оставляет места для дополнительного прикосновения к вашим функциям __getattr__ и __setattr__ в будущем.
Я подозреваю, что это связано с Zen Python: "Должен быть один - и желательно только один - очевидный способ сделать это". Это создаст два очевидных способа доступа к значениям из словарей: obj['key'] и obj.key.
К ним относятся возможное отсутствие ясности и путаницы в коде. т.е. следующее может смутить кого - то другого, кто собирается поддерживать ваш код на более поздний срок или даже на вас, если вы не вернетесь в него некоторое время. Опять же, от Дзэн: "Читаемость считается!"
>>> KEY = 'spam'
>>> d[KEY] = 1
>>> # Several lines of miscellaneous code here...
... assert d.spam == 1
Если d экземпляр или KEY определен, или d[KEY] назначается далеко от того, где используется d.spam, это может легко привести к путанице в отношении того, что делается, поскольку это не является обычно используемой идиомой. Я знаю, что это может смутить меня.
Кроме того, если вы измените значение KEY следующим образом (но не сменив d.spam), теперь вы получите:
>>> KEY = 'foo'
>>> d[KEY] = 1
>>> # Several lines of miscellaneous code here...
... assert d.spam == 1
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
AttributeError: 'C' object has no attribute 'spam'
ИМО, не стоит усилий.
Как отмечали другие, вы можете использовать любой хешируемый объект (а не только строку) в качестве ключа dict. Например,
>>> d = {(2, 3): True,}
>>> assert d[(2, 3)] is True
>>>
является законным, но
>>> C = type('C', (object,), {(2, 3): True})
>>> d = C()
>>> assert d.(2, 3) is True
File "<stdin>", line 1
d.(2, 3)
^
SyntaxError: invalid syntax
>>> getattr(d, (2, 3))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: getattr(): attribute name must be string
>>>
не является. Это дает вам доступ ко всему диапазону печатаемых символов или других хешируемых объектов для ваших ключей словаря, которых у вас нет при доступе к атрибуту объекта. Это делает возможной такую магию, как метаклас кешированного объекта, как рецепт из Cookbook Python (глава 9).
Я предпочитаю эстетику spam.eggs над spam['eggs'] (я думаю, что он выглядит более чистым), и я действительно начал жаждать эту функциональность, когда встретил namedtuple. Но удобство быть в состоянии сделать следующие козыри.
>>> KEYS = 'spam eggs ham'
>>> VALS = [1, 2, 3]
>>> d = {k: v for k, v in zip(KEYS.split(' '), VALS)}
>>> assert d == {'spam': 1, 'eggs': 2, 'ham': 3}
>>>
Это простой пример, но я часто использую dicts в разных ситуациях, чем использовать нотацию obj.key (т. obj.key Когда мне нужно читать prefs из XML файла). В других случаях, когда я испытываю соблазн создать экземпляр динамического класса и пощекотать некоторые атрибуты по эстетическим соображениям, я продолжаю использовать dict для согласованности, чтобы повысить удобочитаемость.
Я уверен, что OP долгое время разрешал это с его удовлетворением, но если он все еще хочет эту функциональность, я предлагаю загрузить один из пакетов из pypi, который предоставляет его:
dict, поэтому у вас есть все эти функции.Однако, чтобы улучшить удобочитаемость его кода, я настоятельно рекомендую не смешивать его стили нотации. Если он предпочитает это обозначение, то он должен просто создать экземпляр динамического объекта, добавить к нему нужные ему атрибуты и назвать его днем:
>>> C = type('C', (object,), {})
>>> d = C()
>>> d.spam = 1
>>> d.eggs = 2
>>> d.ham = 3
>>> assert d.__dict__ == {'spam': 1, 'eggs': 2, 'ham': 3}
В комментариях (ниже) Элмо спрашивает:
Что, если вы хотите пойти глубже? (ссылаясь на тип (...))
Хотя я никогда не использовал этот вариант использования (опять же, я стараюсь использовать вложенный dict, для обеспечения согласованности), работает следующий код:
>>> C = type('C', (object,), {})
>>> d = C()
>>> for x in 'spam eggs ham'.split():
... setattr(d, x, C())
... i = 1
... for y in 'one two three'.split():
... setattr(getattr(d, x), y, i)
... i += 1
...
>>> assert d.spam.__dict__ == {'one': 1, 'two': 2, 'three': 3}
Caveat emptor: По некоторым причинам подобные классы, похоже, разбивают пакет многопроцессорности. Я просто боролся с этой ошибкой некоторое время, прежде чем найти это SO: Поиск исключения в многопроцессорности python
Что делать, если вам нужен ключ, который был методом, например __eq__ или __getattr__?
И вы не сможете иметь запись, которая не начиналась с буквы, поэтому использование 0343853 в качестве ключа отсутствует.
А что, если вы не хотите использовать строку?
Вы можете вытащить удобный класс контейнера из стандартной библиотеки:
from argparse import Namespace
чтобы избежать копирования кодовых битов. Нет стандартного доступа к словарю, но легко получить его обратно, если вы действительно этого хотите. Код в argparse прост,
class Namespace(_AttributeHolder):
"""Simple object for storing attributes.
Implements equality by attribute names and values, and provides a simple
string representation.
"""
def __init__(self, **kwargs):
for name in kwargs:
setattr(self, name, kwargs[name])
__hash__ = None
def __eq__(self, other):
return vars(self) == vars(other)
def __ne__(self, other):
return not (self == other)
def __contains__(self, key):
return key in self.__dict__
кортежи могут использоваться для использования ключей dict. Как получить доступ к кортежу в вашей конструкции?
Кроме того, namedtuple является удобной структурой, которая может предоставлять значения через доступ к атрибуту.
Это не работает в общности. Не все действительные ключи dict образуют адресные атрибуты ( "ключ" ). Итак, вам нужно быть осторожным.
Объекты Python - это в основном словари. Поэтому я сомневаюсь, что есть большая производительность или другое наказание.
Вот краткий пример неизменяемых записей, использующих встроенную collections.namedtuple:
def record(name, d):
return namedtuple(name, d.keys())(**d)
и пример использования:
rec = record('Model', {
'train_op': train_op,
'loss': loss,
})
print rec.loss(..)
Это не относится к исходному вопросу, но должно быть полезно для людей, которые, как и я, заканчивают здесь, когда ищут lib, который предоставляет эту функциональность.
Addict это отличная библиотека для этого: https://github.com/mewwts/addict, он заботится о многих проблемах, упомянутых в предыдущих ответах.
Пример из документов:
body = {
'query': {
'filtered': {
'query': {
'match': {'description': 'addictive'}
},
'filter': {
'term': {'created_by': 'Mats'}
}
}
}
}
С наркоманом:
from addict import Dict
body = Dict()
body.query.filtered.query.match.description = 'addictive'
body.query.filtered.filter.term.created_by = 'Mats'
Не нужно писать свои собственные setattr() и getattr() уже существуют.
Преимущество объектов класса, вероятно, вступает в игру в определении класса и наследовании.
Я создал это на основе ввода из этого потока. Мне нужно использовать odict, хотя, поэтому мне пришлось переопределить get и установить attr. Я думаю, что это должно работать для большинства специальных применений.
Использование выглядит следующим образом:
# Create an ordered dict normally...
>>> od = OrderedAttrDict()
>>> od["a"] = 1
>>> od["b"] = 2
>>> od
OrderedAttrDict([('a', 1), ('b', 2)])
# Get and set data using attribute access...
>>> od.a
1
>>> od.b = 20
>>> od
OrderedAttrDict([('a', 1), ('b', 20)])
# Setting a NEW attribute only creates it on the instance, not the dict...
>>> od.c = 8
>>> od
OrderedAttrDict([('a', 1), ('b', 20)])
>>> od.c
8
Класс:
class OrderedAttrDict(odict.OrderedDict):
"""
Constructs an odict.OrderedDict with attribute access to data.
Setting a NEW attribute only creates it on the instance, not the dict.
Setting an attribute that is a key in the data will set the dict data but
will not create a new instance attribute
"""
def __getattr__(self, attr):
"""
Try to get the data. If attr is not a key, fall-back and get the attr
"""
if self.has_key(attr):
return super(OrderedAttrDict, self).__getitem__(attr)
else:
return super(OrderedAttrDict, self).__getattr__(attr)
def __setattr__(self, attr, value):
"""
Try to set the data. If attr is not a key, fall-back and set the attr
"""
if self.has_key(attr):
super(OrderedAttrDict, self).__setitem__(attr, value)
else:
super(OrderedAttrDict, self).__setattr__(attr, value)
Это довольно крутой шаблон, уже упомянутый в потоке, но если вы просто хотите взять dict и преобразовать его в объект, который работает с автозаполнением в среде IDE и т.д.:
class ObjectFromDict(object):
def __init__(self, d):
self.__dict__ = d
По-видимому, теперь для этого есть библиотека - https://pypi.python.org/pypi/attrdict - которая реализует эту точную функциональность плюс рекурсивное слияние и загрузку json. Возможно, стоит посмотреть.
Чтобы добавить некоторое разнообразие в ответ, sci-kit learn, это реализовано как Bunch:
class Bunch(dict):
""" Scikit Learn container object
Dictionary-like object that exposes its keys as attributes.
>>> b = Bunch(a=1, b=2)
>>> b['b']
2
>>> b.b
2
>>> b.c = 6
>>> b['c']
6
"""
def __init__(self, **kwargs):
super(Bunch, self).__init__(kwargs)
def __setattr__(self, key, value):
self[key] = value
def __dir__(self):
return self.keys()
def __getattr__(self, key):
try:
return self[key]
except KeyError:
raise AttributeError(key)
def __setstate__(self, state):
pass
Все, что вам нужно, это получить методы setattr и getattr - проверка getattr для ключей dict и переход на проверку фактических атрибутов. setstaet является исправлением для исправления для травления/рассыпания "пучков" - если inerested проверяет https://github.com/scikit-learn/scikit-learn/issues/6196
Как насчет Prodict, маленький класс Python, который я написал, чтобы управлять ими все :)
Кроме того, вы получаете автоматическое завершение кода, рекурсивные объекты и автоматическое преобразование типов !
Вы можете сделать именно то, что вы просили:
p = Prodict()
p.foo = 1
p.bar = "baz"
class Country(Prodict):
name: str
population: int
turkey = Country()
turkey.name = 'Turkey'
turkey.population = 79814871
germany = Country(name='Germany', population='82175700', flag_colors=['black', 'red', 'yellow'])
print(germany.population) # 82175700
print(type(germany.population)) # <class 'int'>
print(germany.flag_colors) # ['black', 'red', 'yellow']
print(type(germany.flag_colors)) # <class 'list'>
Позвольте мне опубликовать еще одну реализацию, которая опирается на ответ Кинваиса, но объединяет идеи из AttributeDict, предложенные в http://databio.org/posts/python_AttributeDict.html.
Преимущество этой версии заключается в том, что она также работает для вложенных словарей:
class AttrDict(dict):
"""
A class to convert a nested Dictionary into an object with key-values
that are accessible using attribute notation (AttrDict.attribute) instead of
key notation (Dict["key"]). This class recursively sets Dicts to objects,
allowing you to recurse down nested dicts (like: AttrDict.attr.attr)
"""
# Inspired by:
# http://stackoverflow.com/a/14620633/1551810
# http://databio.org/posts/python_AttributeDict.html
def __init__(self, iterable, **kwargs):
super(AttrDict, self).__init__(iterable, **kwargs)
for key, value in iterable.items():
if isinstance(value, dict):
self.__dict__[key] = AttrDict(value)
else:
self.__dict__[key] = value
Вы можете сделать это, используя этот класс, который я только что сделал. С помощью этого класса вы можете использовать объект Map как другой словарь (включая сериализацию json) или с точечной нотацией. Я надеюсь вам помочь:
class Map(dict):
"""
Example:
m = Map({'first_name': 'Eduardo'}, last_name='Pool', age=24, sports=['Soccer'])
"""
def __init__(self, *args, **kwargs):
super(Map, self).__init__(*args, **kwargs)
for arg in args:
if isinstance(arg, dict):
for k, v in arg.iteritems():
self[k] = v
if kwargs:
for k, v in kwargs.iteritems():
self[k] = v
def __getattr__(self, attr):
return self.get(attr)
def __setattr__(self, key, value):
self.__setitem__(key, value)
def __setitem__(self, key, value):
super(Map, self).__setitem__(key, value)
self.__dict__.update({key: value})
def __delattr__(self, item):
self.__delitem__(item)
def __delitem__(self, key):
super(Map, self).__delitem__(key)
del self.__dict__[key]
Примеры использования:
m = Map({'first_name': 'Eduardo'}, last_name='Pool', age=24, sports=['Soccer'])
# Add new key
m.new_key = 'Hello world!'
print m.new_key
print m['new_key']
# Update values
m.new_key = 'Yay!'
# Or
m['new_key'] = 'Yay!'
# Delete key
del m.new_key
# Or
del m['new_key']
class AttrDict(dict):
def __init__(self):
self.__dict__ = self
if __name__ == '____main__':
d = AttrDict()
d['ray'] = 'hope'
d.sun = 'shine' >>> Now we can use this . notation
print d['ray']
print d.sun
Решение:
DICT_RESERVED_KEYS = vars(dict).keys()
class SmartDict(dict):
"""
A Dict which is accessible via attribute dot notation
"""
def __init__(self, *args, **kwargs):
"""
:param args: multiple dicts ({}, {}, ..)
:param kwargs: arbitrary keys='value'
If ''keyerror=False'' is passed then not found attributes will
always return None.
"""
super(SmartDict, self).__init__()
self['__keyerror'] = kwargs.pop('keyerror', True)
[self.update(arg) for arg in args if isinstance(arg, dict)]
self.update(kwargs)
def __getattr__(self, attr):
if attr not in DICT_RESERVED_KEYS:
if self['__keyerror']:
return self[attr]
else:
return self.get(attr)
return getattr(self, attr)
def __setattr__(self, key, value):
if key in DICT_RESERVED_KEYS:
raise AttributeError("You cannot set a reserved name as attribute")
self.__setitem__(key, value)
def __copy__(self):
return self.__class__(self)
def copy(self):
return self.__copy__()
Как отметил Doug, есть пакет Bunch, который вы можете использовать для достижения функциональности obj.key. На самом деле есть более новая версия под названием
У него есть отличная возможность конвертировать ваш dict в объект NeoBunch через свою функцию neobunchify. Я часто использую шаблоны Mako и передаю данные, поскольку объекты NeoBunch делают их гораздо более удобочитаемыми, поэтому, если вам удастся использовать обычный dict в вашей программе Python, но хотите, чтобы нотация точек в шаблоне Mako вы могли использовать так:/p >
from mako.template import Template
from neobunch import neobunchify
mako_template = Template(filename='mako.tmpl', strict_undefined=True)
data = {'tmpl_data': [{'key1': 'value1', 'key2': 'value2'}]}
with open('out.txt', 'w') as out_file:
out_file.write(mako_template.render(**neobunchify(data)))
И шаблон Мако может выглядеть так:
% for d in tmpl_data:
Column1 Column2
${d.key1} ${d.key2}
% endfor
Это не "хороший" ответ, но я думал, что это отличное (он не обрабатывает вложенные dicts в текущей форме). Просто оберните свой dict в функцию:
def make_funcdict(d={}, **kwargs)
def funcdict(d={}, **kwargs):
funcdict.__dict__.update(d)
funcdict.__dict__.update(kwargs)
return funcdict.__dict__
funcdict(d, **kwargs)
return funcdict
Теперь у вас немного другой синтаксис. Для доступа к элементам dict в качестве атрибутов выполните f.key. Чтобы получить доступ к элементам dict (и другим методам dict) обычным образом, сделайте f()['key'], и мы можем удобно обновить dict, вызвав f с помощью аргументов ключевого слова и/или словаря
d = {'name':'Henry', 'age':31}
d = make_funcdict(d)
>>> for key in d():
... print key
...
age
name
>>> print d.name
... Henry
>>> print d.age
... 31
>>> d({'Height':'5-11'}, Job='Carpenter')
... {'age': 31, 'name': 'Henry', 'Job': 'Carpenter', 'Height': '5-11'}
И вот оно. Я буду рад, если кто-нибудь предложит преимущества и недостатки этого метода.
Каковы были бы оговорки и ловушки доступа к ключам диктатора таким образом?
Как предполагает @Henry, одна из причин, по которой точка-доступ не может использоваться в dicts, заключается в том, что он ограничивает имена ключей ключа действительными переменными python, тем самым ограничивая все возможные имена.
Ниже приведены примеры того, почему пунктирный доступ не будет полезен вообще, учитывая dict, d:
Период действия
Следующие атрибуты недействительны в Python:
d.1_foo # enumerated names
d./bar # path names
d.21.7, d.12:30 # decimals, time
d."" # empty strings
d.john doe, d.denny # spaces, misc punctuation
d.3 * x # expressions
Стиль
Соглашения PEP8 накладывают мягкое ограничение на присвоение атрибутов:
A. Зарезервированное ключевое слово (или встроенная функция):
d.in
d.False, d.True
d.max, d.min
d.sum
d.id
Если имя аргумента функции сталкивается с зарезервированным ключевым словом, обычно лучше добавить одно нижнее подчеркивание...
B. Правило случая о методах и именах переменных:
Имена переменных следуют тому же соглашению, что и имена функций.
d.Firstname
d.Country
Используйте правила именования функций: в нижнем регистре со словами, разделенными символами подчеркивания, для повышения удобочитаемости.
Иногда эти проблемы возникают в таких библиотеках, как панды, что позволяет использовать пунктирный доступ столбцов DataFrame по имени. Механизм по умолчанию для устранения ограничений именования также является обозначением массива - строка в скобках.
Если эти ограничения не применяются к вашему варианту использования, существует несколько вариантов структуры данных с точками доступа.
Вы можете использовать dict_to_obj https://pypi.org/project/dict-to-obj/ Он делает именно то, что вы просили
From dict_to_obj import DictToObj
a = {
'foo': True
}
b = DictToObj(a)
b.foo
True