Python进阶----反射(四个方法),函数vs方法(模块types 与 instance()方法校验 ),双下方法的研究

Python进阶----反射(四个方法),函数vs方法(模块types 与 instance()方法校验 ),双下方法的研究

一丶反射

什么是反射:

​ 反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（反射）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

Python面向对象的反射:

​ 通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）如: 一个py文件, 一个类,一个实例对象,等等都是对象.

####  四个实现反射的函数
	# hasattr(),	getattr(),	setattr(),	delattr()
    

####  反射 整合版
class Foo:
    public_attr='静态属性'

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

    def func(self):
        print('Hello Python')


obj=Foo('张三',18)		# 实例化对象


##  检测是否含有XX属性
print(hasattr(obj,'public_attr'))   #当前实例对象,是否含有静态变量public_attr
print(hasattr(obj,'func'))          #当前实例对象,是否含有func方法



##  获取属性 getattr(对象,字符串,None)
print(getattr(obj,'public_attr'),None)   #静态属性,不存在就返回None
print(getattr(obj,'func'))  # <bound method Foo.func of <__main__.Foo object at 0x0000015FF30EC8D0>>



## 设置属性 setattr(对象,字符串,值)
setattr(obj,'sex','男')  # 设置对象属性
print(obj.__dict__) # {'name': '张三', 'age': 18, 'sex': '男'}

## 设置匿名方法 self为参数
setattr(obj,'show_name',lambda self:self.name)
print(obj.show_name(obj))   # 设置方法,
print(obj.__dict__)# { 'show_name': <function <lambda> at 0x0000018512932EA0>}



## 删除属性
delattr(obj,'name')
delattr(obj,'name')    # 不存在就报错
print(obj.__dict__) # {'age': 18, 'sex': '男', 'show_name': <function <lambda> at 0x000001D901BE2EA0>}

###  从当前 脚本(本类) 研究反射

class B:
    sta_='abc'


def func1():
    print('in func1')

import sys
this_module=sys.modules[__name__]  # 获取py文件对象
print(this_module) # 这是一个对象  <module '__main__' from 'E:/File/oldboy学习笔记/Python之路/day26/01 反射.py'>

print(hasattr(this_module,'func1')) # 判断函数名属性 存在不存在, True
print(getattr(this_module,'func1')) # 获得函数名属性  <function func1 at 0x00000225EBA92EA0>

getattr(this_module,'func1')()   #获得函数名属性+()执行func1函数

print(hasattr(this_module,'B')) # 判断类名属性 存在不存在 True
print(getattr(this_module,'B')) # 获得类名属性打印 <class '__main__.B'>
cls=getattr(this_module,'B')    # cls 得到是一个B类的地址
print(cls)                      # <class '__main__.B'>
obj=cls()                       # cls+() 实例化一个对象
print(obj.sta_)                 #  obj对象.B对象中的静态属性

​ 案例:

class Auth:
    funcli=[('login','请登录'),('register','请注册'),('exit','退出')]
    def login(self):
        print('登录函数')


    def register(self):
        print('注册函数')


    def exit(self):
        print('退出...')


while 1:
    obj=Auth()

    for num , option in enumerate(obj.funcli,1):
        print(num,option[0],option[1])

    func_name = input('请输入选择:').strip()
    if hasattr(obj,obj.funcli[int(func_name)-1][0]):
        getattr(obj,obj.funcli[int(func_name)-1][0],'不存在')()

二丶函数vs方法

函数和方法有什么区别和相同之处？

​ 函数是显性传参, 方法是隐性传参

####  通过打印函数名确定

    def func():
        pass

    print(func)  # 函数  <function func at 0x00000260A2E690D0>


    class A:
        def func(self):
            pass

    print(A.func)  # 函数 <function A.func at 0x0000026E65AE9C80>
    obj = A()
    print(obj.func)  # 方法 <bound method A.func of <__main__.A object at 0x00000230BAD4C9E8>>




