Saya merasa lebih nyaman untuk mengakses kunci dikt sebagai obj.foopengganti obj['foo'], jadi saya menulis cuplikan ini:

class AttributeDict(dict):
    def __getattr__(self, attr):
        return self[attr]
    def __setattr__(self, attr, value):
        self[attr] = value

Namun, saya berasumsi bahwa pasti ada alasan mengapa Python tidak menyediakan fungsi ini di luar kotak. Apa yang akan menjadi peringatan dan perangkap mengakses kunci dikt dengan cara ini?

Cara terbaik untuk melakukan ini adalah:

class AttrDict(dict):
    def __init__(self, *args, **kwargs):
        super(AttrDict, self).__init__(*args, **kwargs)
        self.__dict__ = self

Beberapa pro:

• Ini benar-benar berfungsi!
• Tidak ada metode kelas kamus yang dibayangi (mis .keys(). Berfungsi dengan baik. Kecuali - tentu saja - Anda memberikan beberapa nilai kepada mereka, lihat di bawah)
• Atribut dan item selalu sinkron
• Mencoba mengakses kunci yang tidak ada sebagai atribut dengan benar memunculkan AttributeErrorbukanKeyError

Cons:

• Metode seperti tidak.keys() akan berfungsi dengan baik jika ditimpa oleh data yang masuk
• Menyebabkan kebocoran memori di Python <2.7.4 / Python3 <3.2.3
• Pylint pergi pisang dengan E1123(unexpected-keyword-arg)danE1103(maybe-no-member)
• Bagi yang belum tahu, itu seperti sihir murni.

Penjelasan singkat tentang cara kerjanya

• Semua objek python secara internal menyimpan atribut mereka dalam kamus yang diberi nama __dict__.
• Tidak ada persyaratan bahwa kamus internal __dict__harus "hanya dict biasa", sehingga kami dapat menetapkan subkelas apa pun dict()untuk kamus internal.
• Dalam kasus kami, kami hanya menetapkan AttrDict()contoh kami instantiating (seperti yang kita lakukan __init__).
• Dengan memanggil super()'s __init__()metode kami memastikan bahwa itu (sudah) berperilaku persis seperti kamus, karena fungsi yang memanggil semua kamus Instansiasi kode.

Salah satu alasan mengapa Python tidak menyediakan fungsi ini di luar kotak

Seperti yang tercantum dalam daftar "kontra", ini menggabungkan namespace dari kunci yang disimpan (yang mungkin berasal dari data yang sewenang-wenang dan / atau tidak dipercaya!) Dengan namespace atribut metode dict bawaan. Sebagai contoh:

d = AttrDict()
d.update({'items':["jacket", "necktie", "trousers"]})
for k, v in d.items():    # TypeError: 'list' object is not callable
    print "Never reached!"

Anda dapat memiliki semua karakter string hukum sebagai bagian dari kunci jika Anda menggunakan notasi array. Sebagai contoh,obj['!#$%^&*()_']

Dari pertanyaan SO lainnya ini ada contoh implementasi yang bagus yang menyederhanakan kode Anda yang ada. Bagaimana tentang:

class AttributeDict(dict): 
    __getattr__ = dict.__getitem__
    __setattr__ = dict.__setitem__

Jauh lebih ringkas dan tidak meninggalkan ruang untuk ekstra masuk ke __getattr__dan __setattr__fungsi Anda di masa depan.

Di mana Saya Menjawab Pertanyaan Yang Ditanyakan

Mengapa Python tidak menawarkannya di luar kotak?

Saya menduga itu ada hubungannya dengan Zen Python : "Seharusnya ada satu - dan lebih disukai hanya satu - cara yang jelas untuk melakukannya." Ini akan menciptakan dua cara yang jelas untuk mengakses nilai dari kamus: obj['key']danobj.key .

Peringatan dan Kesalahan

