面向对象编程

面向对象编程

1、面向对象与面向过程编程

# 面向过程与面向对象编程
# 在编程中存在两大编程思想：面向过程编程，面向对象编程
# 1、面向过程:重点在于过程两个字，简单来说就是先做什么，再做什么，最后再说什么，总得来说就是解决问题的流程

"""
生活中这样的例子很多，就拿我们平常最常见的刷牙来说
    第一步：打水
    第二步：漱口
    第三步：刷牙
    第四步：漱口
以上就是刷牙的整个流程，即过程
"""
"""
在编程中，面向过程的思想也是如此，这里拿注册功能来说
    第一步：获取用户输入的注册信息
    第二步：对用户的输入进行比对判断
    第三步：比对成功，写入文件，注册成功
而以上就是注册功能的整个流程，即过程


从以上两个例子可以对面向过程的利弊做一个总结
    利：可以很清晰的知道每一步要做什么，整个过程中的流程很清晰，复杂的问题流程化，进而简单化
    弊：同时，当我们其中某一个环节出错后，或者对某一个环节作出改变时，就会直接影响到整个流程，即牵一发而动全身，可维护性、扩展性差
    因此可以得出面向过程的应用场景：
    适用于不经常作出改变，即对扩展性要求不高的地方
"""
# 2、面向对象：重点在于对象两个字，那么什么是对象
"""
    1、什么是对象
        现实生活中：在现实生活中，一切皆对象，一个人是一个对象，一个动物也属于一个对象
        编程中：在编程中，我们把存放一系列数据和功能（函数）的结合体称为对象
                而函数之前说过，就是一系列功能的结合体
        那么，怎么去更加深刻的理解编程中的对象呐？
        这里我们以超人为例：上面说了，超人本身就是一个对象，超人的数据无非就是体重，身高，体重，性别这些，也可以说是属性
                        而超人本身所具备的能力则可以说成是他所具备的功能，以编程里的术语也就可以理解为，超人就是一系列数据和和功能的结合体，
    2、对象是拿来干什么的
        对象准确来说，就是用来盛放一系列数据和功能的容器           
"""
# 3、下面以一个实例来阐述一下编程中面向对象的利弊
# 这里以学生选课系统来说
# 要有学生基本信息，选课功能
# 获取学生的基本信息
name = 'Jacky Liu'
age = 22
course_list = []  # 用来存放选的课的信息，初始值为空列表
gender = 'male'


# 定义一个选课的函数
def course(course_list, course, name):
    course_list.append(course)
    print('%s选课成功 %s' % (name, course_list))


# 想要选课时就需要调用函数
course(course_list, 'python', name)  # Jacky Liu选课成功 ['python']
'''
我们会发现，每个同学执行一次就要重新录入同学的基本信息并执行选课功能函数，写起来很麻烦
'''
# 这里我们再继续往后推导
"""
之前我们学过可以将函数对象（函数名）作为可变类型的元素，那这里我们可不可以将
数据和调用函数写在一起。
"""


# 定义一个选课的函数
def course(stu_dic, course):
    stu_dic['course_list'].append(course)
    print('%s选课成功 %s' % (stu_dic['name'], stu_dic['course_list']))


# 定义学生信息字典
stu_dic = {
    'name': 'jacky Liu',
    'age': 22,
    'gender': 'male',
    'course_list': [],  # 用来存放选的课的信息，初始值为空列表
    'course_func': course
}
# 执行选课函数
# jacky Liu选课成功 ['python']
stu_dic['course_func'](stu_dic, 'python')  # 将学生信息字典当做参数传进函数
'''
    这里可以看出来，我们将选课功能和学生信息提前写在用户信息字典里，
在需要进行选课时，只需要用字典的取值方式就可以执行选课功能函数；
    到了这里，应该对对象有了一个大概的了解，上面说了，对象就是一系列数据
和功能的结合体，很明显上面的学生信息字典已经符合对象的定义
    而且，从学生信息字典去执行选课功能我们采用的是调用对象里的某个功能，而不是再采用一整个流程的思想去解决问题，
    所以从根本上不存在流程一说，想用什么功能直接从对象里调用就可以了，那这里我们可以总结出面向对象有哪些优点和缺点
    面向对象的利与弊：
        利：由于我们需要什么功能就可以直接从对象中调用功能，所以说不会牵扯到某一环节出问题就使问题的解决受影响的，
        可扩展性强，可维护性强
        弊：面向对象同时也有弊端，由于是一系列数据和功能的结合体，所以编程的复杂度较高
'''

