Bir sınıf veya sözlük kullanmalı mıyım?

Yalnızca alanlar içeren ve bunun gibi yöntem içermeyen bir sınıfım var:

class Request(object):

    def __init__(self, environ):
        self.environ = environ
        self.request_method = environ.get('REQUEST_METHOD', None)
        self.url_scheme = environ.get('wsgi.url_scheme', None)
        self.request_uri = wsgiref.util.request_uri(environ)
        self.path = environ.get('PATH_INFO', None)
        # ...

Bu kolayca bir dikteye çevrilebilir. Sınıf, gelecekteki eklemeler için daha esnektir ve hızlı olabilir __slots__. Öyleyse bunun yerine bir dikt kullanmanın bir faydası olur mu? Bir dikt, bir sınıftan daha mı hızlı olur? Ve slotlu bir sınıftan daha hızlı mı?

Bunu neden sözlük yapıyorsun? Avantajı nedir? Daha sonra bir kod eklemek istersen ne olur? Nerede olacağını __init__kod gitti?

Sınıflar, ilgili verileri (ve genellikle kodu) bir araya getirmek içindir.

Sözlükler, genellikle anahtarların hepsinin aynı türde olduğu ve tüm değerlerin de tek bir türde olduğu anahtar-değer ilişkilerini depolamak içindir. Anahtar / öznitelik adlarının tamamı önceden bilinmediğinde, bazen verileri gruplamak için yararlı olabilirler, ancak bu genellikle tasarımınızda bir sorun olduğuna işaret eder.

Bunu bir sınıf olarak tutun.

Bir sınıfın ekstra mekanizmasına ihtiyacınız yoksa bir sözlük kullanın. Ayrıca namedtuplehibrit bir yaklaşım için de kullanabilirsiniz :

>>> from collections import namedtuple
>>> request = namedtuple("Request", "environ request_method url_scheme")
>>> request
<class '__main__.Request'>
>>> request.environ = "foo"
>>> request.environ
'foo'

Buradaki performans farklılıkları minimum düzeyde olacak, ancak sözlük daha hızlı olmasa şaşırırdım.

Python A sınıfı olan dict altında. Sınıf davranışıyla biraz ek yük alırsınız, ancak profil oluşturucu olmadan bunu fark edemezsiniz. Bu durumda, dersten yararlandığınıza inanıyorum çünkü:

• Tüm mantığınız tek bir işlevde yaşar
• Güncellemesi kolaydır ve kapsüllenmiş halde kalır
• Daha sonra herhangi bir şeyi değiştirirseniz, arayüzü kolayca aynı tutabilirsiniz

Bence her birinin kullanımı, benim buna giremeyecek kadar özneldir, bu yüzden sadece sayılara bağlı kalacağım.

Bir diktede bir değişken oluşturmak ve değiştirmek için gereken zamanı, bir new_style sınıfı ve slotlu bir new_style sınıfını karşılaştırdım.

İşte test etmek için kullandığım kod (biraz dağınık ama işi yapıyor.)

import timeit

class Foo(object):

    def __init__(self):

        self.foo1 = 'test'
        self.foo2 = 'test'
        self.foo3 = 'test'

def create_dict():

    foo_dict = {}
    foo_dict['foo1'] = 'test'
    foo_dict['foo2'] = 'test'
    foo_dict['foo3'] = 'test'

    return foo_dict

class Bar(object):
    __slots__ = ['foo1', 'foo2', 'foo3']

    def __init__(self):

        self.foo1 = 'test'
        self.foo2 = 'test'
        self.foo3 = 'test'

tmit = timeit.timeit

print 'Creating...\n'
print 'Dict: ' + str(tmit('create_dict()', 'from __main__ import create_dict'))
print 'Class: ' + str(tmit('Foo()', 'from __main__ import Foo'))
print 'Class with slots: ' + str(tmit('Bar()', 'from __main__ import Bar'))

print '\nChanging a variable...\n'

