python面向对象基础

面向对象基础

1. 简述

• 编程方式：

  • 面向过程： 根据代码在脚本的堆叠顺序，从上到下依次执行
  • 函数式编程：将相同功能的代码封装到函数中，直接调用即可，减少代码重复性
  • 面向对象：对函数进行分类和封装，将同类的函数放到一个类中，使调用更简单

• 为嘛要面向对象

  • 应用需求 要的对系统的cpu、内存、硬盘等进行监控，超过阈值则告警

  while True：
      if cpu利用率 > 90%:
          #发送邮件提醒
          连接邮箱服务器
          发送邮件
          关闭连接
  
      if 硬盘使用空间 > 90%:
          #发送邮件提醒
          连接邮箱服务器
          发送邮件
          关闭连接
  
      if 内存占用 > 80%:
          #发送邮件提醒
          连接邮箱服务器
          发送邮件
          关闭连接

  随着python的学习，开始使用函数式编程

  def 发送邮件(内容)
      #发送邮件提醒
      连接邮箱服务器
      发送邮件
      关闭连接
  
  while True：
  if cpu利用率 > 90%:
      发送邮件('CPU报警')
  
  if 硬盘使用空间 > 90%:
      发送邮件('硬盘报警')
  
  if 内存占用 > 80%:
      发送邮件('内存报警') 

  函数式编程增加了代码的可读性和重用性，但是，这仅仅是单台机器的监控，如果我要监控多台呢，可能需要需要这样写：

def 发送邮件(内容)
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
 
    while True：
        for host in host-list:  #通过遍历host列表来进行监控
            if cpu利用率 > 90%:
                发送邮件('CPU报警')
         
            if 硬盘使用空间 > 90%:
                发送邮件('硬盘报警')
         
            if 内存占用 > 80%:
                发送邮件('内存报警') 
    

这样貌似实现了，但是如果是1000台机器呢，可能当循环到999台的时候，第100台已经出现问题了。造成告警延误。而如果使用面向对象呢？将很好的解决此问题

class host：
    def 发送邮件(内容)
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
 
    def judge(self):
        while True：
            if cpu利用率 > 90%:
                发送邮件('CPU报警')
         
            if 硬盘使用空间 > 90%:
                发送邮件('硬盘报警')
         
            if 内存占用 > 80%:
                发送邮件('内存报警') 

我将每个机器创建为一个对象，对象中有上面判断的方法,这样我就可以多线程的监控

2. 面向对象

• 类和对象
  类就是一个模板，模板里可以包含多个方法（即函数），方法里实现一些功能，对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

  • 创建类和对象

  ＃创建类  class+类名
  class foo:               #class是关键字，表示类，foo是类的名字
      def f1(self):               ＃类的方法1
          pass
      def f2(self):               ＃类的方法2
          pass
  
  ＃创建对象  对象 = 类名()
  bar ＝ foo()   ＃创建一个bar对象 ，此对象中有类中所有的方法 ，创建对象，类名称后加括号即可 
  
  #调用对象的方法  对象.方法名()
  bar.f1()
  bar.f2()

  • 举例：

  ＃创建类
  class SQL:
  
      def create(self,sql):
          print(sql)
  
      def modify(self, sql):
          print(sql)
  
      def remove(self,sql):
          print(sql)
  
      def fetch(self,sql):
          print(sql)
  
   ＃创建对象
   obj1 ＝ SQL()
   obj2 =SQL()
  
   #调用对象里的方法
   res1 = obj1.modify('修改')
   res2 ＝ obj2.fetch('查看')
   print('obj1:'res1)
   print('obj2:'res2)
  
   运行结果：
   obj1: 修改
   obj2: 查看

  • 应用场景

    • 面向对象：【创建对象】【通过对象执行方法】,适用于当某一些函数中具有相同参数时,可以使用面向对象的方式,将参数值一次性封装到对象里,函数直接调用即可
    • 函数编程：【执行函数】 各个函数之间是独立且无共用的数据

• 类中的self是什么鬼
  self是python自动传值的一个形式参数，那个对象调用方法,就会自动执行self，在一个类中，self就是对象本身
  还用上面的例子，如果我需要在执行方法的时候，验证用户名、密码传，验证通过之后才能执行里面的方法,那我需要创建对象之后，进行赋值用户密码

