एक वर्ग के गुण प्राप्त करना

Question

मैं एक वर्ग के गुण प्राप्त करना चाहता हूँ, कहते हैं:

class MyClass():
  a = "12"
  b = "34"

  def myfunc(self):
    return self.a

उपयोग करने MyClass.__dict__से मुझे विशेषताओं और कार्यों की एक सूची मिलती है, और यहां तक ​​कि जैसे फ़ंक्शन __module__और __doc__। जब MyClass().__dict__तक मैं स्पष्ट रूप से एक खाली हुक्म नहीं देता जब तक कि मैं स्पष्ट रूप से उस उदाहरण का एक विशेषता मूल्य निर्धारित नहीं करता।

मैं सिर्फ उन विशेषताओं को चाहता हूं, जो ऊपर दिए गए उदाहरण में होंगे: aऔरb

Comments

निरीक्षण अजगर वर्ग विशेषताओं के

— Ciro Santilli 冠状 病 p p 事件 at

Answer 1

निरीक्षण मॉड्यूल का प्रयास करें । getmembersऔर विभिन्न परीक्षण सहायक होने चाहिए।

संपादित करें:

उदाहरण के लिए,

class MyClass(object):
    a = '12'
    b = '34'
    def myfunc(self):
        return self.a

>>> import inspect
>>> inspect.getmembers(MyClass, lambda a:not(inspect.isroutine(a)))
[('__class__', type),
 ('__dict__',
  <dictproxy {'__dict__': <attribute '__dict__' of 'MyClass' objects>,
   '__doc__': None,
   '__module__': '__main__',
   '__weakref__': <attribute '__weakref__' of 'MyClass' objects>,
   'a': '34',
   'b': '12',
   'myfunc': <function __main__.myfunc>}>),
 ('__doc__', None),
 ('__module__', '__main__'),
 ('__weakref__', <attribute '__weakref__' of 'MyClass' objects>),
 ('a', '34'),
 ('b', '12')]

अब, विशेष तरीके और विशेषताएं मेरी नसों पर मिलती हैं- जिन्हें कई तरीकों से निपटाया जा सकता है, जिनमें से सबसे आसान है नाम के आधार पर फ़िल्टर करना।

>>> attributes = inspect.getmembers(MyClass, lambda a:not(inspect.isroutine(a)))
>>> [a for a in attributes if not(a[0].startswith('__') and a[0].endswith('__'))]
[('a', '34'), ('b', '12')]

... और अधिक जटिल जिनमें से विशेष विशेषता नाम चेक या यहां तक ​​कि मेटाक्लस शामिल हो सकते हैं;)

Comments

हाँ यह बहुत अच्छा है! मैंने इसका इस्तेमाल किया: attributes = inspect.getmembers(MyClass, lambda a:not(inspect.isroutine(a))) print [a[0] for a in attributes if '_' not in a[0]]

— मोहम्मद खामिस

सावधान रहें- इसमें विशेषताएँ शामिल नहीं होंगी like_this! यह "निजी" विशेषताओं से भी बच जाएगा, जो आपने उद्देश्य से किया होगा।

— मैट लुओंगो

नमस्ते, मुझे यह भी पसंद है कि एक मामूली स्पष्टीकरण के साथ: अभिव्यक्ति में inspect.getmembers(MyClass, ..., MyClassएक वर्ग या एक वस्तु द्वारा प्रतिस्थापित किया जा सकता है, और यदि आपको अपनी वस्तुओं के मूल्यों की सूची की आवश्यकता है, तो आपको MyClassअपने ऑब्जेक्ट चर (या selfयदि आप डालते हैं) से बदलना होगा def __repr__()मेरी तरह एक विधि में यह अभिव्यक्ति )।

— बगुला-ग्वारिन

मैंने इसे (पाइथन 3 में) एक फ़ंक्शन प्राप्त करने के लिए इस्तेमाल किया, जो ' तानाशाह ' मूल्य के लिए देखा : i = inspect.getmembers(MyClass, lambda a:not(inspect.isroutine(a))); z = [_[1] for _ in i if _[0] in '__dict__'][0]और फिर यह सिर्फ जेड से चाबियाँ प्राप्त करने की बात है।

