关于python中的面向对象

1. 编程语言发展历程

复制代码

机器语言(01) → 汇编语言 → 高级语言(C-面向过程) → 面向对象语言(Python)

2. 面向对象 vs 面向过程

面向过程

思想：分析解决问题的步骤，然后逐步实现
示例：小白买电脑
1. 网上查资料
2. 根据预算和需求定型号
3. 去门店考察
4. 砍价付款

面向对象

思想：找出解决问题的对象，然后分配任务
示例：小白买电脑
1. 找电脑高手
2. 给钱交易

3. 面向对象核心概念

基本术语

类(Class)：描述具有相同属性和方法的对象集合
对象：类的实例
方法：类中定义的函数
类变量：类中所有实例共享的变量
实例变量 ：每个实例独有的变量（用self修饰）
继承：子类继承父类的字段和方法
实例化：创建类的实例
方法重写：子类重写父类方法

类与对象关系示例

类	对象	属性	行为
狗	哈士奇、萨摩耶	毛色、年龄、性别	吃、跑、叫

4. 类的使用

创建类

复制代码

class Dog:
    """记录一些喜欢的狗"""
    
    num = 0  # 类变量
    
    def __init__(self, color, age):
        """构造函数，自动调用"""
        self.color = color  # 实例变量
        self.age = age
        Dog.num += 1
        print(f"创建了第{Dog.num}只狗")
    
    def pri(self):
        print(f"白白胖胖的{self.color}小狗太可爱了")

# 实例化对象
hsq = Dog("yellow", 1)
smy = Dog('white', 2)

# 调用方法
hsq.pri()

属性操作

复制代码

# 添加属性
smy.s = 'm'

# 修改属性  
smy.age = 3

# 删除属性
del smy.s

# 属性操作函数
print(hasattr(smy, 's'))        # 判断属性是否存在
print(getattr(smy, 'age'))      # 获取属性值
setattr(smy, 'color1', 'gray')  # 修改/创建属性
delattr(smy, 'age')             # 删除属性

Python内置类属性

复制代码

print(Dog.__doc__)     # 类的文档字符串
print(Dog.__name__)    # 类名
print(Dog.__dict__)    # 类的属性字典
print(Dog.__module__)  # 类定义所在模块
print(Dog.__bases__)   # 类的所有父类

5. 类的继承

单继承

复制代码

class Parent:
    def houseNum(self):
        print("有3套房子")

class Child(Parent):  # 继承Parent类
    pass

c = Child()
c.houseNum()  # 调用继承的方法

多继承

复制代码

class Parent1:
    def houseNum(self):
        print("有3套房子")

class Parent2:
    def houseNum(self):
        print("有4套房子")

class Parent3:
    def houseNum(self):
        print("有2套房子")

class Child(Parent3, Parent1, Parent2):  # 多继承
    pass

c = Child()
c.houseNum()  # 输出：有2套房子（按继承顺序Parent3优先）

继承顺序：子类 → 从左向右第一个父类 → 第二个父类...

继承判断

复制代码

print(issubclass(Child, Parent1))  # 判断是否是子类
print(isinstance(c, Child))         # 判断对象是否是类的实例

6. 方法重写

复制代码

class A:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def addxy(self):
        return self.x + self.y

class B(A):
    def __init__(self, x, y, z):
        A.__init__(self, x, y)  # 调用父类构造函数
        self.z = z
    
    def addxy(self):  # 重写父类方法
        return A.addxy(self) + self.z  # 扩展功能

b = B(2, 3, 4)
print(b.addxy())  # 输出：9

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 __str__(self):  # 重载字符串输出
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(1, 2)
print(v1 + v2)  # 输出：Vector(3, 5)

8. 多态

概念：不同的对象对同一方法做出不同响应
示例：len()函数对字符串返回长度，对列表返回元素个数
鸭子模型："当看到一只鸟走起来像鸭子、游泳像鸭子、叫起来像鸭子，那么这只鸟就可以被称为鸭子"

9. 迭代器与生成器

迭代器

复制代码

l1 = [22, 55, 66, 33, 88]
l2 = iter(l1)  # 创建迭代器对象

print(next(l2))  # 输出：22
print(next(l2))  # 输出：55

for i in l2:     # 继续遍历剩余元素
    print(i)

生成器

复制代码

def fibonacci(max_value):
    """生成器函数：斐波那契数列"""
    a, b = 0, 1
    while a < max_value:
        yield a  # 逐步产生值
        a, b = b, a + b

# 使用生成器
for num in fibonacci(30):
    print(num)

10. 装饰器

基础装饰器

复制代码

def zs():
    print("我是zs")

def zs_age(name):
    name()
    print("zs今年22岁")

zs_age(zs)  # 函数作为参数传递

装饰器实现

复制代码

import random

def lucky_num(name):
    """装饰器函数"""
    def num():
        name()  # 执行原函数
        n = random.randint(1, 50)
        print(f"幸运指数为{n}")
    return num

@lucky_num  # 使用装饰器语法糖
def zs():
    print("我是zs")

@lucky_num
def zw():
    print("我是zw")

zs()  # 自动添加幸运指数功能
zw()

关键要点总结

面向对象核心：类、对象、继承、封装、多态
类定义 ：使用class关键字，__init__为构造函数
self参数：表示实例本身，方法定义必须有但调用时不传
继承机制：支持单继承和多继承，方法解析顺序(MRO)重要
特殊方法 ：__str__、__add__等实现运算符重载
迭代器 ：iter()和next()实现遍历
生成器 ：yield关键字实现惰性计算
装饰器 ：@语法糖实现函数功能扩展