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 fun(cls): # cls=Foo
10 print(cls)
11
12 @staticmethod # 普通函数
13 def func1(x,y):
14 print(x+y)
15
16 f=Foo('alice')
17 #
18 # print(Foo.tell) #普通函数 <function Foo.tell at 0x000001EB7D820C80>
19 # Foo.tell(f)
20 # print(f.tell) #绑定方法 <bound method Foo.tell of <__main__.Foo object at 0x000001EB7D843EB8>>
21 # f.tell()
22
23 # print(Foo.fun) #<bound method Foo.fun of <class '__main__.Foo'>>
24 # Foo.fun() # <class '__main__.Foo'>
25
26 # print(Foo.func1)
27 # print(f.func1)
28
29 Foo.func1(1,2)
30 f.func1(1,2)
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
30 # p=People('alice',18,'female') 一种实例化的方式
31
32 # 绑定给对象 就应该由对象来调用 自动将对象本身当作第一个参数 传入
33 # p.tell_info() # tell_info(p)
34
35 # 绑定给类 就应该由类来调用，自动将类本身当作第一个参数传入
36 # p = People.from_conf() # from_conf(People)
37 # p.tell_info()
38
39 # 非绑定方法 不与类或者对象绑定，谁都可以调用，没有自动传值一说
40 p1=People('alice1',18,'male')
41 time.sleep(1)
42 p2=People('alice2',28,'male')
43 p3=People('alice3',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 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',18)
11 # print(obj.__dict__)
12 # print(obj.name) #.name属性 本质 obj.__dict__['name']
13 # print(obj.talk) #.talk属性
14
15 # 需求 通过用户的输入 让用户来控制 我要访问你什么样的属性
16 # 通过字符串 来映射到一个对象的属性上 ----》反射
17 # choice= input('>>').strip() # choice=name
18 # print(obj.choice) # obj.'name'
19
20 # hasattr(obj,'name') #obj.name #obj.__dict__['name']
21 # print(hasattr(obj,'name'))
22 # print(hasattr(obj,'talk')) #obj.talk #obj.__dict__['talk']
23
24 # print(getattr(obj,'name'))
25 # print(getattr(obj,'namexx',None))
26 # print(getattr(obj,'talk',None))
27 # setattr(obj,'sex','male') # obj.sex='male'
28 # print(obj.sex)
29 # print(obj.__dict__)
30
31 # delattr(obj,'age')
32 # print(obj.__dict__)
33
34 # setattr(obj,'name','alex')
35 # print(obj.__dict__)
36
37 # print(getattr(People,'country',None)) # People.country
38 # print(hasattr(People,'talk'))
39 # setattr(People,'city','sh')
40 # print(People.__dict__)
41 # delattr(People,'country')
42 # print(People.__dict__)
43 # print(hasattr(People,'talk'))
44 # delattr(People,'talk')
45 # print(People.__dict__)
46 # print(hasattr(People,'talk'))
47
48 # --------------------------------------------------------
49 # 反射的应用 # 接收用户的输入触发对象下面的某一个方法
50 class Service:
51 def run(self):
52 while True:
53 inp=input('>>:').strip() # cmd= get a.txt
54 cmds=inp.split() #cmd,args=['get','a.txt'] split() 默认是空格拆分
55 print(cmds)
56 if hasattr(self,cmds[0]):
57 func=getattr(self,cmds[0])
58 func(cmds)
59
60
61 def get(self,cmds):
62 print('get......',cmds)
63
64 def put(self,cmds):
65 print('put......',cmds)
66
67 obj=Service()
68 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 # item系列
17 # class Foo: # Dict # 以 __开头__结尾得 都不要自己去用 python 会自动调用
18 # def __init__(self,name):
19 # self.name=name
20 #
21 # def __getitem__(self, item): # 把对象模拟成了字典 item='name'
22 # # print('getitem...')
23 # # return self.__dict__[item] # 没有会报错
24 # return self.__dict__.get(item) # 没有返回None
25 #
26 # def __setitem__(self, key, value):
27 # # print('setitem...')
28 # # print(key,value)
29 # self.__dict__[key]=value
30 #
31 # def __delitem__(self, key):
32 # # print('delitem...')
33 # # print(key)
34 # # self.__dict__.pop(key)
35 # del self.__dict__[key]
36 #
37 #
38 # obj=Foo('alice')
39 # print(obj.__dict__)
40
41 #查看属性
42 # print(obj.name)
43 # obj['name'] # 自动出发__getitem__ #希望实现 obj.name
44 # print(obj['names'])
45
46 #设置属性
47 # obj.sex='male'
48 # print(obj.__dict__)
49 # obj['sex']='male'
50 # print(obj.__dict__)
51 # print(obj.sex)
52
53 #删除属性
54 # del obj.name
55 # del obj['name']
56 # print(obj.__dict__)
57
58 # -------------------------------------------
59 # __str__()方法 print() 会触发__str__
60 # 数据类型 就是 类
61 # d={'name':'alice'}
62
63 # d=dict({'name':'alice'})
64 # print(isinstance(d,dict))
65 # print(d)
66 # {'name': 'alice'}
67 #
68 # class People:
69 # def __init__(self,name,age):
70 # self.name=name
71 # self.age=age
72 #
73 # def __str__(self):
74 # # print('---->')
75 # return '<name:%s,age:%s>'%(self.name,self.age)
76 #
77 # obj=People('alice',12)
78 # print(obj) # obj.__str__()
79 # <__main__.Foo object at 0x000001C8103B3F98> 打印 显示内存地址 对我没用
80
81 # -------------------------------------------
82 #__del__
83 # 应用程序 不能直接操作 硬盘 需要通过 操作系统
84 # 涉及到两方面得资源 应用程序得资源 和操作系统得资源 一定要在 程序结束之前 关闭操作系统得资源
85 # with open() as f: 会自动回收 f
86 # f=open('settings.py') # 通知操作系统 打开文件 # 涉及到两方面得资源
87 # f.read() # 应用程序向操作系统 发了个调用 让os从硬盘上读出来
88 # f.close() # 回收操作系统得资源
89 # print(f)
90 # f.read()
91
92 class Open: # 如何关闭操作系统 得资源 open()打开文件
93 def __init__(self,filename):
94 print('open file...')
95 self.filename=filename
96
97 def __del__(self): # 程序结束后 py会回收掉应用程序得资源 会触发 __del__() 在这回收os得资源
98 print('回收操作系统得资源：self.close()')
99 # 做一些跟对象相关联 回收机制
100 # 因为py只会回收 应用程序得资源 不会回收操作系统得 资源
101
102
103 f=Open('settings')
104 del f # f.__del__() # 这里会 先触发__del__() 在删除f
105
106 print('-----main----')