####  通过types模块验证
    from types import FunctionType	# 函数
    from types import MethodType	# 方法 

    def func():
        pass


    class A:
        def func(self):
            pass

    obj = A()

	## isinstance(obj,M) 判断 obj对象 ,是不是由M类 或 M类的派生类 实例化的对象
    print(isinstance(func,FunctionType))  		 # True  函数
    print(isinstance(A.func,FunctionType))  	 # True   类调用类中的func 是函数			
    print(isinstance(obj.func,FunctionType))  	 # False   实例对象调用 不是函数	
    print(isinstance(obj.func,MethodType)) 		 # True	   实例对象调用 是方法	

研究类中的三个特殊的方法(静态方法,类方法,属性)

####  类中的静态方法是函数(静态函数)
    from types import FunctionType
    from types import MethodType

    class A:

        def func(self):
            pass

        @classmethod
        def func1(self):
            pass

        @staticmethod
        def func2(self):
            pass
    obj = A()

    # 静态方法其实是函数
    print(isinstance(A.func2,FunctionType))  # True
    print(isinstance(obj.func2,FunctionType))  # True

    
  



####  类中的类方法是方法(类方法)
    from types import FunctionType
    from types import MethodType

    class A:
        
        @classmethod
        def paas(cls):
            pass
        
        @property
        def a(self):
            pass
    obj=A()


    #   类方法 类和对象 调用  都是方法
    print(isinstance(obj.paas,FunctionType))    # False
    print(isinstance(obj.paas,MethodType))      # True

    print(isinstance(A.paas,FunctionType))      # False
    print(isinstance(A.paas,MethodType))        # True

    
 



####  类中的属性伪装函数 .  什么也不是,单纯的伪装属性

    from types import FunctionType
    from types import MethodType

    class A:
        
        @classmethod
        def paas(cls):		# 类方法是 cls, 实例对象或类调用.默认将从属的类地址传给cls (隐性传参)
            pass
        
        @property
        def a(self):
            pass
        
    obj=A()		# 实例化对象

    # 属性 ,     类和对象 调用 什么都不是
    print(isinstance(obj.a,FunctionType))    # False
    print(isinstance(obj.a,MethodType))      # False

    print(isinstance(A.a,FunctionType))      # False
    print(isinstance(A.a,MethodType))        # False



    
    

## 总结:
	#1.类名 或 实例对象 调用类方法 都是 方法 method
	#2.类名 或 实例对象 调用静态方法 都是 函数 function
	#3.类名 或 实例对象 调用伪装属性函数. 什么都不是,单纯属性
  
## 函数 和方法的本质区别:
	## 函数是显性传参,  方法是隐性传参

三丶特殊的双下方法

定义:

​ ' __ 方法名 __ ' 的具有特殊意义的方法,不同的双下方法有不同的触发方式,开发中尽量不要使用双下方法

' __ len __ ' 一个对象可以使用len()函数 ,根本原因是这个对象从属的类有__len__方法

class A:

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

    def __len__(self):  # 必须有返回值 , 如果没有会报错(TypeError: 'NoneType' object cannot be interpreted as an integer)
        print('触发了__len__')
        return len(self.__dict__)       # 返回当前实例对象具有几个属性

obj=A('张三','男',10)
print(len(obj))   # 从属的类中没有__len__方法就报错 TypeError: object of type 'A' has no len()

' __ hash __ '对象使用hash()函数,调用当前本类__hash__方法 ,本类没有就从父类找__hash__

class A:
    def __init__(self):
        self.a=1
        self.b=2

    # 重写父类的__hash__方法
    def __hash__(self): #需要返回值 , 没有返回值 报错:TypeError: __hash__ method should return an integer
        return hash(str(self.a)+str(self.b))

a=A()
print(hash(a))  # 主动触发 __hash__方法, 当前类如果没有__hash__ 就从父类找

