Python匿名函数与面向对象编程核心解析：从lambda到继承多态全掌握

前言
一、匿名函数
二、面向对象
2.1 语言发展
2.2 面向对象和面向过程
2.2.1 面向过程
2.2.2 面向对象
2.3 面向对象的技术点
二、类的使用
三、实例化对象
四、访问方法
4.1 可以删除、修改、添加类的属性
4.2 内置函数访问属性：
五、内置类属性
六、类的继承
6.1 单继承
6.2 多继承
6.3 issubclass和isinstance
6.4 方法重写
6.5 基础重载方法
6.6 运算符重载
七、多态
八、模块与包

前言

书接上文

Python集合与字典操作全解析：从基础到函数应用的核心知识点与实例详解-CSDN博客文章浏览阅读820次，点赞24次，收藏16次。本文聚焦Python集合与字典的核心操作，详细解析集合的元素查找、运算方法及不可变集合frozenset的应用，结合实例展示集合去重与无序特性；针对字典的键值对结构，详细阐述创建、增删改查操作及视图方法的应用，强调键的唯一性与不可变性。函数部分探讨自定义函数的设计，涵盖参数传递方式（关键字传参、默认参数、不定长参数）、返回值处理及变量作用域问题，并通过可变/不可变类型传参的对比，揭示数据传递机制。全文以实例驱动，提供从基础到进阶的实践指导，助力开发者高效利用集合与字典优化代码逻辑。https://blog.csdn.net/qq_58364361/article/details/146087163?fromshare=blogdetail&sharetype=blogdetail&sharerId=146087163&sharerefer=PC&sharesource=qq_58364361&sharefrom=from_link

一、匿名函数

只能使用一次，一半函数的函数体只有一句代码，并且返回值只有一个

lambda 参数列表 : 表达式

lambda n1, n2: n1 + n2
print((lambda n1, n2: n1 + n2)(11, 22))
a = lambda n1, n2: n1 + n2
print(a(11, 22))
b = lambda n1=3, n2=6: n1 + n2
print(b())

二、面向对象

2.1 语言发展

机器语言（0 1） ------> 汇编语言 -------> 高级语言 (c:面向过程) ------>面向对象(python)

2.2 面向对象和面向过程

想喝水

2.2.1 面向过程

自己找饮水机接水喝

分析出来解决问题的步骤，然后逐步实现

2.2.2 面向对象

找个对象，让对象给你接水，喂你喝

找出解决问题的对象，然后分配职责

2.3 面向对象的技术点

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

方法：类中定义的函数。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

局部变量：定义在方法中的变量，只作用于当前实例的类。

实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。

实例化：创建一个类的实例，类的具体对象。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

类	对象	属性	行为
狗	边牧、萨摩耶、金毛	年龄、颜色、性别	吃、睡
人	男、女	年龄、肤色	玩游戏、捏脚、洗浴

二、类的使用

class 类名:

类名一般首字母大写

类由三部分组成：类名、属性（数据成员）、方法（行为成员）

class Dog:"""记录宠物狗"""numbers = 0def __init__(self, name, age):self.name = nameself.age = ageDog.numbers += 1print(self.name, self.age)print(Dog.numbers)db = Dog("大白", 5)
print(db.name)
print(db.age)
hh = Dog("花花", 4)

num:变量是一个类变量，他的值在这个类的所有实例之间共享，使用Dog.num访问

三、实例化对象

类似于函数的调用

格式：

变量名 = 类名(参数)

_init_函数也是类的构造函数或初始化方法，当创建了类的实例时，会自动调用该方法。

self:表示实例化对象，里边存放的对象的地址，在定义类时必须有self，调用的时候可以不用传参

四、访问方法

用.访问对象的属性（调用类中的方法）

class Dog:"""记录宠物狗"""numbers = 0def __init__(self, name, age):self.name = nameself.age = ageDog.numbers += 1def say(self):print("wang~~~")print(f"大家好，我的第{self.numbers}只狗叫{self.name},今年{self.age}岁")db = Dog("大白", 5)
db.say()
hh = Dog("花花", 4)
hh.say()

