【Python面向对象编程】

原创已于 2025-12-02 18:21:37 修改 · 914 阅读

14 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言

于 2025-10-29 18:21:15 首次发布

Python知识持续更新中！！！

一、面向对象基础

1、编程思想：

① 面向过程：遇到问题自己一步一步去分析然后解决问题.强调的过程和步骤
② 面向对象：遇到问题找到能解决这个问题的对象,让这个对象帮我们解决问题.强调的是对象.

2、面向对象的三大特征：

封装：把属性和方法封装在一起，仅提供对外的方法让别人去访问。好处：简化编程.
继承：子类可以继承父类的属性和方法,(孩子可使用老爹的东西)。好处：代码复用
多态：同样一个函数（消息）在不同场景下表现出不同形态。好处：解耦合，可拓展

3、类和对象：

类：对现实事物的抽象描述,我们看到任何的事物都可以认为归纳整理封装成为一个类.即类型.    (重点自己定义类)

定义类的语法为：

class 类名( [父类名] ):
方法(self)

# 定义汽车类
class Car():

    # todo 类中的函数自带self参数。
    def run(self):
        print("汽车正在奔跑")

对象：现实事物的具体体现, 看到某一辆汽车就是汽车类型的具体事物(对象).      (重点创建并使用对象)

实例化类的语法：

创建对象: 对象名 = 类名()

使用对象: 对象名.方法名()

# 创建对象格式： 对象名 = 类名()
c1 = Car() # 对类进行实例化 ---> 造出了对象
print(c1) # <__main__.Car object at 0x0000012FA1DB3830>
print(c1.run()) # 汽车正在奔跑
print(type(c1))# <class '__main__.Car'>

4、 self 关键字：

Self是python内置的关键字，用于指向对象实例本身.

class Car():

    def play_music(self):
        print('听着DJ更精神')

    # self参数是由调用者传递过来的.这里就是调用者c1本人.因此下面打印的地址和c1一样.
    def run(self):
        print(self) # <__main__.Car object at 0x0000026DF72636E0> 

if __name__ == '__main__':
    c1 = Car()
    print(c1) # <__main__.Car object at 0x0000026DF72636E0>
    c1.run()

5、类的外部设置属性：

属性:事物身上固有的特征,例如颜色,大小,重量,形状.一般使用变量表示.
语法:

添加属性 : 对象名.属性 = 属性值

获取属性: 对象名.属性

class Car:
    def run(self):
        print('汽车跑起来了。。。。')


if __name__ == '__main__':
    c1 = Car()
    c1.run()
    # 需求：对车进行改装。添加红色属性和4个车轮。
    # 类的外部添加属性
    c1.color = '红色'
    c1.number = 4

    # 获取属性: 验证属性是否添加到位
    print(f"汽车的颜色是：{c1.color}")
    print(f"汽车的轮胎个数是：{c1.number}")

6、魔法方法：

在这里插入图片描述

在python中，当新创建一个对象时，会自动触发__init__()方法，类似于构造函数。

# 定义类
class Car:
    # 初始化：无参数，类内部直接赋值
    def __init__(self):
        self.color = "Black"
        self.number = 3

    # 类内部访问   self.属性
    def show(self):
        # 对象名.属性  = self.属性
        print(f"车的颜色为:{self.color}")
        print(f"车的轮胎个数为:{self.number}")

car = Car()
# 类外面访问属性:  对象名.属性
print(f"类外面访问属性:{car.color}")
# 调用方法： 对象名.方法名()
car.show()

# 创建类
class Car:
    # 初始化：有参数，参数通过外部传递
    def __init__(self,color,number):
        self.color = color
        self.number = number

# 创建对象，并向__init__传递参数
car = Car("Red",4)
# 获取属性值
print(car.number)

在python中使用print打印对象时，默认输出的是对象地址，假如实现了__str__()方法，print就会自动调用该方法。

class Car:
    # 初始化：无参数，类内部直接赋值
    def __init__(self):
        self.color = "Black"
        self.number = 3

    # 类内部访问   self.属性
    def show(self):
        # 对象名.属性  = self.属性
        print(f"车的颜色为:{self.color}")
        print(f"车的轮胎个数为:{self.number}")

    def __str__(self):
        return f"颜色是{self.color}，轮胎数是{self.number}"

