今日内容概要

• 面向过程概念
• 面向对象概念
• 类的定义和对象的产生
• 属性或者方法的查找
• 练习

面向过程

面向过程：
不是一门技术，是一种编程思想
核心是过程两个字 过程就是先干什么，在干什么，最后干什么， 机械师思维

"""
    案例：
        把大象关进冰箱
        1.打开冰箱
        2.把大象放进去
        3.关闭冰箱门
    案例2：
    优点：
        复杂的问题简单化，流程化
    缺点：
        扩展性差，可维护性差

    应用场景: 对扩展性要求不高的

    问题：
        实现用户注册：
            1.输入用户名密码
            2.验证参数
            3.注册
"""


# 1 与用户交互
def interactive():
    username = input("请输入用户名：")
    password = input("请输入密码：")
    email = input("请输入email：")

    return {
        'username': username,
        'password': password,
        'email': email,
    }


# 2. 验证参数
def check_info(userinfo):
    is_valid = True

    if len(userinfo['username']) == 0:
        print("用户名不能为空")
        is_valid = False

    if len(userinfo['password']) == 0:
        print("密码不能为空")
        is_valid = False
    if len(userinfo['email']) == 0:
        print("email不能为空")
        is_valid = False

    return {
        'is_valid': is_valid,
        'userinfo': userinfo
    }


# 3. 注册
import json


def register(param):
    if param['is_valid']:
        with open('userinfo', 'w', encoding='utf-8') as f:
            json.dump(param['userinfo'], f)


def main():
    userinfo = interactive()
    checkinfo = check_info(userinfo)
    register(checkinfo)


if __name__ == '__main__':
    main()

类的对象

类即类别/种类，是面向对象分析和设计的基石，如果多个对象有相似的数据与功能，那么该多个对象就属于同一种类。有了类的好处是：我们可以把同一类对象相同的数据与功能存放到类里，而无需每个对象都重复存一份，这样每个对象里只需存自己独有的数据即可，极大地节省了空间。所以，如果说对象是用来存放数据与功能的容器，那么类则是用来存放多个对象相同的数据与功能的容器。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sk5nQFW4-1626092358780)(%E4%BB%8A%E6%97%A5%E7%AC%94%E8%AE%B0.assets/image-20210712201511382.png)]

综上所述，虽然我们是先介绍对象后介绍类，但是需要强调的是：在程序中，必须要事先定义类，然后再调用类产生对象（调用类拿到的返回值就是对象）。产生对象的类与对象之间存在关联，这种关联指的是：对象可以访问到类*有的数据与功能，所以类中的内容仍然是属于对象的，类只不过是一种节省空间、减少代码冗余的机制，面向对象编程最终的核心仍然是去使用对象。

在了解了类与对象这两大核心概念之后，我们就可以来介绍一下面向对象编程啦。

面向对象编程

类的定义与实例化

我们以开发一个清华大学的选课系统为例，来简单介绍基于面向对象的思想如何编写程序

面向对象的基本思路就是把程序中要用到的、相关联的数据与功能整合到对象里，然后再去使用，但程序中要用到的数据以及功能那么多，如何找到相关连的呢？我需要先提取选课系统里的角色：学生、老师、课程等，然后显而易见的是：学生有学生相关的数据于功能，老师有老师相关的数据与功能，我们单以学生为例，

"""
面向对象：
    核心是对象二字，
        1.程序里面
            对象就是盛放数据属性和功能的容器，
        2. 现实中
            对象就是特征与技能的结合体

        Linux：一切皆文件

    优点：扩展性强
    缺点：编程复杂度高
    应用场景：对扩展性要求较高的场景，比如：qq， 微信

        案例：
            西天取经
            学生选课系统
"""