print 'Dict: ' + str((tmit('create_dict()[\'foo3\'] = "Changed"', 'from __main__ import create_dict') - tmit('create_dict()', 'from __main__ import create_dict')))
print 'Class: ' + str((tmit('Foo().foo3 = "Changed"', 'from __main__ import Foo') - tmit('Foo()', 'from __main__ import Foo')))
print 'Class with slots: ' + str((tmit('Bar().foo3 = "Changed"', 'from __main__ import Bar') - tmit('Bar()', 'from __main__ import Bar')))

Ve işte çıktı ...

Oluşturuluyor ...

Dict: 0.817466186345
Class: 1.60829183597
Class_with_slots: 1.28776730003

Bir değişkeni değiştirme ...

Dict: 0.0735140918748
Class: 0.111714198313
Class_with_slots: 0.10618612142

Yani, sadece değişkenleri depoluyorsanız, hıza ihtiyacınız var ve çok fazla hesaplama yapmanızı gerektirmiyorsa, bir dikt kullanmanızı tavsiye ederim (her zaman sadece bir metoda benzeyen bir fonksiyon yapabilirsiniz). Ancak, gerçekten derslere ihtiyacınız varsa, unutmayın - her zaman __ yuva __ kullanın .

Not:

"Sınıf" ı hem new_style hem de old_style sınıflarıyla test ettim . Eski stil sınıflarının oluşturulması daha hızlı ancak değiştirilmesinin daha yavaş olduğu ortaya çıkıyor (sıkı bir döngüde çok sayıda sınıf oluşturuyorsanız önemli değil ama önemli (ipucu: yanlış yapıyorsunuz)).

Ayrıca benimki eski ve yavaş olduğu için, değişken oluşturma ve değiştirme zamanları bilgisayarınızda farklılık gösterebilir. 'Gerçek' sonuçları görmek için kendiniz test ettiğinizden emin olun.

Düzenle:

Daha sonra adlandırılmış grubu test ettim: onu değiştiremiyorum ama 10000 örnek (veya bunun gibi bir şey) oluşturmak için 1.4 saniye sürdü, bu yüzden sözlük gerçekten en hızlısı.

İ Eğer dict işlevini değiştirmek bunu oluştururken anahtarlarını ve değerlerini içerecek şekilde ve dicti içeren değişken yerine dicti dönmek için bana verir 0,65 yerine 0,8 saniye.

class Foo(dict):
    pass

Yaratmak, yuvaları olan bir sınıfa benzer ve değişkeni değiştirmek en yavaş olanıdır (0.17 saniye), bu nedenle bu sınıfları kullanmayın . bir dikte (hız) veya nesneden türetilen sınıf ('sözdizimi şekeri') için gidin

@Adw'ye katılıyorum. Bir sözlükle asla bir "nesneyi" (OO anlamında) temsil etmem. Sözlükler ad / değer çiftlerini toplar. Sınıflar nesneleri temsil eder. Nesnelerin sözlüklerle temsil edildiği kodlar gördüm ve nesnenin gerçek şeklinin ne olduğu belirsiz. Belirli adlar / değerler olmadığında ne olur? Müşterinin herhangi bir şey koymasını engelleyen şey. Veya herhangi bir şey çıkarmaya çalışması. Bir şeyin şekli her zaman açıkça tanımlanmalıdır.

Python kullanırken, dil, yazarın kendisini ayağından vurması için birçok yola izin verdiği için disiplinle inşa etmek önemlidir.

Bir taleple ilgili her türlü bilgi olduğu için bir sınıfı tavsiye ederim. Sözlük kullanacak olsaydı, depolanan verilerin doğası gereği çok daha benzer olmasını beklerdim. Kendime uymaya eğilimli olduğum bir kılavuz, tüm anahtar-> değer çiftleri kümesi üzerinde döngü yapmak ve bir şeyler yapmak istersem, bir sözlük kullanmamdır. Aksi takdirde, veriler temel bir anahtar-> değer eşlemesinden çok daha fazla yapıya sahiptir, bu da bir sınıfın muhtemelen daha iyi bir alternatif olacağı anlamına gelir.