c1 = Car()
print(c1)

当删除函数时，python解释器会默认调用__del__()方法，类似析构函数

class Car:
    # 初始化：无参数，类内部直接赋值
    def __init__(self):
        self.color = "Black"
        self.number = 3

    # 类内部访问   self.属性
    def show(self):
        # 对象名.属性  = self.属性
        print(f"车的颜色为:{self.color}")
        print(f"车的轮胎个数为:{self.number}")

  
    def __del__(self):
        print(f"{self}已被删除")

c1 = Car()
c1.show()
del c1

定义类的三种语法：

1.class 类名：
2.class 类名():
3.class 类名(object):
推荐使用第三种

7、继承

生活中的继承：一般指的是子女继承父辈的财产。
面向对象代码中的“继承”：指子类继承父类的属性和方法
注意：继承指的是类的继承，而不是对象的继承

继承的语法：

class 父类名(object):
…(省略)
class 子类名(父类名):
…(省略)

在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

# 父类
class Father(object):
    def __init__(self):
        # 属性
        self.sex = "男"

    def walk(self): 
        # 行为: 方法
        print("喜欢散步行走...")

# 子类
class Son(Father):  # 从Father继承下来的
    pass

# 创建对象
son = Son()
print(son.sex)
son.walk()

继承：一个类从另一个已有的类获得其成员的相关特性，就叫作继承！ (站在子类角度)
派生：从一个已有的类产生一个新的类，称为派生！（站在父类角度）
父类：也叫作基类，就是指已有被继承的类！
子类：也叫作派生类或扩展类

7.1、单继承

单继承就是一个子类只能继承自一个父类，不能继承多个类。这个子类会有具有父类的属性和方法。代码如上。

7.2、多继承

多继承就是一个类同时继承多个父类，并且同时具有所有父类的属性和方法，注意：多继承在遇到同名的属性和方法时，优先继承第一父类的。
可以使用: 类名.__mro__或类名.mro()方法查看方法调用先后关系

class Math_Teacher(object):
    def calculate(self):
        print("计算")

    def jitang(self):
        print("数学学的好，将来赚的高")

class Music_Teacher(object):
    def sing(self):
        print("唱歌")

    def jitang(self):
        print("唱歌唱得好，将来活得老")

class Student(Math_Teacher, Music_Teacher): # 多继承
    pass

if __name__ == '__main__':
    xiaoming = Student()
    xiaoming.calculate()
    xiaoming.sing()
    xiaoming.jitang()
    print(Student.mro())    # [<class '__main__.Student'>, <class '__main__.Math_Teacher'>, <class '__main__.Music_Teacher'>, <class 'object'>]
    print(Student.__mro__)  # (<class '__main__.Student'>, <class '__main__.Math_Teacher'>, <class '__main__.Music_Teacher'>, <class 'object'>)

7.3、重写

重写也叫覆盖，就是当子类属性或方法与父类的属性或方法名字相同时，从父类继承下来的成员可以重新定义！子类重写父类的属性和方法, 优先会调用子类的属性和方法.

class Father(object):
    def life(self):
        print("生活技能")

    def yuehui(self):
        print("写情书")

class Son(Father):
    def yuehui(self):
        print("聊微信")

if __name__ == '__main__':
    my = Son()
    my.yuehui()

7.4、子类重写后调用父类的方法

子类中仍想要保留父类的行为，则需要在子类中调用父类方法.可以直接使用父类名来进行调用，使用的方法：

父类名.父类方法名(self)

使用super()调用父类方法，使用的方法：

super().父类方法名()

class Father(object):
    def __init__(self):
        print("-----父类初始化-----")

    def life(self):
        print("生活技能")

    def yuehui(self):
        print("写情书")