2、类的定义个对象的产生

# 类的定义个对象的产生
# 1、什么是类？
'''
    在了解了对象以后，我们知道了
    对象就是一系列数据和功能的结合体（属性与功能的结合体）
    那么什么又是类吗？
'''
"""
    1、什么是类
        先从现实中说起：我们都知道，凡是带翅膀的，能飞的，我们都称为是飞行类，
                      从这里我们可以挖掘出两个关键字：带翅膀，会飞
                      翅膀这里我们可以把他看成是飞行类都具有的一个特征或者是属性，
                      而会飞行，能飞行，我们都知道是这个事物能做什么，能干什么，也就是能力，功能    
        再从编程的角度来说：上面我们说了现实中的每一个动物都是一个对象，那我们可以想当然的认为
                         带翅膀的，会飞的动物都属于飞行类，那是不是说，飞行类就是一系列会飞的动物（对象）的
                         集合体，而飞行类里的每一个动物（对象）都具有相似的特征和功能
                         那我们在这里就可以断言:
                         编程中的类就是一系列具有相似特征（属性）和相似功能的对象的结合体
    2、类是用来干什么的
        存放一系列具有相似属性（特征）和相似功能的对象的容器
    3、类通常是靠什么来划分的
        从现实中来说：飞行类细分又可分为鸟类，昆虫类等，而编程中的类也是如此
        这里做个结论：站在不同的分类，划分的类也不完全一样
"""
# 在对类进行了了解以后，紧接着又冒出了一个问题
# 2、类和对象的产生顺序
'''
    类和对象产生的先后顺序又是怎样的呐
        从现实世界中看：先有各式各样的会飞的东西，后面才产生了飞行类一词，
                  所以从现实中来看，是先有对象，继而才有的类
        从编程世界里看：前面说了类是一系列具有相似属性（特征）和形似功能的对象的结合体，怎么理解这句话呐，
                      我们可以简单的理解为，编程世界里对象并不是凭空产生的，只有在产生一个类，才能从类中产生
                      各种各样的对象
'''
# 3、类的产生（定义）：关键字：class
'''
语法结构：
    class 类名：  # 类名一般用驼峰体表示（首字母大写）
        类体代码
    在了解了类的定义以后，接下来还是以学生选课为例对类进行剖析   
'''

class Student:
    # 定义一个属性
    school = 'SH'

    # 定义选课功能
    def course(stu_dict, course):
        stu_dict['course'].append(course)
        print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))
    print('选课成功')
# 在定义类以后直接运行，会立即执行类体代码：选课成功
# 查看类的名称空间
print(Student.__dict__)  # 返回一个字典,存有类里的一系列数据和功能
'''
之前在学函数的时候，我们知道，函数在定义阶段是不运行函数体代码的，
而类不一样，在类定义好以后即运行类体代码，那么在类的定义阶段都发生了哪些事：
        1、立即执行类体代码
        2、产生一个类的名称空间,把类体里的面执行的名字都放到类的名称空间里
        3、把类的名称空间绑定给:__dict__，类调用__dict__方法返回存放在类名称空间里的数据和方法（函数）
'''


# 上面说了，编程中现有类才有对象，那么怎么产生对象
class Student:
    # 定义一个属性
    school = 'SH'
    print(222)
    # 定义选课功能
    def course(stu_dict, course):
        stu_dict['course'].append(course)
        print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))

def course(stu_dict, course):
        stu_dict['course'].append(course)
        print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))
        print(111)


# 调用类产生对象
stu1 = Student
print(stu1)
print(Student)
print(stu1.__dict__)  # {}  ,调用类的时候产生对象，默认产生的是一个空对象{}
print(stu1)  # <__main__.Student object at 0x000001F64D00A588>

3、给对象定制自己独有的属性

# 给对象定制自己独有的属性
'''
    上面我们知道了，调用类会产生一个对象，默认为空对象，且类似一个空字典的形式，
    那么怎么给产生的对象增加特征（属性呐）

'''


class Student:
    # 定义一个属性
    school = 'SH'

    # 定义选课功能
    def course(stu1, course):

        print('%s选课成功 ' % stu1.__dict__['name'])


