面向对象之面向对象编程

【一】什么是面向过程

【1】面向过程介绍

• 面向过程，核心在于 “过程” 二字

• 过程的终极奥义就是将程序 “流程化”

• 过程是 “流水线” ，用来分步骤解决问题的

• 过程指的是解决问题的步骤，即先干什么再干什么......

• 面向过程的设计就好比精心设计好一条流水线，是一种机械式的思维方式。

• 在Python中使用面向过程编程时，可以通过定义函数来封装一系列相关的操作或逻辑。这些函数可以接受输入参数并返回结果，以实现特定的任务。代码中的变量可以作为函数之间的传递参数，用于在不同函数之间共享数据。

  以下是一个使用面向过程编程的Python示例：

  # 定义一个计算两个数字之和的函数
  def add_numbers(a, b):
      return a + b
  
  # 定义一个计算两个数字之差的函数
  def subtract_numbers(a, b):
      return a - b
  
  # 定义一个计算两个数字之积的函数
  def multiply_numbers(a, b):
      return a * b
  
  # 调用函数进行计算
  num1 = 5
  num2 = 3
  
  sum_result = add_numbers(num1, num2)
  print("和:", sum_result)
  
  difference_result = subtract_numbers(num1, num2)
  print("差:", difference_result)
  
  product_result = multiply_numbers(num1, num2)
  print("积:", product_result)
  

  在上述示例中，我们定义了三个函数来执行不同的数 ** 算。然后我们调用这些函数来进行具体的计算，并输出结果。

  这只是一个简单的示例，展示了Python中面向过程编程的基本思想。在实际应用中，可以使用面向过程编程来组织和管理更复杂的任务和逻辑。

【2】面向过程的优点

• 复杂度的问题流程化，进而简单化（一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单）

【3】面向过程的缺点

• 一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。

【二】什么是面向对象

Python是一种支持面向对象编程（Object-Oriented Programming，简称OOP）的高级编程语言。面向对象编程是一种编程范式，它以对象（Object）为中心，将数据和处理数据的操作封装在一起，通过定义类（Class）来创建对象，并通过对象之间的交互来完成程序的设计和开发。

在Python中，可以通过定义类来实现面向对象编程。类是一个模板或蓝图，用于创建对象。对象是类的具体实例，拥有类定义的属性和方法。类定义了对象的特征（属性）和行为（方法）。

以下是Python面向对象编程的一些关键概念：

1. 类（Class）：类是用于创建对象的模板。它定义了对象的属性和方法。类是面向对象编程的基本单位。

2. 对象（Object）：对象是类的实例。它拥有类定义的属性和方法。通过实例化类，可以创建对象。

3. 属性（Attribute）：类的属性是存储在对象中的数据。每个对象都有一组属性，用于表示对象的状态。

4. 方法（Method）：类的方法是定义在类中的函数。它们用于执行操作和实现功能。方法可以访问和操作对象的属性。

5. 继承（Inheritance）：继承是类之间实现代码重用的机制。子类可以继承父类的属性和方法，并可以扩展或修改它们。这提供了代码的灵活性和可重用性。

6. 多态（Polymorphism）：多态是面向对象编程的一个重要特性，它允许使用基类定义的方法，而在子类中进行特定实现。多态性使得可以通过统一的方式来处理不同类型的对象。

7. 封装（Encapsulation）：封装是面向对象编程的原则之一，它将数据和与数据相关的操作封装在一起，限制了对数据的直接访问，只能通过类提供的接口来访问和操作数据。封装提高了代码的安全性和可维护性。

通过使用面向对象编程，可以将程序分解为多个对象，每个对象负责完成特定的任务，从而提高代码的可读性、可维护性和复用性。

self 解释和用法

在Python中，self是一个特殊的参数，它会自动传递给类内部的实例方法（函数）。它用作引用当前对象的实例。

当我们创建一个类的实例后，我们可以使用点符号（.）来调用该实例的方法和属性。在调用方法时，Python会自动将实例作为第一个参数传递给方法，并将其赋值给self参数。这样，方法就可以通过self参数访问和操作实例的属性和其他方法。

下面是一个示例，演示了如何在面向对象编程中使用self：

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

    def greeting(self):
        print("Hello, my name is", self.name)

# 创建一个实例
obj = MyClass("Alice")

# 调用实例方法
obj.greeting()

在上述示例中，我们定义了一个名为MyClass的类，它具有一个名为greeting的方法和一个名为name的实例变量。在greeting方法中，我们使用self.name来访问该实例的name变量。

通过调用obj.greeting()，我们将obj实例作为self参数传递给greeting方法，并对其进行调用。这将输出"Hello, my name is Alice"。

举例

我们知道，面向对象最重要的概念就是类（class）和实例（instance），类是抽象的模板，比如学生这个抽象的事物，可以用一个Student类来表示。而实例是根据类创建出来的一个个具体的“对象”，每一个对象都从类中继承有相同的方法，但各自的数据可能不同。
1、以Student类为例，在Python中，定义类如下：

class Student(object):
    pass

（Object）表示该类从哪个类继承下来的，Object类是所有类都会继承的类。