— double0darbo

Answer 2

def props(cls):   
  return [i for i in cls.__dict__.keys() if i[:1] != '_']

properties = props(MyClass)

Comments

इसमें विधि के नाम शामिल होंगे

— lenhhoxung

यह देखने के लिए और अधिक स्पष्ट नहीं होना चाहिए: if not i.startswith('_')इसके बजाय if i[:1] != '_'?

— Mikaelblomkvistson 15

नोट: यदि हम चाइल्ड क्लास (विरासत में मिली) के बारे में बात करते हैं, तो .__dict__.keys()इसमें माता-पिता के गुण शामिल नहीं होंगे।

— vishes_shell

Answer 3

myfunc की एक विशेषता है MyClass। जब आप दौड़ते हैं तो यही पाया जाता है:

myinstance = MyClass()
myinstance.myfunc()

यह myinstanceनाम पर एक विशेषता की तलाश myfuncकरता है, एक को नहीं पाता है, देखता है कि myinstanceइसका एक उदाहरण है MyClassऔर इसे वहां देखता है।

तो इसके लिए विशेषताओं की पूरी सूची MyClassहै:

>>> dir(MyClass)
['__doc__', '__module__', 'a', 'b', 'myfunc']

(ध्यान दें कि मैं dir का उपयोग कक्षा के सदस्यों को सूचीबद्ध करने के लिए एक त्वरित और आसान तरीके के रूप में कर रहा हूं: इसका उपयोग केवल खोजपूर्ण तरीके से किया जाना चाहिए, उत्पादन कोड में नहीं)

आप केवल विशेष गुण चाहते हैं, आप कुछ मानदंड का उपयोग कर इस सूची को फ़िल्टर करने के लिए है, क्योंकि आवश्यकता होगी __doc__, __module__और myfuncकिसी भी तरह से विशेष नहीं हैं, वे गुण ठीक उसी तरह है कि में aऔर bकर रहे हैं।

मैंने कभी मैट और बोरेलिड द्वारा निर्दिष्ट निरीक्षण मॉड्यूल का उपयोग नहीं किया है, लेकिन एक संक्षिप्त लिंक से ऐसा लगता है कि इसमें आपके ऐसा करने में मदद करने के लिए परीक्षण हैं, लेकिन आपको अपना स्वयं का समर्पित कार्य लिखने की आवश्यकता होगी, क्योंकि ऐसा लगता है कि आप क्या चाहते हैं मोटे तौर पर विशेषताओं है कि है नहीं है पारित isroutineपरीक्षण और शुरू करने और दो को अंडरस्कोर से समाप्त नहीं होते।

यह भी ध्यान दें: class MyClass():पायथन 2.7 का उपयोग करके आप पुरानी पुरानी शैली की कक्षाओं का बेतहाशा उपयोग कर रहे हैं। जब तक आप अत्यंत पुराने पुस्तकालयों के साथ संगतता के लिए जानबूझकर ऐसा नहीं कर रहे हैं, आपको अपनी कक्षा को परिभाषित करने के बजाय होना चाहिए class MyClass(object):। पायथन 3 में "पुरानी शैली" वाली कक्षाएं नहीं हैं, और यह व्यवहार डिफ़ॉल्ट है। हालाँकि, न्यूस्टाइल कक्षाओं का उपयोग करने से आपको बहुत अधिक स्वचालित रूप से परिभाषित विशेषताएँ मिलेंगी :

>>> class MyClass(object):
        a = "12"
        b = "34"
        def myfunc(self):
            return self.a
>>> dir(MyClass)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a', 'b', 'myfunc']

Comments

कोई इस पर निर्भर नहीं हो सकता है dir(): " क्योंकि dir () को मुख्य रूप से एक इंटरेक्टिव प्रॉम्प्ट पर उपयोग करने के लिए एक सुविधा के रूप में आपूर्ति की जाती है, यह नामों की एक दिलचस्प सेट की आपूर्ति करने की कोशिश करता है जितना कि यह एक कठोर या लगातार परिभाषित नामों की आपूर्ति करने की कोशिश करता है , और इसका विस्तृत विवरण व्यवहार रिलीज़ के दौरान बदल सकता है । "( प्रलेखनdir() देखें )।

