AI导航网
微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

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

分类：大数据作者：i机器未来原文地址

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

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

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

1. 概述

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

2. 面向对象的概念

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

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

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

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

面向对象的业务逻辑

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

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

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

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

2. 类和对象

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

class Person:
    pass

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

@H_502_28@2225665760280 2225665760224

3. 类的定义

@H_502_28@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.开始的属性是对象的属性，其它属性为类的属性，所有对象共有
@H_502_28@
class menu:
    desc = "自定义类"           # 类的属性，所有对象共有

    def __init__(self,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)

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

3.2.2 类属性

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

class dish:
    desc = "菜品销售信息"

    def __init__(self, 89.9)

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

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

@H_502_28@菜品销售信息
菜品销售信息
菜品销售信息

3.2.3 动态属性-实例属性

python支持类在创建实例对象动态扩展属性，该属性仅属于该对象，不属于类，其它对象也不存在

# 动态属性仅属于当前实例对象，其它实例对象无该属性

class dish:
    desc = "菜品销售信息"

    def __init__(self, 89.9)

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

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


@H_502_28@---------------------------------------------------------------------------

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, 89.9)

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

# 以类创建新的实例对象
d3 = dish(3, "皮蛋豆腐", 18.0)
d3.star         # 新创建的对象没有star属性


@H_502_28@---------------------------------------------------------------------------

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, 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}")

@H_502_28@d1:秦王阁
d3:秦王阁
d1:秦王阁总店,d3:秦王阁总店

3.2.5 私有属性

在实际开发中，对象的某些属性或方法可能只希望在对象内部使用，而不希望在外部被访问到，将没有必要展示的属性隐藏到类的内部

私有属性就是对象不希望公开的属性

定义方法：双下划线+变量名

@H_502_28@__[var_name]

如下代码中的@H_502_28@__freshness就是私有属性，在类的外部无法访问该属性。python的实现原理是将属性改名以实现隐藏的目的,在下面的例程中@H_502_28@__freshness被重命名为@H_502_28@_dish__freshness。

# 动态属性仅属于当前实例对象，类也无此属性，新创建的实例对象无此属性

class dish:
    desc = "菜品销售信息"

    def __init__(self, price):
        self.id = id            # 实例属性
        self.name = name        # 实例属性     
        self.price = price      # 实例属性
        self.__freshness = 0    # 私有属性
    
d1 = dish(1, 89.9)

d1.__freshness

@H_502_28@---------------------------------------------------------------------------

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)

@H_502_28@['__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, 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, 89.9)

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

for dish_item in menu:  # 类的自定义方法
    # 实例方法的调用
    dish_item.display_dish()

@H_502_28@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, 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, 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)

@H_502[email protected]: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, 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, 89.9)

# 实例对象访问
print(dir(d1))     # 

d1.____update_price(39.2)

@H_502_28@['__class__','_dish__update_price','display_dish','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, 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, 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()

@H_502_28@张三喜欢吃东西
李四喜欢吃米饭,尤其喜欢黄焖鸡米饭
李四正在睡觉
王五喜欢吃面食
王五正在睡觉

上面的例子展现了以下知识点：

@H_502_28@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)}元")


@H_502_28@1,青椒肉丝,22
2,皮蛋豆腐,16
3,新疆大盘鸡,89
4,虎皮青椒,22
客人C1消费了38元
客人C2消费了105元

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

class dish:
    """
    菜品
    """
    def __init__(self, price):
        self.id = id
        self.name = name
        self.price = price

class Restaurant:
    """
    菜单
    """
    def __init__(self):
        self.menu = []
        self.ordered_menu = {}
    
    def add(self, price):
        """添加新菜品
        """
        self.menu.append(dish(id, 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}元")

@H_502_28@1	青椒肉丝		22
2	皮蛋豆腐		16
3	新疆大盘鸡		89
4	虎皮青椒		22
客人c1消费了38元
客人c2消费了105元

福利：新增线上运行环境支持，可以直接运行博文中的代码，无需自行部署环境
线上环境地址：https://aistudio.baidu.com/aistudio/projectdetail/4197645?_=1654794787976&shared=1

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

写在末尾：

  • 博客简介：专注AIoT领域，追逐未来时代的脉搏，记录路途中的技术成长！
  • 专栏简介：本专栏的核心就是：快！快！快！2周快速拿下Python，具备项目开发能力，为机器学习和深度学习做准备。
  • 面向人群：零基础编程爱好者
  • 专栏计划：接下来会逐步发布跨入人工智能的系列博文，敬请期待

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 [email protected] 举报，一经查实，本站将立刻删除。

相关推荐

大数据分析案例-基于随机森林模型对北京房价进行预测
自1998年我国取消了福利分房的政策后，房地产市场迅速开展蓬勃起来。同时，随着社会经济的快速开展，居民的经济条件越来越好，住房条件也在不断地提升。而住房是人民根本生活的保障，也是-一个家庭最重要的资产,从一...
机器学习实战——房价预测完整案例建议收藏慢慢品
文章目录获取数据查看数据结构获取数据下载数据可以直接通过浏览器下载压缩包，也可以通过函数来进行。import osimport tarfileimport urllib.requestDOWNLOAD_ROOT = "https://raw.githubusercontent.com/ager...
网上商城系统MySql数据库设计项目实战
网上商城系统MySql数据库设计
常见气象数据获取方式及批量下载代码汇总
26个来源的气象数据获取代码
毕业设计 基于大数据的共享单车数据分析与可视化
大数据分析案例-对电信客户流失分析预警预测
在进入21世纪以来，中国电信业告别了20世纪最后阶段的高速发展状态，转而进入稳步发展阶段。近年来，随着通信的成本逐年下降，电信市场用户覆盖率近乎100%，几乎没有可开发的新市场，移动、联通、电信三大电信企业完...
卡尔曼滤波
目录1.卡尔曼滤波入门2.学卡尔曼滤波的必备知识2.1.状态空间表达式2.2.高斯分布2.3.方差2.4.超参数2.5.卡尔曼直观图解3.卡尔曼滤波3.1.卡尔曼公式理解3.2.调节超参数3.2.1.Q和R的取值3.2.2.P0和X0的取值3.2.3.卡尔曼...
Python大数据-电商产品评论情感数据分析
一、项目背景网上购物已经成为大众生活的重要组成部分。人们在电商平台上浏览商品并购物，产生了海量的用户行为数据，用户对商品的评论数据对商家具有重要的意义。利用好这些碎片化、非结构化的数据，将有利于企业在...
大数据项目之电商数仓、Maxwell使用、 Maxwell启停脚本、增量数据同步、历史数据全量同步、采集通道Maxwell配置、通道测试
但有时只有增量数据是不够的，我们可能需要使用到MySQL数据库中从历史至今的一个完整的数据集。这就需要我们在进行增量同步之前，先进行一次历史数据的全量同步。这样就能保证得到一个完整的数据集。1）第一条type为...
[Hive]一篇带你读懂Hive是什么
✅作者简介：大家好,我是Philosophy7？让我们一起共同进步吧！
    pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native