网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
in ()
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)
in ()
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)
in ()
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)
in ()
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)
in ()
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}元")
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
蛋豆腐
客人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}元")
[外链图片转存中…(img-dZPMGPRl-1715703554224)]
[外链图片转存中…(img-aIcWmAgg-1715703554224)]
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!