# 版本1：
# stu1_name = 'egon'
# stu2_name = 'tom'
# stu1_age = 18
# stu2_age = 20
# stu1_gender = 'male'
# stu2_gender = 'male'
# stu1_courses = []
# stu2_courses = []
#
# def choose_course(stu_name, stu_courses,course):
#     stu_courses.append(course)
#     print("%s 选课成功 %s" % (stu_name, stu_courses))
#
# choose_course(stu1_name ,stu1_courses, 'python全站开发')
# choose_course(stu2_name ,stu2_courses, 'linux全站开发')


# # 版本2
#
# stu1 = {
#     'name':'egon',
#     'age' : 18,
#     'gender' : 'male',
#     'courses': []
# }
#
# stu2 = {
#     'name':'tom',
#     'age' : 18,
#     'gender' : 'male',
#     'courses': []
# }
#
#
# def choose_course(stu_dic,course):
#     stu_dic['courses'].append(course)
#     print("%s 选课成功 %s" % (stu_dic['name'], stu_dic['courses']))
#
# choose_course(stu1, 'python全站开发')
# choose_course(stu2, 'linux全站开发')

# 版本3

def choose_course(stu_dic,course):
    stu_dic['courses'].append(course)
    print("%s 选课成功 %s" % (stu_dic['name'], stu_dic['courses']))

stu1 = {
    'name':'egon',
    'age' : 18,
    'gender' : 'male',
    'courses': [],
    'choose_course':choose_course
}

stu2 = {
    'name':'tom',
    'age' : 18,
    'gender' : 'male',
    'courses': [],
    'choose_course':choose_course
}


stu1['choose_course'](stu2, 'python开发')
stu2['choose_course'](stu2, 'linux开发')

类的概念

"""
对象：特征和节能的结合体

类：一系列对象相似的特征和相似的技能的结合体

强调：站在不同的角度，划分的分类是不一样的

问题：先有类还是先有对象？
    1.现实中：
        必须先有对象，在有类
    2. 程序中:
        必须先定义类，在调用类产生对象
"""

# 定义类
"""
class 类名():
    pass
    
    
def 函数名():
    pass
    
类名： 一般是首字母大写
"""

class Student():
    school = 'SH'

    def choose_course(stu_dic, course):
        stu_dic['courses'].append(course)
        print("%s 选课成功 %s" % (stu_dic['name'], stu_dic['courses']))

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

print(Student.__dict__)
#
#
# # 造对象，调用类，产生对象
stu1 = Student()  # 调用类 产生空对象
# stu2 = Student()
#
print(stu1.__dict__)

调用类的过程就是实例化， 得到的对象就是一个实例

定制对象自己独有的属性

# 版本3


"""
    产生对象发生了几件事？
        1. 产生一个空对象，并且把该空对象当成第一个参数传递
"""

class Student():
    school = 'SH'

    # 初始化方法
    def __init__(stu_obj, name, age, gender, courses=[]):
        stu_obj.name = name  # stu1.__dict__['name'] = 'egon'
        stu_obj.age = age  # stu1.__dict__['age'] = 20
        stu_obj.gender = gender  # stu1.__dict__['gender'] = 'male'
        stu_obj.courses = courses  # stu1.__dict__['courses'] = []

    def choose_course(stu_dic, course):
        stu_dic['courses'].append(course)
        print("%s 选课成功 %s" % (stu_dic['name'], stu_dic['courses']))


    # print(123)


# 类的名称空间
# print(Student.__dict__)
stu1 = Student('egon', 18 ,'male')

print(stu1.__dict__)
# stu2 = Student()

# stu1.name = 'egon'      # stu1.__dict__['name'] = 'egon'
# stu1.age = 18           # stu1.__dict__['age'] = 20
# stu1.gender = 'male'    # stu1.__dict__['gender'] = 'male'
# stu1.courses = []       # stu1.__dict__['courses'] = []
#
#
# stu2.name = 'tom'      # stu2.__dict__['name'] = 'egon'
# stu2.age = 18           # stu2.__dict__['age'] = 20
# stu2.gender = 'male'    # stu2.__dict__['gender'] = 'male'
# stu2.courses = []       # stu2.__dict__['courses'] = []


