10.Python面向对象编程

时间：2021-09-12 11:30:11 收藏：0 阅读：63

初识面向对象

什么是面向对象编程
- 利用(面向)对象(属性与方法)去进行编码的过程
- 自定义对象数据类型就是面向对象中的类(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‘}

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