3.2.4 动态属性-类属性
python支持类动态扩展属性，该属性仅属于该类，该类之前和之后创建的对象均会拥有该类属性。该属性修改时会影响到该类的所有实例对象
# 动态属性仅属于当前实例对象，类也无此属性，新创建的实例对象无此属性
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
dish.restaurant_name = "秦王阁" # 动态类属性：属于类
# 之前创建的实例对象拥有该属性
print(f"d1:{d1.restaurant\_name}")
# 之后创建的实例对象拥有该属性
d3 = dish(3, "皮蛋豆腐", 18.0)
print(f"d3:{d3.restaurant\_name}")
# 修改动态类属性会影响该类的所有实例对象
dish.restaurant_name = "秦王阁总店"
print(f"d1:{d1.restaurant\_name}, d3:{d3.restaurant\_name}")
d1:秦王阁
d3:秦王阁
d1:秦王阁总店, d3:秦王阁总店
3.2.5 私有属性
在实际开发中，对象的某些属性或方法可能只希望在对象内部使用，而不希望在外部被访问到，将没有必要展示的属性隐藏到类的内部
私有属性就是对象不希望公开的属性
定义方法：双下划线+变量名
__[var_name]
如下代码中的__freshness就是私有属性，在类的外部无法访问该属性。python的实现原理是将属性改名以实现隐藏的目的,在下面的例程中__freshness被重命名为_dish__freshness。
# 动态属性仅属于当前实例对象，类也无此属性，新创建的实例对象无此属性
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
self.__freshness = 0 # 私有属性
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
d1.__freshness
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-2-bbebea90b95d> in <module>()
13 d2 = dish(2, "新疆大盘鸡", 89.9)
14
---> 15 d1.__freshness
AttributeError: 'dish' object has no attribute '__freshness'
# 查看\_\_freshness是否暴露出来，可以看到无\_\_freshness，属性改名为\_dish\_\_freshness
dir(d1)
['__class__',
'__delattr__',
'__dict__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__gt__',
'__hash__',
'__init__',
'__init_subclass__',
'__le__',
'__lt__',
'__module__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__',
'_dish__freshness',
'desc',
'id',
'name',
'price']
3.3 方法
3.3.1 实例方法
类的方法用来描述对象的行为。
类的方法定义和普通函数稍微有点不一样，第一个参数必须为self，表示对象自身
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
# 实例方法的定义
def display\_dish(self): # 自定义函数
print(f"id:{self.id}\tname:{self.name}\tprice:{self.price}")
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
menu = []
menu.append(d1)
menu.append(d2)
for dish_item in menu: # 类的自定义方法
# 实例方法的调用
dish_item.display_dish()
id:1 name:青椒肉丝 price:22.9
id:2 name:新疆大盘鸡 price:89.9
3.3.1 动态实例方法
python支持类在创建实例对象动态扩展方法，该属性仅属于该对象，不属于类，其它对象也不存在
from types import MethodType # 动态方法需要引入模块
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
def display\_dish(self): # 自定义函数
print(f"id:{self.id}\tname:{self.name}\tprice:{self.price}")
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
def update\_price(self, price):
self.price = price
# 动态加载方法，需要MethodType配合使用
d1.update_price = MethodType(update_price, d1)
d1.update_price(36.9)
print(f"d1.price:{d1.price}")
# 其它实例对象无此方法
d2.update_price(69.9)
d1.price:36.9
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-22-46959ca8d4f0> in <module>()
25
26 # 其它实例对象无此方法
---> 27 d2.update_price(69.9)
AttributeError: 'dish' object has no attribute 'update_price'
3.3.2 私有方法
私有方法就是对象不希望公开的方法,只可以在类的内部使用，外部无法访问。下面代码中的__update_price就是私有方法，从dir的输出来看，__update_price也被python改名了，改为_dish__update_price了。
from types import MethodType # 动态方法需要引入模块
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
def display\_dish(self): # 自定义函数
print(f"id:{self.id}\tname:{self.name}\tprice:{self.price}")
def \_\_update\_price(self, price):
self.price = price
def update(self, price):
self.__update_price(price)
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
# 实例对象访问
print(dir(d1)) #
d1.____update_price(39.2)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_dish__update_price', 'desc', 'display_dish', 'id', 'name', 'price', 'update']
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-6-bf2ee1f232ce> in <module>()
24 print(dir(d1)) #
25
---> 26 d1.____update_price(39.2)
AttributeError: 'dish' object has no attribute '____update_price'
4. 类的继承和多态
面向对象三大特征：
- 封装:根据职责将属性和方法封装到一个抽象的类中
- 继承:实现代码的重用，相同的代码不需要重复的写
- 多态:以封装和继承为前提，不同的子类对象调用相同的方法，产生不同的执行结果
class Chinese:
def \_\_init\_\_(self, name, age):
self.name = name
self.age = age
def eat(self):
print(f"{self.name}喜欢吃中餐")
def sleep(self):
print(f"{self.name}正在睡觉")
class Southern(Chinese):
def \_\_init\_\_(self, name, age, height):# 子类Southern重载了\_\_init\_\_方法，和父类有差异，新增了height属性
self.name = name
self.age = age
self.height = height
def eat(self, favorate): # 子类Southern重载了eat方法，和父类的参数数量不一样
print(f"{self.name}喜欢吃米饭, 尤其喜欢{favorate}")
return True
class Northern(Chinese):
def eat(self): # 子类Northern重载了eat方法，参数数量和父类一样
print(f"{self.name}喜欢吃面食")
p1 = Chinese("张三", 18)
p1.eat()
s1 = Southern("李四", 20, 190)
s1.eat("黄焖鸡米饭")
s1.sleep()
n1 = Northern("王五", 22)
n1.eat()
n1.sleep()
张三喜欢吃东西
李四喜欢吃米饭, 尤其喜欢黄焖鸡米饭
李四正在睡觉
王五喜欢吃面食
王五正在睡觉
上面的例子展现了以下知识点：
- 类的方法函数第一个参数必须为self, 否则会报错"TypeError: eat() takes 0 positional arguments but 1 was given",实例的方法调用时默认会将自己作为第一个参数传递进去
- Southern、Northern子类会继承父类的__init__方法和sleep方法，如果与父类有差异，也可以重载方法，这是类的多态
- 子类在重载父类的方法时，参数的数量可以和父类不一样，返回值也可以不一样，函数名一致即可。
- 有些父子类，子类在定义__init__方法时需要调用父类的__init__方法，因为子类重载了父类的__init__方法，因此父类的__init__方法不会被执行，有时父类有一些子类没有的属性需要初始化，那么可以这样调用父类的__init__方法：
super(ChildClassName, self).__init__()
就像例子一样，南方人普遍喜欢吃米饭，北方人普遍喜欢面食，但是南方人和北方人都拥有中国人的特性，喜欢吃中餐、会睡觉。
类的继承和多态特性，抽象了子类公共的部分，又保留了子类的多样性，精简了代码，又降低了代码耦合度，提高了代码质量，更容易实现代码复用。
类，完美体现了一致性和多样性共同存在并相互作用，而这就是自然法则！
5. 附录
5.1 面向过程的吃饭例子实现
# 菜谱
menu = []
# 订单列表
order_list = []
def create\_menu():
"""创建菜谱
"""
menu.append((1, "青椒肉丝", 22))
menu.append((2, "皮蛋豆腐", 16))
menu.append((3, "新疆大盘鸡", 89))
menu.append((4, "虎皮青椒", 22))
def display\_menu():
"""打印菜谱
"""
for item in menu:
print(f"{item[0]}, {item[1]}, {item[2]}")
def order(order_id, ordered_menu):
"""下单
Args:
order\_id (int): 订单ID
ordered\_menu (tuple): 已选菜单
"""
order_list.append((order_id, ordered_menu))
def check(order_id):
"""结账
Args:
order\_id (int): 订单ID
Returns:
int: 账单金额
"""
amount = 0
# 获得订单对应的已选菜单
checklist = [ord[1] for ord in order_list if ord[0] == order_id]
checklist = checklist[0] # 取出列表中的元组[(1, 2)]->(1, 2)
# 获得已选菜单对应的菜品单价清单
# 菜谱中的菜品数据格式为元组(1, "青椒肉丝", 22)，通过索引访问元组元素
checklist = [dish[2] for dish in menu if dish[0] in checklist]
# 求清单累计和
for x in checklist:
amount += x
return amount
# 创建菜谱
create_menu()
# 展示菜谱
display_menu()
# 客人C1点了青椒肉丝、皮蛋豆腐，(1, 2)为菜品对应的ID
order(order_id=1, ordered_menu=(1, 2))
# 客人C2点了皮蛋豆腐、新疆大盘鸡，(2, 3)为菜品对应的ID
order(order_id=2, ordered_menu=(2, 3))
# 客人C1结账
print(f"客人C1消费了{check(1)}元")
# 客人C2结账
print(f"客人C2消费了{check(2)}元")
1, 青椒肉丝, 22
2, 皮蛋豆腐, 16
3, 新疆大盘鸡, 89
4, 虎皮青椒, 22
客人C1消费了38元
客人C2消费了105元
5.2 面向对象的吃饭例子实现
class Dish:
"""
菜品
"""
def \_\_init\_\_(self, id, name, price):
self.id = id
self.name = name
self.price = price
class Restaurant:
"""
菜单
"""
def \_\_init\_\_(self):
self.menu = []
self.ordered_menu = {}
def add(self, id, name, price):
"""添加新菜品
"""
self.menu.append(Dish(id, name, price))
def display\_menu(self):
"""展示菜谱
"""
for item in self.menu:
print(f"{item.id}\t{item.name}\t\t{item.price}")
def order(self, order_id, dish_id):
# ord = {item for item in self.ordered\_menu.keys if item == order\_id}
ord = self.ordered_menu.get(order_id, [])
if ord: # 不为空，说明订单已经产生
ord.append(dish_id)
else: # 为空，说明是新订单
self.ordered_menu[order_id] = list([dish_id])
def check(self, order_id):
amount = 0
# self.ordered\_menu[order\_id]直接获得客户的已选菜单，然后用列表推导式获得结算价格
checklist = [dish.price for dish in self.menu if dish.id in self.ordered_menu[order_id]]
for x in checklist:
amount += x
return amount
class customer:
"""客人
"""
def \_\_init\_\_(self, order_id):
self.order_id = order_id
self.amount = 0
def order(self, restaurant, dish_id):
restaurant.order(self.order_id, dish_id)
# 相对于面向过程，面向对象无需定义全局变量来存储菜谱，用餐馆对象存储即可。
restaurant = Restaurant()
# 添加新菜品
restaurant.add(1, "青椒肉丝", 22)
restaurant.add(2, "皮蛋豆腐", 16)
restaurant.add(3, "新疆大盘鸡", 89)
restaurant.add(4, "虎皮青椒", 22)
# 展示菜单
restaurant.display_menu()
# 客人c1点餐
c1 = customer(order_id = 1)
c1.order(restaurant=restaurant, dish_id = 1) # c1点了青椒肉丝
c1.order(restaurant=restaurant, dish_id = 2) # c1点了皮蛋豆腐
# 客人c2点餐
c2 = customer(order_id = 2)
c2.order(restaurant=restaurant, dish_id = 2) # c2点了皮蛋豆腐
c2.order(restaurant=restaurant, dish_id = 3) # c2点了新疆大盘鸡
# 客人c1结账
c1.amount = restaurant.check(c1.order_id)
# 客人c2结账
c2.amount = restaurant.check(c2.order_id)
print(f"客人c1消费了{c1.amount}元")
print(f"客人c2消费了{c2.amount}元")
1 青椒肉丝 22
2 皮蛋豆腐 16
3 新疆大盘鸡 89
4 虎皮青椒 22
客人c1消费了38元
客人c2消费了105元
福利：新增线上运行环境支持，可以直接运行博文中的代码，无需自行部署环境
线上环境地址：https://aistudio.baidu.com/aistudio/projectdetail/4197645?_=1654794787976&shared=1
《Python零基础快速入门系列》快速导航：
- Python快速入门系列(1) 人工智能序章：开发环境搭建Anaconda+VsCode+JupyterNotebook(零基础启动)
- Python快速入门系列(2)一文快速掌握Python基础语法
- Python快速入门系列(3)AI数据容器底层核心之Python列表
- Python快速入门系列(4)为什么内存中最多只有一个“Love“？一文读懂Python内存存储机制
- Python快速入门系列(5)Python只读数据容器：列表List的兄弟，元组tuple
- Python快速入门系列(6)字符串、列表、元组原来是一伙的？快看序列Sequence
- Python快速入门系列(7)成双成对之Python数据容器字典
- Python快速入门系列(8)无序、不重复、元素只读，Python数据容器之集合
- Python快速入门系列(9)高级程序员绝世心法——模块化之函数封装
写在末尾：
- 博客简介：专注AIoT领域，追逐未来时代的脉搏，记录路途中的技术成长！
- 专栏简介：本专栏的核心就是：快！快！快！2周快速拿下Python，具备项目开发能力，为机器学习和深度学习做准备。
- 面向人群：零基础编程爱好者
- 专栏计划：接下来会逐步发布跨入人工智能的系列博文，敬请期待
- Python零基础快速入门系列
- 快速入门Python数据科学系列
- 人工智能开发环境搭建系列
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
写在末尾：
- 博客简介：专注AIoT领域，追逐未来时代的脉搏，记录路途中的技术成长！
- 专栏简介：本专栏的核心就是：快！快！快！2周快速拿下Python，具备项目开发能力，为机器学习和深度学习做准备。
- 面向人群：零基础编程爱好者
- 专栏计划：接下来会逐步发布跨入人工智能的系列博文，敬请期待
- Python零基础快速入门系列
- 快速入门Python数据科学系列
- 人工智能开发环境搭建系列
[外链图片转存中…(img-KYWWSLWT-1714438099040)]
[外链图片转存中…(img-NKeHXGgN-1714438099041)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
602
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
