Python面向对象编程(OOP)与Lambda表达式入门实战

Python面向对象编程(OOP)与Lambda表达式入门实战

前言

Python 支持面向对象编程（OOP），面向对象是现代编程思想的核心，核心思想就是类、对象、继承、方法重写；同时 Python 提供 lambda 匿名函数，用来快速创建简单的单行函数。本文把基础知识点、完整可运行示例整理在一起，适合入门复习。

核心概念一句话：类是模板，对象是根据模板创建出来的实例；lambda 用来快速定义简单匿名函数。

一、lambda 匿名表达式（匿名函数）

定义

匿名函数：没有函数名的函数，也称为lambda函数。 语法：lambda 参数列表: 表达式

说明：

1. lambda函数只能写一个表达式，不能写复杂语句（循环、if分支代码块不行）
2. lambda返回函数对象，一般赋值给变量之后调用
3. 参数可以为空、单个、多个，支持默认参数、可变参数*args、**kwargs

"""
匿名函数:
定义:
    没有函数名的函数，也称为lambda函数。
语法:
    lambda 参数列表: 表达式
说明:
    1. lambda函数只能有一个表达式，不能包含复杂的语句。
    2. lambda函数返回的是一个函数对象，需要赋值给一个变量才能调用。
注意:
    参数列表可以为空，也可以有一个或多个参数。
"""
# 示例一: 普通函数，两数相加
def add():
    a = 10
    b = 20
    return a + b
​
# 示例二: 无参lambda
add_lambda = lambda: 10 + 20
# 示例三: 有参lambda
add_lambda2 = lambda a, b: a + b
# 示例四: 参数带默认值
add_lambda3 = lambda a=10, b=20: a + b
# 示例五: *args可变位置参数
add_lambda4 = lambda *args: sum(args)
# 示例六: **kwargs可变关键字参数
add_lambda5 = lambda **kwargs: sum(kwargs.values())
​
if __name__ == '__main__':
    print(add())
    print(add_lambda)          # <function <lambda> at 0x...>
    print(add_lambda())        # 30
    print(add_lambda2(10, 20)) # 30
    print(add_lambda3(100))    # 120
    print(add_lambda4(10, 20, 30, 40, 50)) #150
    print(add_lambda5(a=10, b=20, c=30, d=40, e=50)) #150

使用场景：一般用于map、filter、sorted等高阶函数，写简单的单行逻辑，复杂逻辑建议用普通def函数。

二、面向对象基础概念

对象（object）：现实世界的实体，在代码里抽象成对象。

想要创建对象，必须先定义类。类是模板，对象是模板实例。

三、类的定义与使用

Python定义类有三种写法，Python3中效果基本一致：

1. class 类名:
2. class 类名(object): 显式继承object（Python所有类顶层父类）
3. class 类名():

"""
定义类的用法:
定义类的语法:
1: class 类名:
    属性
    方法
2: class 类名(object):
    属性
    方法
3: class 类名():
    属性
    方法
"""
# 示例一: 定义一个类，类名为Person
class Person:
    """定义一个类，类名为Person"""
    name = "张三"
    age = 18
​
    def eat(self):
        """定义一个方法，方法名为eat"""
        print("{}正在吃东西".format(self.name))
​
    def sleep(self):
        """定义一个方法，方法名为sleep"""
        print("{}正在睡觉".format(self.name))
​
    def work(self):
        print("{}正在工作".format(self.name))
​
​
# 示例二: class 类名(object)
class Person2(object):
    """定义一个类，类名为Person2"""
    name = "张三"
    age = 18
​
    def eat(self):
        print("{}正在吃东西".format(self.name))
​
    def sleep(self):
        print("{}正在睡觉".format(self.name))
​
​
# 示例三: class 类名()
class Person3():
    """定义一个类，类名为Person3"""
    name = "张三"
    age = 18
​
    def eat(self):
        print("{}正在吃东西".format(self.name))
​
    def sleep(self):
        print("{}正在睡觉".format(self.name))
​
​
if __name__ == '__main__':
    # p1实例
    p1 = Person()
    p1.name = "张三"
    p1.age = 18
    print("p1的姓名为：{}，年龄为：{}".format(p1.name, p1.age))
    p1.eat()
    p1.sleep()
    p1.work()
​
    # p2实例
    p2 = Person2()
    p2.name = "李四"
    p2.age = 20
    print("p2的姓名为：{}，年龄为：{}".format(p2.name, p2.age))
    p2.eat()
    p2.sleep()
​
    # p3实例
    p3 = Person3()
    p3.name = "王五"
    p3.age = 30
    print("p3的姓名为：{}，年龄为：{}".format(p3.name, p3.age))
    p3.eat()
    p3.sleep()

