基于Python语言 面向对象编程：类与对象 [持续更新蓄力中... ...求关注~]

本文章主要是自己平时的一些积累，不适合纯纯小白哈，稍微有点基础的可以看看，有错请指正，时间比较久了，可能我也忘记了，欢迎大家一起来讨论还是希望大家点个赞，收个藏，关个注，拜托拜托~~~人生需要鼓励和被鼓励，嘿嘿

文章主要涉及到类与对象中的比较重要的几点：面向对象编程的最显著的几个特征：封装、继承、和多态，魔法方法、函数、重写、钻石继承等......

主要是举了一些例子来展示，这个需要一定基础。本文有些代码是Python交互模式完成的，因为当时还不会使用pycharm，惭愧惭愧~，所以大家实践的时候注意下！

目录

一、 python既是面向过程编程，又是面向对象编程（封装、继承、多重继承）

01.定义一个点类（封装）

02.创建一个矩形类

03.银行账户类（定义私有属性，方法）

04.学生信息管理（init表示构造函数）

05.车辆管理系统（基类、派生类，即子类父类[super().init(self,year,model)函数，继承父类的变量]）继承***

06.组合（self是实例化对象本身）

07.绑定（dict进行内省）

二、构造函数、重写、钻石继承

01.构造函数

02.重写（直接通过类名访问类里面的方法的做法称之为调用未绑定的父类方法）

03.钻石继承（调用super函数来解决）

01. 解决方法：super（）函数（避免重复调用）

02. surper()函数依靠于MRO(Method Resolution Order)来运行:方法解析顺序 C.mro()或者C.mro

三、类与对象案例分析（继承类的顺序为从左至右的顺序来继承）

01.Mixin案例

02.案例分析

四、多态和鸭子类型（鸭子类型（它的行为是否合乎规矩））

例01 多态（不同场景不同表现形式）

例02 自定义函数如何实现多态接口，接收不同的对象作为参数，并且不检查其类型的情况下执行它的方法

五、私有变量和slots

例01 私有变量（名字改编是发生在类实例化对象的时候）

例02 单个下横线开头的变量 单个下横线结尾的变量分别代表什么

例03 效率提升

python由于灵活性有时候会抛弃很多内存空间

slots(副作用，没有动态添加属性的能力) 注：继承自父类的slots属性是不会在子类中生效的

六、魔法方法

例01 改变不可变对象

例02 del方法（垃圾回收机制，只有当对象没有任何引用的时候才会被执行）

总结：虽然__del__方法在这个类中被定义了，但你不能直接控制它何时被调用。它的调用是由Python的垃圾回收机制管理的，并且这个机制通常是在需要回收内存时才会运行的。

例03 对象重生

七、运算相关的魔法方法

例01 重写add方法 注意(self,other)

例02 radd ()方法调用前提

例03 将一个对象转换成整数类型

例04 & | ~ ^(异或) << >>

八、 index魔法方法 ，与属性相关的函数和魔法方法

例01 当对象作为索引值被调用的时候才会被调用

例02 属性访问(与属性相关的函数和魔法方法)

例03 getattr

例04 setattr

九、索引、切片、迭代协议

例01 切片

例02 迭代协议

---

一、 python既是面向过程编程，又是面向对象编程（封装、继承、多重继承）

01.定义一个点类（封装）

# 定义一个点类
import math
​
class Point():
    #__init__对x,y进行初始化
        def __init__(self,x = 0,y = 0):
            self.__x = x
            self.__y = y
        def move(self,dx,dy):
            self.__x += dx
            self.__y += dy
​
        def distance_to_origin(self):
            return math.sqrt(self.__x**2 + self.__y**2)
p = Point(3,4)
print(p.distance_to_origin())

02.创建一个矩形类

# 创建一个矩形类
题目描述：
创建一个名为 Rectangle 的类，用来描述矩形，包括:
​
私有属性 width 和 height（矩形的宽和高）。
初始化方法，设置 width 和 height 的初始值。
方法 area()，返回矩形的面积。
方法 perimeter()，返回矩形的周长。
​
​
# 3.创建一个矩形类:计算面积和周长的方法
class Rectangle:
    #进行初始化
    def __init__(self,width,height):           #__init__:表示构造函数
        self.width = width
        self.height = height
    def area(self):
        return self.width * self.height
​
    def perimeter(self):
        return (self.width + self.height)*2
# 调用
r = Rectangle(4,5)
print(r.area())
print(r.perimeter())
'''

03.银行账户类（定义私有属性，方法）

 # 银行账户类
题目描述：
设计一个名为 BankAccount 的类，用来模拟银行账户，包括:
私有属性 balance（账户余额）。
初始化方法，接收一个初始存款额度。
方法 deposit(amount)，存款。
方法 withdraw(amount)，取款，如果账户余额不足，打印警告。
'''
'''
class BankAccount:
    # 使用双下划线来表示私有属性
    def __init__(self,balance = 0):
        self.__balance = balance
    def deposit(self,amount):
        self.__balance += amount
    def withdraw(self,amount):
        if amount > self.__balance:
            print('余额不足')
        else:
            self.__balance -= amount
    def get_balance(self):
        return self.__balance
# 调用
BK = BankAccount(1000)
BK.deposit(500)
BK.withdraw(600)
print(BK.get_balance())
BK.withdraw(1000)
'''