class Son(Father):
    def __init__(self):
        super().__init__()
        Father.__init__(self)

        print("-----子类初始化-----")

    def yuehui(self):
        print("聊微信")

    def laodeng_yuehui(self):

        super().yuehui()    # 适用于单继承情况 在对多继承中应用时 解释器会根据MRO来动态的循序执行父类该方法 避免遗漏

        # Father.yuehui(self)   # 适用于多继承情况 可以指定父类

if __name__ == '__main__':
    my = Son()
    my.yuehui()
    my.laodeng_yuehui()

7.5、多层继承

C继承了B, B继承了A这样结构的多层级继承关系，C同时拥有B和A的属性和方法。

8、私有属性和私有方法

在Python中，可以为属性和⽅法设置私有权限，即设置某个属性或⽅法不继承给⼦类。设置私有属性和方法的方式：在属性或方法名前面加上 “__”

# 私有属性
__属性名

# 私有方法
def __方法名():

使用规则：只能在类的内部使用，不能在类的外部使用；如果想在类的外部使用通过公共接口

class Father(object):
    def __init__(self):
        self.gender = '男'
        self.__money = 10000

    def life(self):
        print("生活技能：唱跳rap篮球")

    def __smoke(self):
        print("来根华子！")

    def private(self):
        self.__smoke()
        self.__money -= 60
        print(f"还剩{self.__money}")

    def set_money(self, money):
        self.__money += money       

    def get_money(self):
        return self.__money

class Son(Father):
    pass

if __name__ == '__main__':
    laowang = Father()
    laowang.private()
    xiaoming = Son()
    xiaoming.private()

    xiaoming.set_money(50)
    print(xiaoming.get_money())

9、多态

同样的函数，传入不同的对象，得到不同的状态

实现多态的三个条件：

有继承
函数重写
父类引用指向子类对象

好处：在不改变框架代码的情况下，通过多态语法轻松的实现模块和模块之间的解耦合；实现了软件系统的可拓展

class Animal(object):
    def speak(self):    # todo 没有方法体的方法叫做抽象方法
        pass

class Cat(Animal):
    def speak(self):
        print("Oi Oi Oi")

class Dog(Animal):
    def speak(self):
        print("开胃萝卜")

class Pig(Animal):
    def speak(self):
        print("吾乃天蓬元帅")

if __name__ == '__main__':
    cat = Cat()
    dog = Dog()
    pig = Pig()

抽象类（接口）设计：

父类制定接口标准，子类实现接口标准
含有抽象方法的类称之为抽象类
方法体是空实现的（pass）称之为抽象方法

10、类属性

类属性，指的就是类所拥有的属性，它被共享于整个类中
类属性可以通过：类名.类属性名 或者 对象名.类属性名获取

class Phone(object):
    brand = '华为'    # 类属性
    def __init__(self, price):
        self.price = price  # 对象属性

if __name__ == '__main__':
    p = Phone(2000)
    p2 = Phone(5000)
    print(p.brand)
    print(p.price)
    p.color = 'red'
    print(p.color)

    print("--------")
    print(Phone.brand)

11、类方法

所谓类方法，指的是类所拥有的方法，并需要使用装饰器@classmethod来标识其为类方法，同时一定要注意的是对于类方法的第一个参数必须是类对象，通常以cls作为第一个参数名。

语法格式：

@classmethod
def 类方法名(cls):
    ...

调用语法：

类名.类方法名 或者 对象名.类方法名

class Phone(object):

    @classmethod    # 装饰器
    def show(cls):  # cls表示类对象 在内存地址中 存在于类空间中
        print('我是类方法')

    def call(self):
        print("可以打电话")

if __name__ == '__main__':
    Phone.show()
    phone = Phone()
    phone.show()
    phone.call()

12、静态方法

静态方法需要通过装饰器@staticmethod来标识其为静态方法，且静态方法不需要多定义参数。

语法：

@staticmethod
def 静态方法名():
    ...

调用语法：
类名.静态方法名 # 推荐使用或者 对象名.静态方法名

class Phone(object):
    @staticmethod
    def show_info():
        # 这里想要调用其它类方法，只能使用类名调用。因为这里没有cls
        print("我是静态方法")

if __name__ == '__main__':
    Phone.show_info()
    p1 = Phone()
    p1.show_info()