— १३:३१ बजे टाडेक

@ टैडेक: अच्छी बात है। मैं इसे समाधान के रूप में सुझाव देने के बजाय इसे गलत तरीके से उपयोग कर रहा था, क्योंकि यह आसानी से आपको उन विशेषताओं के आधार पर फ़िल्टर करने की अनुमति नहीं देता है जो इसके लिए संदर्भित करते हैं। लेकिन मुझे इस बारे में अधिक स्पष्ट होना चाहिए।

— बेन

Answer 4

केवल उदाहरण विशेषताएँ प्राप्त करना आसान है।
लेकिन फ़ंक्शंस के बिना भी क्लास की विशेषताओं को प्राप्त करना थोड़ा अधिक मुश्किल है।

उदाहरण केवल विशेषताएँ हैं

यदि आपको केवल इंस्टेंस विशेषताएँ सूचीबद्ध करनी हैं तो उपयोग करें
for attribute, value in my_instance। __dict__।items()

>>> from __future__ import (absolute_import, division, print_function)
>>> class MyClass(object):
...   def __init__(self):
...     self.a = 2
...     self.b = 3
...   def print_instance_attributes(self):
...     for attribute, value in self.__dict__.items():
...       print(attribute, '=', value)
...
>>> my_instance = MyClass()
>>> my_instance.print_instance_attributes()
a = 2
b = 3
>>> for attribute, value in my_instance.__dict__.items():
...   print(attribute, '=', value)
...
a = 2
b = 3

उदाहरण और वर्ग गुण

कार्यों के बिना भी वर्ग विशेषताओं को प्राप्त करने के लिए , चाल का उपयोग करना है callable()।

लेकिन स्थिर तरीकों हैं हमेशा नहींcallable !

इसलिए, बजाय का उपयोग करने का callable(value)उपयोग
callable( getattr(MyClass, attribute))

उदाहरण

from __future__ import (absolute_import, division, print_function)

class MyClass(object):
   a = "12"
   b = "34"               # class attributes

   def __init__(self, c, d):
     self.c = c
     self.d = d           # instance attributes

   @staticmethod
   def mystatic():        # static method
       return MyClass.b

   def myfunc(self):      # non-static method
     return self.a

   def print_instance_attributes(self):
     print('[instance attributes]')
     for attribute, value in self.__dict__.items():
        print(attribute, '=', value)

   def print_class_attributes(self):
     print('[class attributes]')
     for attribute in self.__dict__.keys():
       if attribute[:2] != '__':
         value = getattr(self, attribute)
         if not callable(value):
           print(attribute, '=', value)

v = MyClass(4,2)
v.print_class_attributes()
v.print_instance_attributes()

नोट: print_class_attributes() होना चाहिए,       लेकिन इस बेवकूफ और सरल उदाहरण में नहीं।@staticmethod

इसके लिए परिणाम को Python2

$ python2 ./print_attributes.py
[class attributes]
a = 12
b = 34
[instance attributes]
c = 4
d = 2

के लिए एक ही परिणाम python3

$ python3 ./print_attributes.py
[class attributes]
b = 34
a = 12
[instance attributes]
c = 4
d = 2

Answer 5

MyClass().__class__.__dict__

हालांकि, ऐसा करने के लिए "सही" था निरीक्षण मॉड्यूल के माध्यम से ।

Comments

MyClass().__class__.__dict__==MyClass.__dict__

— याक

@ याक की टिप्पणी काफी सत्य नहीं है। वर्ग और उदाहरण विशेषताओं के बीच अंतर के बारे में निम्नलिखित देखें। Stackoverflow.com/questions/35805/… देखें ।

— शोलेप्प

@sholsapp वास्तव में @yak सही है। आपके द्वारा दी गई लिंक कहती है कि MyClass().__class__.__dict__ != MyClass().__dict__, लेकिन याक दाईं ओर के कोष्ठकों में शामिल नहीं है, जिसके मामले में वह सही है

