面向对象进阶

 1 class Animal(object):
 2     name = "hello"
 3 
 4     def __init__(self, name):
 5         self.name = name
 6         self.__num = 100
 7 
 8     @classmethod  # 类方法,只能访问类属性,不能调用实例属性
 9     def talk(self):
10         print("%s talk wang" % self.name)
11 
12     def walk(self):
13         print("%s walking now" % self.name)
14 
15     @staticmethod  # 静态方法,不能直接访问类属性,以及实例属性
16     def habbit(self):
17         print(" %s habbit ..." % self.name)
18 
19     @property  # 属性,将类方法变成类属性形式对外提供访问
20     def total(self):
21         print("total pro is %s" % self.__num)
22 
23     @property
24     def total_num(self):
25         print("total  num pro is %s" % self.__num)
26 
27     @total_num.setter
28     def total_num(self, num):  # 静态属性修改值,如果要修改,则必须传入一个参数
29         self.__num = num
30         print("total num  set is %s" % self.__num)
31 
32     @total_num.deleter
33     def total_num(self):
34         print("total num del is %s" % self.__num)
35         del self.__num
36 
37 newdog = Animal("san")
38 newdog.talk()
39 newdog.walk()
40 newdog.habbit(newdog)
41 print(newdog._Animal__num)
42 newdog.total
43 newdog.total_num
44 newdog.total_num = 3
45 del newdog.total_num
46 newdog.total_num  # 已经删除了该实例属性,所以不存在了,报错

类的继承

 1 class A:
 2     def f1(self):
 3         print("from A")
 4 
 5 class B(A):
 6     def f1(self):
 7         print("from B")
 8 
 9 class C(A):
10     def f1(self):
11         print("from C")
12 
13 class D(B, C):
14     def f3(self):
15         print("from d")
16 
17     def f2(self):
18         print("from D")
19 
20 
21 m = D()
22 m.f1()
23 
24 #3.x时经典类和新式类都是默认广度优先
25 #2.x 时,新式类使用广度优先,经典类使用深度优先

 

 1 class Foo:
 2     """
 3     hello,
 4     这里的代码通过类名.__doc__()可以获取到
 5     """
 6 
 7     def __init__(self):  # 构造方法,通过创建对象时.自动触发执行
 8         print("__init")
 9         #  静态字段
10 
11     def __del__(self):  #析构方法,当对象在内存中被释放时自动触发执行
12         pass
13 
14     def __new__(cls, *args, **kwargs):
15         pass
16 
17     def __call__(self, *args, **kwargs):  # 创建的对象加括号后,触发执行
18         # 构造方法的执行是由创建对象触发的,即:对象 = 类名();call方法的执行是由对象加括号触发的,即对象()或者类()()
19         pass
20 
21     def __str__(self):  # 当一个类中定义了__str__方法,则在打印对象时,默认输出该返回值
22         return "zengchunyun"
23 
24     def __getitem__(self, item):
25         pass  # 用于索引操作.如字典,这个方法主要用来获取数据
26 
27     def __setitem__(self, key, value):
28         pass
29         # 用于对索引对设置
30 
31     def __delitem__(self, key):
32         pass
33     # 用于删除索引的数据
34 
35     def __iter__(self):
36         pass  # 用于迭代器,之所以列表,字典,元组可以进行FOR循环,是因为定义了该方法
37 
38     def __metaclass__(self):
39         pass
40     # 
41 
42 
43 
44 
45 a = Foo()
46 a.__doc__
47 # print(a.__module__)  # 表示当前操作的对象在哪个模块,仅限在另一个文件调用时才有该属性
48 print(a.__class__)  # 输出"NoneType  即当前操作的对象的类是什么
49 
50 #获取类成员
51 class MM(object):
52     def __init__(self):
53         self.hello = None
54     def say(self):
55         pass
56 print(MM.__dict__)  # 获取类成员
57 obj = MM()
58 print(obj.__dict__)  # 获取对象成员
59 
60 class Foo(object):
61     def __init__(self):
62         pass
63 
64 obj = Foo()  # obj 是Foo类实例化的对象
65 print(type(obj))  # obj对由Foo类创建
66 print(type(Foo))    #Foo类对象由type类创建
67 
68 #创建类的两种方式
69 # 第一种就是上面这种
70 # 第二种就是type类的构造函数
71 def func(self):
72     print("hello")
73 
74 Foo = type("Foo",(object,), {"func":func})
75 #type第一个参数为 类名
76 # type第二个参数为当前类的基类
77 # type第三个参数为类的成员