stu1 = Student  # 调用类产生一个空对象
print(stu1.__dict__)  # {}  对象名调用__dict__方法返回对象中存储的数据和方法（函数）
# 由于产生的空对象是一个空字典，因此我们可以用字典增加值的方式给对象添加属性
stu1.__dict__['name'] = 'jacky Liu'
stu1.__dict__['age'] = 18
stu1.__dict__['gender'] = 'male'
print(stu1.__dict__)  # {'name': 'jacky Liu', 'age': 18, 'gender': 'male'}

'''
这样传值看起来是不是很麻烦，其实类中有一个特殊的方法__init__,又叫类的构造函数或初始化方法，
在调用类产生对象时自动执行该方法，将对象当作第一个参数自动传给__init__方法,
'''


class Student:
    # 定义一个属性
    school = 'SH'

    def __init__(self, name, age, gender, sex=None):
        # 空对象.__dict['name'] = name
        # 空对象.__dict['age'] = age
        # 空对象.__dict['gender'] = gender
        # print(222)
        self.__dict__['name'] = name
        self.__dict__['age'] = age
        self.__dict__['gender'] = gender
        # return None # 在__init__方法中不能有返回值，

    # def __init__(self):
    # 定义选课功能
    def course(self, course):
        print('%s选课成功' % self.name)


# 调用类生成对象
stu1 = Student('jacky Liu', 22, 'male', 20)
print(stu1.__dict__)
'''
__init__方法是类里的一个内置方法，在定义阶段，第一个参数就是对象本身，也就是self，不过也可以使用其他名字代替，
__init__是在调用类的时候首先执行初始化对象，再执行其他的，
且__init__方法不能通过类点__init__的方式直接调用，只能通过调用类的时候自动执行__init__方法，
且会把对象自身当作第一参数传给__init__，
因为__init__在定义阶段就已经定死了第一个参数就是对象本身self
'''
print(Student.__dict__['school'])
stu1 = Student('jacky Liu', 22, 'male', 20)
print(stu1)  # <__main__.Student object at 0x000001439E7FF080>
print(stu1.__dict__)  # {'name': 'jacky Liu', 'age': 22, 'gender': 'male'}
'''
    类调用阶段发生了什么：
        1、产生一个空对象stu
        2、产生一个空对象的名称空间stu.__dict__
        3、让对象指向类的名称空间
        4、调用了Student.__dict__方法(空对象，'jacky Liu', 22, 'male'),将空对象和类所需要的值传到类里
        5、执行__init__方法为对象增加属性，并将产生的名字放到空对象的名称空间里，得到一个初始化对象（有值的对象）
'''
'''
在类中，我们把产生对象的过程称为实例化对象，把变量称为属性，函数称为方法，
类里的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self
上面的self代表了类的实例(对象本身)，在定义类的方法时是必须有的，但是可以用其他变量代替
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 
按照惯例它的名称是 self
'''

4、属性的查找顺序

# 属性的查找顺序
'''
上面说了如何给对象增加属性，那么取出对象的属性的时候，查找顺序又是什么
'''


class Student:
    # 定义一个属性
    school = 'SH'

    def __init__(stu1, name, age, gender, sex=None):
        # 空对象.__dict['name'] = name
        # 空对象.__dict['age'] = age
        # 空对象.__dict['gender'] = gender
        stu1.__dict__['school'] = 'bj'
        if sex:
            stu1.__dict__['sex'] = sex
        stu1.__dict__['name'] = name
        stu1.__dict__['age'] = age
        stu1.__dict__['gender'] = gender
        # return None # 在__init__方法中不能有返回值，

    # 定义选课功能
    def course(stu1, course):
        stu1['course'].append(course)
        print('%s选课成功 %s' % (stu1['name'], stu1['course']))