' __ str __ ' 和' __ repr __ '

###  这俩方法的返回值必须是字符串,否则抛出异常
###  str函数或者print函数--->obj.__str__()
###  repr或者交互式解释器--->obj.__repr__()
###  如果__str__没有被定义,那么就会使用__repr__来代替输出


format_dict={
    'nat':'{obj.name}-{obj.age}-{obj.sex}',#学校名-学校地址-学校类型
    'tna':'{obj.sex}:{obj.name}:{obj.age}',#学校类型:学校名:学校地址
    'tan':'{obj.sex}/{obj.age}/{obj.name}',#学校类型/学校地址/学校名
}
class School:

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

    def __repr__(self):
        return f'__repr__  {self.name} {self.age}'

    def __str__(self):
        return f'__str__ {self.name}{self.age}'

    def __format__(self, format_spec):
        if not format_spec or format_spec not in format_dict:
            format_spec = 'nat'
        fmt = format_dict[format_spec]
        return fmt.format(obj=self)

s1=School('ABC','男','123')
print(repr(s1))  #  现在本类本类找__repr__ 如果没有 .  直接去父类找,返回一个对象地址
print(str(s1))  #  会触发__str__  , 先在本类找__str__ 如果没有 ,找__repr__ .如果还没有去object类找,返回的是一个对象地址


print('%s'%obj)     # %s 调用__str__
print('%r'%obj)     # %r 调用 __repr__
print(s1)   ###  __str__的优先级高于__repr__



### 现在一般不再使用format()函数
print(format(s1,'nat'))          # ABC-123-男
print(format(s1,'tna'))          # 男:ABC:123
print(format(s1,'tan'))          # 男/123/ABC
print(format(s1,'asfdasdffd'))   # ABC-123-男

' __ call __ '

class A:
    def __init__(self):
        self.a=1
        print(111)

    def __call__(self, *args, **kwargs):    # 不需要返回值,如果当前不存__call__在报错: TypeError: 'A' object is not callable
        print(666)

obj1=A()
obj1()      # 实例对象+() 调用__call__方法

' __ eq __'

class A:
    def __init__(self):
        self.a=1
        self.b=2

    def __eq__(self, other):    #  没有return 默认返回None
        if self.a==other.a and self.b==other.b: # 条件不成立时,也返回None
            return True
a=A()
b=A()
print(a==b)     # 调用__eq__方法






### 面试题:
###  set方法依赖集合中元素对象的__hash__ __eq__
class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __hash__(self):       # TypeError: unhashable type: 'Person'
        # print('调用了1')
        return hash(self.name+self.sex)

    def __eq__(self, other):      #  判断当前对象是否 和其他对象的某些属性相同  other 接收set集合每次迭代的对象
        # print('调用了')
        # 解读 : 第一次实例化对象,self.name是列表中第一个对象执行__init__封装了
        if self.name == other.name and self.sex == other.sex:return True


p_lst = []
for i in range(84):
    p_lst.append(Person('egon',i,'male'))   # 存放实例化对象

print(p_lst)
print(set(p_lst))       #  必须调用 __hash__  , 如果有__eq__ 就调用 , 没有就不调用.  迭代去重. so 第一次的时候 name 的值为列表第一个元素执行__init__封装的属性
# print(dir(set))

	
	

' __ del __ '析构方法，当对象在内存中被释放时，自动触发执行。

​ 此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:

    def __del__(self):
        print('执行我啦')

f1=Foo()
del f1
print('------->')

' __ new __ '

class A:

    def __init__(self,name):
        self.name=name
        print('in the __init__')

    def __new__(cls, *args, **kwargs):      # cls 自动接收 类名地址
        print('in the __new__')
        result=object.__new__(A)#由于重写了父类的__new__,需要调用父类的__new__方法才能创造对象空间
        print(result)           # 生成对象空间的内存地址
        return result           # 必须返回这个对象空间地址返回 ,才能执行__init__为对象封装属性

    
