python -- 面向对象

 1 例如：
 2 class Role(object):
 3     ac = None    #类的变量，随着类的创建，存在与内存中
 4     
 5     def __init__(self,name,role,weapon,life_value):
 6         self.name = name
 7         self.role = role     #这都是成员变量（实例化的对象的变量）
 8         self.weapon = weapon
 9         self.life_value = life_value
10         
11     def buy_weapon(self,weapon):
12         print(‘%s is buying [%s]‘ %(self.name,weapon))
13         self.weapon = weapon
14 
15 在这个类里面，有一个类的变量ac，可以理解为静态变量，要修改ac的值，需要通过‘ Role.ac = xxx ‘，即 类名.类变量名
16 
17 类变量与成员变量区别：
18      1、类变量在定义类时就存在于内存中了，而成员变量只有在实例化时才被构造方法创造
19      2、定义时，成员变量前面都有self，而类变量没有。因为self时指向的不同对象，而类变量只
20         能由‘类名.类变量’来修改，可以通过‘对象.类变量’来访问，但是不能修改
21 
22 类不能直接调用实例变量（实例变量存储在对象中，不在类中）
23      
24 __init__() 是构造方法，在实例化对象时自动调用，就是用来初始化对象属性等
25 
26 在实例化对象时，根据构造参数传递参数
27 
28 定义类时，里面属性前面都有一个self，方法的第一个参数默认是self，这个self是指向实例化的对象，不是指向的类
29     
30 
31 内存详解：
32     在类定义时，就在系统内存里面生成了一块内存来存放类的内容，包括 类变量、类方法 等
33     即：类变量存储在类里面，类里面的方法也是存储在类这块内存里面的
34     
35     构造函数是在实例化对象才会调用，所以构造函数里面的属性都是存在于实例化的对象的内存里面(是特定对象的属性)
36 
37 对象调用类的方法：
38     在实例化对象时，并没有把类里面的方法都copy到对象内存空间里面，所以对象的内存空间里面只有属性，并没有方法
39   方法都是存在于类的内存中(这样就算是实例化了无数个对象，方法在内存中还是只有类空间里面这一份，节约空间)
40   方法都是类的方法，实例化对象在调用方法时，都会去类空间里面找。

 1 ‘‘‘
 2  私有属性：只能在类里面通过类自己的方法调用，对象不能直接调用(可以通过方法)
 3  要把一个属性变为私有属性，只需要在属性名前面加两个下划线‘__‘
 4  
 5  （特例，尽量别用）从外部直接访问私有变量方法： t._Human__life
 6 
 7 ‘‘‘
 8 
 9 class Human(object):
10     __num = 10
11     def __init__(self,name):
12         self.name = name
13         self.__life = 100
14         
15     def interface1(self):
16         print(‘血量 self.__life：‘,self.__life)
17     
18     def interface2(self):
19         print(‘__num：‘,self.__num)
20         
21         
22 t = Human(‘Tom‘)
23 print(t.name)
24 #print(t.__life)
25 ‘‘‘
26 builtins.AttributeError: ‘Human‘ object has no attribute ‘__life‘
27 因为__life 是对象里面的私有属性，在外部不能直接调用，但可以通过方法调用
28 ‘‘‘
29 t.interface1()  #血量： 100
30 #print(Human.__num)
31 ‘‘‘
32 builtins.AttributeError: type object ‘Human‘ has no attribute ‘__num‘
33 ‘‘‘
34 t.interface2()
35 
36 print("特例访问私有变量方法 t._Human__life ：",t._Human__life) 

 1 #!/usr/bin/env python
 2 #coding:utf-8
 3 
 4 class A(object):
 5     ‘‘‘Test class‘‘‘
 6     num = 10
 7     
 8     #类里面的__init__()是由__new__()触发执行的
 9     #def __new__(self):
