Python 面向对象编程

最新推荐文章于 2025-03-22 05:08:39 发布

qwe352633

最新推荐文章于 2025-03-22 05:08:39 发布

阅读量1k

点赞数 26

文章标签： python 开发语言

本文链接：https://blog.youkuaiyun.com/qwe352/article/details/143750287

版权

一、面向对象编程

1.1 面向过程与面向对象

在理解面向对象编程（OOP）之前，我们先要了解 面向过程（POP） 和 面向对象（OOP） 的区别。

1.1.1 面向过程（POP）

-面向过程的编程思想将一个功能分解为一个一个小的步骤，我们通过完成一个一个的小的步骤来完成一个程序

- 这种编程方式，符合我们人类的思维，编写起来相对比较简单

- 但是这种方式编写代码的往往只适用于一个功能，如果要在实现别的功能，即使功能相差极小，也往往要重新编写代码，所以它可复用性比较低，并且难于维护

优点：简单直观、性能高效、代码简洁。

缺点：不易维护、不易扩展、代码重用性低。

例如：

# 面向过程编程示例
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

result = add(5, 3)
print(result)

1.1.2 面向对象（OOP）

- 面向对象的编程思想，将所有的功能统一保存到对应的对象中比如，妈妈功能保存到妈妈的对象中，孩子的功能保存到孩子对象中。要使用某个功能，直接找到对应的对象即可

- 这种方式编写的代码，比较容易阅读，并且比较易于维护，容易复用。

- 但是这种方式编写，不太符合常规的思维，编写起来稍微麻烦一点

优点：模块化、安全性高、代码重用性高。

缺点：学习难度大、性能开销大、调试困难。

例如：

# 面向对象编程示例
class Calculator:
    def add(self, a, b):
        return a + b
    
    def subtract(self, a, b):
        return a - b

calc = Calculator()
print(calc.add(5, 3))

1.2 类和对象

目前我们所学的python中的内置类型都是对象——内置对象，内置对象有时候不能满足我们的需求，需要自定义一些对象。

10， 20， 30， -40， a=10, b=20等等等，都是整数，对其进行抽象——int类。

python 中一切都是对象。

类也是一个对象。

1.2.1 类的定义与实例化对象

在面向对象编程中，类是对象的蓝图，它定义了对象的属性和方法。通过类创建对象（即实例化类），每个对象都有自己的属性和方法。

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        print(f"{self.name} says woof!")
        
# 实例化对象
dog = Dog("Buddy", 3)
dog.bark()  # 输出: Buddy says woof!

1.2.2 访问属性/方法

使用符号 . 进行访问

# 访问属性
对象名.属性
# 访问方法
对象名.方法名()

1.2.3 对象与类的关系【1】

对象拥有类的所有属性和方法
对象的属性和方法可以单独添加、删除、修改
对象与对象之间的属性和方法不可共享
对象不能独自创建，必须依托于类，类可以实例化N个对象

类是对象的模板。对象是类的实例化，每个对象都有自己独立的属性，但方法是共享的。

# 类与对象的关系
class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

car1 = Car("Toyota", "Corolla")
car2 = Car("Honda", "Civic")

1.2.3 对象与类的关系【2】

类定义了对象的结构和行为，而对象是类的具体实例。类中定义的变量叫做实例变量，每个对象拥有独立的实例变量，而类变量是所有对象共享的。

class Animal:
    species = "Unknown"  # 类变量
    
    def __init__(self, name):
        self.name = name  # 实例变量

cat = Animal("Whiskers")
print(cat.species)  # 输出: Unknown

还可以使用以下函数的方式来访问属性：

getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
delattr(obj, name) : 删除属性。

1.2.5 魔方方法——构造函数与析构函数

构造函数（__init__）：在创建对象时自动调用，用来初始化对象。
析构函数（__del__）：当对象销毁时自动调用，用于清理资源。
__str__ 打印方法：输出执行信息，自动执行。

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model
        print(f"{self.make} {self.model} created.")
    
    def __del__(self):
        print(f"{self.make} {self.model} destroyed.")

car = Car("Toyota", "Corolla")
del car

1.2.6 类属性/方法与实例对象属性/方法与静态方法

class MyClass:
    class_variable = 10
    

    #实例方法中能调用类属性、实例属性
    def instance_method(self):
        print(f"Instance method: {self.class_variable}")
    

    #类方法中只能调用类属性和类方法
    @classmethod
    def class_method(cls):
        print(f"Class method: {cls.class_variable}")
    

    #静态方法
    @staticmethod
    def static_method(x):
        print(f"{x}Static method: This doesn't access instance or class.")

obj = MyClass()
#调用实例方法
obj.instance_method()
MyClass.instance_method(obj)
#调用类方法
obj.class_method()
MyClass.instance_method()
# 调用静态方法
MyClass.instance_method(x)
obj.static_method(x)

1.2.7 Python的内置类属性

Python 中的类有一些内置的属性，比如 :

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

