面向对象编程

一、面向对象编程

　　面向对象是一门编程思想，核心是“对象”二字，对象指的是特征与技能的结合体，基于该编程思想写程序，就好比创造世界，一种“上帝式”的思维方式

优点：解决了程序的扩展性

缺点：编写程序的复杂度高，可控性差

面向对象编程可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

二、类与对象

1、什么是类

类指的是类型，类别，是具有相同的特征和技能的一类事物就是类，对象指的是特征与技能的结合体，在现实世界中，先有一个个的对象，总结出类。在程序中，必须先有类，再通过调用类，产生对象。对象是实际存在的，类是抽象产生的

2、如何定义类

比如: 选课系统:
            - 选课系统学生类:
                - 学生对象1:
                    特征:
                        - 姓名: 张三
                        - 性别: 男
                        - 年龄: 23
                        - 学校: oldboy

                    - 技能:
                        - 技术: python
                        - 学习: learn
                        - 选课: course

                - 学生对象2:
                    特征:
                        - 姓名: 李四
                        - 性别: 男
                        - 年龄: 27
                        - 学校: oldboy

                    - 技能:
                        - 技术: python
                        - 学习: learn
                        - 选课: course

先从现实世界中通过一个个对象总结出类，然后再定义类，后调用类产生对象。

定义类语法:
        class 关键字: 帮你产生类的。

        class 类的名字:
            - 对象之间相同的特征
                - 学校
                school = 'oldboy'

            - 对象之间相同的技能
                - python
                    def python():
                        pass

                - learn
                    def learn():
                        pass

                - course
                    def course():
                        pass

3、类的使用

'''
class 类名:
    特征
    技能

定义类名的规范:
    - 驼峰命名法

'''

def foo():  # 函数名指向的是函数的内存地址
    pass


print(foo)  # <function foo at 0x000001CDFF119048>


# 定义老男孩学生类
class OldboyStudent:  # 类名指向的是类的内存地址
    # 学生相同的特征
    # 在类中的特征 也称之为 “属性” attribute
    school = 'oldboy'

    # 学生相同的技能
    # 注意: 在类内部定义函数，会默认有一个参数self
    def learn(self):  # self此时当做一个形参
        print('learning....')


print(OldboyStudent)  # <class '__main__.OldboyStudent'>

# 查看类的名称空间
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])
OldboyStudent.__dict__['learn'](123)


# 类提供一种特殊获取名字的方式  “类名.名字” 的方式
# 查
print(OldboyStudent.school)
OldboyStudent.learn('tank')

# 改
OldboyStudent.school = 'OldGirl'
print(OldboyStudent.school)

# 删
del OldboyStudent.school

# 增
OldboyStudent.school = 'Oldboy'
print(OldboyStudent.school)
OldboyStudent.old_student = 'HuChenYang'
print(OldboyStudent.old_student)

'''
- 函数的名称空间：
    在调用函数时产生，函数调用结束后销毁。
    
- 类的名称空间:
    在定义阶段时产生，会将类中所有的名字，扔进类的名称空间中。
'''

4、对象

'''
对象的产生:
    - 调用类产生对象

    类名 + () 调用类产生对象

    类的名称空间在定义时产生，对象的名称空间在调用类时产生。

    调用类产生对象的过程称之为类的实例化，对象称之为类的一个实例。
'''

class Student:
    # 学校
    school = 'oldboy'

    # 学习技能   ----> method ---》 方法
    def learn(self):
        print(self)  #
        print('learning...')

stu1 = Student()
stu2 = Student()
stu3 = Student()
print(Student)  #
print(Student.school, 'Student...')
print(Student.learn, 'Student...')
Student.learn(123)
print('=' * 100)

print(stu1)  # <__main__.Student object at 0x0000017BFF8A5898>
print(stu1.school, 'stu1...')
print(stu1.learn, 'stu1...')
print(stu1)
# 对象调用方法时: 会将对象当做第一个参数传入方法中。
stu1.learn()  #

print('=' * 100)
print(stu2)  # <__main__.Student object at 0x0000017BFF8A5898>
print(stu2.school, 'stu2...')
print(stu2.learn, 'stu2...')
stu2.learn()

print('=' * 100)
print(stu3)  # <__main__.Student object at 0x0000017BFF8A5898>
print(stu3.school, 'stu3...')
print(stu3.learn, 'stu3...')
stu3.learn()

'''
由对象来调用类内部的函数，称之为对象的绑定方法。
    对象的绑定方法特殊之处: 会将对象当做第一个参数传给该方法。
'''

class Student():
    # 学校
    school = 'oldboy'

    # 给对象添加新的属性
    def __init__(self, name, age, sex):
        print(self.__dict__)

        self.name = name
        self.age = age
        self.sex = sex

        # 查看当前类的名称空间
        print(self.__dict__)

    # 公共方法
    def learn(self):
        print(self)
        print('learning...')


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

# stu1 = Student()  # Student(stu1)  ---> __init__(self)  ----> self == stu1
# stu2 = Student()  # Student(stu2)  ---> __init__(self)  ----> self == stu2
# stu3 = Student()  # Student(stu3)  ---> __init__(self)  ----> self == stu3
#
# stu1.name = '张三'
# stu1.age = 25
# stu1.sex = '男'
# print(stu1.name, stu1.age, stu1.sex)

stu1 = Student('李四', 27, '女')
print(stu1)
print(stu1.name, stu1.age, stu1.sex)

想要在调用类时，为对象传入对象独有的特征，需要用到绑定方法__init__

# __init__(self, name, sex, age):  # name---> 张三 ,  sex---> 女,  age----> 27
# 调用类时: 会将对象当做第一个参数，与括号内所有的参数一并传给__init__()
# stu1 = Student('李四', 27, '女')

在python中，一切皆对象，包括我们之前所学的数据类型例如

num = 10 ----> num = int(10)，int就是一个类

list1 = [1, 2, 3] ----> list1 = list([1, 2, 3])，list也是一个类

对象名字的查找顺序:

　　- 对象.属性，会先找对象自己的

　　- 若对象没有，会去找类的

　　- 若类没有，就会报错

调用类产生对象发生的事情:
1.会产生一个空对象的名称空间
2.会自动触发__init__，并且会将对象当做第一个参数传入。
3.会将调用类括号内的参数一并传给__init__()

对象绑定方法的特殊之处:
1.会将对象当做第一个参数传入。
2.若对象的绑定方法中还有其他参数，会一并传入。