面向过程、面向对象最详细！

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

面向过程编程

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

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

# 做菜的步骤，通过面向过程编程实现
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']

# 升级版
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

1. 定义类：

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']

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