第五章---面向对象---1.绑定方法与非绑定方法介绍/2.绑定方法与非绑定方法应用/3.反射/4.内置方法

1.绑定方法与非绑定方法介绍

在类内部定义的函数，分为两大类：
  1.绑定方法:绑定给谁，就应该由谁来调用，谁来调用 就会把调用者当作第一个参数自动传入
      绑定到对象的方法：在类内定义的没有被任何装饰器修饰的

      绑定到类的方法：在类内定义的被装饰器 @classmethod 修饰的方法

  2.非绑定方法:没有自动传值这么一说，就类中定义的一个普通工具，对象和类都可以使用
     非绑定方法：不与类或对象绑定  在类内定义的被装饰器 @staticmethod  修饰的方法

 1 class Foo:
 2     def __init__(self,name):
 3         self.name = name
 4 
 5     def tell(self): # 绑定给对象使用的
 6         print('名字是%s' % self.name)
 7 
 8     @classmethod    # 绑定给类
 9     def func(cls): # cls = Foo
10         print(cls)
11 
12     @staticmethod   # 普通函数
13     def func1(x,y):
14         print(x+y)
15 
16 f = Foo('agon')
17 
18 print(Foo.tell)    # 普通函数 <function Foo.tell at 0x00520150>
19 Foo.tell(f)
20 print(f.tell)      # 绑定方法 <bound method Foo.tell of <__main__.Foo object at 0x0051FF70>>
21 
22 # print(Foo.func)
23 # Foo.func()
24 
25 print(Foo.func1)
26 print(f.func1)
27 
28 Foo.func1(1,2)
29 f.func1(2,3)

2.绑定方法与非绑定方法应用

# 绑定给对象 就应该由对象来调用 自动将对象本身当作第一个参数 传入
   def tell_info(self):

# 绑定给类 就应该由类来调用，自动将类本身当作第一个参数传入
    @classmethod
    def from_conf(cls):

# 非绑定方法 不与类或者对象绑定，谁都可以调用，没有自动传值一说
    @staticmethod
    def create_id():

 1 import settings
 2 import hashlib
 3 import time
 4 
 5 class People:
 6     def __init__(self,name,age,sex):
 7         self.id = self.create_id()
 8         self.name = name
 9         self.age = age
10         self.sex = sex
11 
12     def tell_info(self): # 绑定到对象的方法  # 根据函数体的逻辑 来想 参数 应该传什么进来
13         print('Name:%s Age:%s Sex:%s'% (self.name,self.age,self.sex))
14 
15     @classmethod
16     def from_conf(cls):   # 读配置文件里的内容   一种实例化的方式
17         obj = cls(
18             settings.name,
19             settings.age,
20             settings.sex
21         )
22         return obj
23 
24     @staticmethod
25     def create_id():
26         m = hashlib.md5(str(time.time()).encode('utf-8'))
27         return m.hexdigest()
28 
29 # p = People('egon',18,'male')  # 一种实例化的方式
30 
31 # 绑定给对象，就应该由对象来调用，自动将对象本身当作第一个参数传入
32 # p.tell_info() # tell_info(p)
33 
34 # 绑定给类，就应该由类来调用，自动将类本身当作第一个参数传入
35 # p = People.from_conf()  # from_conf(People)
36 # p.tell_info()
37 
38 # 非绑定方法：不与类或者对象绑定，谁都可以调用，没有自动调用一说
39 p1 = People('egon1',18,'male')
40 time.sleep(1)
41 p2 = People('egon2',28,'male')
42 time.sleep(1)
43 p3 = People('egon3',38,'male')
44 
45 print(p1.id)
46 print(p2.id)
47 print(p3.id)

3.反射

# 需求 通过用户的输入 让用户来控制 我要访问你什么样的属性
反射：通过字符串 来映射到一个对象的属性上  ----》反射
    hasattr(obj,'name')
    getattr(obj,'talk',None)
    setattr(obj,'name','alex')
    setattr(obj,'sex','male')
    delattr(obj,'age')
    # 可以是对象 可以是类
    getattr(People,'country',None)
    hasattr()
    setattr()
    delattr()

总结：通过字符串来访问到对象或类的数据属性和函数属性
用处：接收用户的输入触发对象下面的某一个方法

 1 # 反射：通过字符串映射到对象的属性
 2 class People:
 3     country = 'China'
 4     def __init__(self,name,age):
 5        self.name = name
 6        self.age = age
 7 
 8     def talk(self):
 9         print('%s is talking...' % self.name)