Ini termasuk kemungkinan kurangnya kejelasan dan kebingungan dalam kode. yaitu, yang berikut ini dapat membingungkan orang lain yang akan mempertahankan kode Anda di kemudian hari, atau bahkan untuk Anda, jika Anda tidak akan kembali ke sana untuk sementara waktu. Lagi, dari Zen : "Keterbacaan penting!"

>>> KEY = 'spam'
>>> d[KEY] = 1
>>> # Several lines of miscellaneous code here...
... assert d.spam == 1

Jika ddipakai atau KEY didefinisikan atau d[KEY] ditugaskan jauh dari tempat d.spamyang digunakan, itu dapat dengan mudah menyebabkan kebingungan tentang apa yang sedang dilakukan, karena ini bukan idiom yang umum digunakan. Saya tahu itu akan berpotensi membingungkan saya.

Selain itu, jika Anda mengubah nilai KEYsebagai berikut (tetapi tidak mengubah d.spam), Anda sekarang mendapatkan:

>>> 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'

IMO, tidak sepadan dengan usaha.

Barang-barang lainnya

Seperti yang telah dicatat orang lain, Anda dapat menggunakan objek hashable apa saja (bukan hanya string) sebagai kunci dict. Sebagai contoh,

>>> d = {(2, 3): True,}
>>> assert d[(2, 3)] is True
>>> 

legal, tapi

>>> 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
>>> 

tidak. Ini memberi Anda akses ke seluruh jajaran karakter yang dapat dicetak atau objek hashable lainnya untuk kunci kamus Anda, yang tidak Anda miliki ketika mengakses atribut objek. Hal ini memungkinkan keajaiban seperti metaclass objek yang di-cache, seperti resep dari Python Cookbook (Bab 9) .

Di mana saya Editorialize

Saya lebih suka estetika spam.eggslebih spam['eggs'](saya pikir itu terlihat lebih bersih), dan saya benar-benar mulai mendambakan fungsi ini ketika saya bertemu namedtuple. Tetapi kenyamanan untuk dapat melakukan hal-hal berikut ini.

>>> 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}
>>>

Ini adalah contoh sederhana, tetapi saya sering menemukan diri saya menggunakan dicts dalam situasi yang berbeda dari yang saya gunakan obj.key notasi (yaitu, ketika saya perlu membaca prefs dari file XML). Dalam kasus lain, ketika saya tergoda untuk membuat kelas dinamis dan menampar beberapa atribut di atasnya untuk alasan estetika, saya terus menggunakan dikt untuk konsistensi untuk meningkatkan keterbacaan.

Saya yakin OP telah lama menyelesaikan ini untuk kepuasannya, tetapi jika dia masih menginginkan fungsi ini, maka saya sarankan dia mengunduh salah satu paket dari pypi yang menyediakannya:

• Bunch adalah orang yang aku kenal. Subkelas daridict, jadi Anda memiliki semua fungsi itu.
• AttrDict juga terlihat seperti itu juga cukup bagus, tapi saya tidak terbiasa dengannya dan belum melihat sumbernya sedetail Bunch .
• Addict dirawat secara aktif dan menyediakan akses seperti attr dan lainnya.
• Seperti disebutkan dalam komentar oleh Rotareti, Bunch telah ditinggalkan, tetapi ada garpu aktif yang disebut Munch .

Namun, untuk meningkatkan keterbacaan kodenya, saya sangat menyarankan agar dia tidak mencampur gaya notasinya. Jika dia lebih suka notasi ini maka dia hanya perlu instantiate objek dinamis, tambahkan atribut yang diinginkan untuk itu, dan menyebutnya sehari:

>>> C = type('C', (object,), {})
>>> d = C()
>>> d.spam = 1
>>> d.eggs = 2
>>> d.ham = 3
>>> assert d.__dict__ == {'spam': 1, 'eggs': 2, 'ham': 3}

Di mana Saya Memperbarui, untuk Menjawab Pertanyaan Tindak Lanjut dalam Komentar

