Python 面向对象编程（OOP）基础

已于 2024-10-20 21:07:13 修改
阅读量871 收藏 19
点赞数 13
分类专栏： python 文章标签： python 开发语言
于 2024-10-20 20:56:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxy2711352/article/details/143089828
版权

Python 面向对象编程（OOP）简介

Python 面向对象编程（OOP）是一种编程范式，强调将数据和操作数据的代码封装在一起。通过使用类和对象，OOP 提供了一种更自然和直观的方式来组织和管理代码。这里将介绍 OOP 的基本概念，包括定义类和对象、构造函数、类的方法与属性，以及继承与多态。

面向对象编程（OOP）基础内容

1. 定义类和对象

类

类是创建对象的蓝图或模板。它定义了对象的属性（数据）和方法（行为）。

对象

对象是类的实例。通过类可以创建多个对象，每个对象都有自己的属性值。

示例
class Dog:
    # 类定义
    class_attribute = "可爱的小狗子"  # 类属性

    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age

# 创建对象
my_dog = Dog("辣白菜", 5)
print(my_dog.name)  # 输出: 辣白菜

2. 构造函数（__init__）

构造函数是类的一个特殊方法，用于在创建对象时初始化属性。它的名称为 __init__，并且会在每次实例化对象时自动调用。

示例

class Car:
    def __init__(self, brand, color):
        self.brand = brand  # 实例属性
        self.color = color

my_car = Car("劳斯莱斯", "蓝黑")
print(my_car.brand)  # 输出: 劳斯莱斯

注意

  • self 是指向对象自身的引用，使我们可以访问对象的属性和方法。

3. 类的方法与属性

类的方法

类的方法是定义在类中的函数，用于实现特定的功能。它们通常会操作对象的属性。

示例
class Number:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def add(self):
        return self.a + self.b # 计算a+b的值

number = Number(5, 6)
print(number.add())  # 输出: 11

类的属性

类的属性是属于类本身的变量，所有实例共享。例如，可以定义一个类属性来表示所有狗的共同特性。

示例
class Dog:
    class_attribute = "可以四条腿走路"

# 访问类属性
print(Dog.class_attribute)  # 输出: 可以四条腿走路
类方法与实例方法的区别
特性类方法实例方法
绑定对象绑定到类绑定到实例
第一个参数cls（类本身）self（实例本身）
访问权限可以访问类属性可以访问实例属性
调用方式可以通过类名或实例调用只能通过实例调用
类属性和实例属性之间的区别.
特性类属性实例属性
定义位置类体内部（方法外部）在构造方法 __init__ 内部
作用域与类关联，所有实例共享与特定实例关联，每个实例独立
访问方式通过类名或实例访问通过实例访问
共享性所有实例共享同一值每个实例有自己的值
适用场景用于需要在多个实例之间共享的常量或状态用于需要跟踪特定实例的状态
修改影响修改类属性会影响所有实例修改实例属性只影响特定实例
建议使用当需要定义常量或类级别的状态时使用当需要为每个实例存储独立状态时使用

4. 继承与多态

继承

继承是 OOP 的一个重要特性，允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以重用父类的代码，并可以扩展或修改其功能。

示例
class Animal: # 父类, 这是个动物
    def speak(self):
        return "我是个动物"

class Dog(Animal):  # Dog 继承 Animal
    def speak(self):
        return "旺旺"

my_dog = Dog()
print(my_dog.speak())  # 输出: 旺旺

多态

多态是指同一种方法可以在不同的类中表现出不同的行为。通过父类引用调用子类的方法，可以实现灵活性。

示例
class Cat(Animal): # 猫继承动物
    def speak(self):
        return "喵~哦~"

def animal_sound(animal): # 直接调用父类定义的方法, 参数传入的实例来选择不同执行.
    print(animal.speak())
my_dog = Dog() # 狗子
animal_sound(my_dog)  # 输出: 旺旺
my_cat = Cat() # 猫咪
animal_sound(my_cat)  # 输出: 喵~哦~

二、继续深入面向对象编程（OOP）

在掌握了 OOP 的基础概念后，我们可以进一步探讨一些更高级的主题，包括类的封装、类的组合、运算符重载和抽象类。

5. 封装

封装是 OOP 的一个核心原则，旨在将数据（属性）和操作数据的代码（方法）包装在一起，并控制对数据的访问。通过封装，可以隐藏对象的内部状态，只暴露必要的接口，增强代码的安全性和灵活性。

