【Python零基础快速入门系列 10】类的设计哲学：自然法则的具现(4)

最新推荐文章于 2024-06-17 21:44:46 发布

沉默的王二

最新推荐文章于 2024-06-17 21:44:46 发布

阅读量994

点赞数 18

分类专栏：程序员文章标签：大数据面试学习

本文链接：https://blog.csdn.net/2301_76379606/article/details/138686702

版权

程序员专栏收录该内容

184 篇文章 0 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

 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}元")
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](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)
> 
> 
> 


**《Python零基础快速入门系列》快速导航：**


* [Python快速入门系列(1) 人工智能序章：开发环境搭建Anaconda+VsCode+JupyterNotebook(零基础启动)](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)
* [Python快速入门系列(2)一文快速掌握Python基础语法](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)
* [Python快速入门系列(3)AI数据容器底层核心之Python列表](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)
* [Python快速入门系列(4)为什么内存中最多只有一个“Love“？一文读懂Python内存存储机制](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)
* [Python快速入门系列(5)Python只读数据容器：列表List的兄弟，元组tuple](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)
* [Python快速入门系列(6)字符串、列表、元组原来是一伙的？快看序列Sequence](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)
* [Python快速入门系列(7)成双成对之Python数据容器字典](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)
* [Python快速入门系列(8)无序、不重复、元素只读，Python数据容器之集合](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)
* [Python快速入门系列(9)高级程序员绝世心法——模块化之函数封装](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)



> 
> 写在末尾：
> 
> 


![img](https://img-blog.csdnimg.cn/img_convert/546712372511dbdd30b491634a527e63.png)
![img](https://img-blog.csdnimg.cn/img_convert/c922df82f742d4f1fac1c13e18d8d1dd.png)
![img](https://img-blog.csdnimg.cn/img_convert/ea4afb6d5cade7a29736c4ac55c72b57.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**

/4f45ff00ff254613a03fab5e56a57acb)
* [Python快速入门系列(8)无序、不重复、元素只读，Python数据容器之集合](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)
* [Python快速入门系列(9)高级程序员绝世心法——模块化之函数封装](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)



> 
> 写在末尾：
> 
> 


[外链图片转存中...(img-kYD7eKuI-1715356260670)]
[外链图片转存中...(img-6xTZ2qmK-1715356260670)]
[外链图片转存中...(img-XI2OZMYI-1715356260671)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**

沉默的王二

关注

18
点赞
踩
30

收藏

觉得还不错? 一键收藏
0
评论
【Python零基础快速入门系列 10】类的设计哲学：自然法则的具现(4)

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新需要这份系统化资料的朋友，可以戳这里获取—> 18 d3.star # 新创建的对象没有star属性AttributeError: ‘dish’ object has no attribute ‘star’动态属性仅属于当前实例对象，类也
复制链接

扫一扫