python之面向对象

面向对象

在说面向对象前,先回忆一下什么是面向过程

一.面向过程

面向过程即为一种编程思想,重点在'过程'二字,过程指的就是解决问题的步骤,即先做什么,再做什么,基于该思想编写的程序就像在编写一条流水线,即是一种机械式思维

优点:将复杂问题流程化,简单化

缺点:程序扩展性差

二.面向对象

1.什么是面向对象

面向对象也是一种编程思想,重点在对象二字上,对象指的就是特征与技能的结合体,基于该思想编写程序就像是创造世界,这是一种上帝式思维

优点:可扩展性强

缺点:编写复杂程度高

2.什么是类

通俗的说,类就是指的是类型,类别

在两种角度去看待:

• 现实世界中:

  先有一个个的对象，经过社会的文明发展，随之总结出类。对象是实际存在的，而类抽象产生的。

• 在程序中:

  必须先有类，再通过“调用类，产生对象”。

类:就是一系列对象相同特征与技能的结合体,对象是真实存在的,而类是人总结归纳出来的

3.如何定义类

• 如何写类并产生对象:

  先从现实世界中通过一个个对象总结出类。

  然后再定义类，后调用类产生对象。

  (注意:在程序中务必保证先定义类,再调用类产生对象)

• 定义类的语法:

  class 就是定义类的关键字,产生类的

  '''
  - 学生对象1:
  特征:
      - 姓名: 马冬梅
      - 性别: female
      - 年龄: 95
      - 学校: oldboy
  
  - 技能:
      - 技术: python
      - 学习: learn
      - 选课: course
  
  - 学生对象2:
  特征:
      - 姓名: 夏洛
      - 性别: male
      - 年龄: 98
      - 学校: oldboy
  
  - 技能:
      - 技术: python
      - 学习: learn
      - 选课: course
  '''
  # 定义一个类
  class OldboyStudent:  # 注意类名的命名规范,使用驼峰体
  
      # 用变量表示特征(对象之间相同的特征),在类中的特征也称之为属性
      school = 'oldboy'
  
      # 用函数表示技能(对象之间相同的技能),在类的内部定义函数,会默认有一个参数self
      def learn(self):
          pass
  
      def cours(self):
          pass
  
      def python(self):
          pass
  

  # 定义一个类
  class OldboyStudent:  # 类名指向的是类的内存地址
         
      school = 'oldboy'
  
  
      def learn(self):
          pass
  
      def cours(self):
          pass
  
      def python(self):
          pass
      
      
      
  print(OldboyStudent)   
  # <class '__main__.OldboyStudent'>
  
  print(OldboyStudent.__dict__) 
  
  
  # 通过.__dict__可以查看类和对象的名称空间,返回的是一个字典
  
  
  
  #  输出结果:{'__module__': '__main__', 'school': 'oldboy', 'learn': <function OldboyStudent.learn at 0x000001F0D3C10048>, 'cours': <function OldboyStudent.cours at 0x000001F0D3C10678>, 'python': <function OldboyStudent.python at 0x000001F0D3C10E58>, '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None}
  
  查
  print(OldboyStudent.__dict__['school'])
  # 类名.名字的方式也可以获取属性
  print(OldboyStudent.school)   # 这两种方式都可以获取名字
  
  print(OldboyStudent.__dict__['learn'])   # 得到一个类里面的函数的内存地址
  OldboyStudent.__dict__['learn'](123)  # 需要传一个参数给self,函数才能执行
  
  
  输出结果
  # oldboy
  # oldboy
  # 类和对象都可以进行增删改查的操作
  
  改:
  OldboyStudent.school = 'YongBoy'
  print(OldboyStudent.school)
  
  输出结果:
  #  YongBoy
  
  
  删:
  del OldboyStudent.school
  print(OldboyStudent.school)
  
  输出结果:
  # 报错,该特征已经被删除
  
  
  增
  
  OldboyStudent.school = 'goodboy'  # 可以新建一个属性
  print(OldboyStudent.school)  
  
  输出结果:
  goodboy
      
   
  
  # 函数的名称空间：
      在调用函数时产生，函数调用结束后销毁。
      
  # 类的名称空间:
      在定义阶段时产生，会将类中所有的名字，扔进类的名称空间中。    
      
  
  

  4.对象的产生

  调用类产生对象

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

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

  调用类产生对象发生的事情:    
  1.会产生一个空对象的名称空间    
  2.会自动触发__init__，并且会将对象当做第一个参数传入。    
  3.会将调用类括号内的参数一并传给__init__().
  
  school = 'oldboy'
  
      def __init__(self, name, sex, age):  # stu1, 'tank', 'male', 17
         print(self.__dict__)
  
         # 给对象添加新的属性,这些值是由stu_1 = Student('tank', 'male', 17)传入的
        self.name = name  # stu1.x = 'tank'
        self.sex = sex  # stu1.y = 'male'
        self.age = age  # stu1.z = 17
  
         # 查看当前对象的名称空间
         print(self.__dict__)
  
  想要在调用类时，为对象传入对象独有 特征
  __init__(self, name, sex, age): 
  stu_1 = Student('tank', 'male', 17)
  # name---> tank ,  sex---> male,  age----> 17
  调用类时: 会将对象当做第一个参数，与括号内所有的参数一并传给__init__() stu1 = 
                      # 发生的过程
  # 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 = 'tank'
  # stu1.sex = 'female'
  # stu1.age = 84   
  # print(stu1.name, stu1.sex, stu1.age)
  #
  # print(stu1)
  # print(stu2)
  # print(stu3)
  
  

  5.调用类产生对象的过程称之为类的实例化，

  对象称之为类的一个实例。

  class OldboyStudent:
  
      # 用变量表示特征(对象之间相同的特种)
      school = 'oldboy'
  
      # 用函数表示技能(对象之间相同的技能)---->技能就是指方法(method)
      def learn(self):
          pass
  
  obj_1 = OldboyStudent()  # 类名 + () 调用类产生对象
  obj_2 = OldboyStudent()  # 产生的对象地址都是不同的 
  obj_3 = OldboyStudent()
  print(OldboyStudent)  # <class '__main__.OldboyStudent'>
  print(obj_1) #<__main__.OldboyStudent object at 0x0000025D6E71E348>
  print(obj_2) # <__main__.OldboyStudent object at 0x0000025D6E71E908>
  print(obj_3) # <__main__.OldboyStudent object at 0x0000025D759FA5C8>
  
  
  print(obj_1.school)  # 也可以通过对象调用特征属性和函数技能
  print(obj_1.learn())  # 对象调用方法时会将对象本身作为第一个参数传入
  print(OldboyStudent.learn('123')) # 通过类调用函数
  
  # 两种方式调用的函数是同一个内存地址的函数,但是不同的对象调用同一个函数会产生一个独立的内存地址
  
  
  
  

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

  6.对象名字的查找顺序

  对象名字的查找顺序：

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

  2.若对象没有，会去找类的。

  3.若类没有，则会报错。

  class People:
      country = 'China'
      name = 'jason'
  
      def __init__(self, name, age, sex):
          self.name = name
          self.age = age
          self.sex = sex
  
      def run(self):
          print('running...')
  
  
  obj1 = People('tank', 17, 'male')
  print(obj1.name)  # tank  找对象自己的name属性
  print(obj1.country)  # China  对象没有，找类中的属性
  # AttributeError: 'People' object has no attribute 'jason'
  # print(obj1.jason)  # 对象没有，类也没有，就会报错!
  print(obj1.__dict__)
  # 给对象的名称空间添加 country='中国' 属性
  obj1.country = '中国'
  print(obj1.__dict__)
  print(People.__dict__)
  print(obj1.country)
  
  

  7.一切皆对象

  在python中一切皆对象

补充：
什么叫方法？什么叫函数？
答：方法可以是类的绑定方法也可以是对象的绑定方法，但是有些情况类来调用就是普通函数，有几个参数就要传几个值