self关键字说明

self代表当前实例对象本身，类里面所有实例方法第一个参数必须写self；调用实例方法时，Python自动把实例传给self，不用手动传参。

四、__init__ 初始化构造函数

__init__：构造方法，创建对象的时候自动执行，用来初始化实例属性。

"""
__init__方法: 初始化函数，用于初始化对象的属性
"""
class Person:
    """定义一个类，用于模拟一个人的信息"""
    def __init__(self, name, age):
        """
        初始化函数，用于初始化对象的属性
        :param name: 姓名
        :param age: 年龄
        """
        self.name = name
        self.age = age
        print("初始化对象：", self)
​
    def eat(self):
        """定义一个方法，方法名为eat"""
        print("self:{}, {}正在吃东西".format(self, self.name))
​
​
if __name__ == '__main__':
    p1 = Person(name="张三", age=18)
    p1.eat()
    p2 = Person(name="李四", age=20)
    p2.eat()

五、魔法方法 __call__

作用：让实例对象可以像函数一样加括号调用 obj() 。

"""
__call__方法: 调用函数，用于调用对象的方法
"""
class Adder:
    """定义一个类"""
    def __init__(self, value=0):
        """初始化函数，用于初始化对象的属性"""
        self.data = value
        print("初始化对象：", self)
​
    def __call__(self, x):
        print("调用对象：", self)
        """定义一个方法"""
        return self.data + x
​
​
if __name__ == '__main__':
    adder = Adder()
    print(adder(10))

区分： __init__：创建实例时触发 obj = Class() __call__：实例加括号调用 obj()

六、继承的使用

继承两大特点：

1. 子类自动继承父类全部属性和方法
2. 子类可以重写父类方法，覆盖原有逻辑

"""
继承的用法
1: 子类可以继承父类的属性和方法
2: 子类可以重写父类的方法
"""
# 定义一个动物的类（父类/基类）
class Animal:
    def eat(self):
        print("吃东西")
    def sleep(self):
        print("睡觉")
​
# Dog 子类，继承 Animal
class Dog(Animal):
    def eat(self):
        print("狗正在吃东西")
​
# Cat 子类，继承 Animal
class Cat(Animal):
    def eat(self):
        print("猫正在吃东西")
    def sleep(self):
        print("猫正在睡觉")
​
​
if __name__ == '__main__':
    dog = Dog()
    dog.eat()
    dog.sleep()
    cat = Cat()
    cat.eat()
    cat.sleep()

七、super() 关键字

super()：在子类中调用父类的方法 ，最常用在__init__，复用父类初始化代码。

class Car(object):
    def __init__(self, name, color):
        self.name = name
        self.color = color
        print("初始化对象：", self)
​
    def run(self):
        print("{}汽车开始运行".format(self.name))
​
# 油车子类
class OilCar(Car):
    def __init__(self, name, color, oil_type):
        super().__init__(name, color)
        self.oil_type = oil_type
        print("初始化对象：", self)
​
    def run(self):
        print("{}牌子{}油车开始运行".format(self.name, self.color))
​
# 电车子类
class ElectricCar(Car):
    def __init__(self, name, color, battery_type):
        super().__init__(name, color)
        self.battery_type = battery_type
        print("初始化对象：", self)
​
    def run(self):
        print("{}牌子{}电车开始运行".format(self.name,self.color))
​
​
if __name__ == '__main__':
    # 油车实例
    oil_car = OilCar("大众", "黑色", "95#")
    oil_car.run()
    # 电车实例
    e_car = ElectricCar("特斯拉", "白色", "三元锂")
    e_car.run()

八、多继承拓展（补充，承接前面的鸭子示例）

Python支持多继承：一个子类可以同时继承多个父类；MRO（方法解析顺序）决定查找方法的顺序，从左往右查找。

class Flyable:
    """会飞的类"""
    def fly(self):
        print("可以飞行")
​
class Swimmable:
    """会游泳的类"""
    def swim(self):
        print("可以游泳")
​
class Duck(Flyable, Swimmable):
    """鸭子类，多继承"""
    def quack(self):
        print("嘎嘎叫")
​
# 实例化
duck = Duck()
duck.fly()
duck.swim()
duck.quack()
​
# 查看MRO方法查找顺序
print(Duck.mro())

总结

1. lambda：快速单行匿名函数，适合简单计算；复杂业务优先def普通函数。
2. 类与对象：类是模板，对象是实例；self代表实例本身。
3. __init__构造函数：实例创建自动执行，初始化属性。
4. __call__魔法方法：让对象支持对象()调用。
5. 继承：子类复用父类代码，重写实现差异化；super()调用父类方法。
6. 多继承：一个子类继承多个父类，MRO控制方法查找顺序。