####  类名()  先触发__new__ 并且将类名自动传递给cls
obj=A('ale')        # 先执行__new__方法,如果没有执行父类的__new__.    
				  # 只有返回对象空间,才继续执行__init__方法,如果没有返回对象空间,对象为None
print(obj.name)
print(obj)          #  __new__ 没有返回对象内存空间  对象=None

单例模式 : 节省内存

class F:
    __instance=None
    def __init__(self):
        print('执行了init方法')

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            object1=object.__new__(cls)
            cls.__instance=object1
        return cls.__instance
obj=F()
obj1=F()
obj2=F()
print(obj,obj1,obj2)	# 三个内存地址都一样

' __ item __ ' 对对象进行类似于字典的操作

### 类似于 @property

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

    def __getitem__(self, item):  #
        print('调用时执行 get')
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        print('设置时调用 set')
        self.__dict__[key] = value

    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)

    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)


f1 = Foo('sb')

f1['name']      # 调用时执行 __getitem__

f1['age'] = 18  #设置新属性  __setitem__

f1['age1'] = 19  # 设置新属性 __setitem__

del f1.age1  # 删除属性 __delitem__

del f1['age']  #删除属性 __delattr__

f1['name'] = 'alex'  # 修改属性  __setitem__

print(f1.__dict__)

' __ enter __ __ exit __

## __enter__   __exit__
# 如果想要对一个类的对象进行with  as 的操作

## 案例一:  with语句

class A:
    def __enter__(self):                            # 开启上下文管理器对象时触发此方法
        print('before')

    def __exit__(self, exc_type, exc_val, exc_tb):  # 执行完上下文管理器对象f1时触发此方法
        print('after')


with A() as a:
    print('123')
# before
# 123
# after
  
    
    
## 案例二: with语句和init
class A:
    def __init__(self):
        print('init')

    def __enter__(self):
        print('before')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('after')


with A() as a:
    print('123')
    
# init 先执行    
    
    
    
    
### 案例三:with和文件操作

class Myfile:
    def __init__(self,path,mode='r',encoding = 'utf-8'):
        self.path = path
        self.mode = mode
        self.encoding = encoding

    def __enter__(self):
        print('进来了')
        self.f = open(self.path, mode=self.mode, encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('关闭了')
        self.f.close()


with Myfile('file',mode='a') as f:
    f.write('wahaha')
    print('写完; ')
    


    
    
### 案例四:  with和pickle
import  pickle
class MyPickledump:
    def __init__(self,path):
        self.path = path

    def __enter__(self):
        self.f = open(self.path, mode='ab')
        return self

    def dump(self,content):
        pickle.dump(content,self.f)

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

class Mypickleload:
    def __init__(self,path):
        self.path = path

    def __enter__(self):
        self.f = open(self.path, mode='rb')
        return self


    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

    def load(self):
         return pickle.load(self.f)


    def loaditer(self):
        while True:
            try:
                yield  self.load()
            except EOFError:
                break



# with MyPickledump('file') as f:
#      f.dump({1,2,3,4})

with Mypickleload('file') as f:
    for item in f.loaditer():
        print(item)
        
        

        
### 案例五: with和pickle和iter


import  pickle
class MyPickledump:
    def __init__(self,path):
        self.path = path

    def __enter__(self):
        self.f = open(self.path, mode='ab')
        return self

    def dump(self,content):
        pickle.dump(content,self.f)

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

class Mypickleload:
    def __init__(self,path):
        self.path = path

    def __enter__(self):
        self.f = open(self.path, mode='rb')
        return self


    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

    def __iter__(self):
        while True:
            try:
                yield  pickle.load(self.f)
            except EOFError:
                break



# with MyPickledump('file') as f:
#      f.dump({1,2,3,4})

with Mypickleload('file') as f:
    for item in f:
        print(item)