Dalam komentar (di bawah), Elmo bertanya:

Bagaimana jika Anda ingin masuk lebih dalam? (mengacu pada tipe (...))

Meskipun saya belum pernah menggunakan use case ini (sekali lagi, saya cenderung menggunakan nested dict, untuk konsistensi), kode berikut berfungsi:

>>> 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: Untuk beberapa alasan, kelas-kelas seperti ini tampaknya merusak paket multi-pemrosesan. Saya baru saja berjuang dengan bug ini untuk sementara waktu sebelum menemukan SO ini: Menemukan pengecualian dalam python multiprocessing

Anda bisa menarik kelas kontainer yang nyaman dari perpustakaan standar:

from argparse import Namespace

untuk menghindari harus menyalin bit kode. Tidak ada akses kamus standar, tetapi mudah mendapatkannya kembali jika Anda benar-benar menginginkannya. Kode dalam argparse sederhana,

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__

Bagaimana jika Anda menginginkan kunci yang merupakan metode, seperti __eq__atau __getattr__?

Dan Anda tidak akan dapat memiliki entri yang tidak dimulai dengan huruf, jadi gunakan 0343853sebagai kunci keluar.

Dan bagaimana jika Anda tidak ingin menggunakan string?

tuple dapat digunakan kunci dict. Bagaimana Anda mengakses tuple dalam konstruk Anda?

Juga, namedtuple adalah struktur yang nyaman yang dapat memberikan nilai melalui akses atribut.

Bagaimana dengan Prodict , kelas Python kecil yang saya tulis untuk mengatur semuanya :)

Plus, Anda mendapatkan penyelesaian kode otomatis , instantiasi objek rekursif , dan konversi tipe otomatis !

Anda dapat melakukan persis apa yang Anda minta:

p = Prodict()
p.foo = 1
p.bar = "baz"

Contoh 1: Ketik mengisyaratkan

class Country(Prodict):
    name: str
    population: int

turkey = Country()
turkey.name = 'Turkey'
turkey.population = 79814871

Contoh 2: Konversi tipe otomatis

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'>

Itu tidak bekerja secara umum. Tidak semua kunci dict yang valid membuat atribut yang dapat dialamatkan ("kunci"). Jadi, Anda harus berhati-hati.

Objek Python pada dasarnya adalah kamus. Jadi saya ragu ada banyak performa atau penalti lainnya.

Ini tidak menjawab pertanyaan awal, tetapi harus bermanfaat bagi orang-orang yang, seperti saya, berakhir di sini ketika mencari lib yang menyediakan fungsi ini.

Kecanduan itu adalah lib yang bagus untuk ini: https://github.com/mewwts/addict menangani banyak masalah yang disebutkan dalam jawaban sebelumnya.

Contoh dari dokumen:

body = {
    'query': {
        'filtered': {
            'query': {
                'match': {'description': 'addictive'}
            },
            'filter': {
                'term': {'created_by': 'Mats'}
            }
        }
    }
}

Dengan pecandu:

from addict import Dict
body = Dict()
body.query.filtered.query.match.description = 'addictive'
body.query.filtered.filter.term.created_by = 'Mats'

Saya menemukan diri saya bertanya-tanya apa keadaan saat ini "kunci dict sebagai attr" di ekosistem python. Seperti yang ditunjukkan oleh beberapa komentator, ini mungkin bukan sesuatu yang ingin Anda buat sendiri dari awal , karena ada beberapa perangkap dan footgun, beberapa di antaranya sangat halus. Juga, saya tidak akan merekomendasikan menggunakan Namespacesebagai kelas dasar, saya sudah jalan itu, itu tidak cantik.

Untungnya, ada beberapa paket sumber terbuka yang menyediakan fungsi ini, siap untuk dipasang! Sayangnya, ada beberapa paket. Ini sinopsisnya, per Desember 2019.

