面向过程

面向过程编程（Procedural Programming）是一种以过程（procedure）为中心的编程范式。这种模式强调通过函数（或称为过程、步骤）来组织和执行代码，按照这些函数的调用顺序来完成任务。面向过程编程是编程的基础思想之一，早期的编程语言如 C、Pascal 等都采用了这种范式。

面向过程的核心概念

  1. 过程（函数）：面向过程编程中的核心概念是函数，它是一段独立的代码，完成特定的任务。函数的主要目的是将复杂问题分解为多个可管理的小步骤。
  2. 顺序执行：程序从头到尾按顺序执行，函数的调用与返回按照一定的顺序进行。程序的流程控制非常明确，依赖于函数调用的次序。
  3. 数据与函数分离：面向过程的编程风格将数据和操作分开。数据是独立的，函数通过参数传递来对数据进行处理。
  4. 模块化：通过将代码划分为多个函数，可以实现代码的复用和模块化设计。每个函数负责一个单一的任务，使得代码更易于理解和维护

面向过程的典型步骤

在面向过程编程中，解决问题的思路通常是这样的：

  1. 分析问题：将问题分解为多个步骤，明确每个步骤需要完成的任务。
  2. 设计函数：为每个步骤编写一个或多个函数，使每个函数单独完成一个子任务。
  3. 实现函数：编写函数体，完成具体的逻辑。
  4. 顺序调用：按步骤调用函数，完成整个程序的功能。

面向对象

面向对象编程（Object-Oriented Programming，简称 OOP）是一种以对象为核心的编程范式。它通过将数据和操作封装在一起组成对象，并通过对象之间的交互来设计和实现程序。面向对象编程使得代码更加模块化、可复用、易扩展、易维护，是现代编程中非常流行的编程范式。

面向对象编程的核心概念

  1. 类（Class）：类是面向对象编程中的核心概念，它是对象的蓝图或模板。类定义了对象的属性（数据）和行为（方法）。通过类，我们可以创建多个共享相同属性和行为的对象。
  2. 对象（Object）：对象是类的实例，它是具体的、独立的实体。每个对象都有自己的数据，并可以调用类中定义的方法来操作这些数据。
  3. 封装（Encapsulation）：封装是指将数据和操作数据的方法绑定在一起，并对外部隐藏对象的内部细节。外部只能通过公开的接口与对象交互。这种隐藏内部实现的机制提高了代码的安全性和可维护性。
  4. 继承（Inheritance）：继承是面向对象编程中非常强大的特性，它允许一个类继承另一个类的属性和方法。通过继承，子类可以复用父类的代码，并可以在子类中扩展或修改父类的行为。
  5. 多态（Polymorphism）：多态允许我们通过相同的接口来操作不同类型的对象。多态性使得程序更加灵活，可以根据具体对象的类型来决定如何执行某个操作。
  6. 抽象（Abstraction）：抽象是指隐藏复杂的实现细节，只向外部提供简单的接口。通过抽象，程序员可以专注于解决问题的核心，而不必关心底层实现。

两者对比

面向过程—怎么做

  1. 把完成某一个需求的 所有步骤 从头到尾 逐步实现
  2. 根据开发需求，将某些 功能独立 的代码 封装 成一个又一个 函数
  3. 最后完成的代码，就是顺序地调用 不同的函数

注重步骤与过程，不注重职责和分工，如果需求比较复杂，虽然有函数封装，但是还是会导致代码比较臃肿。开发起来比较复杂。

image-20241024134726628

面向对象—谁来做

相比较函数，面向对象 是 更大 的 封装，根据 职责 在 一个对象中 封装 多个方法

  1. 在完成某一个需求前，首先确定 职责 —— 要做的事情（方法）
  2. 根据 职责 确定不同的 对象，在 对象 内部封装不同的 方法（多个）
  3. 最后完成的代码，就是顺序地让 不同的对象 调用 不同的方法

特点

  1. 注重 对象和职责，不同的对象承担不同的职责
  2. 更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路
  3. 需要在面向过程基础上，再学习一些面向对象的语法

image-20241024134946916

image-20241024134959245

类与对象

在面向对象中，类与对象是两个核心的概念

类的概念

  • 类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
    • 特征 被称为 属性
    • 行为 被称为 方法
  • 类 就相当于制造飞机时的图纸，是一个 模板，是 负责创建对象的

