面向对象 - 绑定方法与非绑定方法/反射/内置方法 - 总结 

面向对象 - 绑定方法与非绑定方法：
    定义：
        在类内部定义的函数，分为两大类：
        1.绑定方法：绑定给谁，就应该由谁来调用，谁来调用 就会把调用者当作第一个参数自动传入
            绑定到对象的方法：在类内部定义的，没有被任何装饰器修饰的
                对于类来说   它就是个 普通函数 <function Foo.tell at 0x000001FD0D800B70>
                对于对象来说 它就是个 绑定方法 <bound method Foo.tell of <__main__.Foo object at 0x000001FD0D832710>>
            绑定到类的方法：在类内部定义的，被装饰器@classmethod 修饰的方法
                对于类和对象来说 它就是个 绑定方法 <bound method Foo.func1 of <class '__main__.Foo'>>
        2.非绑定方法：
            非绑定方法：不与类或对象绑定 在类内部定义的，被装饰器@staticmethod 修饰的方法
                对于类和对象来说 它就是个 普通函数 < function Foo.fun2 at 0x00000157332C0C80>
    应用：
        1.绑定给对象 就应该由对象来调用 自动将对象本身当作第一个参数 传入
             def tell_info(self):
        2.绑定给类 就应该由类来调用 自动将类本身当作第一个参数 传入
            @classmethod     def from_conf(cls)  # 读配置文件里的内容 一种实例化的方式
        3.非绑定方法 不与类或者对象绑定 谁都可以调用 没有自动传值一说
            @staticmethod    def create_id():    # 创建随机的 id

 1 class Foo:
 2     all_type='hello'          # 公用的
 3     def __init__(self,name):  # 绑定到 对象
 4         self.name=name
 5 
 6     def tell(self):           # 绑定到 对象
 7         print('名字是 %s'%self.name)
 8 
 9     @classmethod              # 绑定到 类
10     def func1(cls,data):
11         print(cls,data)
12 
13     @staticmethod             # 非绑定 方法
14     def fun2(x,y):
15         print(x+y)
16 
17 f=Foo('alice')
18 # f.tell()
19 # f.func1(2)   # 不限制 你使用
20 # Foo.func1(4)
21 # f.fun2(2,3)
22 # Foo.fun2(3,4)
23 
24 # print(Foo.tell)
25 # print(f.tell)
26 # print((Foo.func1))
27 # print(f.func1)
28 # print(Foo.fun2)
29 # print(f.fun2)
30 # print(Foo.tell)
31 # print(f.tell)
32 # print(Foo.__init__)
33 # print(f.__init__)
34 # print(Foo.all_type)
35 # print(f.all_type)
36 # Foo.tell(f)
37 # Foo.__init__(f,'aa')
38 # f.tell()
39 # Foo.func1(3)
40 
41 import settings
42 import hashlib
43 import time
44 import string
45 import random
46 
47 class People:
48     def __init__(self,name,age,sex):
49         self.id=self.create_id()
50         self.name=name
51         self.age=age
52         self.sex=sex
53 
54     def tell_info(self):  # 绑定到对象  # 根据函数体的逻辑 来想 参数 应该传什么进来
55         print('Name:%s Age:%s Sex:%s'%(self.name,self.age,self.sex))
56 
57     @classmethod
58     def from_conf(cls):   # 读配置文件里的内容 一种实例化的方式
59         obj=cls(
60             settings.name,
61             settings.age,
62             settings.sex
63         )
64         return obj
65 
66     @staticmethod
67     def create_id():  # 创建随机的 id
68         # m=hashlib.md5(str(time.time()).encode('utf-8'))
69         m=hashlib.md5(''.join(random.sample(string.ascii_letters+string.digits+string.punctuation,8)).encode('utf-8'))
70         return m.hexdigest()
71 
72 p=People('alice',12,'female')
73 p2=People('alice',12,'female')
74 p3=People('alice',12,'female')
75 # p.tell_info()
76 # print(settings.name,settings.age,settings.sex)
77 
78 # People.from_conf().tell_info()
79 
80 # print(p.create_id())
81 # print(People.create_id())
82 # print(p.id)
83 # print(p2.id)
84 # print(p3.id)
绑定方法与非绑定方法

面向对象 - 反射:
    反射:通过字符串来映射到一个对象的属性上面,与用户交互
        hasattr(obj,'name') 
        getattr(obj,'talk',None) 
        getattr(obj,'age') 
        setattr(obj,'sex','male') 
        delattr(obj,'age') 
        注：obj可以是对象也可以是类 
        hasattr(People,'country') 
        getattr(People,'country',None) 
        setattr(People,'city','中国') 
        delattr(People,'country') 
    总结:通过字符串来访问到对象或类的数据属性和函数属性
    用处:接受用户的输入触发对象的某一个方法
         if hasattr(self,cmds[0]):
             func=getattr(self,cmds[0])
             func(cmds)

 1 class People:
 2     country='China'
 3     def __init__(self,name,age):
 4         self.name=name
 5         self.age=age
 6 
 7     def talk(self):
 8         print('%s is talking'%self.name)
 9 