示例：使用封装
class BankAccount:
    def __init__(self, balance=0):
        self.__balance = balance  # 私有属性，使用双下划线前缀
    # 存款, 余额增加
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
	# 取款, 余额减少
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
        else:
            print("取款失败：余额不足或金额不合法。")
    # 获取余额
    def get_balance(self):
        return self.__balance  # 提供公共方法访问私有属性

my_account = BankAccount()
my_account.deposit(200) # 存入 +200
my_account.withdraw(50) # 取出 -50
print(my_account.get_balance())  # 输出: 150

解释：

  • 使用 __balance 声明私有属性，外部无法直接访问, 硬访问会报错。
  • 通过公共方法（deposit, withdraw, get_balance）来操作和访问私有数据。

6. 类的组合

组合是另一种代码复用的方式，通过在一个类中包含其他类的对象来实现。这使得类的功能更加灵活。

示例：组合
class Engine: # 引擎
    def start(self):
        return "发动机启动"

class Car:
    def __init__(self):
        self.engine = Engine()  # Car 类包含 Engine 类的对象

    def start(self):
        return self.engine.start()  # 调用 Engine 的方法

my_car = Car()
print(my_car.start())  # 输出: 发动机启动

解释：

  • Car 类包含 Engine 类的实例，利用组合实现更复杂的功能。

7. 运算符重载

运算符重载允许我们定义如何对自定义对象使用常规运算符（如 +, -, * 等）。这使得自定义对象可以像内置类型一样自然地使用。

示例：运算符重载
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):  # 重载 + 运算符
        return Vector(self.x + other.x, self.y + other.y)

    def __repr__(self):  # 定义对象的字符串表示
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(4, 5)
result = v1 + v2  # 使用重载的 + 运算符
print(result)  # 输出: Vector(6, 8)

解释：

  • + (加法) 通过重载 __add__ 方法，我们可以定义 Vector 对象如何相加。
  • -（减法）：使用__sub__方法进行重载。比如实现两个自定义对象相减的操作。
  • *（乘法）：通过__mul__方法实现乘法运算符的重载。
  • /（除法）：定义__truediv__方法来重载除法运算符。
  • %（取模）：可使用__mod__方法。
  • **（幂运算）：借助__pow__方法。
  • +=、-=、*=、/=等复合赋值运算符可以通过相应的算术运算符重载方法与__iadd__、__isub__、__imul__、__itruediv__等方法结合实现。
  • [0]（索引操作）：使用__getitem__、__setitem__和__delitem__方法分别实现对象的索引取值、赋值和删除操作。
class MyClass:
       def __init__(self):
           self.data = [1, 2, 3]
       def __getitem__(self, index):
           return self.data[index]
       def __setitem__(self, index, value):
           self.data[index] = value
myclass=MyClass ()

print(myclass[0]) # 1
myclass[2] = 5
print(myclass[2]) # 5
  • ()（函数调用）：通过定义__call__方法，使得对象可以像函数一样被调用。
class Adder:
    def __init__(self, initial_value=0):
        self.value = initial_value

    def __call__(self, x):
        self.value += x
        return self.value

adder = Adder()
print(adder(5))  # 输出 5.
print(adder(3))  # 输出 8.

8. 抽象类与接口

抽象类是一种不能被实例化的类，通常用于定义接口和共通方法。子类必须实现这些方法，从而保证一定的接口一致性。

示例：抽象类
from abc import ABC, abstractmethod

class Animal(ABC):  # 抽象类
    @abstractmethod # 抽象方法
    def speak(self):
        pass  # 抽象方法，没有实现

class Dog(Animal):
    def speak(self):
        return "旺~旺~"

class Cat(Animal):
    def speak(self):
        return "喵~呜~"

# animal = Animal()  # 不能实例化抽象类
my_dog = Dog()
my_cat = Cat()
print(my_dog.speak())  # 输出: 旺~旺~
print(my_cat.speak())  # 输出: 喵~呜~

解释：

  • Animal 是一个抽象类，定义了一个抽象方法 speak，强制所有子类实现该方法。
调用父类的方法

使用spuer()

   class Parent:
       def method(self):
           print("父")

   class Child(Parent):
       def method(self):
           super().method() # 调用父类方法
           print("子")

   c = Child()
   c.method() # 输出: 父
              #      子

三、继续深入面向对象编程（OOP）的实用技巧与模式

在进一步了解 OOP 的高级概念后，我们可以探索一些实用的设计模式、属性装饰器、类的静态方法和类方法等。

10. 常用设计模式

设计模式是解决特定问题的最佳实践，能够提升代码的可复用性和可维护性。以下是几种常用的设计模式。

10.1 单例模式

单例模式确保一个类只有一个实例，并提供全局访问点。

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# 测试单例
s1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # 输出: True