10 
11 obj = People('egon',18)
12 # print(obj.name)   #.name属性  本质  obj.__dict__['name']
13 # print(obj.talk)   #.talk属性
14 
15 # 需求 通过用户的输入 让用户来控制 我要访问你什么样的属性
16 # 通过字符串 来映射到一个对象的属性上  ----》反射
17 # 用户的输入是个字符串
18 # choice = input('>>:') # choice = 'name'
19 # print(obj.choice) # print(obj.'name')  这是错误的，调用的应该是属性而不是字符串
20 
21 # 判断
22 # print(hasattr(obj,'name')) #
23 # #  obj.name 判断obj中有没有name这个属性(本质就是obj.__dict__['name'],判断有没name这个key)
24 # print(hasattr(obj,'talk'))
25 
26 # 查
27 # print(getattr(obj,'name',None))
28 # print(getattr(obj,'talk',None))
29 
30 # 增,改
31 # setattr(obj,'sex','male') # obj.sex = 'male'
32 # print(obj.sex)
33 
34 # 删
35 # delattr(obj,'age') # del obj.age
36 # print(obj.__dict__)
37 
38 # print(getattr(obj,'country'))  # People.country
39 
40 
41 # 反射的应用：
42 
43 # 接收用户的输入，然后触发对象下面的某一个方法
44 
45 # class Service:
46 #     def run(self):
47 #         while True:
48 #             cmd = input('>>:').strip()
49 #             if hasattr(self,cmd):
50 #                 func = getattr(self,cmd)
51 #                 func()
52 #
53 #     def get(self):
54 #         print('get...')
55 #
56 #     def put(self):
57 #         print('put...')
58 #
59 # obj = Service()
60 # obj.run()
61 
62 
63 class Service:
64     def run(self):
65         while True:
66             inp = input('>>:').strip()  # inp = 'get a.txt'
67             cmds = inp.split() # cmds = ['get','a.txt']
68             # print(cmds)
69 
70             if hasattr(self,cmds[0]):
71                 func = getattr(self,cmds[0])
72                 func(cmds)
73 
74     def get(self,cmds):
75         print('get...',cmds)
76 
77     def put(self,cmds):
78         print('put...',cmds)
79 
80 obj = Service()
81 obj.run()

4.内置方法

内置方法：
参考：http://www.cnblogs.com/linhaifeng/articles/6204014.html
1.isinstance()
2.issubclass()
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):     print(obj)   触发
5.__del__()
    #del f                 会触发__del__()   # f.__del__()  # 这里会  先触发__del__()  在删除f
    #应用程序结束后 回收f时 会触发 __del__()  # 因为py只会回收应用程序得资源，不会回收操作系统得资源，在这做一些跟对象相关联得回收机制

  1 # class Foo():
  2 #     pass
  3 # obj=Foo()
  4 # print(isinstance(obj,Foo))
  5 
  6 # -------------------------------------------
  7 # class Foo():
  8 #     pass
  9 #
 10 # class Bar(Foo):
 11 #     pass
 12 #
 13 # print(issubclass(Bar,Foo))
 14 
 15 # -------------------------------------------
 16 
 17 # item系列
 18 # __x__这种方法不需要自己用，python会自动调用
 19 # class Foo:  # Dick
 20 #     def __init__(self,name):
 21 #         self.name = name
 22 #
 23 #     def __getitem__(self, item):# item = 'name'
 24 #         # print('getitem...')
 25 #         # print(item)
 26 #         return self.__dict__.get(item)
 27 #
 28 #     def __setitem__(self, key, value):
 29 #         # print('setitem...')
 30 #         # print(key,value)
 31 #         self.__dict__[key] = value
 32 #
 33 #     def __delitem__(self, key):
 34 #         # print('delitem')
 35 #         # print(key)
 36 #         # del self.__dict__[key]  # 这种删除方式，或者下面那种
 37 #         self.__dict__.pop(key)
 38 #
 39 # obj = Foo('agen')
 40 # print(obj.__dict__)
 41 
 42 # 查看属性：
 43 # obj.属性名
 44 # obj['name']
 45 # print(obj['name'])
 46 
 47 # 设置属性：
 48 # obj.sex = 'male'
 49 # obj['sex'] = 'male'
 50 #
 51 # print(obj.__dict__)
 52 # print(obj.sex)
 53 
 54 # 删除属性：
 55 # print(obj.__dict__)
 56 # del obj['sex']
 57 # print(obj.__dict__)
 58 
 59 
 60 # __str__方法  打印对象的时候自动触发对象下面的__str__方法,把一个字符串的返回结果作为打印结果打印出来
 61 # 数据类型就是类
 62 # d = dict({'name':'egon'})
 63 # # print(isinstance(d,dict))
 64 # print(d)
 65 
 66 # class Foo:
 67 #     pass
 68 # obj = Foo()
 69 # print(obj)
 70 
 71 # class People:
 72 #     def __init__(self,name,age):
 73 #         self.name = name
 74 #         self.age = age
 75 #
 76 #     def __str__(self):
 77 #         # print('======>str')
 78 #         r eturn '<name:%s,age:%s>' % (self.name,self.age)
 79 #
 80 # obj = People('egon',18)
 81 # print(obj) # res = obj.__str__()
 82 
 83 # -------------------------------------------------------
 84 # __del__方法：
 85 # 应用程序 不能直接操作 硬盘  需要通过 操作系统
 86 # 涉及到两方面得资源 应用程序得资源 和操作系统得资源 一定要在 程序结束之前 关闭操作系统得资源
 87 # with open() as f: 会自动回收 f
 88 # f = open('settings.py')  # 通知操作系统 打开文件  # 涉及到两方面得资源
 89 # f.read()  # 应用程序向操作系统 发了个调用 让os从硬盘上读出来
 90 #
 91 # f.close() # 回收操作系统的资源
 92 
 93 class Open:    # 如何关闭操作系统 得资源 open()打开文件
 94     def __init__(self,filename):
 95         print('open file......')
 96         self.filename = filename
 97 
 98     def __del__(self):   # 程序结束后 py会回收掉应用程序得资源 会触发 __del__() 在这回收os得资源
 99         print('回收操作系统资源')
100         # 做一些跟对象相关联 回收机制
101         # 因为py只会回收  应用程序得资源 不会回收操作系统得 资源
102 f = Open('settings.py')
103 # del f # f.__del__()   # 这里会  先触发__del__()  在删除f
104 print('----main----')  # 到这一步python回收机制会回收f,但留下操作系统的资源,这时候程序结束的时候触发__del__，可以回收操作系统资源