面向对象编程

一、面向对象编程

1. 面向过程编程：
               核心是过程二字，过程指的是解决问题的步骤，即想干什么再干什么后干什么。。。
               基于该思想编写程序就好比在设计一条流水线，是一种机械式的思维方式

     优点:
        复杂的问题流程化、进而简单化
     缺点：
        可扩展性差

2.面向对象编程：
              核心对象二字，对象是特征也技能的结合体。
              基于改思想编写的程序就好比在创造一个世界，你就是这个世界的上帝，是上帝的一种思维方式。

      优点：可扩展性强
      缺点：编程的复杂程度要高于面向过程

3.类
    类：种类、分类、类别
    对象是特征与技能的结合体，类是一系列对象相似的特征与技能的结合体
    强调：站的角度不同，总结出来的类是截然不同的

    在现实世界中：先有的一个个具体存在的对象，然后随着人类文明的发展才分了类的概念。
    在程序中：必须先定义类，后调用类来产生对象

    现实世界总结对象———》抽取相似之处，得到现实世界中的类————》定义为程序中的类————》调用类产生程序中的对象

   站在老男孩选课系统的角度，先总结现实世界中的老男孩的学生对象
    对象1：
        特征：
            学校='oldboy'
            姓名='耗哥'
            年龄=18
            性别='male'
        技能：
            选课

    对象2：
        特征：
            学校='oldboy'
            姓名='猪哥'
            年龄=17
            性别='male'
        技能：
            选课

    对象3：
        特征：
            学校='oldboy'
            姓名='帅翔'
            年龄=19
            性别='female'
        技能：
            选课

站在老男孩选课系统的角度，先总结现实世界中的老男孩学生类
    老男孩学生类：
        相似的特征：
            学校='oldboy'
        相似的技能
            选课


在程序中：
          1.先定义类
          class OldboyStudent:
              school='oldboy'

          def choose_course(self):
               print('is choosing course')


          类体代码会在定义类阶段就立刻执行，会产生一个类的名称空间，将类体代码执行过程中产生的名字都丢进去

          类的本身其实就是一个容器/名称空间，从类的名称空间中增、删、改、查名字
          如何查看：（可以进行增、删、改、查）
          print（OldboyStudent.__dict__)
          print(OldboyStudent.__dict__['school'])
          print(OldboyStudent.__dict__['choose_course'])
          OldboyStudent.__dict__['choose_course']()

          print(OldboyStudent.school) #OldboyStudent.__dict__['school']
          print(OldboyStudent.choose_course) #OldboyStudent.__dict__['choose_course']

           类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个
           OldboyStudent.choose_course(123)


          OldboyStudent.country='China' #OldboyStudent.__dict__['country']='China'
          OldboyStudent.country='CHINA' #OldboyStudent.__dict__['country']='China'
          del OldboyStudent.school
          print(OldboyStudent.__dict__)


          2.后调用类产生对象，调用类的过程，又称为类的实例化，实例化的结果成为类的对象/实例

          stu1=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
          stu2=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
          stu3=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例


3.为对象定制自己独有的属性

            对象的本质也就是一个名称空间而已，对象的名称空间是用存放对象自己独有的名字/属性，而类中存放的是对象们共有的属性


            class OldboyStudent:
                school='oldboy'


                def __init__(obj, x, y, z): #会在调用类时自动触发
                    obj.name = x    #stu1.name='耗哥'
                    obj.age = y     #stu1.age=18
                    obj.sex = z     #stu1.sex='male'

                def choose_course(self):
                    print('is choosing course')

            调用类时发生两件事
            1、创造一个空对象stu1
            2、自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入
            stu1=OldboyStudent('耗哥',18,'male') #OldboyStudent.__init__(stu1,'耗哥',18,'male')
            stu2=OldboyStudent('猪哥',17,'male')
            stu3=OldboyStudent('帅翔',19,'female')

            print(stu1.__dict__)
            print(stu2.__dict__)
            print(stu3.__dict__)



4.属性查找

           先从对象自己的名称空间找，没有则取类中找，如果类也没有则报错

       eg:统计实例或多少次
            class OldboyStudent:
                school='oldboy'
                count=0

                def __init__(self,x,y,z):
                    self.name=x
                    self.age=y
                    self.sex=z
                    OldboyStudent.count+=1

                def choose_course(self):
                    print('ids choosing course')
            stu1=OldboyStudent('猴哥',18,'male')
            stu2=OldboyStudent('八戒',17,'male')
            stu3=OldboyStudent('沙僧',16,'male')
            print(stu1.count)
            print(stu2.count)
            print(stu3.count)




5.绑定方法

          类名称空间中定义的数据属性和函数属性都是共享给所有对象用的
          对象名称空间中定义的只有数据属性，而且是对象所独有的数据属性


         类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意为着要完全遵循函数的参数规则，该传几个就传几个
         OldboyStudent.choose_course(123)


         类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象用的
         绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当做第一个参数自动传入
          print(id(stu1.choose_course))
          print(id(stu2.choose_course))
          print(id(stu3.choose_course))
          前三个id相同
          print(id(OldboyStudent.choose_course)

         补充：类中定义的函数，类确实可以使用，但其实类定义的函数大多情况下都是绑定给对象用的，所以在类中定义的函数都应该自带一个参数self


6.类即类型
          在python3中统一了类与类型的概念，类就是类型

            l=[1,2,3] #l=list([1,2,3])
            # print(type(l))
            # l.append(4) #（本质就是）list.append(l,4)
            list.append(l,4)
            print(l)



7.小结
        对象是一个高度整合的产物，整合数据与专门操作数据的方法（绑定方法）