Python 面向对象的进阶
2021-07-11 22:06
标签：property input back 基本 限制 静态 color height ini 类的成员可以分为三大类 : 字段 , 方法 和 属性 注 : 所有的成员中,只有普通字段的内容保存对象中, 即 : 根据此类创建了对象,在内存就有多少个普通字段. 而其他的成员,则都是保存在类中 , 即 : 无论对象的多少,在内存中只创建一份. 字段包括 : 普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同. 有上述代码可以看出 [普通字段需要通过对象来访问] [静态字段通过类访问] , 在使用上可以看出普通字段和静态字段的归属是不同的,其在内容的存储方式类似如下图: 右上图可知: 应用场景 : 通过类创建对象时 , 如果每个对象都具有相同的字段,那么就使用静态字段 方法包括 : 普通方法 , 静态方法 , 和 类方法 , 三种方法在内存中都归属类 , 区别在于调用方式不同 相同点 : 对于所有的方法而言 , 均属于类(非对象) 中 , 所以 , 在内存中也只保存一份. 不同点 : 方法调用者不同 , 调用方法时自动转入的参数不同 如果你已经了解Python类中的方法 , 那么属性就非常简单了 , 因为Python中的属性其实是普通方法的变种 对于属性 ,有三个知识点 由属性的定义和调用要注意一下几点: 方法 : foo_obj.func() 属性 : foo_obj.prop 注意 : 属性存在意义是 : 访问属性是可以制造出和访问字段完全相同的假象 属性由方法变种而来 , 如果Python中没有属性 , 方法完全可以代替其功能 实例 : 对于主机列表页面, 每次请求不可能把数据库中的所有内容都显示带页面上 , 而是通过分页的功能局部显示, 所以在向数据库中请求数据时要显示的指定获取从第M条到第N条的所有数据 (即 : limit m, n) , 这个分页的功能包括 : 从上述可见 , Python的属性的功能是: 属性内部进行一系列的逻辑计算 , 最终将计算结果返回 装饰器方式：在类的普通方法上应用@property装饰器 类的所有成员在上一步骤中已经做了详细的介绍 , 对于每一个类的成员而言都有两种形式: 私有成员和公有成员的定义不同 : 私有成员命名时, 前两个字符是下划线 . (特殊成员除外 , 例如: __init__ , __call__ , __dict __ 等) 私有成员和公有成员的访问限制不同 : 静态字段 普通字段 ps : 如果想要强制访问私有字段 , 可以通过 [对象.__类名__私有字段段名] 访问 ( 如: obj.__C__foo) , 不建议强制访问私有成员 . 方法 , 属性 的访问 和上述的方式相似 , 即私有成员只能在类的内部使用 ps : 非要访问私有属性的话 , 可以通过 对象.__类__属性名 Python 面向对象的进阶 标签：property input back 基本 限制 静态 color height ini 原文地址：https://www.cnblogs.com/heshun/p/9549560.html 类的成员
一 , 字段
1 class Province:
2 """
3 字段的定义和使用
4 """
5 # 静态字段
6 country = "中国"
7 def __init__(self,name):
8
9 # 普通字段
10 self.name = name
11
12 # 直接访问普通字段
13 obj = Province("和顺")
14 print(obj.name)
15
16 # 直接访问静态字段
17 print(Province.country)
二 方法
1 class Foo:
2
3 def __init__(self,name):
4 self.name = name
5
6 def ord_func(self):
7 ‘‘‘
8 定义一个普通方法,至少有一个self参数
9 ‘‘‘
10 print(self.name)
11 print("普通方法")
12
13 @classmethod
14 def class_func(cls):
15 ‘‘‘
16 定义一个类方法,至少有一个cls参数
17 ‘‘‘
18 print("类方法")
19
20 @staticmethod
21 def static_func():
22 """
23 定义一个静态类方法, 无需默认参数
24 """
25 print("静态类方法")
26
27 # 调用普通方法
28 f = Foo("和顺")
29 f.ord_func()
30
31 # 调用类方法
32 Foo.class_func()
33
34 # 调用静态类方法
35 Foo.static_func()
三 属 性
1 , 属性的基本使用
1 class Foo:
2
3 def func(self):
4 pass
5 # 定义属性
6 @property
7 def prop(self):
8 pass
9
10 foo_obj = Foo()
11 foo_obj.func()
12 foo_obj.prop # 调用属性
1 class Pagenation:
2 ‘‘‘
3 分页处理代码
4 ‘‘‘
5 def __init__(self,data_list, page,per_page_num = 10):
6 ‘‘‘
7 初始化
8 :param data_list: 所有数据
9 :param page: 第几页
10 :param per_page_num: 每页显示几条数据
11 ‘‘‘
12 self.data_list = data_list
13 self.page = page
14 self.per_page_num = per_page_num
15 @property
16 def start(self):
17 """
18 计算起始页
19 :return:
20 """
21 return (self.page - 1) * self.per_page_num
22 @property
23 def end(self):
24 """
25 计算结尾页
26 :return:
27 """
28 return self.page * self.per_page_num
29
30 def show(self):
31 """
32 打印当前页面
33 :return:
34 """
35 ret = self.data_list[self.start:self.end]
36 for i in ret :
37 print(i)
38
39
40 data_list = []
41 for i in range(1,10001):
42 data_list.append("皇家%s号" % i)
43 # obj = Pagenation(data_list)
44 while True:
45 page = int(input("请输入你查看的页数:"))
46 obj = Pagenation(data_list,page)
47 obj.show()
属性的两种定义方式
类成员的修饰符
1 class C:
2
3 def __init__(self):
4 self.name = "公有字段"
5 self.__foo = "私有字段"
1 class C:
2
3 name = "公有静态字段"
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() # 派生类中可以访问
1 class C:
2
3 __name = "公有静态字段"
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() # 派生类中可以访问 ==> 错误
1 class C:
2
3 def __init__(self):
4 self.foo = "公有字段"
5
6 def func(self):
7 print self.foo # 类内部访问
8
9 class D(C):
10
11 def show(self):
12 print self.foo ＃ 派生类中访问
13
14 obj = C()
15
16 obj.foo # 通过对象访问
17 obj.func() # 类内部访问
18
19 obj_son = D();
20 obj_son.show() # 派生类中访问
1 class C:
2
3 def __init__(self):
4 self.__foo = "私有字段"
5
6 def func(self):
7 print self.foo # 类内部访问
8
9 class D(C):
10
11 def show(self):
12 print self.foo ＃ 派生类中访问
13
14 obj = C()
15
16 obj.__foo # 通过对象访问 ==> 错误
17 obj.func() # 类内部访问 ==> 正确
18
19 obj_son = D();
20 obj_son.show() # 派生类中访问 ==> 错误