10         #print("=======new======")
11     ‘‘‘
12     =======new======
13     None
14     报错：builtins.AttributeError: ‘NoneType‘ object has no attribute ‘__module__‘
15     说明在这里重载__new__()方法后，没有再执行__init__()
16     ‘‘‘
17     def __init__(self,name,age):
18         self.name = name
19         self.age = age
20         print(‘__init__‘)
21     
22     def __call__(self):
23         print("__call__")
24     
25     def test(self):
26         print("=====test=====")
27     #重载析构函数
28     def __del__(self):
29         print(‘deleting the ...‘)
30 
31 a = A(‘root‘,20)
32 print(a.__doc__)   
33 ‘‘‘
34 Test class
35 __doc__ 获取类的说明(即：注释)
36 在定义类的函数时，最好在注释里面对其作用、功能、参数等做个说明
37 ‘‘‘
38 ‘‘‘
39 __module__ 表示当前操作的对象或类在那个模块
40 
41 __class__     表示当前操作的对象的类是什么
42 ‘‘‘
43 print(a.__module__)
44 ‘‘‘
45 __main__ 在这里代表的是当前模块。如果对象a在其他模块，则会打印a所在的模块名
46 ‘‘‘
47 #import test.Human
48 from test import Human
49 #from test import h
50 h1 = Human()
51 #print(h.__module__)   #test
52 print(h1.__module__)   #test
53 print(h1.__class__)   #<class ‘test.Human‘>
54 
55 #python中，析构函数是： __del__()   析构函数会自己在程序执行结束自动调用
56 
57 ‘‘‘
58  __call__  对象后面加括号，触发执行。
59 注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；
60 而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
61 ‘‘‘
62 #执行__call__ 方法
63 a()  #__call__
64 #A()()   #__call__
65 
66 ‘‘‘
67  __dict__    只能显示对象中的所有成员变量，不能显示类变量
68 
69 我们知道：实例变量(成员变量)属于对象；类中的静态变量和方法等属于类，
70 ‘‘‘
71 print(a.__dict__)
72 ‘‘‘
73 {‘name‘: ‘root‘, ‘age‘: 20}
74 ‘‘‘
75 print(type(a))   #<class ‘__main__.A‘>
76 print(a)  #<__main__.A object at 0x000001BA3967D128>
77 
78 #类是由‘type‘创造出来的
79 print(type(A))    #<class ‘type‘>

 1 #!/usr/bin/env python
 2 #coding:utf-8
 3 
 4 ‘‘‘
 5 @classmethod  类方法装饰器（不能访问实例变量）
 6   作用：把装饰的方法变为类方法(相似于类变量，只能通过类来访问，对象不能访问类方法)
 7 
 8 @staticmethod  静态方法装饰器（不能访问类变量和实例变量）
 9   作用：类的工具箱，与类直接相互独立，要调用类的东西只有传参（一般不用）
10   
11 @property 类属性装饰器
12   作用：把装饰的方法变为一个属性（能调用，不可执行）
13 
14 ‘‘‘
15 class Animal(object):
16     hobbie = "meat"
17     def __init__(self,name):
18         self.name = name
19         self.num = None
20      
21     @classmethod    #类方法，不能访问实例变量
22     def talk(self):
23         print(‘%s is talking...‘ %self.hobbie)    #可以直接调用，但不能修改
24         #print(‘%s is talking...‘ %self.name)
25     ‘‘‘
26     builtins.AttributeError: type object ‘Animal‘ has no 
27     attribute ‘name‘
28     ‘‘‘
29      
30     @staticmethod
31     def walk(self):
32         print(‘%s is walking...‘ %self.name)
33     ‘‘‘
34     builtins.TypeError: walk() missing 1 required positional 
35     argument: ‘self‘
36     不知道self是谁，在调用时应该把self当参数传进来
37     ‘‘‘   
38        
39     @property
40     def habit(self):
41         print("%s habit is xxoo" %self.name)
42     ‘‘‘
43     builtins.TypeError: ‘NoneType‘ object is not callable
44     ‘‘‘ 
45     
46     #property 用法补充
47     #1、直接调用(此时不能传值，否则报错)
48     @property
49     def total_player(self):
50         print("this is a property")
51         return self.num
52     
53     #2、经过1后，total_player变成了属性，因此可以用setter
54     @total_player.setter
55     def total_player(self,num):
56         self.num = num
57         print("self.num:",self.num)
58         
59     #3、相对于2可以给属性传值，那么也可以用删除属性值
60     @total_player.deleter
61     def total_player(self):
62         print("total player got deleted")
63         del self.num
64     
65 d = Animal(‘zhaolin‘)
66 d.talk()
67 d.walk(d)
68 d.habit
69 #1：
70 d.total_player
71 #2：
72 d.total_player = 20
73 #3:
74 del d.total_player    #用deleter时，要这样调用
75 
76 ‘‘‘
77 meat is talking...
78 zhaolin is walking...
79 zhaolin habit is xxoo
80 
81 this is a property
82 self.num: 20
83 total player got deleted
84 
85 ‘‘‘

 1 #!/usr/bin/env python
 2 #coding:utf-8
 3 
 4 ‘‘‘
 5 反射是非常非常重要的！
 6 反射的作用：通过一个字符串来去调用一个对象中名字跟字符串值相同的方法(属性)的内存地址
 7 ‘‘‘
 8 
 9 import sys
