这是机器未来的第14篇原创文章

原文首发链接：https://blog.csdn.net/RobotFutures/article/details/125213936

!!!重磅福利，博文中代码可直接线上运行，无需部署环境，线上运行地址详见文章末尾!!!

1. 概述

类在函数的基础上进一步提升了模块化封装程度，类的继承和多态特性，抽象了子类公共的部分，又保留了子类的多样性。

2. 面向对象的概念

面向过程编程：面向过程是一种以事件为中心的编程思想，编程的时候把解决问题的步骤分析出来，然后用函数把这些步骤实现，在一步一步的具体步骤中再按顺序调用函数。

# 顺序结构
吃饭：
建立菜谱 
展示菜谱
客人C1点了青椒肉丝、皮蛋豆腐 
客人C2点了皮蛋豆腐、新疆大盘鸡
客人C1结账 
客人C2结账

面向对象编程：面向对象是一种以“对象”为中心的编程思想，把要解决的问题分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个对象在整个解决问题的步骤中的属性和行为。

以吃饭为例。
吃饭的参与方有餐馆、食客。按照对象的特征和行为进行划分，如下：

菜品
- 属性
  - 菜品ID
  - 菜品名称
  - 菜品单价
餐馆
- 属性
  - 菜单
  - 订单列表
- 方法
  - 构建菜谱
  - 展示菜谱
  - 结算餐费
食客
- 属性
  - 订单号
  - 账单金额
- 方法
  - 点餐
  - 结账

面向对象的业务逻辑

新建餐馆对象
餐馆对象.建立菜谱
餐馆对象.展示菜谱
新建客人c1
新建客人c2
客人c1.点餐青椒肉丝、皮蛋豆腐
客人c2.点餐皮蛋豆腐、新疆大盘鸡
餐馆对象.结算餐费(客人c1.结账)
餐馆对象.结算餐费(客人c2.结账)

业务逻辑和顺序结构类似，但是业务逻辑都分配到各个对象，封装性更强了。

面向对象编程可以核心思想为在面向过程编程的基础上将业务逻辑又抽象了一层，以业务逻辑的参与方进行划分，然后将参与方的特征和行为封装在一起。最终也会调用对象的属性和方法按照步骤实现业务需求。

面向过程编程适用于简单的应用场景，面向对象编程适用于复杂的业务场景
面向对象编程更加适应复杂的需求变化，因为对象相关的代码都封装在一起，在需求变更时也更容易快速迭代；而面向过程编程相关代码都分散在不同的位置，维护迭代时相对困难。

2. 类和对象

类是分类，是模板，对象是基于类创建的一个具体的实例。
例如人是一个类，人有五官、四肢、有智慧，会吃饭、睡觉、学习，张三是具体一个人，他有人这一个分类的所有特征和行为。

class Person:
    pass

# p1和p2是基于同一个类创建的两个不同的实例
p1 = Person()   
p2 = Person()
# 变量的地址是不一样的，指向2个不同的对象
print(id(p1), id(p2))

2225665760280 2225665760224

3. 类的定义

定义类的关键字为class
class后跟的是类名
类名后小括号中的是父类，这是类的继承特性，可以继承父类的属性和方法，不继承时可不添加小括号
类中可定义对象的属性、类的属性、自定义方法、对象私有属性等

class [class_name](Object):
    desc = "自定义类"           # 类的属性，所有对象共有

    def __init__(self, arg1, arg2, name):
        self.arg1 = arg1        # 对象的属性
        self.arg2 = arg2
        self.__name = name      # 对象的私有属性

    # 自定义方法
    def user_defined_func(self, ...):
        pass

3.1 特殊方法：init函数

类的初始化函数，创建对象的时候就会被执行
必须存在，函数名不可更改，双下划线开始双下划线结束；
所有类方法的第一个参数必定为self；
目的是挂载类的属性，self.开始的属性是对象的属性，其它属性为类的属性，所有对象共有


class menu:
    desc = "自定义类"           # 类的属性，所有对象共有

    def __init__(self, arg1, arg2): # 初始化方法，创建对象时调用
        self.arg1 = arg1        # 对象的属性
        self.arg2 = arg2

    # 自定义方法
    def user_defined_func():
        pass

3.2 属性

3.2.1 实例属性

使用self定义的属性都是实例属性。

class dish:
    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)

menu = []
menu.append(d1)
menu.append(d2)

for dish_item in menu:
    print(dish_item.id, dish_item.name, dish_item.price)

1 青椒肉丝 22.9
2 新疆大盘鸡 89.9

3.2.2 类属性

在类中定义的非self属性属于类的属性，它属于类，类创建的所有实例对象都拥有这个属性，且值一样

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)

menu = []
menu.append(d1)
menu.append(d2)

print(dish.desc)        # 类调用类属性
print(d1.desc)          # 对象d1调用类属性
print(d2.desc)          # 对象d2调用类属性

菜品销售信息
菜品销售信息
菜品销售信息

3.2.3 动态属性-实例属性

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)

d1.star = 5     # 动态属性：客户评分，仅属于d1实例对象

d2.star         # 之前创建的实例对象无star属性

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

 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}tt{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:     #  不为空，说明订单已经产生

网络知识

【Python零基础入门笔记 | 10】类的设计哲学：自然法则的具现

1. 概述

2. 面向对象的概念

2. 类和对象

3. 类的定义

3.1 特殊方法：init函数

3.2 属性

3.2.1 实例属性

3.2.2 类属性

3.2.3 动态属性-实例属性

3.2.4 动态属性-类属性

3.2.5 私有属性

3.3 方法

3.3.1 实例方法

3.3.1 动态实例方法

3.3.2 私有方法

4. 类的继承和多态

5. 附录

5.1 面向过程的吃饭例子实现

5.2 面向对象的吃饭例子实现

1. 概述

2. 面向对象的概念

2. 类和对象

3. 类的定义

3.1 特殊方法：__init__函数

3.2 属性

3.2.1 实例属性

3.2.2 类属性

3.2.3 动态属性-实例属性

3.2.4 动态属性-类属性

3.2.5 私有属性

3.3 方法

3.3.1 实例方法

3.3.1 动态实例方法

3.3.2 私有方法

4. 类的继承和多态

5. 附录

5.1 面向过程的吃饭例子实现

5.2 面向对象的吃饭例子实现

相关文章

央媒谈“文盲演员”引发饭圈甩锅大战

野生大熊猫深夜遛达 镜头前呆萌打卡

张萌谈演员到底需不需要有文化

情人节多地迎领证高峰

婚房烂尾10年业主住进毛坯房

多地首套房贷利率降至4%以下 为什么急于提前还贷

3.1 特殊方法：init函数

野生大熊猫深夜遛达镜头前呆萌打卡

多地首套房贷利率降至4%以下为什么急于提前还贷