— shadi

Answer 6

import re

class MyClass:
    a = "12"
    b = "34"

    def myfunc(self):
        return self.a

attributes = [a for a, v in MyClass.__dict__.items()
              if not re.match('<function.*?>', str(v))
              and not (a.startswith('__') and a.endswith('__'))]

MyClass के एक उदाहरण के लिए, जैसे

mc = MyClass()

सूची समझ के type(mc)स्थान पर उपयोग करें MyClass। हालाँकि, यदि कोई गतिशील रूप से एक विशेषता जोड़ता है mc, जैसे कि mc.c = "42", type(mc)इस रणनीति में उपयोग करने पर विशेषता दिखाई नहीं देगी । यह केवल मूल वर्ग के गुण देता है।

एक वर्ग उदाहरण के लिए पूरा शब्दकोश प्राप्त करने के लिए, आपको type(mc).__dict__और के शब्दकोश को COMBINE करने की आवश्यकता होगी mc.__dict__।

mc = MyClass()
mc.c = "42"

# Python 3.5
combined_dict = {**type(mc).__dict__, **mc.__dict__}

# Or Python < 3.5
def dict_union(d1, d2):
    z = d1.copy()
    z.update(d2)
    return z

combined_dict = dict_union(type(mc).__dict__, mc.__dict__)

attributes = [a for a, v in combined_dict.items()
              if not re.match('<function.*?>', str(v))
              and not (a.startswith('__') and a.endswith('__'))]

Comments

वास्तव में साफ समाधान।

— Gitnik

Answer 7

मुझे नहीं पता कि क्या ऐसा ही कुछ अब तक बना है या नहीं, लेकिन मैंने var () का उपयोग करके एक अच्छी विशेषता खोज फ़ंक्शन बनाया है। vars () आपके द्वारा पास किए गए वर्ग की विशेषताओं का एक शब्दकोश बनाता है।

class Player():
    def __init__(self):
        self.name = 'Bob'
        self.age = 36
        self.gender = 'Male'

s = vars(Player())
#From this point if you want to print all the attributes, just do print(s)

#If the class has a lot of attributes and you want to be able to pick 1 to see
#run this function
def play():
    ask = input("What Attribute?>: ")
    for key, value in s.items():
        if key == ask:
            print("self.{} = {}".format(key, value))
            break
    else:
        print("Couldn't find an attribute for self.{}".format(ask))

मैं पायथन में एक बहुत बड़े पैमाने पर पाठ साहसिक विकसित कर रहा हूं, मेरे खिलाड़ी वर्ग में अब तक 100 से अधिक विशेषताएँ हैं। मैं इसका उपयोग विशिष्ट विशेषताओं को खोजने के लिए करता हूं जिन्हें मुझे देखने की आवश्यकता है।

Comments

दुर्भाग्यवश vars () क्लास की विशेषताओं को वापस नहीं करेगा

— user2682863

क्या आपने मेरे द्वारा पोस्ट किए गए कोड को चलाने की कोशिश की है? वर्स निश्चित रूप से वर्ग विशेषताओं को वापस कर सकते हैं। मुझे एक उदाहरण दिखाएं कि यह कैसे नहीं होता है? शायद मेरा कोड गलत है। लेकिन वेरिएबल () को एक वेरिएबल में असाइन करना और एक कुंजी का उपयोग करना, उस वैरिएबल के माध्यम से वैल्यू सर्च क्लास की विशेषताओं को वापस ला सकता है।

— कोरी बेली

वर्ग T: x = 1; t = T (); vars (t)

— user2682863

आपको ठीक से दिखाने के लिए मुझे काम बंद करने तक इंतजार करना होगा। लेकिन आपका कोड गलत है। आपकी कक्षा की वस्तु को __init __ (स्व) को परिभाषित करने की आवश्यकता है और x को self.x = 1 होना चाहिए। फिर t = T () असाइन करें और प्रिंट (var (t)) का उपयोग करें और यह आपको सभी वर्ग विशेषताओं का शब्दकोश दिखाएगा।