4.1 可以删除、修改、添加类的属性

class Dog:"""记录宠物狗"""numbers = 0def __init__(self, name, age):self.name = nameself.age = ageDog.numbers += 1def say(self):print("wang~~~")print(f"大家好，我的第{self.numbers}只狗叫{self.name},今年{self.age}岁")db = Dog("大白", 5)
db.age = 6  #修改
db.color = "white"  # 添加
del db.color  # 删除
db.say()
hh = Dog("花花", 4)
hh.say()

4.2 内置函数访问属性：

getattr( ): 访问对象的属性

hasattr( ):检测属性是否存在

delattr( ): 删除属性

setattr( ):设置属性；如果属性不存在，会创建一个新属性，存在则修改属性值

class Dog:"""记录宠物狗"""numbers = 0def __init__(self, name, age):self.name = nameself.age = ageDog.numbers += 1def say(self):print("wang~~~")print(f"大家好，我的第{self.numbers}只狗叫{self.name},今年{self.age}岁")db = Dog("大白", 5)
db.age = 6  #修改
print("age=", getattr(db, "age"))  #查找一下age的结果
db.color = "white"  # 添加
print("color=", getattr(db, "color"))
del db.color  # 删除
print("有color吗", hasattr(db, "color"))  #查找是否有color内容
db.color = "black"  #创建一个新属性
delattr(db, "color")  #删除属性
print("有color吗", hasattr(db, "color"))
setattr(db, "age", 8)  #修改属性
setattr(db, "color", "red")  #创建属性
print("有color吗", hasattr(db, "color"))
db.say()

五、内置类属性

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）

__doc__ :类的文档字符串()

__name__: 类名

__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）

__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组)

python3.n,所有的类都有一个共同的父类，叫object类(顶级父类)

class Dog:"""记录宠物狗"""numbers = 0def __init__(self, name, age):self.name = nameself.age = ageDog.numbers += 1def say(self):print("wang~~~")print(f"大家好，我的第{self.numbers}只狗叫{self.name},今年{self.age}岁")print(Dog.__name__)  #类名
print(Dog.__doc__)  #文档字符串，说明
print(Dog.__module__)  #模块
print(Dog.__dict__)  #类的属性
print(Dog.__bases__)  #顶级父类

六、类的继承

继承是实现代码重用的方法之一

类可以被继承，也可以继承别的类，被继承的类叫父类或者基类或超类，继承的类叫子类或派生类

子类会继承父类的所有的属性和行为，子类可以有多个父类，一个父类可以有多个子类。

6.1 单继承

一个类只有一个父类，如果子类中有和父类相同的属性或行为时，优先调用子类

class 子类名（父类）

class DaBai:"""定义父类"""num = 22def __init__(self):print("调用了父类的构造函数")def house(self):print("父类有3个窝")def NewNum(self, n):DaBai.num = nprint(f"父类现在有{DaBai.num}袋狗粮")class XiaoBai(DaBai):"""定义子类"""def __init__(self):print("调用子类构造函数")def basin(self):print("子类有2个盆")xb = XiaoBai()  # 子类实例化
xb.house()  # 调用父类的方法
xb.basin()  # 调用子类的方法
xb.NewNum(25)  # 调用父类的方法 - 设置、获取属性值

6.2 多继承

一个类有多个父类。

如果子类和多个父类有相同的属性或方法，顺序：

子类 >从左向右的第一个父类>第二个>第三个

class A:@staticmethoddef pt():print("A")@staticmethoddef hobby():print("跑步")class B:@staticmethoddef pt():print("B")@staticmethoddef play():print("够级")class C(B, A):passc = C()
c.pt()
c.play()

6.3 issubclass和isinstance

issubclass判断第一个参数是否是第二个参数的子类

isinstance判断第一个参数是否是第二个参数的实例化对象

class A:@staticmethoddef pt():print("A")@staticmethoddef hobby():print("跑步")class B:@staticmethoddef pt():print("B")@staticmethoddef play():print("够级")class C(B, A):passc = C()
c.pt()
c.play()
print(issubclass(C, A))  #C是A的子类
print(issubclass(C, B))
print(issubclass(A, C))
print(isinstance(c, C))  #c是C的实例化对象
print(isinstance(c, B))
print(isinstance(c, A))