10 # obj=People('alice',12)
11 # print(obj.name) #obj.__dict___['name']
12 # print(obj.__dict__)
13 # print(obj.__dict__['age'])
14 # obj.talk()
15 
16 # choice=input('>>:').strip()
17 # print(obj.choice)
18 # print(hasattr(obj,choice))
19 # print(getattr(obj,choice))
20 # print(getattr(obj,choice,None))
21 
22 # if hasattr(obj,choice):
23 #     print(getattr(obj,choice))
24 # setattr(obj,'sex','male')
25 # print(obj.sex)
26 # print(obj.__dict__)
27 # delattr(obj,choice)
28 # print(obj.__dict__)
29 #
30 # print(getattr(People,'country',None))
31 
32 # print(hasattr(obj,choice))
33 # print(getattr(obj,choice,None))
34 # print(getattr(obj,choice))
35 # print(getattr(obj,'talk'))
36 # setattr(obj,'sex','male')
37 # print(obj.__dict__)
38 # delattr(obj,'name')
39 # print(obj.__dict__)
40 # setattr(obj,'age',18)
41 # print(obj.__dict__)
42 # print(getattr(People,'country'))
43 # setattr(People,'city','中国')
44 # print(People.__dict__)
45 # delattr(People,'country')
46 # print(People.__dict__)
47 # print(hasattr(People,'country'))
48 
49 class Service:
50     def run(self):
51         while True:
52             inp=input('>>:').strip()
53             cmds = inp.split()
54             print(cmds)
55             if hasattr(self,cmds[0]):
56                 func=getattr(self,cmds[0])
57                 func(cmds)
58 
59     def get(self,cmds):
60         print('get...',cmds)
61 
62     def put(self,cmds):
63         print('put...',cmds)
64 
65 # obj=Service()
66 # obj.run()
反射

面向对象 - 内置方法：
    1.isinstance()   isinstance(f,Foo)    什么是什么的对象 
    2.issubclass()   issubclass(Foo,Bar)  什么是什么的子类
    3.item系列: 把对象做成一个像字典对象那样 像字典对象那样访问数据
        #查看属性  def __getitem__(self, item):          obj['name']        触发
        #设置属性  def __setitem__(self, key, value):    obj['sex']='male'  触发
        #删除属性  def __delitem__(self, key):           del obj['name']    触发
    4.__str__()
        设置打印的格式  def __str__(self): return ...     print(obj)         触发
    5.__del__()
        del obj 会触发 __del__():... 在这里面做一些 回收机制 删除os的资源
                因为py只会回收应用程序的资源，不会回收os的资源 eg:关掉文件 
        应用程序 不能直接操作 硬盘  需要通过 操作系统
        涉及到两方面得资源 应用程序得资源 和操作系统得资源 一定要在 程序结束之前 关闭操作系统得资源
        with open() as f:   #会自动关闭文件
        f=open() f.close()  #需要回收资源
        
     注：在类内部定义 __开头 __结尾得方法，这些方法会在某种情况下自动触发，完成定制化得效果
   
     参考：http://www.cnblogs.com/linhaifeng/articles/6204014.html 

 1 class Bar:
 2     pass
 3 class Foo(Bar):
 4     pass
 5 f=Foo()
 6 # print(isinstance(f,Foo))
 7 # print(issubclass(Foo,Bar))
 8 # print(issubclass(Bar,Foo))
 9 
10 # item 系列
11 class Foo:
12     def __init__(self,name):
13         self.name=name
14 
15     def __getitem__(self, item):
16         # return self.__dict__[item]  # 若是没有 会报错
17         return self.__dict__.get(item)
18 
19     def __setitem__(self, key, value):
20         self.__dict__[key]=value
21 
22     def __delitem__(self, key):
23         del self.__dict__[key]
24 
25     def __str__(self):
26         return '<name:%s>'%self.name
27 
28     def __del__(self):
29         # self.close()
30         print('回收操作系统的 资源')
31 
32 obj=Foo('alice')
33 # print(obj.__dict__)
34 # print(obj.name)
35 # print(obj['name'])
36 # obj['name']='aaaa'
37 # print(obj.__dict__)
38 # del obj['name']
39 # print(obj.__dict__)
40 # obj.sex='12'
41 # print(obj.__dict__)
42 
43 # print(obj)
44 
45 # del obj
46 # print('---main---')
内置方法


posted @ 2018-03-12 12:31  Alice的小屋  阅读(202)  评论(0)  编辑  收藏  举报