002_飞机设计图纸

对象的概念

  • 对象 是 由类创建出来的一个具体存在，可以直接使用
  • 由哪一个类创建出来的对象，就拥有在哪一个类中定义的：
    • 属性
    • 方法
  • 对象 就相当于用 图纸 制造 的飞机

在程序开发中，应该 先有类，再有对象

003_飞机对象

类与对象的关系

  • 类是模板，对象 是根据 类 这个模板创建出来的，应该 先有类，再有对象
  • 类只有一个，而对象可以有很多个
    • 不同的对象 之间 属性 可能会各不相同
  • 类 中定义了什么 属性和方法，对象 中就有什么属性和方法，不可能多，也不可能少

类的设计

在使用面相对象开发前，应该首先分析需求，确定一下，程序中需要包含哪些类

image-20241024135613490

在程序开发中，要设计一个类，通常需要满足一下三个要素：

  1. 类名 这类事物的名字，满足大驼峰命名法
  2. 属性 这类事物具有什么样的特征
  3. 方法 这类事物具有什么样的行为

大驼峰命名法

CapWords
  • 每一个单词的首字母大写
  • 单词与单词之间没有下划线

类名的确定

通常类名的选择，我们应该根据整个业务流程来提取，或者从大的角度来选择

属性和方法的确定

  • 对 对象的特征描述，通常可以定义成 属性
  • 对象具有的行为（动词），通常可以定义成 方法

类的定义

类的基本定于语法如下：

class Human:
    '''
    这里可以写上对于这个类的说明
    '''
    变量 = xxxx    # 这里是类的静态属性，也可以理解为该类共有的特性
    dic = {}
    l1 = []
    def __init__(self,xxx,xxx):        # 初始化方法
        pass

    def func(self):                    # 方法，动态属性
        pass

示例：

定义一个人"类"，人类有思想，并且具备姓名，年龄，身高。人类还会吃饭，还会跑步等

image-20241024140516791

class Human(object):    # 默认继承自 object
    """
    此类用来构造人类
    """
    mind = "思考问题.."
    def __init__(self,name,age,height):、
        # 在__init__中，通过self给对象封装属性
        self.name = name
        self.age = age
        self.height = height

    def run(self):
        print('高高兴兴的跑步')

    def eat(self):
        print('大口大口的吃饭')

这里的object和self的解释如下：

object 是 Python 中所有类的基类。它是所有用户自定义类和内置类的顶层父类。可以理解为所有的类都继承自object类，所以才能具备类的初始化等许多基础特性。

self 是一个约定俗成的参数名，用于引用类的实例。它代表当前对象的实例，使我们能够访问实例的属性和方法。

在实例方法中，第一个参数通常命名为 self，但你可以使用其他名称（虽然不推荐）。

实例化对象

通过类（模板）生成（实例化）出来一个具体的对象的过程，我们称之为实例化

class Human(object):    # 默认继承自 object
    """
    此类用来构造人类
    """
    mind = "思考问题.."
    def __init__(self,name,age,height):
        self.name = name
        self.age = age
        self.height = height

    def run(self):
        print('高高兴兴的跑步')

    def eat(self):
        print('大口大口的吃饭')

# 实例化出一个具体的对象
xiaoming = Human('小明',18, 173.5)
xiaohong = Human('小红',20, 165)

这里的小明和小红就是我们通过Human这个类实例化出来的具体的对象

其实实例化一个对象总共发生了三件事：

  1. 在内存中开辟了一个对象空间。

  2. 自动执行类中的init方法，并将这个对象空间（内存地址）传给了init方法的第一个位置参数self。

  3. 在init 方法中通过self给对象空间添加属性。

对象访问类中的属性和方法

# 访问静态属性
print(xiaoming.mind)
print(xiaohong.name)
print(xiaohong.age)

# 访问动态方法
xiaohong.run()
xiaoming.eat()

# Output:
思考问题..
小红
20
高高兴兴的跑步
大口大口的吃饭

查看对象的所有属性

我们可以通过object基类中提供的__dict__方法来查看某个对象的属性

# 通过对象查看类中所有的属性
print(xiaoming.__dict__)

从类名的角度研究类

类名操作静态属性

查看类中所有的内容，用类名.__dict__