class SQL:
    
     def modify(self, sql):
        print(sql)
        print(self.name)
        print(self.passwd)
    def remove(self,sql):
        print(sql)
        print(self.name)
        print(self.passwd)
    def fetch(self,sql):
        print(sql)
        print(self.name)
        print(self.passwd)

     
     ＃创建对象
     obj1 ＝ SQL()
     obj1.user = 'user'
     obj1.passwd = 'passwd'
     res1 = obj1.modify('修改')
     res2 ＝ obj2.fetch('结果')
     print(res1)
     print(res2)
     
     输出结果：
     修改
     user
     passwd
     结果
     user
     passwd

我们使用self来定义user和passwd变量，这样user和passwd对整个对象是生效的，所以在每个方法都都可以调用到

• 类的构造方法

上例发现每次对象调用方法都要进行对user 和password进行赋值。非常麻烦。
python类中使用init自动构造方法，当创建对象的时候自动执行该方法。如下使用init，这样我只需要定义一次即可

class SQL:
         def __init__(self,user,password):
              self.user = user
              self.password = password
        def create(self,sql):
        print(sql)
        print(self.name)
        print(self.passwd)
    def modify(self, sql):
        print(sql)
        print(self.name)
        print(self.passwd)
    def remove(self,sql):
        print(sql)
        print(self.name)
        print(self.passwd)
    def fetch(self,sql):
        print(sql)
        print(self.name)
        print(self.passwd)
obj1 = SQL('username','password')
obj1.remove()
obj2 = SQL('username1','password1')
obj2.remove()

3. 面向对象的三大特性

• 封装

  封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。所以，在使用面向对象的封装特性时，需要：

  • 将内容封装到某处

  class SQL:
      def __init__(self,name,passwd):   #类的构造方法，自动执行 
          self.name = name
          self.passwd = passwd
      def create(self,sql):    ＃类的一个方法
          print(sql,self.name,self.passwd)
  
  ＃创建类SQL的obj对象
  
  obj1 = SQL('fuzj','123')  #自动fuzj和123分别封装到对象obj1的name和asswd属性中
  obj2 = SQL('jie','311')  #自动jie和311分别封装到对象obj2的name和asswd属性中

  • 从某处调用被封装的内容

    • 方式1 通过对象直接调用

      res = obj1.name  ＃直接调用obj的user属性
      res2 = obj1.passwd   ＃直接调用obj的passwd属性
      print(res,res2)
      
      输出结果：
      fuzj 12313

    • 方式2 通过self间接调用

      res3 = obj1.create('fasdasda')
      print(res3)
      
      输出结果：
      fasdasda fuzj 12313

    • 多重封装

    类不仅可以将普通字符串封装到类中，还可以将一个对象封装到类中，看下面代码

  ＃创建类
  class SQL:
      def __init__(self,name,passwd):
          self.name = name
          self.passwd = passwd
      def create(self,sql):
          print(sql)
  
  class test:
      def __init__(self,name,obj):
          self.name = name
          self.obj = obj
  
      def add(self,arg):
          print(arg)
  
  class test2:
      def __init__(self,obj):
          self.obj = obj
      def iner(slef,arg):
              print(arg)
  
  ＃创建对象
  c1 = SQL('fuzj','12313')
  c2 = test('aaa',c1)   ＃把c1对象封装到c2对象里，c2对象会有c1对象的所有方法
  c3 = test2(c2)          ＃把c2对象封装到c3对象中，c3对象会有c2对象的所有方法，同时也就有了c1对象的所有方法
  
  ＃调用
  c1.create("c1调用自身create方法")
  c2.obj.create('c2调用c1的create方法')
  c3.obj.add('c3调用c2的add方法')
  c3.obj.obj.create('c3调用c1的create方法')
  
  结果：
  c1调用自身create方法
  c2调用c1的create方法
  c3调用c2的add方法
  c3调用c1的create方法

  可以看出，将a对象封装到b对象中，b对象也就有了a对象的所有方法，
  其关系如图：

  

  所以c3如果要使用c1的create的方法，需要如下调用
  c3.obj.obj.create()