Bu nedenle, sınıfa bağlı kalın.

Elde etmek istediğiniz tek şey obj.bla = 5yerine sözdizimi şekeri ise obj['bla'] = 5, özellikle de bunu çok tekrarlamak zorunda kalırsanız, martineaus önerisinde olduğu gibi bazı sade konteyner sınıfları kullanmak isteyebilirsiniz. Yine de, oradaki kod oldukça şişirilmiş ve gereksiz yere yavaş. Bunu şu şekilde basit tutabilirsiniz:

class AttrDict(dict):
    """ Syntax candy """
    __getattr__ = dict.__getitem__
    __setattr__ = dict.__setitem__
    __delattr__ = dict.__delitem__

namedtupleS veya bir sınıfa geçmenin bir başka nedeni __slots__de bellek kullanımı olabilir. Dicts, liste türlerinden önemli ölçüde daha fazla bellek gerektirir, bu nedenle üzerinde düşünülmesi gereken bir nokta olabilir.

Her neyse, özel durumunuzda, mevcut uygulamanızdan vazgeçmek için herhangi bir motivasyon yok gibi görünüyor. Görünüşe göre bu nesnelerin milyonlarcasını tutmuyorsunuz, bu nedenle listeden türetilmiş türlere gerek yok. Ve aslında içinde bazı işlevsel mantık içeriyor __init__, bu yüzden de sahip olmaman gerekiyor AttrDict.

Pastanızı alıp yemek de mümkün olabilir. Başka bir deyişle, hem bir sınıfın hem de sözlük örneğinin işlevselliğini sağlayan bir şey yaratabilirsiniz. ActiveState'in Dɪᴄᴛɪᴏɴᴀʀʏ ᴡɪᴛʜ ᴀᴛᴛʀɪʙᴜᴛᴇ-sᴛʏʟᴇ ᴀᴄᴄᴇss tarifine ve bunu yapmanın yolları hakkındaki yorumlara bakın.

Bir alt sınıf yerine normal bir sınıf kullanmaya karar verirseniz, Tʜᴇ sɪᴍᴘʟᴇ ʙᴜᴛ ʜᴀɴᴅʏ "ᴄᴏʟʟᴇᴄᴛᴏʀ ᴏғ ᴀ ʙᴜɴᴄʜ ᴏғ ɴᴀᴍᴇᴅ sᴛᴜғғ" ᴄʟᴀss tarifinin (Alex Martelli tarafından) çok esnek ve bu tür şeyler için yararlı olduğunu buldum yaptığınız gibi görünüyor (yani göreceli basit bir bilgi toplayıcısı oluşturun). Bir sınıf olduğu için, yöntemler ekleyerek işlevselliğini daha da genişletebilirsiniz.

Son olarak, sınıf üyelerinin adlarının yasal Python tanımlayıcıları olması gerektiği, ancak sözlük anahtarlarının olmadığı unutulmamalıdır - bu nedenle, bir sözlük bu konuda daha fazla özgürlük sağlar, çünkü anahtarlar karma bir şey olabilir (dizge olmayan bir şey bile).

Güncelleme

Python 3.3 modülüne bir alt sınıf object(a sahip olmayan __dict__) adlı bir sınıf SimpleNamespaceeklenmiştir typesve bu da başka bir alternatiftir.

class ClassWithSlotBase:
    __slots__ = ('a', 'b',)

def __init__(self):
    self.a: str = "test"
    self.b: float = 0.0


def test_type_hint(_b: float) -> None:
    print(_b)


class_tmp = ClassWithSlotBase()

test_type_hint(class_tmp.a)

Bir ders öneririm. Bir sınıf kullanıyorsanız, gösterildiği gibi tip ipucu alabilirsiniz. Ve sınıf, işlevin bağımsız değişkeni olduğunda otomatik tamamlamayı destekler.