class Human(object):    # 默认继承自 object
    """
    此类用来构造人类
    """
    mind = "思考问题.."
    def __init__(self,name,age,height):
        # 在__init__中，通过self给对象封装属性
        self.name = name
        self.age = age
        self.height = height

    def run(self):
        print('高高兴兴的跑步')

    def eat(self):
        print('大口大口的吃饭')

print(Human.__dict__)
print(Human.__dict__['mind'])
Human.__dict__['mind'] = '高智慧'
print(Human.__dict__)
# 通过这种方式只能查询，不能增删改

万能的点.

在面向对象中，我们更多的是使用.来获取类或者对象的属性或方法

class Human(object):  # 默认继承自 object
    """
    此类用来构造人类
    """
    mind = "思考问题.."

    def __init__(self, name, age, height):
        # 在__init__中，通过self给对象封装属性
        self.name = name
        self.age = age
        self.height = height

    def run(self):
        print('高高兴兴的跑步')

    def eat(self):
        print('大口大口的吃饭')


print(Human.mind)
Human.mind = '高智慧'
print(Human.mind)

del Human.mind
Human.run = '慢慢悠悠的走路'
print(Human.run)
# 通过万能的点 可以增删改查类中的单个属性
        print('大口大口的吃饭')

总结：如果想要查看类的内容，我们可以使用__dict__方法，如果想要操作类中的某个属性，可以使用.

类名操作动态方法

class Human(object):  # 默认继承自 object
    """
    此类用来构造人类
    """
    mind = "思考问题.."

    def __init__(self, name, age, height):
        # 在__init__中，通过self给对象封装属性
        self.name = name
        self.age = age
        self.height = height

    def run(self):
        print(self,'高高兴兴的跑步')

    def eat(self):
        print(self,'大口大口的吃饭')


Human.eat('小明')
Human.__dict__['run']('小红')
# 可以直接通过human调用动态方法，也可以通过dict为类内部方法传递实参

从对象的角度研究类

对象操作对象属性

对象也可以通过__dict__查看对象的所有属性

class Human(object):  # 默认继承自 object
    """
    此类用来构造人类
    """
    mind = "思考问题.."

    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height

    def run(self):
        print('高高兴兴的跑步')

    def eat(self):
        print('大口大口的吃饭')


# 实例化出一个具体的对象
xiaoming = Human('小明', 18, 173.5)
xiaohong = Human('小红', 20, 165)

print(xiaoming.__dict__)

同样也可以使用万能的点操作对象属性

class Human(object):  # 默认继承自 object
    """
    此类用来构造人类
    """
    mind = "思考问题.."

    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height

    def run(self):
        print('高高兴兴的跑步')

    def eat(self):
        print('大口大口的吃饭')


# 实例化出一个具体的对象
xiaoming = Human('小明', 18, 173.5)
xiaohong = Human('小红', 20, 165)

# 修改属性
xiaoming.name = "小小明"

# 增加属性
xiaoming.sex = "男"
print(xiaoming.sex)

# 删除属性
del xiaoming.height

# 查看属性
print(xiaoming.__dict__)

对象查看类的属性

class Human(object):  # 默认继承自 object
    """
    此类用来构造人类
    """
    mind = "思考问题.."

    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height

    def run(self):
        print('高高兴兴的跑步')

    def eat(self):
        print('大口大口的吃饭')


# 实例化出一个具体的对象
xiaoming = Human('小明', 18, 173.5)
xiaohong = Human('小红', 20, 165)

print(xiaoming.mind)

类的内置方法

序号 方法名 类型 作用
01 __new__ 方法 创建对象时，会被 自动 调用
02 __init__ 方法 对象被初始化时，会被 自动 调用
03 __del__ 方法 对象被从内存中销毁前，会被 自动 调用
04 __str__ 方法 返回对象的描述信息，print 函数输出使用
05 __dir__ 方法 查看对象内的所有属性以及方法

总结：

  1. 现有类才有对象，类是模块，对象是通过类实例化出来的
  2. 一个类可以实例化很多个对象
  3. 类中包含静态属性和动态方法，包括内置方法，自定义方法
  4. 对象实例化的时候，会自动调用__init__来初始化，我们可以在__init__中定义对象初始化的属性
  5. 实例化好的对象可以调用类中方法或者是静态属性
学前沿IT，到英格科技!本文发布时间： 2024-10-25 19:41:31

results matching ""

    No results matching ""