首页 > 编程语言 > 详细

10.Python面向对象编程

时间:2021-09-12 11:30:11      阅读:46      评论:0      收藏:0      [点我收藏+]

初识面向对象

  • 什么是面向对象编程

    • 利用(面向)对象(属性与方法)去进行编码的过程

    • 自定义对象数据类型就是面向对象中的类(class)的概念

    • 类的关键字class

      • class来声明类,类的名称首字母大写,多单词情况下每个单词首字母大写

类的定义与调用

  • class Person(object):
        name = ‘ckk‘
    
        def add(self, a, b):
            return a + b
    
    
    ckk = Person() #类的实例化
    print(ckk.name)  #通过实例化进行属性调用, 控制台输出:ckk
    print(ckk.add(1, 2))  #通过实例化进行函数调用  控制台输出:3
    

类的参数self

  • self是类函数中的必传参数,且必须放在第一个参数位置
  • self是一个对象,他代表实例化的变量自身
  • self可以直接通过点来定义一个类变量
  • self中的变量与含有self参数的函数可以在类中的任何一个函数内随意调用
  • 非函数中定义的变量在定义的时候不用self

类的构造函数

  • 类中的一种默认函数,用来将类实例化的同时,将参数传入类中。
  • 自己可以创建构造函数,自己不创建,系统默认提供一个无参构造函数。
  • 子类不定义构造函数时候,默认引用父类构造函数
  • 子类定义了构造函数,默认不会引用父类构造函数

构造函数的创建:

  • def __init__(self,a,b):
      self.a=a
      self.b=b
    
  • 示例代码:

    • class Person(object):
      
          def __init__(self, name):
              self.name = name
      
          def run(self):
              print(f‘我叫{self.name}‘)
      
      p = Person(‘ckk‘)
      p.run()#我叫ckk
      

对象的生命周期

  • ____开头____结尾的类函数都是类的默认函数
  • 技术分享图片

私有函数和私有变量

  • 什么是私有函数和私有变量

    • 无法被实例化后的对象调用的类中的函数与变量
    • 类内部可以调用私有函数与变量
    • 只希望类内部业务调用使用,不希望被使用者调用
  • 私有函数与私有变量的定义方法

    • 在变量或函数前添加__(两个下横线),变量或函数名后边无需添加
  • 示例代码:

    • class Person(object):
      
          def __init__(self, name):
              self.name = name
      
          def run(self):
              print(f"我叫{self.name}.")
      
          def __run(self):
              print("我是Person类的,私有函数__run()")
      
      
      ckk = Person(‘ckk‘)
      ckk.run()  # 我叫ckk.
      # ckk.__run()# ‘Person‘ object has no attribute ‘__run‘ 报错 无法直接调用私有函数
      
      # 通过dir()内置函数 可以找到调用私有函数和属性的办法,但是既然是私有的,不推荐调用
      print(dir(ckk))  # ‘_Person__run‘, ‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__dir__‘, ‘__.....
      ckk._Person__run()  # 我是Person类的,私有函数__run()
      

封装

  • 将不对外的私有属性或方法通过可以对外使用的函数而使用(类中定义私有的,只有类内部使用,外部无法访问)

  • 这样做的主要原因:保护隐私,明确区分内外

  • 示例代码:

    • class Person(object):
      
          def __init__(self, name):
              self.name = name
      
          def run(self):
              print(f"我叫{self.name}.")
      
          def __run(self):
              print("我是Person类的,私有函数__run()")
      
      
      ckk = Person(‘ckk‘)
      ckk.run()  # 我叫ckk.
      # ckk.__run()# ‘Person‘ object has no attribute ‘__run‘ 报错 无法直接调用私有函数
      
      # 通过dir()内置函数 可以找到调用私有函数和属性的办法,但是既然是私有的,不推荐调用
      print(dir(ckk))  # ‘_Person__run‘, ‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__dir__‘, ‘__.....
      ckk._Person__run()  # 我是Person类的,私有函数__run()
      

