Python—面向对象小解(1)

一、面向对象     

        面向对象编程（Object-Oriented Programming，简称 OOP）是一种程序设计范式，它通过使用“对象”和“类”来组织代码。Python 是一种面向对象的编程语言，支持 OOP 的核心概念。   

面向过程：

• 侧重点是过程

• 按照一定的顺序步骤完成对某一特定问题的处理

• 如何将大象放入冰箱中？

  • 1-打开冰箱门

  • 2-将大象放入冰箱

  • 3-关上冰箱门

• 如何将老虎放入冰箱中？

  • 1-打开冰箱门

  • 2-将老虎放入冰箱

  • 3-关上冰箱门

• 如何将狮子关在笼子中？

  • 1-打开笼子门

  • 2-将狮子赶入笼子中

  • 3-关上笼子门

• 面向过程需要针对某一类问题需要重复编写代码

面向对象：

• 侧重点在对象

• 将一类问题进行归纳总结，按照一个统一标准处理同一类问题

• 如何将一项物品放入一个空间内?

  • 物品是什么？和空间是什么？

    • 处理的数据

  • 处理方式(动作) 函数功能

    • 打开

    • 关闭

• 将一类问题分析后的内容进行类的创建，归纳过程

  • 针对类进行创建对象，对象是什么有数据本身决定

    • 数据是大象，对象就是一个大象对象

    • 大象的处理方式可以通过函数实现

---

面向过程的开发 比较简单快捷，但是需要重复编写代码

面向对象的开发 开发较复杂，需要考虑一类问题的处理，可以重复利用代码，不需要针对每个问题重复写代码

二、面向对象特性

        面向对象开发（OOP）的三大主要特性是：封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。这些特性使得 OOP 能够创建模块化、可维护和可扩展的代码。下面详细介绍每个特性：

封装（Encapsulation）

封装是将对象的状态（属性）和行为（方法）捆绑在一起，并隐藏对象的内部实现细节。通过封装，类可以控制其属性的访问和修改，这有助于保护对象的完整性和防止外部代码对其进行不正当的操作。

class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age    # 私有属性

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age > 0:
            self.__age = age
        else:
            raise ValueError("Age must be positive")

# 创建对象
person = Person("Alice", 30)
print(person.get_name())  # 输出：Alice
print(person.get_age())   # 输出：30

person.set_age(31)
print(person.get_age())   # 输出：31

继承（Inheritance）

        继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码重用。子类可以扩展或修改父类的行为。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

# 创建对象
dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.speak())  # 输出：Buddy says Woof!
print(cat.speak())  # 输出：Whiskers says Meow!

多态（Polymorphism）

        多态允许不同类的对象通过相同的接口执行不同的操作。它使得代码可以处理不同类型的对象，而无需知道这些对象的具体类型。

class Animal:
    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

# 多态函数
def make_animal_speak(animal):
    print(animal.speak())

# 使用多态函数
dog = Dog()
cat = Cat()

make_animal_speak(dog)  # 输出：Woof!
make_animal_speak(cat)  # 输出：Meow!

三、匿名函数

和函数的作用一致，都是进行代码逻辑的封装，

区别1 在定义时，匿名函数可以不指定函数的名字

区别2 匿名函数执行实现简单的计算

区别3 匿名函数会自动将计算的结果返回

定义格式：

lambda 参数1,参数2...:计算逻辑(参数的处理逻辑)

# 匿名函数的使用
# 加法计算功能
def add(a,b):
    data = a+b
    return data

res = add(12,15)
print(res)

# 使用匿名函数实现
# 定义匿名函数时，需要指定一个变量接收
f = lambda a,b:a+b

# 使用变量调用匿名函数
print(type(f))
res2 = f(20,30)
print(res2)

使用场景：

        1、进行简单的数据计算

        2、匿名函数当成参数进行传递，实现对数据的处理

# 匿名函数成参数使用
rdd = [1,2,3,4,5,6]

def reduce(f):
    # f参数  接收一个累加计算的函数计算的函数
    # 实现数据的遍历过程
    init = 0
    for i in rdd:
        # 遍历数据时进行数据的sum求和
        # 实际的pyspark开发中，sum求和的计算不在reduce中实现，由开发人员自己编写计算逻辑
        # init = init+i
        init= f(init,i)
    return init

# 开发人员在调用reduce函数编写数据的累加计算逻辑
res= reduce(lambda a,b:a+b)
print(res)

四、类的构成

面向对象开发的流程

        1-封装一个类

        2-使用类创建一个对象

在封装一个类的时候需要指定数据和行为，数据可以通过变量进行定义，在类中不叫变量，称为属性，行为可以通过函数进行定义，在类中称为方法

class 类名:
    属性
    name = '张三'
    
    方法
    def eat(self):
        
    def paly_game(self):

# 调用类创建对象
object = 类名()   # 当前对象就是张三

# 执行某个行为
object.eat()

object.paly_game()