解释：

  • __new__ 方法用于控制对象的实例化，确保每次调用返回同一个实例。
  • super(Singleton, cls).__new__(cls)调用了父类（在这里是object，因为如果没有显式指定父类，Python 中的类默认继承自object）的__new__方法来创建一个新的实例。如果cls._instance为None，就创建一个新实例并将其赋值给_instance；如果已经存在实例，就直接返回这个实例，从而保证了单例模式。
10.2 工厂模式

工厂模式用于创建对象的接口，允许子类决定实例化哪一个类。

class Shape: # 形状
    def draw(self):
        pass

class Circle(Shape): # 圆
    def draw(self):
        return "画出一个圆形"

class Square(Shape): # 方形
    def draw(self):
        return "画出一个方形"

class ShapeFactory: # 形状工厂
    @staticmethod # 静态方法, ShapeFactory.get_shape(...)
    def get_shape(shape_type):
        if shape_type == "圆形":
            return Circle()
        elif shape_type == "方形":
            return Square()
        return None

# 使用工厂模式
shape = ShapeFactory.get_shape("圆形")
print(shape.draw())  # 输出: 画出一个圆形

11. 属性装饰器

属性装饰器允许你定义 getter 和 setter 方法，从而在访问或修改属性时执行额外逻辑。

示例：使用 @property 和 @setter
class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property # 只读属性, print(实例.celsius)
    def celsius(self):
        return self._celsius

    @celsius.setter # 可修改属性: 实例.celsius=10
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("温度不能低于绝对零度")
        self._celsius = value

temp = Temperature(25)
print(temp.celsius)  # 输出: 25
temp.celsius = 30    # 设置新温度
print(temp.celsius)  # 输出: 30
# temp.celsius = -300  # 触发异常

解释：

  • @property 用于定义只读属性，@setter 用于定义可以修改的属性。

12. 静态方法和类方法

静态方法和类方法是与类关联的方法，但不需要实例化对象。

12.1 静态方法

静态方法不需要访问实例或类属性，可以直接通过类调用。

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

print(MathUtils.add(3, 5))  # 输出: 8
12.2 类方法

类方法接收类作为参数，可以访问类属性和其他类方法。

class MyClass:
    count = 0

    @classmethod
    def increment_count(cls):
        cls.count += 1

MyClass.increment_count()
print(MyClass.count)  # 输出: 1

解释：

  • 静态方法不涉及类或实例，类方法可以访问和修改类属性。

13. 反射与动态属性

Python 允许动态添加属性和方法，可以使用 setattr、getattr 和 hasattr 函数进行反射操作。

示例：动态属性
class Person:
    def __init__(self, name):
        self.name = name

person = Person("张三")
setattr(person, "age", 30)  # 动态添加属性
print(person.age)  # 输出: 30

# 反射检查属性, 是否存在属性
if hasattr(person, "name"):
    print(getattr(person, "name"))  # 输出: 张三

解释：

  • 使用反射可以在运行时动态修改对象的属性和方法，增加灵活性。
  • getattr(object, name[, default])：用于获取对象的属性值。参数 object 是要获取属性的对象，name 是属性名，如果属性不存在且提供了 default 参数，则返回 default，否则会抛出 AttributeError 异常。
  • setattr(object, name, value)：用于设置对象的属性值。参数含义与 getattr 类似，将对象 object 的属性 name 的值设置为 value。
  • hasattr(object, name)：用于判断对象是否具有某个属性。返回 True 如果对象有指定的属性，否则返回 False。
  • callable(object)：用于判断对象是否可调用（例如函数、方法等）。如果对象可调用，则返回 True，否则返回 False。
   def my_function():
       return "Hello, World!"

   print(callable(my_function))  # 输出 True

** 应用场景 **

  • 动态加载模块和对象：根据用户输入或配置文件动态地加载不同的模块和对象，以实现灵活的程序架构。
    假设有模块: hello_module.py
class MyClass:
    def __init__(self) : 
        self.a = 10
        print("Myclass create")
        pass

    def __str__(self):
       return "Myclass instace"

动态加载代码: app.py

module_name = "hello_module"
try:
    module = __import__(module_name) # 模块
    cls = getattr(module, "MyClass") # 获得模块中的类
    obj = cls() # 创建实例
    print(obj) # 
    print(dir(obj)) # 获得属性名、方法名们
except ImportError:
    print(f"Module {module_name} not found.")
  • 功能插件: 允许第三方开发者通过定义特定的接口来扩展程序的功能，而不需要修改程序的核心代码.
  • 自动化测试：通过反射可以动态地调用被测试对象的方法和属性，进行自动化测试。