Peserta (komitmen terkini untuk dikuasai | #commits | #contribs | coverage%):

• pecandu (2019-04-28 | 217 | 22 | 100%)
• mengunyah (2019-12-16 | 160 | 17 |?%)
• easydict (2018-10-18 | 51 | 6 |?%)
• attrdict (2019-02-01 | 108 | 5 | 100%)
• prodict (2019-10-01 | 65 | 1 |?%)

Tidak lagi dipertahankan atau kurang terawat:

• treedict (2014-03-28 | 95 | 2 |?%)
• bunch (2012-03-12 | 20 | 2 |?%)
• NeoBunch

Saat ini saya merekomendasikan munch atau pecandu . Mereka memiliki komitmen, kontributor, dan rilis terbanyak, menunjukkan basis kode sumber terbuka yang sehat untuk masing-masing. Mereka memiliki readme.md yang tampak bersih, cakupan 100%, dan serangkaian tes yang bagus.

Saya tidak punya anjing dalam perlombaan ini (untuk saat ini!), Selain telah memutar kode dict / attr saya sendiri dan membuang banyak waktu karena saya tidak mengetahui semua opsi ini :). Saya dapat berkontribusi untuk pecandu / mengunyah di masa depan karena saya lebih suka melihat satu paket yang solid daripada sekelompok yang terfragmentasi. Jika Anda menyukainya, berkontribusi! Secara khusus, sepertinya pengunyah dapat menggunakan lencana codecov dan pecandu dapat menggunakan lencana versi python.

pecandu pro:

• inisialisasi rekursif (foo.abc = 'bar'), argumen seperti dict menjadi kecanduan.Dict

pecandu kontra:

• membayangi typing.Dictjika Andafrom addict import Dict
• Tidak ada pemeriksaan kunci. Karena memungkinkan init rekursif, jika Anda salah mengeja kunci, Anda hanya membuat atribut baru, bukan KeyError (terima kasih AljoSt)

pro mengunyah:

• penamaan yang unik
• fungsi ser / de bawaan untuk JSON dan YAML

kontra mengunyah:

• tidak ada init rekursif / hanya dapat init satu attr pada suatu waktu

Di mana saya Editorialize

Beberapa bulan yang lalu, ketika saya menggunakan editor teks untuk menulis python, pada proyek dengan hanya saya atau pengembang lain, saya menyukai gaya dict-attrs, kemampuan untuk memasukkan kunci dengan hanya mendeklarasikan foo.bar.spam = eggs. Sekarang saya bekerja dalam tim, dan menggunakan IDE untuk semuanya, dan saya telah menjauh dari struktur data semacam ini dan pengetikan dinamis secara umum, lebih menyukai analisis statis, teknik fungsional, dan petunjuk tipe. Saya sudah mulai bereksperimen dengan teknik ini, subclassing Pstruct dengan objek-objek desain saya sendiri:

class  BasePstruct(dict):
    def __getattr__(self, name):
        if name in self.__slots__:
            return self[name]
        return self.__getattribute__(name)

    def __setattr__(self, key, value):
        if key in self.__slots__:
            self[key] = value
            return
        if key in type(self).__dict__:
            self[key] = value
            return
        raise AttributeError(
            "type object '{}' has no attribute '{}'".format(type(self).__name__, key))


class FooPstruct(BasePstruct):
    __slots__ = ['foo', 'bar']

Ini memberi Anda objek yang masih berperilaku seperti dict, tetapi juga memungkinkan Anda mengakses kunci seperti atribut, dengan cara yang jauh lebih kaku. Keuntungannya di sini adalah saya (atau konsumen kode Anda yang malang) tahu persis bidang apa yang bisa dan tidak bisa ada, dan IDE bisa mengisi bidang isian secara otomatis. Juga mengelompokkan vanilla dictberarti serialisasi json mudah. Saya pikir evolusi berikutnya dalam ide ini akan menjadi generator protobuf kustom yang memancarkan antarmuka ini, dan ketukan yang bagus adalah Anda mendapatkan struktur data lintas-bahasa dan IPC melalui gRPC untuk hampir gratis.

