#In this way, the module itself is imported, and then the reflection method is applied
import sys
obj1=sys.modules[__name__]
print('==>',hasattr(obj1,'x')) 

Built in function supplement

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattr__(self, item):
        print('The implementation is getattr')

    def __getattribute__(self, item):#This will be triggered regardless of whether the attribute can be found,
        print('The implementation is getattribute')
        raise AttributeError('An exception was thrown')#Only when this instruction is thrown will it be triggered getattr

f1=Foo(10)
# f1.x
f1.xxxxx

item series

#The calling method of. Is related to getattr and other three methods, and the dictionary operation is related to getitem and other three methods
class Foo:
    def __getitem__(self, item):
        print('getitem')
        return self.__dict__[item]

    def __setitem__(self, key, value):
        print('setitem')
        self.__dict__[key] = value  # Method of adding key value pairs to analog dictionary

    def __delitem__(self, key):
        print('delitem')
        self.__dict__.pop(key)


f1 = Foo()
print(f1.__dict__)
# f1.name='egon'#setitem will not be triggered in this way
f1['name'] = 'egon'  # Assignment in dictionary mode will trigger setitem method
f1['age'] = 18
print(f1.__dict__)

del f1.name  # adopt.The way, with delattr That way, match, don't match delitem The way
print(f1.__dict__)

Change the string display of the object

class Foo:
    #Class has a default str Method. If it is not customized, the system's
    def __str__(self):#Customize the print results of the objects of this class instance
        return 'Display of self customized objects'
f1=Foo()
print(f1)#The essence is called--str(f1)--The way is f1.__str__()method

class Foo:
    #Class has a default str Method. If it is not customized, the system's
    
    def __str__(self):
        return 'This is str'
    def __repr__(self):#Customize the print results of the objects of this class instance
        return 'The name is%s Age is%s'%(self.name,self.age)
        #Cannot return non string format
f1=Foo()
#Enter in the interpreter f1#The essence is to call the -- repr(f1) -- method, which is F1__ repr__ () method
print(f1)#If so str Just find str，If not, find repr. If none, find the built-in system

Customize the format for the instance

format_dic = {
    'ymd': '{0.year}{0.mon}{0.day}',
    'm-d-y': '{0.mon}-{0.day}-{0.year}',
    'y:m:d': '{0.year}:{0.mon}:{0.day}'
}


class Date:
    def __init__(self, year, mon, day):
        self.year = year
        self.mon = mon
        self.day = day

    def __format__(self, format_spec):
        print('I did')
        print('-->', format_spec)
        if not format_spec or format_spec not in format_dic:
            format_spec = 'ymd'
        fm = format_dic[format_spec]
        return fm.format(self)


d1 = Date(2016, 12, 26)
# format(d1)
print(format(d1, 'y:m:d')) 

slots property

class Foo:
    # __slots__ = ['name','age']
    __slots__ = 'name'  # Instead of creating an attribute dictionary for each instance, you can find it in the class attribute dictionary
    # Disadvantages: only one can be created per instance name Cannot create other properties
    # The advantage is to save memory, rather than limiting instance extension properties


f1 = Foo()
f1.name = 'egon'
print(f1.name)

# print(f1.__dict__)
print(f1.__slots__)

_ doc_ Class method

class Foo:
    'I'm describing information'  # This information cannot be inherited
    pass
class Bar(Foo):
    pass
print(Bar.__doc__)

class Foo:
    def __call__(self, *args, **kwargs):
        print('The instance is executed, obj()')


f1 = Foo()
f1()  # Execution is the execution of the class that calls the instance call method
Foo()  # Call to create the Foo Class of instance call method#Class is an object, so it is also generated by other classes

Iterator protocol

#Manually implement the iterator protocol, including iter and next methods
class Foo:
    def __init__(self, n):
        self.n = n

    def __iter__(self):
        return self

    def __next__(self):
        if self.n==100:
            raise StopIteration('Terminated')
        self.n += 1
        return self.n


f1 = Foo(10)
print(f1.__next__())
print(f1.__next__())
print(f1.__next__())
print(next(f1))

for i in f1:
    print(i)

# The iterator implements the Fibonacci sequence
class Fib:
    def __init__(self):
        self._a = 1
        self._b = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self._b > 100:
            raise StopIteration('Terminated')
        self._a, self._b = self._b, self._a + self._b
        return self._a


f1 = Fib()
print(next(f1))
print(next(f1))
print(next(f1))
print('>>>>>>>>>>>>>>')
for i in f1:#Then the for loop above begins
    print(i)

descriptor