python-面向过程、面向对象、类

目录

• python-面向过程、面向对象、类
• 面向过程编程
• 面向对象
  • 类和对象
    • 二者区别
    • 定义格式：
    • 定义类发生的事情
    • 定义类的标准格式
    • 属性的查找顺序

python-面向过程、面向对象、类

面向过程编程

前言：编程不就编程吗？怎么还有这么多的洋气词后缀？？今天主要介绍一下面向过程和面向对象是什么。

大白话版本：面向过程编程可以比作是做一道菜，那么做一道菜分为几步呢？？

1. 准备食材
2. 起锅烧油
3. 放辅料
4. 炒菜
5. 出锅

最高端的食材往往只需要最简单的烹饪方式，呸，撤回来昂。这个过程，分布来，按部就班的，一步一步的过程为面向过程。

如果还不理解的话，那么想一想，把大象装进冰箱需要几步？，显然是三步了，打开冰箱把大象塞进去，关上冰箱！

• 面向过程编程其实也是一样的，将编程要实现的目标，按步骤实现，每一步就是一个过程！
  
  

实例一：

# 做菜的步骤，通过面向过程编程实现
def step1():
    print('第一步，准备食材')
def step2():
    print('第二步，起锅烧油')
def step3():
    print('第一步，放辅料')
def step4():
    print('第一步，炒菜')
def step5():
    print('第一步，出锅')

def mainstep():
    step1()
    step2()
    step3()
    step4()
    step5()
    print('感谢老板祝老板生八个儿子')

mainstep()

#结果
第一步，准备食材
第二步，起锅烧油
第一步，放辅料
第一步，炒菜
第一步，出锅
感谢老板祝老板生八个儿子

实例二：

# 用户注册功能
'''
1.获取用户名和密码
2.组织成固定的格式
3.文件操作写入文件
'''

# 定义获取用户信息函数
def get_info():
    username = input('please input your name>>>:').strip()
    pwd = input('please input your pwd>>>:').strip()
    if len(username) == 0 or len(pwd) == 0:
        print('your username or name is empty,please try again!')
        return
    else:
        user_id = {
            '1': 'admin',
            '2': 'user'
        }
        print(user_id)
        choice = input('please choice your position:')
        if choice == '1':
            id = user_id[choice]
            print('you are admin!')
        elif choice == '2':
            id = user_id[choice]
            print('you are user!')
    return make_info(username, pwd, id)

# 处理信息格式
def make_info(username, pwd, id):
    data = f'{username}|{pwd}|{id}\n'
    return save_info(data)

# 存储到文件
def save_info(data):
    with open(r'user_info.txt', 'a', encoding='utf8') as f:
        f.write(data)
    print('sign success!')

# 调用主体函数
get_info()

# 结果
please input your name>>>:hammer
please input your pwd>>>:123
{'1': 'admin', '2': 'user'}
please choice your position:1
you are admin!
sign success!

---

牛逼定义：面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度

---

面向对象

前言：面向对象，此对象非彼对象，面向对象的核心在于“对象”二字。

大白话版本：面向对象可以理解为，做菜的过程我们创造了一个机器人，把食材准备好和步骤写入机器人，那么可以理解为食材是我们需要的“数据”，如何做菜的步骤理解为“功能”，这个就是面向对象，总的来说就是定义出一系列的功能来对数据进行操作

• 

• 程序中对象：对象是把数据和功能整合到一起的产物，或对象就是盛放数据与功能的容器
• 现实生活中：对象就是特征和技能的结合体

示例如下：

# 未学习面向对象前，所有数据和功能都是散开的
# 数据
name = 'HammerZe'
course = []
# 功能
def add_course(name,course):
    course.append('python')
    print(f"学生{name}选课{course}")
add_course(name,course)

# 结果
学生HammerZe选课['python']

这样我们发现，如果有100个学生需要和格式化输出结果怎么办？写100次吗？是不是非常的麻烦

# 升级版
def add_course(user_info,course):
    user_info['course'].append(course)
    print(f"学生{user_info['name']}选课{user_info['course']}")

user_info = {
    'name': 'HammerZe',
    'course':[],
    'add_course':add_course,
}

user_info['add_course'](user_info,'python')
# 结果
学生HammerZe选课['python']
'''通过整合，把数据和功能写在一起，结果是一样的'''

类和对象

二者区别