— कोरी बेली

नहीं, वे उदाहरण हैं, वर्ग गुण नहीं, कई उप-वर्ग कभी भी इनिट नहीं कहते हैं । जैसा कि मैंने कहा, var () क्लास की विशेषताएँ नहीं लौटाएंगी, आपको dir () या inspect.getmembers ()

— user2682863

Answer 8

यह बिना निरीक्षण के किया जा सकता है, मुझे लगता है।

निम्न वर्ग लें:

 class Test:
   a = 1
   b = 2

   def __init__(self):
     self.c = 42

   @staticmethod
   def toto():
     return "toto"

   def test(self):
     return "test"

सदस्यों के साथ उनके प्रकारों को देखते हुए:

t = Test()
l = [ (x, eval('type(x.%s).__name__' % x)) for x in dir(a) ]

... देता है:

[('__doc__', 'NoneType'),
 ('__init__', 'instancemethod'),
 ('__module__', 'str'),
 ('a', 'int'),
 ('b', 'int'),
 ('c', 'int'),
 ('test', 'instancemethod'),
 ('toto', 'function')]

इसलिए केवल चर का उत्पादन करने के लिए, आपको केवल परिणामों को टाइप करके फ़िल्टर करना होगा, और '__' से शुरू होने वाले नाम नहीं। उदाहरण के लिए

filter(lambda x: x[1] not in ['instancemethod', 'function'] and not x[0].startswith('__'), l)

[('a', 'int'), ('b', 'int'), ('c', 'int')] # actual result

बस।

नोट: यदि आप पायथन 3 का उपयोग कर रहे हैं, तो पुनरावृत्तियों को सूचियों में बदलें।

यदि आप इसे करने के लिए अधिक मजबूत तरीका चाहते हैं, तो निरीक्षण का उपयोग करें ।

Answer 9

पायथन 2 और 3, वाइटआउट आयात, वस्तुओं को उनके पते द्वारा फ़िल्टर करना

संक्षेप में समाधान:

वापसी dict {ATTRIBUTE_NAME: ATTRIBUTE_VALUE} , फ़िल्टर वस्तुओं। अर्थात{'a': 1, 'b': (2, 2), 'c': [3, 3]}

{k: val for k, val in self.__dict__.items() if not str(hex(id(val))) in str(val)}

वापसी सूची [विशेषता_नाम] , फ़िल्टर की गई वस्तुएँ। अर्थात['a', 'b', 'c', 'd']

[k for k, val in self.__dict__.items() if not str(hex(id(val))) in str(val)]

वापसी सूची [विशेषता_कार्य] , फ़िल्टर की गई वस्तुएँ। अर्थात[1, (2, 2), [3, 3], {4: 4}]

[val for k, val in self.__dict__.items() if not str(hex(id(val))) in str(val)]

---

वस्तुओं को छानना नहीं

को हटाना if शर्त। वापसी{'a': 1, 'c': [3, 3], 'b': (2, 2), 'e': <function <lambda> at 0x7fc8a870fd70>, 'd': {4: 4}, 'f': <object object at 0x7fc8abe130e0>}

{k: val for k, val in self.__dict__.items()}

---

लंबे समय में समाधान

लंबे समय तक के डिफ़ॉल्ट कार्यान्वयन के रूप में के रूप में __repr__ओवरराइड नहीं कर रहा हैif विवरण वापस आ जाएगा Trueयदि रिटर्न की स्मृति में हेक्साडेसिमल का प्रतिनिधित्व स्थान में valहै __repr__।

डिफ़ॉल्ट कार्यान्वयन के बारे में __repr__आप उपयोगी पा सकते हैं यह उत्तर । संक्षेप में:

def __repr__(self):
    return '<{0}.{1} object at {2}>'.format(
      self.__module__, type(self).__name__, hex(id(self)))

जो एक स्ट्रिंग लौटाता है जैसे:

<__main__.Bar object at 0x7f3373be5998>

प्रत्येक तत्व की स्मृति में स्थान इसके माध्यम से प्राप्त होता है id() विधि के ।