# 调用类
stu = Student('jacky Liu', 22, 'male', 20)
# 取出对象里的数据
print(stu.__dict__['name'])  # jacky Liu
# 也可以直接用点加名字直接取值
print(stu.name)  # jacky Liu
# 当前对象内是没有school这个名字的
print(stu.school)  # SH
# 在init方法中加入一个school对象
print(stu.school)  # bj
'''
由此可以得出一个结论：
    当对象中有对应属性时，优先从对象中找，对象中没有时，从类的名称空间里找
    对象的名称空间>>>类的名称空间
属性的分类：
    类属性：在类中写的属性就叫类属性，类中的属性为共有属性，可供产生的每一个调用
    对象属性：在对象中写的属性就叫对象属性
'''
# 类属性的查找
# 增
Student.country = 'china'
# 删
del Student.country
print(Student.__dict__)
# 改
Student.country = 'BJ'
# 查
print(Student.school)  # 找不到报错
# 对象属性的查找
# 增
stu.salary = 200
print(stu.__dict__)  # {'school': 'bj', 'sex': 20, 'name': 'jacky Liu', 'age': 22, 'gender': 'male', 'salary': 200}
# 删
del stu.salary
print(stu.__dict__)  # {'school': 'bj', 'sex': 20, 'name': 'jacky Liu', 'age': 22, 'gender': 'male'}
# 改
stu.name = 'jason'
print(stu.__dict__)  # {'school': 'bj', 'sex': 20, 'name': 'jason', 'age': 22, 'gender': 'male'}
# 查
print(stu.name)  # jason


class Student:
    # 定义一个属性
    school = 'SH'

    def __init__(stu1, name, age, gender, sex=None):
        # 空对象.__dict['name'] = name
        # 空对象.__dict['age'] = age
        # 空对象.__dict['gender'] = gender
        stu1.__dict__['school'] = 'bj'
        if sex:
            stu1.__dict__['sex'] = sex
        stu1.__dict__['name'] = name
        stu1.__dict__['age'] = age
        stu1.__dict__['gender'] = gender
    #     return None # 在__init__方法中不能有返回值，

    # 定义选课功能
    def course(self, course):
        print('%s选课成功' % self)
    # x = 1
    def inner(self,x):
        print(222)

# 调用类里的方法（功能）
# 类调用
stu1 = Student('jacky Liu', 22, 'male', 20)
Student.course(stu1, 'python')  # jacky Liu选课成功
# 对象调用
stu1.course('python')  # jacky Liu选课成功
'''
类里的方法是公共的，类可以调用，对象也可以调用，但是推荐对象调用，因为对象调用的时候，
会默认把自身当作第一个参数传递给函数，类调用的时候必须按照函数的传统方式传值,
对象在调用类里的方法的时候，必须要先调用类初始化对象（调用__init方法），
'''


# 在之前我们学了一个内置方法isinstance用来判断数据类型
# 其实也可以拿来判断对象是不是属于某个类，返回True和False
class Text:
    pass


print(isinstance(stu, Student))  # True
print(isinstance(stu, Text))  # False
#

5、一切皆对象的概念

# 一切皆对象
'''
python是一门面向对象的语言，而在python中一切皆对象，所有的东西都是对象，
在python3中统一了类与类型的概念，比如：整型，浮点型、列表等这些都属于数据类型，即类型，
一个类型可以称为一个类，类其实就等同于类型
'''
# 自定义一个类
class Student:
    # 定义一个属性
    school = 'SH'

    def __init__(stu1, name, age, gender, sex=None):
        # 空对象.__dict['name'] = name
        # 空对象.__dict['age'] = age
        # 空对象.__dict['gender'] = gender
        stu1.__dict__['school'] = 'bj'
        if sex:
            stu1.__dict__['sex'] = sex
        stu1.__dict__['name'] = name
        stu1.__dict__['age'] = age
        stu1.__dict__['gender'] = gender
        # return None # 在__init__方法中不能有返回值，

    # 定义选课功能
    def course(stu1, course):
        print('%s选课成功' % stu1.name)
# 调用类生成一个对象
stu = Student('jason',20,'male')
# 查看对象里的属性
print(stu.__dict__)  # {'school': 'bj', 'name': 'jason', 'age': 20, 'gender': 'male'}
# 查看对象的类型
print(type(stu))  # <class '__main__.Student'>
# 查看列表的类型
print(list)  # <class 'list'>
# 再来看一下列表添加值的方式
l = [1,2,3]
# 采用内置方法append
l.append(5)
print(l)  # [1, 2, 3, 5]
# 再来看一下对象添加值的方式
stu.salary = 200
print(stu.__dict__)  # {'school': 'bj', 'name': 'jason', 'age': 20, 'gender': 'male', 'salary': 200}
'''
从以上实例中就可以说python中一切皆为对象
'''