#
# init(stu1, 'egon', 18, 'male')
# init(stu2, 'tom', 18, 'male')
#
#
# print(stu1.__dict__)
# print(stu2.__dict__)

属性查找

class Student():
    school = 'SH'
    # 初始化方法
    def __init__(stu_obj, name, age, gender, courses=[]):
        stu_obj.name = name  # stu1.__dict__['name'] = 'egon'
        stu_obj.age = age  # stu1.__dict__['age'] = 20
        stu_obj.gender = gender  # stu1.__dict__['gender'] = 'male'
        stu_obj.courses = courses  # stu1.__dict__['courses'] = []

    def choose_course(self, course):
        self.courses.append(course)
        print("%s 选课成功 %s" % (self.name, self.courses))


    # print(123)


# 类的名称空间
# print(Student.__dict__)
stu1 = Student('egon', 18 ,'male')
stu2 = Student('tom', 18 ,'male')

# print(stu1.__dict__)

# 1 类的属性查找
# print(Student.__dict__['school'])

# # Student.__dict__['xxx'] = 'xxx'
# del Student.__dict__['xxx']

# Student.xxx = 'xxx'
#
# del  Student.xxx

# Student.school = 'MMM'
# print(Student.school)

# print(Student.choose_course)
# Student.choose_course(stu1, 'python')


# 对象操作属性  点语法取值，先从自己对象中取，如果没有，在取类中取值
# print(stu1.school)
#
# stu1.xxx = 'x'
# del  stu1.xxx
# stu1.school = 'y'

# Student.school = 'x'
# print(stu1.school)


# 类中的属性是共享给所有对象的，但是，类中的方法是给对象用的, 并且，把对象自己当成第一个参数传递
# stu1.school = 'y'
# print(stu1.school)
#
# print(stu2.school)

stu1.choose_course('python')

小练习

"""
定义个学生类，产生一堆对象


要求：
    增加一个计数器，记录产生了多少个对象？
"""
class Student():
    school = 'SH'
    # 初始化方法
    count = 0

    def __init__(self, name, age, gender, courses=[]):
        self.name = name
        self.age = age
        self.gender = gender
        self.courses = courses
        Student.count += 1

    def choose_course(self, course):
        self.courses.append(course)
        print('%s选课成功 %s' % (self.name, self.courses))


stu1 = Student('egon', 18, 'male')
stu2 = Student('eva', 21, 'male')
print(Student.count)

print(stu1.count)
print(stu2.count)

print(stu1.__dict__)
print(Student.__dict__

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DNsx3na4-1626092358782)(%E4%BB%8A%E6%97%A5%E7%AC%94%E8%AE%B0.assets/image-20210712164245792.png)]

"""
定义两个英雄类，

要求：
    1. 英雄要有昵称，生命值， 攻击力
    
    2. 产生两个对象
    
    3. 互相攻击，生命值小于0，判定为死亡

"""

class Hero:

    def __init__(self, name, level, attack):
        self.name = name
        self.level = level
        self.attack = attack

    def action(self, people):
        if people.name == self.name:
            print("自己对自己无法进行攻击")
            return

        people.level -= self.attack

        if people.level <= 0:

            print('%s已经被%s打死了' % (people.name, self.name))
            return
        print("%s攻击了%s，%s还剩%s的生命值" % (self.name,people.name, people.name,people.level))

hero1 = Hero('eva', 100, 50)
hero2 = Hero('wyz', 80, 20)

hero2.action(hero1)
hero1.action(hero2)
hero1.action(hero2)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JeNhWu1x-1626092358784)(%E4%BB%8A%E6%97%A5%E7%AC%94%E8%AE%B0.assets/image-20210712164610733.png)]