print(MyClass.__name__)  # 输出: MyClass
print(MyClass.__dict__)  # 输出类的属性和方法字典

1.3 类的封装【私有属性与方法】

封装是类的三大特性之一。

封装指的是隐藏对象中一些不希望让外部所访问的属性或方法。

python中封装其实是通过设置访问权限来体现的，私有属性和私有方法是控制访问权限的组成部分。

1.3.1 私有属性

私有属性以双下划线开头，表示该属性不可从类外直接访问。

class MyClass:
    def __init__(self):
        self.__private = "I am private"
    
    def __private_method(self):
        print("Private method")

obj = MyClass()
# print(obj.__private)  # 会抛出 AttributeError

1.3.2 私有方法

私有方法也以双下划线开头，只能在类的内部调用。

class MyClass:
    def __private_method(self):
        print("This is a private method.")

    def call_private(self):
        self.__private_method()

obj = MyClass()
obj.call_private()  # 允许调用类内私有方法

1.3.3 属性装饰器

属性装饰器是实现把方法转为属性的装饰器。

作用：

把方法转为属性，便于操作属性
实现对属性的更改（验证）、查看、删除

@property 用于将实例方法转换为属性访问。

语法格式：

class 类名(object):
    def __init__(self):
        self.__名字 = xxx
    
    @property
    def 函数名(self):
        return self.__名字
    
    @函数名.setter
    def 函数名(self, m):
        self.__名字 += m

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        return self._radius
    
    @radius.setter
    def radius(self, value):
        if value > 0:
            self._radius = value
        else:
            raise ValueError("Radius must be positive.")

1.4 类的继承

面向对象的编程带来的主要好处之一就是代码的重用，实现这种重用的方法之一就是通过继承机制。

通过继承创建的新类称之为【子类】或者【派生类】，被继承的类称之为【父类】、【基类】、【超类】。

1.4.1 继承语法格式

子类通过继承父类来扩展或修改父类的功能。

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

1.4.2 多继承语法【明白即可，不建议乱用】

Python 支持多继承，即一个子类可以继承多个父类。

class A:
    def method_a(self):
        print("Method A")
        
class B:
    def method_b(self):
        print("Method B")

class C(A, B):
    def method_c(self):
        print("Method C")

1.4.3 继承重写父类方法

子类可以重写父类的方法，以实现不同的行为。

class Animal:
    def sound(self):
        print("Animal makes sound")

class Dog(Animal):
    def sound(self):
        print("Dog barks")

这里列出了一些通用的功能，可以在自己的类重写：

__init__ ( self [,args...] ) 构造函数简单的调用方法: obj = className(args)
__del__( self ) 析构方法, 删除一个对象简单的调用方法 : del obj
__repr__( self ) 转化为供解释器读取的形式简单的调用方法 : repr(obj)
__str__( self ) 用于将值转化为适于人阅读的形式简单的调用方法 : str(obj)
__cmp__ ( self, x ) 对象比较简单的调用方法 : cmp(obj, x)

1.4.4 Python继承特点

在子类中如果需要父类的构造方法，需要显式调用父类的构造方法，或者不重写父类的构造方法。__init__()
在子类中调用父类的方法，需要显式调用，且第一个参数self不能省略。

class Parent(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def method(self):
        print(f"{self}的方法")

class Child(Parent):
    def fun1(self):
        print(self.x , self.y)
# 不重写父类构造方法
c = Child(1, 2)
c.fun1()

class Parent(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def method(self):
        print(f"{self}的方法")

class Child(Parent):
    def __init__(self, x, y, z):
        Parent.__init__(self, x, y)
        self.z = z

    def fun1(self):
        print(self.x , self.y, self.z)

# 重写父类构造方法、里面显式调用父类构造方法
c = Child(1, 2, 33)
c.fun1()

1.4.5 运算符重载

在Python中，并没有像其他语言（如C++）中那样的内置机制来重载运算符。但是，你可以通过定义特定的方法来模拟运算符重载的行为。

以下是一些常见运算符以及它们对应的特殊方法：

加法：+ 对应 __add__

减法：- 对应 __sub__

乘法：* 对应 __mul__

除法：/ 对应 __truediv__

取模：% 对应 __mod__

幂运算：** 对应 __pow__

位运算：<< 对于__lshift__

位运算：>> 对应 __rshift__

位运算：& 对应 __and__

位运算：| 对应 __or__

位运算：^ 对应 __xor__

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

1.5 类的多态

多态允许不同类的对象通过相同的接口调用不同的实现，通常通过继承和方法重写来实现。

class Animal(object):
    name = '动物'
    age = 0
    def speak(self):
        print("动物的声音")

class Dog(Animal):
    def speak(self):
        print("汪汪汪")

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

a = Animal()
d = Dog()
c = Cat()

a.speak()
d.speak()
c.speak()

1.6 关于下划线说明

__foo__: 以双下划线开头双下划线结尾，定义的是特殊方法，一般是系统定义名字，类似 __init__() 之类的，自动。
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import ···
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。