# 动态属性仅属于当前实例对象,其它实例对象无该属性
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)
d1.star = 5 # 动态属性:客户评分,仅属于d1实例对象
d2.star # 之前创建的实例对象无star属性
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-12-2cf61b7d68db> in <module>()
12 d1.star = 5 # 动态属性:客户评分,仅属于d1实例对象
13
---> 14 d2.star
AttributeError: 'dish' object has no attribute 'star'
# 动态属性仅属于当前实例对象,类也无此属性,新创建的实例对象无此属性
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)
d1.star = 5 # 动态属性:客户评分,仅属于d1实例对象
# 以类创建新的实例对象
d3 = dish(3, "皮蛋豆腐", 18.0)
d3.star # 新创建的对象没有star属性
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-13-a2911ace03c1> in <module>()
16 # 以类创建新的实例对象
17 d3 = dish(3, "皮蛋豆腐", 18.0)
---> 18 d3.star # 新创建的对象没有star属性
AttributeError: 'dish' object has no attribute 'star'
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()
![img](https://img-blog.csdnimg.cn/img_convert/61ca0fabb46d1456ec6a060587c85ecb.png)
![img](https://img-blog.csdnimg.cn/img_convert/e272eb0052308772757dff95639b6105.png)
![img](https://img-blog.csdnimg.cn/img_convert/98f828b79fb661e99ddbcb2ad0106084.png)
**既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上大数据知识点,真正体系化!**
**由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新**
**[需要这份系统化资料的朋友,可以戳这里获取](https://bbs.csdn.net/topics/618545628)**
er:
"""客人
"""
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()
[外链图片转存中...(img-2OZVaAKc-1714438168384)]
[外链图片转存中...(img-7yJlgLHW-1714438168384)]
[外链图片转存中...(img-TUBx0t2j-1714438168384)]
**既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上大数据知识点,真正体系化!**
**由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新**
**[需要这份系统化资料的朋友,可以戳这里获取](https://bbs.csdn.net/topics/618545628)**