装饰器

  • 什么是装饰器

    • 也是一种函数

    • 可以接受函数作为参数

    • 可以返回函数

    • 接收一个函数,内部对其处理,然后返回一个新的函数,动态的增强函数的功能。

    • 将b函数在a函数中执行,在a函数中可以选择执行或不执行b函数,也可以对b函数的结果进行二次加工处理。

    • def a():
        def b():
          print(‘hello‘)
        b()
        
      a()
      
  • 装饰器的定义

    • def out(func_args):  # 外围函数
          def inter(*args, **kwargs):  # 内嵌函数
              return func_args(*args, **kwargs)
      
          return inter  # 外围函数返回内嵌函数
      
  • 装饰器的用法

    • 将被调用的函数直接作为参数传入装饰器的外围函数括弧

    • 将装饰器与被调用函数绑定在一起

    • @符号+装饰器函数放在被调用函数的上一行,下一行创建函数,只需要直接调用被执行函数即可

    • 示例代码:

      • def check_str(func):
            def inner(*args, **kwargs):
                result = func(*args, **kwargs)
        
                if result == ‘ok‘:
                    return ‘ok‘
                else:
                    return ‘no‘
        
            return inner
        
        
        @check_str
        def test(data):
            return data
        
        
        print(test(‘no‘))#no
        

类中的装饰器

  • classmethod

    • 将类函数可以不经过实例化而直接被调用

    • 用法:

      • @classmethod
        def func(cls,....):
          do
        
    • 参数介绍:

      • clas替代普通类函数中的self
      • 变为cls,代表当前操作的是类
    • 示例代码:

      • class Person(object):
        
            @classmethod
            def add(cls, a, b):
                return a + b
        
        print(Person.add(1, 2))  # 3
        
  • staticmethod

    • 将类函数可以不经过实例化而直接被调用,被该装饰器调用的函数不许传递self或cls参数,且无法再该函数内调用其它类函数或类变量。

    • 用法:

      • @staticmethod
        def func(..):
          do
        
    • 参数介绍

      • 函数体内无clas或self参数
    • 示例代码:

      • class Person(object):
        
            @staticmethod
            def add(a, b):
                return a + b
        
        
        print(Person.add(1, 2))  # 3
        
  • Preperty

    • 将类函数的执行免去括弧,类似于调用属性(变量),只适用于无参数的类函数(self与cls除外)

    • 用法:

      • @perperty
        
        def func(self):
          do
        
    • 参数介绍:

      • 无重要函数说明
        
    • 示例代码:

      • class Person(object):
        
            def __init__(self, name):
                self.name = name
        
            @property
            def say(self):
                print(f‘你好,{self.name}‘)
        
        ckk = Person(‘ckk‘)
        ckk.say  # 你好,ckk
        

类的继承

  • 什么是继承

    • 通过继承基类来得到基类的功能
    • 所以我们把被继承的类称作父类或基类,继承者被称作子类
    • 代码的重用
  • 父(基)类与子类

    • 子类拥有父类的所有属性和方法
    • 父类不具备子类自有的属性和方法
  • 继承的用法

    • 定义子类时,将父类传入子类参数内

    • 子类实例化可以调用自己与父类的函数与变量

    • 父类无法调用子类的函数与变量

    • 示例代码:

      • class Person(object):
            def say(self):
                print("我是父类的say方法")
        
        
        class Chinese(Person):
            def prints(self):
                pass
        
        c = Chinese()
        c.say()  # 我是父类的say方法
        

类的super函数

  • super函数的作用

    • Python子类继承父类的方法而使用的关键字,当子类继承父类后,就可以使用父类的方法
    • 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。
    • MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
  • super函数的用法

    • class Person(object):
          def add(self, a, b):
              return a + b
      
      
      class Chinese(Person):
          def add(self):
              result = super().add(1, 2)
              print(result)
      
      c = Chinese()
      c.add()  # 3
      