10 
11 class WebServer(object):
12     def __init__(self,host,port):
13         self.host = host
14         self.port = port
15         
16     def start(self):
17         print("Server is starting...")
18     def stop(self):
19         print("Server is stoped...")
20     def restart(self):
21         self.stop()
22         self.start()
23         
24 def test_run(ins,name):
25     print("test_run",name,ins.host)
26     
27         
28 if __name__ == ‘__main__‘:
29     #print(sys.argv[0],sys.argv[1])
30     ‘‘‘
31     sys.argv是一个获取文件名后面参数的数组，sys.argv[0]是当前文件路径，
32     后面依次为传递的参数
33     ‘‘‘
34     server = WebServer(‘localhost‘, 8080)
35     if hasattr(server, sys.argv[1]): 
36     #if hasattr(WebServer, sys.argv[1]):   #对象或类名都可以   
37         func = getattr(server,sys.argv[1])   #得到对象server中名字与传入字符串相等的函数(方法)
38         func()
39     else:
40         print("your input incorrect!")    
41      
42     #server1 = WebServer(‘localhost1‘, 80)
43     #setattr(server1,‘run‘,test_run)
44     #server1.run(server1,‘admin‘)
45     
46     #delattr(server1,‘port‘)
47     #print(server1.port)   
48     #AttributeError: ‘WebServer‘ object has no attribute ‘port‘
49     
50     ‘‘‘
51     以下的obj可以是类，也可以是实例化的对象
52     
53     hasattr(obj,attr)  判断对象中有没有指定属性(方法)
54     
55     getattr(obj,attr)  获取对象中的属性(方法)的内存地址
56     
57     setattr(obj,attr,method)  把方法(属性)method添加到对象中，并改名为attr
58         通过对象调用method：obj.attr
59        
60         这样把方法(属性)添加到对象中与原生方法区别：
61           不会自动把self传进去，若要调用obj原生属性，只有先把obj当成参数传进去
62     
63     delattr(obj,attr)  把对象obj里面的attr属性(方法)删除掉
64          注意：因为实例化对象的方法是存在于类中，对象只是能访问类中的方法，不能
65            更改，但是对象可以更改自己的成员变量。所以这里的attr是对象自身的属性
66            或方法，不是类里面的。
67          
68          可以通过delattr(classname,attr)来删除类的属性(方法)
69     
70     ‘‘‘
71     ‘‘‘
72     #方式比较low
73     cmd_dict = {
74         ‘start‘:server.start,
75         ‘stop‘:server.stop,
76         ‘restart‘:server.restart
77     }
78     if sys.argv[1] in cmd_dict:
79         cmd_dict[sys.argv[1]]()
80     else:
81         print("your input incorrect!")
82    
83     ‘‘‘
84