Python 反射和面向对象

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。

__import__ （‘模块名’，fromlist=True） ： 通过字符串形式，导入模块

getattr(object, name, default=None)    ：根据字符串的形式去某个模块中寻找东西 

Mokuai

def f1():
    print('F1')


def f2():
    print('F2')
#================================
    import Mokuai
targer=getattr(Mokuai,'f1',None)#寻找F1函数

targer()#找到并执行



r=hasattr(Mokuai,'f1') #再模块中寻找F1函数 找到返回Ture  ，否则返回False

print(r)   #False


setattr(Mokuai,'AGEBOX',lambda a:a+1)   #再模块中创建函数，或者全局变量

delattr(Mokuai,'f1') #再模块中删除函数或者全局变量

反射就是根据字符串的形式去对象中操作某个成员

 利用反射模拟web框架路由系统

url=input('请输入url：')
targer_module,targer_func=url.split('/')
m=__import__('lib.'+targer_module,fromlist=True)
if hasattr(m,targer_func): #判断导入模块名是否在模块中
    targer_func=getattr(m,targer_func) 寻找模块名，并执行
    r=targer_func
    print(r)
else:
    print('404')

面向对象self用法

>>> class FOO:
    def fetch(self,back):
        print(back)
        print(self,back)
        print(back,self)
>>> obj=FOO()
>>> print(obj)
<__main__.FOO object at 0x03350C10>
>>> obj.fetch
<bound method FOO.fetch of <__main__.FOO object at 0x03350C10
>>> obj.fetch('saf')
saf
<__main__.FOO object at 0x03350C10> saf
saf <__main__.FOO object at 0x03350C10>

面向对象封装

class FOO:
    def fetch(self):
        print(self.back)

        
obj=FOO()
obj.back='http:\\www.baidu.com'
obj.fetch()

 

class FOO:
    def __init__(self,arg):
        self.arg=arg

    def get_box(self):
        return self.arg

面向对象继承

class Aot:

    def he(self):
        print(self.name+'he')


class Bot(Aot):
    def __init__(self,name):
        self.name=name
    def chi(self):
        print('chile henduo ')


obj=Bot('wanzghe')
obj.chi()
obj.he()

当类和子类都有相同的方法时会优先调用自己的方法。

多继承，里面可以继承多个，优先自己，从左到右

import socket
class Cot:

    def sds(self):
        print(self.name+'he')
class Aot:

    def he(self):
        print(self.name+'he')


class Bot(Aot,Cot):  #多态继承里面可以继承多个，优先自己，然后从左到右
    def __init__(self,name):
        self.name=name
    def chi(self):
        print('chile henduo ')


obj=Bot('wanzghe')
obj.chi()
obj.he()

重载：函数名相同，参数名不同(python不支持)

重写 ，派生类中重新是实现基类中的方法

__init__沟槽方法实力  super 构造方法

class Annimal:
    def __init__(self):
        print('Agouzaofanbfa ')
        self.ty='alemed '

class Cat(Annimal):
    def __init__(self):
        print('Bgouzaofangfa ')
        self.n='mapo '
        super(Cat, self).__init__() #继承1
        #Annimal.__init__(self) #继承方法2

obj=Cat()

print(obj.__dict__)
'''
Bgouzaofangfa
Agouzaofanbfa
{'n': 'mapo ', 'ty': 'alemed '}'''

super().__init__()  从底层开始找源码

=====================

静态字段访问：

class Provice:
    country = 'China'
    def __init__(self, name):

        temp="xxx"
        self.name=name


    def show(self):pass

hebei=Provice('HEIBEI')
henan=Provice('HEINAN')
print(hebei.country)  #China

静态方法常用例子@staticmethod

class Provice:
    country = 'China'
    def __init__(self, name):

        temp="xxx"
        self.name=name

    @staticmethod
    def show():
        print('start I  me  jingtai')#静态方法使用类去访问,静态方法没有self

hebei=Provice('HEIBEI')
Provice.show()  #Provice.show() 
静态方法不需要创建对象就能使用的方法

类方法常用例子@classmethad，普通方法有个self参数，类方法必须有个cls参数。类方法使用犯法和静态方法类似

得出类名

class Provice:
    country = 'China'
    def __init__(self, name):

        temp="xxx"
        self.name=name


    @classmethod
    def show(cls):
        print('start I  me  jingtai',cls)#静态方法使用类去访问,静态方法没有self

Provice.show()  #start I  me  jingtai <class '__main__.Provice'>
#print(hebei.show())  #China

@property 加上函数前，是以方法方式访问，加上之后可以自字段访问不需要加括号

============================================

def __getitem__(self, item):

def __setitem__(self, key, value):

def __delitem__(self, key): 方法使用
使用切片工具时将会调用这些方法

class FOO:
    def __init__(self):
        print('init')
    def __call__(self, *args, **kwargs):
        print('call')
        return '1'
    def __getitem__(self, item):
        print(item)
    def __setitem__(self, key, value):

        print(key,value)  #key1 123  ,接受两个值
    def __delitem__(self, key):
        print(key)
r=FOO()
r['boxin']#里面写砂纸 item传什么值
r['key1']=123
del r['key1']

 __dict__ 用法

class FOO:
    def __init__(self):
        self.name = 'Boxc'
        print('init')
    def __call__(self, *args, **kwargs):

        return '1'
    def __getitem__(self, item):
        print(item)
    def __setitem__(self, key, value):

        print(key,value)  #key1 123  ,接受两个值
    def __delitem__(self, key):
        print(key)
r=FOO()
print(r.__dict__)#表示类里调用的成员  #{'name': 'Boxc'}
print(FOO.__dict__)#表示类里所有的成员
#{'__module__': '__main__', '__init__': <function FOO.__init__ at 0x03463978>, '__call__': <function FOO.__call__ at 0x03463930>, '__getitem__': <function FOO.__getitem__ at 0x034638E8>, '__setitem__': <function FOO.__setitem__ at 0x034638A0>, '__delitem__': <function FOO.__delitem__ at 0x03463858>, '__dict__': <attribute '__dict__' of 'FOO' objects>, '__weakref__': <attribute '__weakref__' of 'FOO' objects>, '__doc__': None}