类的多态

  • 什么是类的多态

    • 同一个功能的多状态化
    • 多态是指一类事物有多种形态,比如动物类,可以有猫,狗,猪等等。(一个抽象类有多个子类,因而多态的概念依赖于继承)
  • 多态与多态性是两种概念

    • 多态性是指具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性:向不同的对象发送同一条消息,不同的对象在接收时会产生不同的行为(即方法)。也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。
  • 多态的用法

    • 子类中重写父类的方法
  • 示例代码:

    • import abc
      
      
      class Animal(metaclass=abc.ABCMeta):  # 同一类事物:动物
          @abc.abstractmethod
          def talk(self):
              pass
      
      
      class Cat(Animal):  # 动物的形态之一:猫
          def talk(self):
              print(‘say miaomiao‘)
      
      
      class Dog(Animal):  # 动物的形态之二:狗
          def talk(self):
              print(‘say wangwang‘)
      
      
      class Pig(Animal):  # 动物的形态之三:猪
          def talk(self):
              print(‘say aoao‘)
      
      
      c = Cat()
      d = Dog()
      p = Pig()
      
      
      def func(obj):
          obj.talk()
      
      func(c)#say miaomiao
      func(d)#say wangwang
      func(p)#say aoao
      

类的多重继承

  • 什么是多重继承

    • 可以继承多个基(父)类
    • 在开发中没有特殊的情况,应该尽量避免使用多重继承,因为多重继承会让我们的代码过于复杂
    • 如果多个父类中有同名的方法,则会现在第一个父类中寻找,然后找第二个,然后找第三个。。。
    • 前边父类的方法会覆盖后边父类的方法
  • 多重继承的方法

    • 将被继承的类放入子类的参数位中,用逗号隔开
    • 从左向右一次继承
  • 示例代码:

    • class A:
      
          def aa(self):
              print("aa")
      
      
      class B:
      
          def bb(self):
              print("bb")
      
      
      class C(B, A):
      
          def cc(self):
              print("cc")
      
      
      c = C()
      c.cc()  # cc
      c.bb()  # bb
      c.aa()  # aa
      

    类的高级函数

    • str

      • 如果定义了该函数,当print当前实例化对象的时候,会返回该函数的return信息

      • 用法:

        • def __str__(self):
            return str_type
          
      • 参数:

      • 返回值:

        • 一般返回对于该类的描述信息
      • 示例代码:

        • class Person(object):
          
              def __str__(self):
                  return ‘这是个测试类‘
          
          
          ckk = Person()
          print(ckk)  # 这是个测试类
          
    • getattr

      • 当调用的属性或者方法不存在时,会返回该方法定义的信息

      • 方法:

        • def __getattr__(self,key):
            print(something..)
          
      • 参数:

        • key:调用任意不存在的属性名
      • 返回值:

        • 可以是任意类型也可以不进行返回
      • 示例代码:

        • class Person(object):
          
              def __getattr__(self, item):
                  print(f‘这个{item},不存在‘)
          
          ckk = Person()
          ckk.name#这个name,不存在
          
    • setattr

      • 拦截当前类中不存在的属性与值

      • 用法:

        • def __setattr__(self,key,value):
            self.__dict__[key]=value
          
      • 参数:

        • key:当前的属性名
        • value:当前的参数对应的值
      • 返回值:

      • 示例代码:

        • class Person(object):
              def __setattr__(self, key, value):
                  if key not in self.__dict__:
                      self.__dict__[key] = value
          
          
          t = Person()
          t.name = ‘ckk‘
          print(t.name)  # ckk
          
    • call

      • 本质是将一个类编程一个函数

      • 用法:

        • def __call__(self,*args,**kwargs):
            print(‘call will start‘)
          
      • 参数:

        • 可传任意参数
      • 返回值:

        • 与函数情况相同可有可无
      • 示例代码:

        • class Person(object):
              def __call__(self, **kwargs):
                  print(‘args is {}‘.format(kwargs))
          
          
          t = Person()
          t(name=‘ckk‘)  # args is {‘name‘: ‘ckk‘}
          
          

10.Python面向对象编程

原文:https://www.cnblogs.com/gockk/p/15247276.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!