• 生活中

  • 对象：特征与技能的结合体

  • 类：具有相似的特征，相似的技能归为一类，

  • 例如：西瓜和哈密瓜可以归为一水果类，

    ​ 狗和猫可以归为动物一类·····

  • 强调：站在不同的分类角度，划分的类可能不一样，是先有对象，才有类的

• 程序中：

  • 对象：数据和功能的结合体
  • 类：具有相似数据，相似功能 的为一类
  • 强调：必须先定义类，再调用类产生对象

定义格式：

1. 定义函数

   def 函数名():

   ​ pass

2. 定义类：

   class 类名():

   ​ pass

   类比两者记忆

定义类发生的事情

1. 立即执行类内代码
2. 产生一个类的名称空间，把类内执行的名字都丢到名称空间中（丢到大字典中）
3. 把类的名称空间绑定给__ dict __，类名 . __dict__查看名称空间

示例如下：

class Student():
    def add_course(user_info, course):
        user_info['course'].append(course)
        print(f"学生{user_info['name']}选课{user_info['course']}")
    print('调用类就会执行我！！')

# 查看类的名称空间
print(Student.__dict__)

# 产生对象：调用类的时候产生一个空对象{}
stu1 = Student()

# 查看对象的名称空间
print(stu1.__dict__)  # {}

定义类的标准格式

用学生类举例

class Student():
    # 初始化
    def __init__(self,name,age):
        self.name = name # stu.__dict__['name'] = 'Hammer'
        self.age = age

    '''注意：return 在这个方法中不能有返回值'''

    # 选课方法
    def choose_course(stu_dict,course):
        stu_dict['course'].append(course)
        print(f"学生{stu_dict['name']}选课{course}")

stu = Student('HammerZe',18)
'''1.调用类产生一个空对象
   2.调用了Student.__dict__(空对象,'HmmerZe',18)'''

# 查看类的名称空间
print(Student.__dict__)
# 查看对象的名称空间
print(stu.__dict__)# {'name': 'HammerZe', 'age': 18}
# 取值
print(stu.__dict__['name'])
print(stu.name)

属性的查找顺序

• 属性的查找：
  • 类属性：在类中的属性就称为类属性
  • 对象属性：在对象自己的名称空间中属性就是对象属性
  • 注意：
    • 属性的查找：先从自己的对象中查找，然后在去产生对象的类中取找
      
      如果使用dict从对象的名称空间获取值，找不到会报错
      
      使用.获取值，在自己的名称空间找不到会取类的名称空间查找

示例如下

class Student():
    # 初始化
    school = 'SH'

    def __init__(self, name, age,course = None):
        if course is None:
            course = []
        self.name = name  # stu.__dict__['name'] = 'Hammer'
        self.age = age
        self.course = course

    '''注意：return 在这个方法中不能有返回值'''

    # 选课方法
    def choose_course(self, course):
        self.course.append(course)
        print(f"学生{self.name}选课{self.course}")

stu = Student('HammerZe', 18)
'''1.调用类产生一个空对象
   2.调用了Student.__dict__(空对象,'HmmerZe',18)'''

''' 属性的查找：先从自己的对象中查找，然后在去产生对象的类中取找
        如果使用__dict__从对象的名称空间获取值，找不到会报错
        使用.获取值，在自己的名称空间找不到会取类的名称空间查找
'''
# 类的查找
# 查看名称空间
print(Student.__dict__)
# 查看值
print(Student.school)  # SH
# 查看方法
print(Student.choose_course)
# 类的增加
Student.country = 'China'
print(Student.__dict__['country']) # China
# 类的修改
Student.school = 'BJ'
print(Student.__dict__['school']) # BJ
# 类的删除
del Student.school
print(Student.__dict__.get('school')) # None
''' 底层为字典可以用get '''

# 对象的增删查改
# 查看名称空间
print(stu.__dict__) # {'name': 'HammerZe', 'age': 18}
# 查看值
print(stu.name) # HammerZe

# 修改值
stu.name = 'Ze'
print(stu.name) # Ze

# 增加值
stu.gender = 'male'
print(stu.__dict__) # {'name': 'Ze', 'age': 18, 'gender': 'male'}

# 删除值
del stu.gender
print(stu.__dict__) # {'name': 'Ze', 'age': 18}

# 方法的调用
# 类调用
Student.choose_course(stu,'python') # 学生Ze选课['python']
# 对象调用
stu.choose_course('java') # 学生Ze选课['python', 'java']

• 注意：类中的方法，类可以调用，对象也可以调用, 但是，推荐对象来调用，因为对象来调用，会把自己当成第一个参数传递给函数

---