6.4 方法重写

当父类中的方法不能满足子类的需求，可以在子类中重写父类的方法

初版：不继承A，也可以

class A:def __init__(self, x, y):self.x = xself.y = ydef addxy(self):print(self.x, self.y)class B(A):def __init__(self, x, y, z):self.x = xself.y = yself.z = zdef addxy(self):print(self.x + self.y + self.z)b = B(10, 20, 30)
b.addxy()

直接调用A的init函数，直接获取x y 参数值

class A:def __init__(self, x, y):self.x = xself.y = ydef addxy(self):return self.x + self.yclass B(A):def __init__(self, x, y, z):A.__init__(self, x, y)self.z = zdef addxy(self):return A.addxy(self) + self.zb = B(3, 3, 3)
print(b.addxy())

6.5 基础重载方法

python3.x之后，不支持cmp方法

_ _lt_ _小于

_ _gt_ _大于

_ _le_ _小于等于

class Cat:def __init__(self, name, age):self.name = nameself.age = agedef __lt__(self, other):print(self)print(other)return self.age < other.agehh = Cat("huahua", 2)
haha = Cat("haha", 3)
print(hh < haha)
print(hh)
print(haha)

6.6 运算符重载

使用熟悉的符号执行特定的操作，而不是调用方法

class Cat:def __init__(self, name, age):self.name = nameself.age = agedef __lt__(self, other):return self.age < other.age# def test(self, other):#     return self.age < other.agehh = Cat("huahua", 2)
haha = Cat("haha", 3)
print(hh < haha)
# print(hh.test(haha))

__add__   +

__sub__ -

__mul__ *

__truediv__   /

__lt__   <

__gt__ >

__le__ <=

__ge__ >=

七、多态

不同的对象对同一个方法做出不同的响应，用来设计更灵活的代码，提高代码的重复使用。

例：

len（）

字符串：计算字符串长度

列表、元祖：计算元素个数

在类的继承中用的方法重写就是一种实现多态的方法

python中，鸭子模型，想要一只鸭子，身边没有，但是旁边有一只鸡，这只鸡的属性和行为都特别像鸭子，比如长的像，走路也像，就把其当成鸭子来用；没有这种类型的对象，但是有一种类似的对象，就可以拿过来改一下使用。

class Cat:def say(self):print("miao~~~")class Dog:def say(self):print("wang~~~")class Duck:def say(self):print("ga~~~")cat = Cat()
dog = Dog()
duck = Duck()def fun(obj):obj.say()fun(cat)
fun(dog)
fun(duck)

八、模块与包

创建的.py文件，就是一个模块。

我们需要两个文件

先看day001

def say_fun(name):print(f"{name}说：'明天下午唱歌'")

再看day002

import day001day001.say_fun("猫猫")

总结

本文系统讲解了Python中匿名函数lambda的语法与应用场景，其简洁的lambda 参数: 表达式结构适用于单行逻辑的快速定义，支持参数传递与默认值设置，并通过实例演示了lambda的调用方式。随后深入探讨面向对象编程的核心概念，从面向过程与面向对象的对比切入，强调对象的行为与属性封装思想，详细解析了类的定义、构造方法__init__、实例化过程及属性操作（增删改查），结合getattr、setattr等内置函数实现对属性的动态管理。通过内置类属性如__dict__、__doc__等揭示了类的元信息，并借助继承机制实现代码复用，涵盖单继承、多继承的方法调用顺序及issubclass、isinstance的类型校验，重点阐述了方法重写的逻辑与super()的应用。进一步以运算符重载（如__lt__、__gt__）和鸭子类型多态为例，展示如何通过统一接口实现不同对象的行为统一性。最后简述模块与包的导入机制，通过import实现跨文件代码复用，完整覆盖Python面向对象编程的核心技术栈，为开发高效、可维护的代码提供理论支撑与实践指导。