类的成员

类的成员分为三大类:

  1,字段 静态字段(每个对象都有一份时用)、普通字段(每个对象都不的数据时用)

  2,方法 静态方法(无需使用对象封装的内容)、类方法、普通方法(使用对象中的数据)

  3,特性 普通特性(将方法伪造成字段)

 

通过类访问:静态字段、静态方法、类方法

通过对象访问:普通字段、普通方法,类方法

 1 class Provice:
 2     #静态字段:在类中;在内存中只保存一份
 3     country = "中国"
 4 
 5 
 6 
 7     def __init__(self,name):
 8         temp = "xxx"
 9         #普通字段,在对象中;在每个对象中都要保存一份
10         self.name = name
11 
12     #普通方法,类中
13     def show(self):
14         print('show')
15 
16     #类方法
17     @classmethod
18     def xxoo(cls):  #类名
19         print('xxoo')
20         # print('xxoo',cls)
21 
22     #静态方法
23     @staticmethod
24     def xo(arg1,arg2):
25             print('xo')
26 
27     def start(self):
28         temp = "%s sb" %self.name
29         return temp
30 
31     #特性,将方法伪造成一种字段
32     @property
33     def end1(self):
34         temp = "%s sb" % self.name
35         return temp
36 
37     @end1.setter  #类名+setter 修改参数
38     def end1(self,value):
39 
40         # print(value)
41         self.name = value
42 
43 obj = Provice("123")
44 print(obj.end1)
45 obj.end1 = "456"
46 print(obj.end1)
47 
48 obj = Provice('alex')
49 print(obj.end1)
50 obj.end1 = "123"
51 print(obj.end1)
52 
53 
54 obj = Provice('alex')
55 #print(obj.name)
56 ret1 = obj.start()
57 ret2 = obj.end1
58 print(ret1)
59 Provice.xo(1,2)  #执行静态方法
60 Provice.xxoo()   #执行类方法
61 hebei = Provice("河北")
62 henan = Provice("河南")
63 #1,自己去访问自己的成员
64 #2,除了类中的方法
65 
66 print(Provice.country)
67 obj = Provice('alex')
68 obj.show()

总结:

快速判断,是类执行还是对象执行:

  1,有self  对象执行

  2,无self  类调用

调用方法:

  普通方法:由对象调用;至少一个self参数;执行普通方法时,自动将调用该方法的对象赋值给self;

  类方法:由类调用; 至少一个cls参数;执行类方法时,自动将调用该方法的类复制给cls;

  静态方法:由类调用;无默认参数;

特性:

  定义时,普通方法的基础上添加 @property

  定义时,属性仅有一个self参数

  调用时,无需括号

 

 成员修饰符

公共成员,在任何地方都能访问

私有成员,只有在类的内部才能访问;私有成员命名,前两个字符使下划线(特殊成员除外)。

1,静态字段

a,公有静态字段:类可以访问;类内部可以访问;派生类中可以访问

实例:

 1 class C:
 2 
 3     name = "hello"
 4 
 5     def func(self):
 6         print(C.name)
 7 
 8 class D(C):
 9 
10     def show(self):
11         print(C.name)
12 
13 
14 C.name         # 类访问
15 
16 obj = C()
17 obj.func()     # 类内部可以访问
18 
19 obj_son = D()
20 obj_son.show() # 派生类中可以访问
公有静态字段

相关文章:

  • 2021-06-10
  • 2021-06-09
  • 2022-12-23
  • 2022-12-23
  • 2021-11-20
  • 2021-11-07
猜你喜欢
  • 2021-08-31
  • 2022-12-23
  • 2021-08-26
  • 2021-12-10
  • 2021-06-08
  • 2021-09-20
  • 2021-11-19
相关资源
相似解决方案