Jika Anda memutuskan untuk menggunakan attr-dicts, penting untuk mendokumentasikan bidang apa yang diharapkan, untuk kewarasan Anda sendiri (dan rekan tim Anda).

Jangan ragu untuk mengedit / memperbarui posting ini agar tetap terbaru!

Berikut adalah contoh singkat dari catatan abadi menggunakan built-in collections.namedtuple:

def record(name, d):
    return namedtuple(name, d.keys())(**d)

dan contoh penggunaan:

rec = record('Model', {
    'train_op': train_op,
    'loss': loss,
})

print rec.loss(..)

Hanya untuk menambahkan beberapa variasi pada jawabannya, sci-kit learn telah menerapkan ini sebagai Bunch:

class Bunch(dict):                                                              
    """ Scikit Learn's 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                       

Yang Anda butuhkan adalah mendapatkan setattrdan getattrmetode - getattrpemeriksaan untuk kunci dict dan langkah-langkah untuk memeriksa atribut yang sebenarnya. Ini setstaetadalah perbaikan untuk perbaikan untuk pengawetan / pembongkaran "tandan" - jika dicabut periksa https://github.com/scikit-learn/scikit-learn/issues/6196

Tidak perlu menulis sendiri sebagai setattr () dan getattr () sudah ada.

Keuntungan dari objek kelas mungkin berperan dalam definisi dan pewarisan kelas.

Saya membuat ini berdasarkan masukan dari utas ini. Saya perlu menggunakan odict, jadi saya harus mengganti get dan set attr. Saya pikir ini harus bekerja untuk sebagian besar kegunaan khusus.

Penggunaannya terlihat seperti ini:

# 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

Kelas:

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)

Ini adalah pola yang cukup keren yang telah disebutkan di utas, tetapi jika Anda hanya ingin mengambil dikt dan mengubahnya menjadi objek yang berfungsi dengan lengkapi-otomatis dalam IDE, dll:

class ObjectFromDict(object):
    def __init__(self, d):
        self.__dict__ = d

Rupanya sekarang ada perpustakaan untuk ini - https://pypi.python.org/pypi/attrdict - yang mengimplementasikan fungsionalitas yang tepat ini ditambah penggabungan rekursif dan pemuatan json. Mungkin patut dilihat.

Inilah yang saya gunakan

args = {
        'batch_size': 32,
        'workers': 4,
        'train_dir': 'train',
        'val_dir': 'val',
        'lr': 1e-3,
        'momentum': 0.9,
        'weight_decay': 1e-4
    }
args = namedtuple('Args', ' '.join(list(args.keys())))(**args)

print (args.lr)

Anda dapat melakukannya menggunakan kelas yang baru saja saya buat. Dengan kelas ini Anda dapat menggunakan Mapobjek seperti kamus lain (termasuk serialisasi json) atau dengan notasi titik. Saya harap membantu Anda:

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]

Contoh penggunaan:

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']

Izinkan saya memposting implementasi lain, yang dibangun berdasarkan jawaban Kinvais, tetapi mengintegrasikan ide-ide dari AttributeDict yang diusulkan di http://databio.org/posts/python_AttributeDict.html .

Keuntungan dari versi ini adalah bahwa ia juga berfungsi untuk kamus bersarang:

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

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

Solusinya adalah:

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__()

Apa yang akan menjadi peringatan dan perangkap mengakses kunci dikt dengan cara ini?

Seperti yang disarankan @Henry, salah satu alasan titik-akses tidak dapat digunakan dalam dikte adalah bahwa ia membatasi nama kunci dict ke variabel python-valid, sehingga membatasi semua nama yang mungkin.

Berikut ini adalah contoh-contoh tentang mengapa titik-akses tidak akan membantu secara umum, mengingat dict, d:

Keabsahan

Atribut berikut tidak valid dalam 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's             # spaces, misc punctuation 
d.3 * x                           # expressions  

Gaya

Konvensi PEP8 akan memberikan batasan lunak pada penamaan atribut:

A. Nama kata kunci yang dicadangkan (atau fungsi builtin):

d.in
d.False, d.True
d.max, d.min
d.sum
d.id

Jika nama argumen fungsi bentrok dengan kata kunci yang dipesan, umumnya lebih baik untuk menambahkan satu garis bawah garis bawah ...

B. Aturan kasus tentang metode dan nama variabel :

Nama variabel mengikuti konvensi yang sama dengan nama fungsi.

d.Firstname
d.Country

Gunakan aturan penamaan fungsi: huruf kecil dengan kata-kata yang dipisahkan oleh garis bawah seperlunya untuk meningkatkan keterbacaan.

Terkadang kekhawatiran ini muncul di perpustakaan seperti panda , yang memungkinkan akses bertitik kolom DataFrame dengan nama. Mekanisme default untuk mengatasi batasan penamaan juga notasi array - string dalam tanda kurung.

Jika kendala ini tidak berlaku untuk kasus penggunaan Anda, ada beberapa opsi pada struktur data akses bertitik .

Anda dapat menggunakan dict_to_obj https://pypi.org/project/dict-to-obj/ Itu tidak persis seperti yang Anda minta

From dict_to_obj import DictToObj
a = {
'foo': True
}
b = DictToObj(a)
b.foo
True

Ini bukan jawaban yang 'baik', tapi saya pikir ini bagus (tidak menangani dicts bersarang dalam bentuk saat ini). Cukup bungkus dict Anda dalam suatu fungsi:

def make_funcdict(d=None, **kwargs)
    def funcdict(d=None, **kwargs):
        if d is not None:
            funcdict.__dict__.update(d)
        funcdict.__dict__.update(kwargs)
        return funcdict.__dict__
    funcdict(d, **kwargs)
    return funcdict

Sekarang Anda memiliki sintaks yang sedikit berbeda. Untuk mengakses item dict seperti atribut lakukan f.key. Untuk mengakses item dict (dan metode dict lainnya) dengan cara yang biasa dilakukan f()['key']dan kami dapat dengan mudah memperbarui dict dengan memanggil f dengan argumen kata kunci dan / atau kamus

Contoh

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'}

Dan itu dia. Saya akan senang jika ada yang menyarankan manfaat dan kelemahan dari metode ini.

Seperti dicatat oleh Doug ada paket Bunch yang dapat Anda gunakan untuk mencapai obj.keyfungsionalitas. Sebenarnya ada versi yang lebih baru yang disebut

NeoBunch

Ini memiliki fitur hebat yang mengubah dikt Anda menjadi objek NeoBunch melalui fungsi neobunchify -nya . Saya menggunakan banyak template Mako dan mengirimkan data sebagai objek NeoBunch membuatnya jauh lebih mudah dibaca, jadi jika Anda akhirnya menggunakan dict normal dalam program Python Anda tetapi ingin notasi titik dalam template Mako Anda dapat menggunakannya seperti itu:

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)))

Dan template Mako dapat terlihat seperti:

% for d in tmpl_data:
Column1     Column2
${d.key1}   ${d.key2}
% endfor

Cara termudah adalah mendefinisikan kelas, sebut saja Namespace. yang menggunakan objek dict .update () pada dict. Kemudian, dikt akan diperlakukan sebagai objek.

class Namespace(object):
    '''
    helps referencing object in a dictionary as dict.key instead of dict['key']
    '''
    def __init__(self, adict):
        self.__dict__.update(adict)



Person = Namespace({'name': 'ahmed',
                     'age': 30}) #--> added for edge_cls


print(Person.name)