总结

每日一记、开心一天.

python面向对象
09-13
python面向对象精彩讲解视频，详细讲解了python在面向对象中的用途。
面向对象与面向过程
zhangxuelong461的博客
08-29 324
面向过程 VS 面向对象 面向过程： 面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。 优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。 缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。 应用场景：一旦完成基本很少改变的场景，著名的例子有Linu...
Python入门（6）：面向对象编程（OOP）
最新发布
赶紧的博客
04-02 1424
Python面向对象编程以类和对象为核心，通过封装隐藏实现细节，继承实现代码复用，多态支持统一接口不同行为。类包含属性（数据）和方法（操作），__init__方法初始化对象。类方法（@classmethod）操作类级数据，静态方法（@staticmethod）作为工具函数。属性装饰器（@property）控制属性访问，添加验证逻辑。魔术方法（如__str__、__add__）重载运算符或内置行为。OOP提升代码模块化、可维护性，适合复杂系统设计，遵循SOLID原则可构建高扩展性架构。
面向对象编程
jie的博客
09-16 493
面向对象编程类和实例访问限制继承和多态获取对象信息实例属性和类属性 面向对象的程序设计：把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。 面向过程的程序设计：把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。 在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的
python-面向对象
qq_64395810的博客
05-18 436
将生活中的实物 创建一个类并实例化类 就叫封装 （概念）创建类 + 实例化 = 封装1.面向对象的私有方法私有方法：定义一个函数 在函数名前面加上 __函数名私有方法作用：只能在函数内使用应用场景： 后面的案例会讲到2.面向对象的公有方法公有方法：在任意地方 都可以被使用3.如何区别公有方法和私有方法看函数名前是否加了__。加了就是私有 没加就是公有1.什么是继承？从字面上来讲：儿子继承父亲的基因和财产 子承父业在我们类中什么叫继承？：子类继承父类的成员属性 和 成员方法。
基于Python面向对象编程(OOP)构建简单图书管理系统的实例代码
01-05
内容概要：本文档提供了使用Python语言并采用面向对象编程（OOP）思想构建的一个基础图书管理系统的源码示例。主要涵盖四大基本操作——添加书籍、展示库存列表、搜索特定条目以及移除记录。每项功能都封装在一个...
面向对象编程基础_python面向对象_python教程_
09-29
以上就是Python面向对象编程的基本概念和特性。掌握这些基础知识，能帮助你更好地理解和编写Python程序，尤其在处理复杂逻辑和大型项目时，面向对象编程的优势会更加明显。在实际应用中，不断实践和探索，才能真正...
Python基础课程-面向对象编程.pdf
06-12
面向对象编程（OOP）是Python编程中的一个核心概念，它允许程序员以更接近现实世界的方式组织和构建代码。在OOP中，我们通过创建类（Class）来定义对象（Object），类是对象的模板，它包含了对象可能具有的属性...
Python基础：面向对象编程（OOP）
Snailandfish的专栏
11-20 873
与函数定义 (def 语句) 一样，类定义必须先执行才能生效。把类定义放在 if 语句的分支里或函数内部试试。在实践中，类定义内的语句通常都是函数定义，但也可以是其他语句。类里的函数定义一般是特殊的参数列表，这是由方法调用的约定规范所指明的当进入类定义时，将创建一个新的命名空间，并将其用作局部作用域 — 因此，所有对局部变量的赋值都是在这个新命名空间之内。特别的，函数定义会绑定到这里的新函数名称。
Python面向对象编程基础与应用-图书管理系统实战案例
12-27
内容概要：本文深入讲解了Python面向对象编程的基础知识及其在实际项目中的应用。文章先从类和对象的概念出发，解释了面向对象编程（OOP）的特点如封装、继承、多态等核心概念，并提供了详尽的例子进行展示。随后，...
Python面向对象
Amo Xiang的博客
12-24 3085
Python面向对象1. 面向对象基础语法2. 初始化方法__init__3. 属性查找与绑定方法4. 跑步案例5. 家具案例6. 私有属性7. 继承7.1 面向对象的三大特性7.2 单继承7.2.1 继承的概念7.2.2 继承的语法7.2.3 方法的重写 1. 面向对象基础语法 # -*- coding: utf-8 -*- # @Time : 2019/12/9 14:33 # @Aut...
Python面向对象编程基础详解
"Python面向对象编程基础解析" 在Python编程中，面向对象编程（Object-Oriented Programming，简称OOP）是一种强大的设计模式，它通过模拟现实世界中的对象和概念来组织代码，使得程序更加模块化、可维护和易于扩展...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值