面向对象——类，对象，属性

• 面向过程
  • 核心是过程二字，过程指的是解决问题的步骤，设计一条流水线，机械式的思维方式
  • 优点：复杂的问题流程化，进而简单化
  • 缺点：可扩展性差
• 面向对象：　　
  • 核心是对象二字，以上帝的视角，所有的物体都是对象，对象是特征与技能的结合体
  • 优点：可扩展性强
  • 缺点：编程复杂度高
  • 应用场景：用户需求经常变化：互联网应用，游戏，企业内部应用
• 类：一些列对象相似的特征与技能的结合体
  • 强调：站在不同的角度，得到的分类是不一样的
  • 在现实世界中：先有对象，再有类
  • 在程序世界中：先有类，再有对象，类相当于一个模型，定义好模型后，就可以照着这个模子生产对象了
  • 类在定义阶段，内部函数已经运行，这一点与函数不同，函数是在调用时才运行
• 创建类和对象

#定义类：程序中，先定义类（首字母大写）
class OldboyStudent:
    school = "oldboy"
    def learn(self):
        print("is learning")
    def eat(self):
        print("is eatting")
    def sleep(self):
        print("is sleeping")

• 类的使用
  • 引用类的属性

• #查询
  print(OldboyStudent.school)#oldboy
  #改
  OldboyStudent.school = "Oldboy"
  print(OldboyStudent.school)#Oldboy
  #增
  OldboyStudent.x = 1
  print(OldboyStudent.x)#1
  #删
  del OldboyStudent.x
  print(OldboyStudent.x)#没找到，报错

  • 调用类，或称为实例化，得到程序中的对象

• s1 = OldboyStudent()

  • __init__方法和对象的使用（__init__方法用来为对象定制自己独有的属性）
    • 加上__init__后，实例化的步骤为：
      • 1.先产生一个空对象s1
      • 2.OldboyStudent.__init__(s1,"Jone","男",23)

  • class OldboyStudent:
        def __init__(self,name,age,sex):
            self.name = name
            self.age = age
            self.sex = sex
    s1 = OldboyStudent("Jone","男",23)#先调用类产生空对象s1，然后调用oldboy_student.__init__(s1,"Jone","男",23)
    s2 = OldboyStudent("Tony","男",24)
    s3 = OldboyStudent("Lucy","女",20)
    #查
    print(s3.__dict__)#{'name': 'Lucy', 'age': '女', 'sex': 20}
    print(s3.name)#Lucy，和下面的代码等价
    print(s3.__dict__["name"])#Lucy
    #增
    s3.course = "python"#等同于s3.__dict__["course"]="python
    #删
    del s3.course  #等同于s2.__dict__.pop('course')
    print(s3.course)#报错

• 属性查找：类有两种属性：数据属性和函数属性
  • 类的数据属性是所有对象共享的，id都一样
  • 类的函数属性是绑定给对象用的，称为绑定到对象的方法，obj.methon称为绑定方法，内存地址都不一样 
    • 类中定义的函数（没有被任何装饰器装饰的）即为类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数
  • 　对象本身只有独有的特征，相似的特征放在类中，当对象在查找一个属性时，首先从自己独有的特征中查找，如果没有，再从类中查找
• 补充说明：
  • python中一切皆为对象，在python3中统一了类和类型的概念
  • 定义一个数字，实际上是创建了一个int类的对象

  • #绑定方法
    class OldboyStudent:
        school = "oldboy"#类的数据属性，所有对象共享，id都一样
        def __init__(self, name, age, sex):
            self.name = name
            self.age = age
            self.sex = sex
        def learn(self):#类的函数属性
            print("%s is learning"%self.name)
        def eat(self):
            print("%s is eatting"%self.name)
        def sleep(self):
            print("%s is sleeping"%self.name)
    s1 = OldboyStudent("Jone","男",23)#需遵循函数的参数规则，传入相应个数的参数
    s2 = OldboyStudent("Tony","男",24)
    s3 = OldboyStudent("Lucy","女",20)
    #类的数据属性，所有对象共享的，id都一样
    # print(id(OldboyStudent.school))#42042400
    # print(id(s1.school))#42042400
    # print(id(s2.school))#42042400
    # print(id(s3.school))#42042400
    #类的函数属性，类中定义的函数即类的函数属性
    # 类的函数属性是绑定给对象使用的，obj.method称为绑定方法，内存地址都不一样
    # print(OldboyStudent.learn)#<function OldboyStudent.learn at 0x00000000027E40D0>
    # print(s1.learn)#<bound method OldboyStudent.learn of <__main__.oldboy_student object at 0x00000000027E75C0>>
    # print(s2.learn)#<bound method OldboyStudent.learn of <__main__.oldboy_student object at 0x00000000027E75F8>>
    # print(s3.learn)#<bound method OldboyStudent.learn of <__main__.oldboy_student object at 0x00000000027E7630>>
    #绑定方法
    s1.learn()#Jone is learning
    OldboyStudent.learn(s1)#Jone is learning
    #以上两句代码是等同的，绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，
    #self可以是任意名字，但是约定成俗地写成self