04.学生信息管理（init表示构造函数）

'''
'''
练习题4: 学生信息管理
题目描述：
编写一个名为 Student 的类，用以存储一个学生的信息，包括:
​
私有属性 name 和 scores（学生名字和成绩列表）。
初始化方法，设置学生的名字和成绩。
方法 add_score(score)，添加一个新的成绩到列表中。
方法 average()，返回学生的平均成绩。
'''
'''
​
class Student:
    def __init__(self,name,scores = None):
        if scores is None:
            scores = []
        self.__name = name
        self.__scores = scores
    def add_score(self,score):
        self.__scores.append(score)
    def average(self):
        if self.__scores:
            return sum(self.__scores) / len(self.__scores)
        return 0
# 调用
Stu = Student('张三')
Stu.add_score(95)
Stu.add_score(88)
Stu.add_score(95)
print(Stu.average())
'''

05.车辆管理系统（基类、派生类，即子类父类[super().init(self,year,model)函数，继承父类的变量]）继承***

# 车辆管理系统
题目描述：
实现一个名为 Vehicle 的基类，以及两个派生类 Car 和 Truck，其中:
​
Vehicle 类包含属性 year（年份）, make（制造商）和 model（型号），所有属性为私有。
Vehicle 类还包含方法 description()，返回一个包含年份、制造商和型号的字符串。
Car 类增加属性 doors（车门数），覆盖 description() 方法以包括门数。
Truck 类增加属性 bed_length（车厢长度），覆盖 description() 方法以包含车厢长度。
'''
'''
class Vehicle:
    def __init__(self,year,make,model):
        self.__year = year
        self.__make = make
        self.__model = model
    def description(self):
        str = f'年份为：{self.__year},制造商是：{self.__make},型号是：{self.__model}'
        return str
class Car(Vehicle):
    def __init__(self,year,make,model,doors):
        super().__init__(self,year,model)
        self.doors = doors
    def description(self):
        str = f'年份为：{self.__year},制造商是：{self.__make},型号是：{self.__model},门数是{self.doors}'
        return str
class Truck(Vehicle):
    def __init__(self, year, make, model, bed_length):
        super().__init__(self, year, model)
        self.bed_length = bed_length
    def description(self):
        return f'年份为：{self.__year},制造商是：{self.__make},型号是：{self.__model},车厢长度是{self.bed_length}'
​
car = Car(2019, "Toyota", "Camry", 4)
truck = Truck(2020, "Ford", "F150", "5.5 ft")
print(car.description())  # 输出: 2019 Toyota Camry with 4 doors
print(truck.description())  # 输出: 2020 Ford F150 with a bed length of 5.5 ft

06.组合（self是实例化对象本身）

# 组合
class Turtle:
    def say(self):
        print('不积跬步无以至千里！')
class Cat:
    def say(self):
        print('喵喵喵~')
class Dog:
    def say(self):
        print('呦呵，我是一只修狗~')
# 现在我们想把小狗和小猫放在一个花园里面，很明显两者之间并不是继承关系，这时候我们就用到了组合
class Garden:
    t = Turtle()
    c = Cat()
    d = Dog()
    def say(self):
        self.t.say()
        self.d.say()
        self.c.say()
g = Garden()
g.say()
​

运行结果：
不积跬步无以至千里！
呦呵，我是一只修狗~
喵喵喵~

07.绑定（dict进行内省）

# 定义一个空类（可以当做字典来存储数据）
class C :
    pass
C.x = 250
C.y = "小甲鱼"
C.z = [1,2,3]
print(C.x)
print(C.y)
print(C.z)
​
# 生成实例对象的方法
class C:
    pass
c = C()
c.x = 250
c.z = [1,2,3]
c.y = "小甲鱼"
​
c.y = 660
print(c.__dict__)
​
class C:
    def set_x(self,v):
        self.x = v
c = C()
print(c.__dict__)       #{}
c.set_x(250)
print(c.__dict__)       #{'x': 250}
print(c.x)              #250
​
​
class C:
    x = 100
    def set_x(self,v):
        x = v
c = C()
c.set_x(250)
print(c.x)          #100
print(C.x)          #100
C.x = 250
print(c.x)          #250
c.__dict__          #{}

二、构造函数、重写、钻石继承

01.构造函数

class C:
    def __init__(self,x ,y):
        self.x = x              #等号左边是绑定到实例化对象里面的x属性，等号右边的x是传进来的参数
        self.y = y
    def add(self):
        return self.y+self.x
    def mul(self):
        return self.y*self.x
c = C(2,3)
print(c.mul())
print(c.add())
# 内省
print(c.__dict__)           #{'x': 2, 'y': 3}