面向对象基础——初识面向对象

面向过程思想和面向对象思想

面向过程思想

​ 面向过程不是一门技术，而是一种编程的思想。

​ 面向过程思想的核心是“过程”二字，所谓“过程”，即为先干什么，再干什么，最后干什么，所展现的是一种机械式思维方式。我们通过下面的例子来简单认识一下：

# 例1：大象放冰箱的步骤：
    1. 打开冰箱门，
    2. 把大象放进冰箱
    3. 观赏冰箱门
        
# 例2:写一个简单的注册功能
    # 1. 先获取用户名和密码
    def get_userinfo():
        username = input('username：').strip()
        password = input('password：').strip()
        email = input('email：').strip()

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

    # 2. 验证参数
    def check_info(userinfo):
        flag = False
        if len(userinfo['username']) == 0:
            print('username不能为空')
            flag = True
        if len(userinfo['password']) == 0:
            print('password不能为空')
            flag = True
        if len(userinfo['email']) == 0:
            print('email不能为空')
            flag = True

        return {
            'userinfo': userinfo,
            'flag': flag
        }


    import json
    # 3. 写入文件保存用户注册信息
    def save_info(param):
        # 验证参数
        if not param['flag']:
            with open('userinfo.txt', 'w', encoding='utf-8') as f:
                json.dump(param['userinfo'], f)


    def main():
        userinfo = get_userinfo()
        param = check_info(userinfo)
        save_info(param)


    if __name__ == '__main__':
        main()

上面的例子就是按照面向过程的编程思想来完成的，下面说说面向过程思想的优缺点以及应用场景做出介绍：

• 优点：将复杂的问题简单化，流程化。
• 缺点：可扩展性差
• 应用场景：对扩展性要求不高的地方

面向对象思想

​ 面向过程思想的核心是“过程”二字，类比可知，面向对象思想的核心是“对象”二字，所谓对象，我们通过两个方面来考虑，在程序中，“对象”就是盛放数据属性和功能的容器，python语言中，一切皆对象；在现实生活中，“对象”就是特征与技能的结合体。下面我们通过例子来认识一下：

# 在python中，一切皆对象

例：学生选课系统

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

stu1 = {
    'name': 'tom',
    'age': 19,
    'gender': 'male',
    'courses': [],
    'choose_course':choose_course
}

stu2 = {
    'name': 'mary',
    'age': 20,
    'gender': 'female',
    'courses': [],
    'choose_course': choose_course
}

stu1['choose_course'](stu1, 'python')
stu2['choose_course'](stu2, 'python')

下面来说说面向对象思想的优缺点以及应用场景：

• 优点：扩展性强
• 缺点：设计难度复杂，上手难度高
• 应用场景：对扩展性要求高的地方

类的定义和对象的产生

​ 上面提到，“对象”是特征和技能的结合体，那么我们下面所要提到的类则表示一系列对象相似的特征和相似的技能的结合体，简单来说，就是一系列对象的相似点。那么问题来了，到底是先有类还是先有对象呢？

​ 在现实生活中，一定是先有对象，再根据对象的相似点进行分类，得到了类；而在程序中，则必须是先定义类，再调用类，才能产生对象。下面我们通过代码来看看如何定义类，以及如何产生对象：

• 定义类：使用class关键字

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("我执行啦！")

    
# 如何查看类的名称空间，通过.调用__dict__
print(Student.__dict__)


'''
    定义类发生了哪几件事？
        1. 类定义完成后，会立马执行类体代码
        2. 执行类体代码，把类中的名字都丢到类的名称空间去
        3. 把类的名称空间绑定给__dict__, 类名.__dict__
'''
# 注意事项：类名，遵循变量的命名规范即可，类名一般都是首字母大写，当类名有多个单词时，推荐使用大驼峰体。

• 产生对象： 调用类，通过类名加括号实现，这种过程我们称为实例化，类通过实例化生成对象。

stu1 = Student()  # 调用类，得到一个空对象
stu2 = Student()

# 如何查看对象的名称空间
print(stu1.__dict__)  # 空字典
print(stu2.__dict__)  # 空字典

定制对象独有的属性

​ 在类中定义的属性为类所有，那么通过实例化后产生的对象独有的属性该如何定义呢？

# 在类中，我们可以通过定义__init__方法，又称魔术方法，在__init__方法中定制属于对象独有的属性
class Student():
    # 定义类属性
    school = 'SH'

    # 初始化, 魔术方法
    def __init__(stu_dic, name, age, gender, course=[]):
        stu_dic.name = name  # stu.__dict__['name'] = 'tom'
        stu_dic.age = age  # stu.__dict__['age'] = 19
        stu_dic.gender = gender  # stu.__dict__['gender'] = 'male'
        stu_dic.course = course  # stu.__dict__['course'] = []

    # 在类中，函数被称为是方法
    def choose_course(stu_dic, course):
        stu_dic['courses'].append(course)
        print('%s选课成功%s' % (stu_dic['name'], stu_dic['courses']))



# 调用类的时候，会自动触发__init__方法，并且，会把对象自己当成第一个参数传给函数
stu = Student('tom', 19, 'male')   # 等价于stu = Student(stu, 'tom', 19, 'male')
stu1 = Student('kevin', 19, 'male') 

print(stu.__dict__)
print(stu1.__dict__)

'''
    调用类的过程也称为是实例化的过程，得到的对象就是一个实例，实例化发生了三件事：
    	1. 先产生一个空对象
    	2. python会自动调用类中的__init__方法，将空对象以及调用类时括号内传入的参数一同传给__init__
    	3. 返回初始化完成的对象
'''

总结：__init__方法注意事项

• 会在调用类时自动触发执行，用来为对象初始化自己独有的数据
• __init__内应该存放的是为对象初始化属性的功能，但是可以存放任意其他代码，想要在类调用的时候就立即执行的代码都可以放在该方法中
• __init__方法必须返回None

属性的查找顺序

print(stu1.__dict__)
# 1.类属性

# 查
# 方式一：通过__dict__获取
print(Student.__dict__['school'])
# 方式二：通过.方式（推荐）
print(Student.school)

# 改：直接.名字重新赋值即可
Student.school = 'xxx'

# 删除：通过del关键字
del Student.school

# 增
Student.aaa = 'xxx'
print(Student.__dict__)

# 2. 对象属性的增删改查

# 查
print(stu.name)
print(stu.age)
print(stu.gender)

# 增
stu.x = 'aaa'
print(stu.__dict__)

# 改
stu.x = 'bbb'

# 删除
del  stu.x

# 对象的属性查找顺序：先在对象自己的名称空间中查找，如果找不到，去产生对象的类中取查找
print(stu.school)
# print(stu.__dict__['school'])

练习题

# 练习一：定义一个学生类，产生一堆对象

class Student():
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

sut1 = Student('mary',18,'female')
stu2 = Student('jack',28,'male')
stu3 = Student('tom',38,'male')

    
# 练习二：在练习一的基础上，需要一个计数器，记录产生了几个对象

class Student():
    count=0
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        Student.count += 1


stu1 = Student('tom1', 19, 'male')
stu2 = Student('tom2', 19, 'male')
stu3 = Student('tom3', 19, 'male')

# 类属性一改则全改
print(stu1.count)
print(stu2.count)
print(stu3.count)