पायथन डॉक्सआईडी के बारे में कहना है:

किसी वस्तु की "पहचान" लौटाएं। यह एक पूर्णांक है जो अपने जीवनकाल के दौरान इस वस्तु के लिए अद्वितीय और निरंतर होने की गारंटी है। गैर-अतिव्यापी जीवनकाल वाली दो वस्तुओं में एक ही आईडी () मूल्य हो सकता है।

CPython कार्यान्वयन विवरण: यह मेमोरी में ऑब्जेक्ट का पता है।

---

अपने आप से कोशिश करो

class Bar:

    def __init__(self):

        self.a = 1
        self.b = (2, 2)
        self.c = [3, 3]
        self.d = {4: 4}
        self.e = lambda: "5"
        self.f = object()

    #__str__ or __repr__ as you prefer
    def __str__(self):
        return "{}".format(

            # Solution in Short Number 1
            {k: val for k, val in self.__dict__.items() if not str(hex(id(val))) in str(val)}

        )

# Main
print(Bar())

आउटपुट:

{'a': 1, 'c': [3, 3], 'b': (2, 2), 'd': {4: 4}}

---

नोट :

• पायथन 2.7.13और पायथन के साथ परीक्षण किया गया3.5.3

• पायथन में 2.x .iteritems()को अधिक पसंद किया जाता है.items()

Answer 10

मुझे हाल ही में इस प्रश्न के समान कुछ जानने की आवश्यकता थी, इसलिए मैं कुछ पृष्ठभूमि जानकारी पोस्ट करना चाहता था जो भविष्य में उसी का सामना करने वाले दूसरों के लिए सहायक हो।