• 继承

  类的继承是子类继承父类的所有方法，或者说基类继承派生类的所有方法

  class 父类:
      def 方法1(slef):
              pass
  class 子类(父类)：
        pass

  
  那么子类中就会有父类的方法1
  

  • 单继承

  一个子类只继承一个父类
  如下：

  class c1:
  def __init__(self):
      self.name = 'c1'
      self.user = 'c1uer'
  
  def test(self):
      print("c1_test")
  
  def test1(self):
      print("c1_test1")
  
  def test3(self):
      self.test()
  
  class c2(c1):
  
      def __init__(self):
          self.passwd = 'c2'
  
      def test(self):
          print("c2_test")
      def test2(self):
          self.test3()
  obj = c2()
  obj.test()
  obj.test1()
  obj.test2()
  
  执行结果：
  c2_test
  c1_test1
  c2_test

  继承规则：

  1) 调用子类的某个方法时，如果这个方法在子类中存在，则执行子类的方法，如果子类方法不存在，再去找父类的方法。所以执行obj.test()时，子类中有该方法，就直接执行该方法，不再父类中找，因此返回结果是c2_test;执行obj.test1()时，子类中没有改方法，就找到父类的方法，再执行,因此返回的结果是c1_test1
  2) 子类的方法优先于父类的方法，当父类的方法中有调取其他方法时，会优先查找子类的方法，所以执行c2_test2()时，发现该方法调用的时是test3(),于是开始从自己方法中查找test3()，然后再去找父类中的方法，找到父类的test3()方法，发现该方法调用了test()方法，于是会再次查找test()方法，发现自己有，所以就直接调用自己的test()方法，返回c2_test
  3) 子类继承父类，其实就是将父类中的方法子类中没有的全部挪到子类下

  • 多继承

    • python的子类可以继承多个父类，这是比java、c++等开发语言最大的优势

    单父继承，即没有共同的父类，规则为一条道走到黑

    class 父类1:
        pass
    class 父类2:
        pass
    class 子类(父类1，父类2)
        pass
    那么，子类中就会有父类1，父类2的所有方法

  #c4继承了c2，c3两个父类，c2继承了c1父类,c3和c1中都有test()的方法
  
  class c1:
      def test1(self):
          print("c1_test")
  
      def test(self):
          print("c1_test")
  
  class c2(c1):
      def test2(self):
          print('c2_test')
  
  class c3:
      def test3(self):
          print("c3_test")
      def test(self):
          print("c3_test")
  
  class c4(c2,c3):
      def test4(self):
          print('c4_test')
  
  obj = c4()
  obj.test()
  obj.test3()
  
  运行结果：
  c1_test
  c3_test
  
  从结果可以看出：obj.test()执行顺序为：
  首先去c4类中查找，如果c4类中没有，则继续去c2类中找，如果c2类中没有，则继续去父类c1类中找，所以test()打印的结果为c1_test
  obj.test3()执行顺序为：
  首先去c4类中查找，如果c4类中没有，则继续去c2类中找，如果c2类中没有，则继续去父类c1类中找，c1没有，则返回继续去另一个c4的父类c3中找，所以test3()打印的结果为c3_test
      ```

继承规则：
1）子类中有两个父类，会从左到右依次查找父类的方法
2）子类的父类如果还有继承，优先查找当前父类的父类
3）多继承的每次查找父类仍然遵循单继承的原则
即


同父继承，最上边有继承的是一个父类，情况则不一样了

#c4继承c2和c3两个父类，c2继承c1父类，c3继承c0父类，c0和c1继承c父类
class c:
    def test(self):
        print("c_test")

class c0(c):
    def test(self):
        print("c0_test")

class c1(c):
    def test1(self):
        print("c1_test")

class c2(c1):
    def test2(self):
        print('c2_test')

class c3(c0):
    def test3(self):
        print("c3_test")


class c4(c2,c3):
    def test4(self):
        print('c4_test')

obj = c4()
obj.test()

运行结果：
c0_test

查找顺序为：
1.查找c4中是否有test()方法，如果没有则查找c2中，c2中没有则查找c1中，c1中没有，不会继续查找父类了，会反回来查找c3类，c3类没有则找c0类，最后返回结果



该规则同样适用下面情况


• 多态：
  
  Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”

多态中python和其他编程语言最大的区别是传参问题。python的函数传参，参数可以是列表，字典，字符串，数字等，而java、c++等语言传递参数时，参数需要指定类型，一旦参数类型被指定，就只能处理此中类型的数据

• • 　举例：　

    python：
    
    ```
    def func(arg):
    pass
    
    arg 可以是字符串、数字、列表、字典等
    
    ```
    
    java或c++
    
    ```
    def func(int,arg)
    pass
    
    arg 只能处理int类型的数据
    def func(str，arg)
    pass
    arg只能处理字符串类型的数据，如果数据类型不符合的话。直接报错
    
    ```

  •  java如何支持多态
    
    

    class A:
    pass
    class B(A):
    pass
    class C(A)
    pass
    
    def func(B,arg):
    pass
    此时arg指定类型为B，那么只能为B的对象类型
    def func(A,arg)
    pass
    此时指定arg类型为A类型，而B和C都继承Ａ，所以ABC类型都可以使用了
    
    所以类似java的编程语言，都是利用类的继承关系来实现多态