2、实例：定义好了类，就可以通过Student类创建出Student的实例，创建实例是通过类名+()实现：

student = Student()

3、由于类起到模板的作用，因此，可以在创建实例的时候，把我们认为必须绑定的属性强制填写进去。这里就用到Python当中的一个内置方法__init__方法，例如在Student类时，把name、score等属性绑上去:

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

这里注意：（1）、__init__方法的第一参数永远是self，表示创建的类实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。（2）、有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器会自己把实例变量传进去：

和普通数相比，在类中定义函数只有一点不同，就是第一参数永远是类的本身实例变量self，并且调用时，不用传递该参数。除此之外，类的方法(函数）和普通函数没啥区别，你既可以用默认参数、可变参数或者关键字参数（*args是可变参数，args接收的是一个tuple，**kw是关键字参数，kw接收的是一个dict）。

class Student(obiect):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print "%s: %s" % (self.name, self.score)
>>>student = Student("hope", 99)
>>>student.print_score
Hugh: 99

Student.__dict__来查看类这个容器内盛放的东西

将函数封装在类中使用的方式

当将函数封装在类中使用时，可以通过定义类和将函数作为类的方法来实现。

class Calculator:
    def add(self, num1, num2):
        return num1 + num2
    
    def subtract(self, num1, num2):
        return num1 - num2

# 创建Calculator对象
calc = Calculator()

# 调用类的方法
result1 = calc.add(5, 3)
result2 = calc.subtract(10, 6)

print(result1)  # 输出: 8
print(result2)  # 输出: 4

在这个示例中，我们创建了一个名为Calculator的类，它包含两个方法：add和subtract。这些方法分别接受两个参数，并返回计算结果。然后我们创建了一个Calculator对象（calc），并通过调用对象的方法来执行计算。最后，我们打印了计算结果。

class HopeStudent(object):
    school = '学城'

    def read_books(self):
        print('is reading books')

    def write_nodes(self):
        print('is write nodes')

    def running(self):
        print('is running')

    def set_info(obj, name, age, gender):
        obj.name = name  # obj.__dict__['name'] = name
        obj.age = age  # obj.__dict__['age'] = age
        obj.gender = gender  # obj.__dict__['gender'] = gender


'''方案3:简单的封装成函数没有提现出面向对象整合的精髓>>>:将函数写到类中去'''
obj1 = HopeStudent()
obj2 = HopeStudent()
HopeStudent.set_info(obj1,'dream',18,'male')
HopeStudent.set_info(obj2,'hope',28,'female')
print(obj1.name)  # dream
print(obj2.name)  # hope

通过将函数封装在类中，可以更好地组织和管理相关功能的代码，并使其更具可读性和可复用性。

___i__nit_____的使用

class Students(object):
    school='希望小学'
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

    def read(self):
        print("{} is reading.".format(self.name))

    def sleep(self):
        print("{} is sleeping.".format(self.name))

student1=Students("张三",18, 90)
print(student1.__dict__)
print(student1.name)
print(student1.age)
student1.read()
print(id(Students.school))
print(id(student1.school))
print(dir(student1))
#{'name': '张三', 'age': 18, 'score': 90}
#张三
#18
#张三 is reading.
#2541980412752
#2541980412752
#['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name', 'read', 'school', 'score', 'sleep']

登录注册练习

class ATM():
    user_data_dict={}
    def __init__(self):
        self.name=None
    def get_user_pwd(self):
        username=input("请输入用户名：").strip()
        password=input("请输入密码：").strip()
        return username,password
    def register(self):
        username,password=self.get_user_pwd()
        if not password.isdigit() or len(password)!=3:
            return False,f'用户{username}密码格式错误'
        self.user_data_dict['username']=username
        self.user_data_dict['password']=password
        print(self.user_data_dict)
        return True,f'用户{username}注册成功'
    def login(self):
        username,password=self.get_user_pwd()
        if username not in self.user_data_dict:
            return False,f'用户{username}不存在'
        if password!=self.user_data_dict['password']:
            return False,f'用户{username}密码错误'
        return True,f'用户{username}登录成功'
    def deposit(self):
        ...
    def withdraw(self):
        ...
    def check_balance(self):
        ...
    def exit(self):
        ...
atm=ATM()
# atm.register()

#
while True:
    print("""
    1.注册
    2.登录
    3.存款
    4.取款
    5.查询余额
    6.退出
    """)
    user_data_dict={
        1:atm.register,
        2:atm.login
    }
    choice=input("请输入操作序号：").strip()
    choice=int(choice)
    func=user_data_dict[choice]
    flag,msg=func()
    if flag:
        print(msg)

    else:
        print(msg)
        continue

本栏目推荐文章
• NUS CS1101S：SICP JavaScript 描述：三、模块化、对象和状态
• js中的对象，如果赋值给多个变量，那么会有性能问题吗
• Python面向对象之反射
• 面向过程(函数)和对象(类)
• 面向对象的三大特性及派生和组合
• Python面向对象之派生
• Python面向对象之组合
• Python面向对象之三大特征-多态
• 对象图作业
• 自定制过滤器与封装Response对象

对象对象06 对象java javascript对象 threading对象 对象amp 对象bom 对象oop response对象 对象minio 对象list