यहाँ बताया गया है कि यह पाइथन में कैसे काम करता है ( https://docs.python.org/3.5/reference/datamodel.html#the-standard-type-hierarchy से ):

MyClassएक वर्ग वस्तु है, वर्ग वस्तु MyClass()का एक उदाहरण है। एक उदाहरण की __dict__केवल विशेषताएँ और विधियाँ उस उदाहरण (जैसे self.somethings) के लिए विशिष्ट हैं । यदि कोई विशेषता या विधि किसी वर्ग का हिस्सा है, तो वह कक्षा का है __dict__। जब आप करते हैं MyClass().__dict__, का एक उदाहरण MyClassवर्ग विशेषताओं के अलावा कोई विशेषता या विधियों के साथ बनाया जाता है, इस प्रकार खाली है__dict__

इसलिए, यदि आप कहते हैं print(MyClass().b), तो पायथन पहले नए उदाहरण की जाँच करता है MyClass().__dict__['b']और खोजने में विफल रहता है b। यह तब वर्ग की जाँच करता है MyClass.__dict__['b']और पाता है b।

इसलिए आपको inspectउसी खोज प्रक्रिया का अनुकरण करने के लिए मॉड्यूल की आवश्यकता है।

Comments

स्कॉट - उत्तर के रूप में पोस्ट की गई एक टिप्पणी को हटा दिया जाना चाहिए, अन्यथा हम उनमें डूब जाएंगे। हालांकि, एक समाधान के प्रति एक आंशिक उत्तर या "सहायक कुहनी" अभी भी एक उत्तर है । आप देखेंगे कि मैंने आपका पद कैसे पुन: प्राप्त किया; उम्मीद है कि मैंने आपका इरादा बरकरार रखा। यदि नहीं, तो आप इसे आकार में आगे संपादित कर सकते हैं । चीयर्स!

— मोगादाद

Answer 11

आप विशेषता नामों को प्राप्त करने के लिए सूची सूचीdir() में उपयोग कर सकते हैं :

names = [p for p in dir(myobj) if not p.startswith('_')]

getattr()विशेषताओं को स्वयं प्राप्त करने के लिए उपयोग करें :

attrs = [getattr(myobj, p) for p in dir(myobj) if not p.startswith('_')]

Answer 12

एक वर्ग के सभी गुण (विधियां नहीं) प्राप्त करने का मेरा उपाय (यदि कक्षा में एक उचित रूप से लिखित डॉकस्ट्रिंग है, जिसमें विशेषताओं को स्पष्ट रूप से लिखा गया है):

def get_class_attrs(cls):
    return re.findall(r'\w+(?=[,\)])', cls.__dict__['__doc__'])

यह टुकड़ा cls.__dict__['__doc__']कक्षा के डॉकस्ट्रिंग को निकालता है।

Answer 13

आपको विशेषताओं को सूचीबद्ध करने की आवश्यकता क्यों है? लगता है कि शब्दार्थ आपकी कक्षा एक संग्रह है। इस मामले में मैं एनम का उपयोग करने की सलाह देता हूं:

import enum

class myClass(enum.Enum):
     a = "12"
     b = "34"

अपनी विशेषताएँ सूचीबद्ध करें? इससे आसान कुछ नहीं:

for attr in myClass:
    print("Name / Value:", attr.name, attr.value)

Answer 14

यदि आप एक विशेषता "प्राप्त" करना चाहते हैं, तो एक बहुत ही सरल उत्तर है , जो स्पष्ट होना चाहिए: गेटअटर

class MyClass(object):
a = '12'
b = '34'
def myfunc(self):
    return self.a

>>> getattr(MyClass, 'a')
'12'

>>> getattr(MyClass, 'myfunc')
<function MyClass.myfunc at 0x10de45378>

यह अजगर में 2.7 और अजगर 3.x दोनों में काम करता है।

यदि आप इन वस्तुओं की सूची चाहते हैं, तो आपको अभी भी निरीक्षण का उपयोग करने की आवश्यकता होगी।

Comments

क्या वह उत्तर बहुत सरल है और किसी भी अंक के लायक भी सही है, और उसे खराब अंकों के लायक भी होना चाहिए? ऐसा लगता है कि अर्थव्यवस्था और सादगी अब अलग नहीं है।

— फ्रालाउ

Answer 15

दो समारोह:

def get_class_attr(Cls) -> []:
    import re
    return [a for a, v in Cls.__dict__.items()
              if not re.match('<function.*?>', str(v))
              and not (a.startswith('__') and a.endswith('__'))]

def get_class_attr_val(cls):
    attr = get_class_attr(type(cls))
    attr_dict = {}
    for a in attr:
        attr_dict[a] = getattr(cls, a)
    return attr_dict

उपयोग:

>>> class MyClass:
    a = "12"
    b = "34"
    def myfunc(self):
        return self.a

>>> m = MyClass()
>>> get_class_attr_val(m)
{'a': '12', 'b': '34'}

Answer 16

निम्नलिखित मैं क्या चाहता हूँ।

परीक्षण डेटा

class Base:
    b = 'b'


class MyClass(Base):
    a = '12'

    def __init__(self, name):
        self.name = name

    @classmethod
    def c(cls):
        ...

    @property
    def p(self):
        return self.a

    def my_fun(self):
        return self.name

print([name for name, val in inspect.getmembers(MyClass) if not name.startswith('_') and not callable(val)])  # need `import inspect`
print([_ for _ in dir(MyClass) if not _.startswith('_') and not callable(getattr(MyClass, _))])
# both are equ: ['a', 'b', 'p']

my_instance = MyClass('c')
print([_ for _ in dir(my_instance) if not _.startswith('_') and not callable(getattr(my_instance, _))])
# ['a', 'b', 'name', 'p']

Answer 17

मुझे पता है कि यह तीन साल पहले था, लेकिन उन लोगों के लिए जो भविष्य में मेरे लिए इस सवाल पर आने वाले हैं:

class_name.attribute 

ठीक काम करता है।

Comments

सिवाय जब आपको एक एट्रीब्यूट मिलता है।

— rady

आप हमेशा नहीं जानते कि attributeपहले से क्या है।

— मैट लूंगो

Answer 18

आप उपयोग कर सकते हैं MyClass.__attrs__। यह सिर्फ उस वर्ग के सभी गुण देता है। और कुछ नहीं।

Comments

गुण: प्रकार की वस्तु 'X' की कोई विशेषता नहीं है ' Attrs '

— Ramazan Polat