[阶段一] 10. Python面向对象编程

ゝ一世哀愁。 2022-09-10 03:13 158阅读 0赞

### python面向对象编程 ###

*  什么是面向对象？

类是一类具有同一特征的统称，如人类是一个类，张三、李四就是人类的某个具体对象。

利用（面向）对象（属性和方法）去进行编码的过程，就称为面向对象编程。面向对象编程是把构成事物的整个需求按照特点、功能划分，把这些存在共性的部分封装成对象，创建对象的目的不是为了完成某一个步骤，而是为了描述整个事物在整个解决问题的步骤中的行为。

python 中一切皆对象，比如变量也是对象，包括整型（`int`）、浮点型（`float`）、字符串（`str`）、列表（`list`）、元组（`set`）、字典和集合（`set`）。

面向过程：主要分析出解决问题所需要的步骤，用函数把这些步骤一步一步实现，使用的时候一个一个依次调用即可。

面向对象：主要找出问题中的共性问题，作为对象进行操作。

面向过程是一种以过程为中心的编程思想，面向对象是一类以对象为核心的编程思想。

*  类的定义与调用：

自定义对象数据类型就是面向对象中的类（`class`）的概念，通过自定义类，可以实例化出具体的对象，类有自己的属性和方法，实例化出来的对象也具备类的属性和方法。

可以把类理解为一个模板，通过这个模板可以创建出无数个具体的实例。类是抽象的模板，而实例是根据类创建出来的一个个具体的对象，每个对象都拥有相同的方法。

类并不能直接使用，通过类创建出来的实例才能使用。类的所有变量称为属性，类的所有函数称为方法。方法和函数不同的是，方法至少要包含一个 `self` 参数，且方法无法单独使用，只能和类实例出来的对象一起使用。

python 中，使用关键字 `class` 来声明类，类的名称首字母大写，多单词情况下每个单词首字母大写，这就是“驼峰命名法”。

用法：

class ClassName(object):
        attr = something
        
        def 函数名(self):
            函数具体实现代码块
            return 返回值

示例：

# coding:utf-8
    
    class Person(object):
        name = 'xiaobai'
    
        def sing(self):
            print(f'{ self.name} can sing')
    
    xxx = Person()              #类的实例化
    print(xxx.name)             #通过实例化进行属性调用
    xxx.sing()                  #通过实例化进行函数调用

结果：

xiaobai
    xiaobai can sing

*  `self`：

`self` 是一个对象，它代表实例化的变量自身。`self` 是类方法中的必传参数，且必须放在第一个参数位置。

定义类属性的变量可以不用加上 `self`，但在定义类方法中的变量是必须要加上 `self` 的。`self` 中的变量与含有 `self` 参数的函数可以在类中的任何一个函数内随意调用。

如果在类中定义函数时加了 `self` 参数，那这个函数是类实例的方法，而不是类的方法。反之，如果在类中定义函数时没有加 `self` 参数，那这个函数就只是类的方法，而不是类实例的方法。

*  类的构造函数：

构造函数，是类中的一种默认函数，用来将类实例化的同时，将参数传入类中。构造函数应该定义在类中所有函数的最上面，作为类的第一个函数。

用法：

class ClassName(object):
        def __init__(self, a, b):               #构造函数
            self.a = a
            self.b = b

示例：

# coding:utf-8
    
    class Person(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def sing(self):
            print(f'{ self.name} can sing')
    
        def study(self):
            print(f'{ self.name}\'s age is { self.age}, so he is an elementary school student')
    
    xiaobai = Person('xiaobai', 10)
    print(xiaobai.name)
    xiaobai.sing()
    xiaobai.study()

结果：

xiaobai
    xiaobai can sing
    xiaobai's age is 10, so he is an elementary school student

对于一个对象，构造函数 `__init__` 标志着对象生命的开始，系统会从内存中内配一个内存块给这个对象。析构函数 `__del__` 标志着对象生命的结束，它会删除对象，系统会从内存中释放这个内存块。

*  私有函数和私有变量：

私有函数与私有变量，就是无法被实例化后的对象调用的类中的函数与变量。

私有函数与私有变量，只希望类内部业务调用使用，不希望被使用者调用。因此，类内部可以调用私有函数与私有变量。

私有函数与私有变量，只需要在变量或函数前添加双下划线 `__` 来定义。尽量不要在实例化对象中直接调用私有函数和私有变量。

用法：

class ClassName(object):
        def __init__(self, a):
            self.a = a
            self.__b = b                #私有变量
        
        def __函数名(self):             #私有函数
            函数具体实现代码块
            return 返回值

示例：

# coding:utf-8
    
    class Person(object):
        def __init__(self, name):
            self.name = name
            self.__age = 10
    
        def __sing(self):
            return f'{ self.name} can sing'
    
        def sing(self):
            result = self.__sing()
            return result
    
        def __study(self):
            return f'{ self.name}\'s age is { self.__age}, so he is an elementary school student'
    
        def study(self):
            result = self.__study()
            return result
    
    xiaobai = Person('xiaobai')
    print(xiaobai.name)
    print(xiaobai.sing())
    print(xiaobai.study())

结果：

xiaobai
    xiaobai can sing
    xiaobai's age is 10, so he is an elementary school student

*  python 中的封装：

使用类中的非私有函数，来调用类中不对外的私有属性和方法，就称为 python 中的封装。这样做的目的是保护隐私，明确区分内外。

示例：

# coding:utf-8
    
    class Hello(object):
        def __init__(self, data):
            self.data = data
        def __hello(self):
            print('hello %s' % self.data)
    
        def hello(self):
            self.__hello()
    
    
    if __name__ == "__main__":
        say = Hello('world')
        say.hello()

结果：

hello world

*  装饰器：

装饰器也是一种函数，它可以接受函数作为参数，也可以返回一个新的函数。因此，接收一个函数作为参数，在内部对其进行处理，然后返回一个新的函数，动态的增强函数功能，这就是装饰器。

装饰器本质上是一个高阶函数，它接收一个函数作为参数，然后返回一个新的函数，可以让该函数在不改动源代码的情况下增加其他新功能。

当装饰器和被装饰函数在同一个 `py` 文件时，装饰器需要定义在被装饰函数的前面，python 代码是自上而下依次执行的（从而使得程序在自上而下执行时可以调用上面定义的装饰器）。

用法：

def out(func_args):             #外围函数
        def inter(*args, **kwargs):             #内嵌函数
            return func_args(*args, **kwargs)
        return inter                #外围函数返回内嵌函数

python 通过一个语法糖`@`符号来使用装饰器，这样可以避免编写 `f = decorate(f)` 这样形式的代码。所谓的语法糖便是不使用也可以完成任务，但是使用它可以让代码更简洁。

对于装饰器，需要记住的就是

@decorate
    def f():
        pass

其中，

@decorate   等价于  f = decorate(f)

示例：

# coding:utf-8
    
    import time
    from functools import reduce
    
    def performance(f):
        def fn(*args, **kw):
            t1 = time.time()                #unix时间戳
            r = f(*args, **kw)
            t2 = time.time()
            print('call %s() in %f s' % (f.__name__, t2 - t1))
            return r
        return fn
    
    @performance
    def factorial(n):
        return reduce(lambda x, y: x * y, range(1, n+1))
    
    print(factorial(10))

执行结果：

call factorial() in 0.002750 s
    3628800

*  `classmethod` 装饰器：

`classmethod` 装饰器的功能是将类函数可以不经过实例化而被直接调用。

用法：

@classmethod
    def func(cls,...):
        函数具体实现代码块
        return 返回值

参数 `cls` 替代普通类函数中的 `self`，代表当前操作的是类。

示例：

# coding:utf-8
    
    class Test(object):
        def __init__(self, a):
            self.a = a
    
        def run(self):
            print('run')
            self.dump()
    
        @classmethod
        def dump(cls):
            print('dump')
    
    t = Test('a')
    t.run()
    print('-----')
    Test.dump()

结果：

run
    dump
    -----
    dump

*  `staticmethod` 装饰器：

`staticmethod` 装饰器的功能是将类函数可以不经过实例化而被直接调用。被该装饰器调用的函数不允许传递 `self` 或 `cls` 参数，且无法在该函数内调用其它类函数或类变量。

用法：

@classmethod
    def func(...):
        函数具体实现代码块
        return 返回值

函数体内无 `self` 或 `cls` 参数。

示例：

# coding:utf-8
    
    class Test(object):
        def __init__(self, a):
            self.a = a
    
        def run(self):
            print('run')
            self.dump()
    
        @staticmethod
        def dump():
            print('dump')
    
    t = Test('a')
    t.dump()
    print('-----')
    Test.dump()

结果：

dump
    -----
    dump

*  `property` 装饰器：

`property` 装饰器的功能是将类函数的执行去掉括号，类似于调用属性（类变量）。

用法：

@property
    def func(self):
        函数具体实现代码块
        return 返回值

函数体内只能有 `self` 参数。

示例：

# coding:utf-8
    
    class Test(object):
        def __init__(self, name):
            self.__name = name
    
        @property
        def name(self):
            return self.__name
    
        @name.setter
        def name(self, value):
            self.__name = value
    
    
    n = Test('xiaobai')
    print(n.name)
    n.name = 'xiaohei'
    print(n.name)

结果：

xiaobai
    xiaohei

*  类的继承：

继承时类与类之间的一种关系，一个类可以通过继承基类来得到基类的功能。所以把被继承的类称为父类或基类，把继承父类的类称为子类。

通过继承，子类可以拥有父类的所有属性和方法，但父类不会拥有子类自有的属性和方法。

用法：

class Parent_ClassName(object):                #父类
        父类代码实现
    
    class Child_ClassName(Parent_ClassName):                #子类
        子类代码实现

定义子类时，将父类类名作为参数传入子类，就完成了继承。子类实例化后，可以调用自己与父类的属性和方法。

*  `super` 函数：

`super` 函数的功能是作为 python 子类继承父类的方法而使用的关键字，当子类继承父类后，就可以使用父类的方法。

用法：

class Parent_ClassName(object):                #父类
        def __init__(self):
            ...
    
    class Child_ClassName(Parent_ClassName):                #子类
        def __init__(self):
            super(Child_ClassName, self).__init__()             #初始化父类的构造函数

示例：

# coding:utf-8
    
    class Person(object):
        def __init__(self, name, gender):
            self.name = name
            self.gender = gender
    
        def speak(self):
            print(f'hello！我是{ self.name}')
    
    
    class Student(Person):
        def __init__(self, name, gender, score, major, stu_num='2018014002'):
            super().__init__(name, gender)
            super().speak()
            self.score = score
            self.major = major
            self.__stu_num = stu_num
    
        def speak(self):
            print(f'我的学号为{ self.__stu_num}，很高兴认识大家')
    
        def identify(self):
            if self.__stu_num == '2018014002':
                print('我的分组已完成')
            else:
                print('请稍后，马上为你自动分组')
    
        def set_num(self, new_num):
            self.__stu_num = new_num
    
        def relation(self):
            if issubclass(Student, Person):
                print('我的父类是Person')
            else:
                print('父类正在查询中')
    
    
    if __name__ == '__main__':
        stu = Student('小明', '男', 90, '数学')
        stu.speak()
        stu.identify()
        stu.relation()
        print('*****************')
        stu_2 = Student('小红', '女', 89, '英语')
        stu_2.set_num('2018040625')
        stu_2.speak()
        stu_2.identify()

结果：

hello！我是小明
    我的学号为2018014002，很高兴认识大家
    我的分组已完成
    我的父类是Person
    *****************
    hello！我是小红
    我的学号为2018040625，很高兴认识大家
    请稍后，马上为你自动分组

对于 `super` 函数，`super(Child_ClassName, self).__init__()` 表示初始化父类的 `__init__` 函数，也可以初始化父类其它的函数。此外，python3 中，`super(Child_ClassName, self).__init__()` 可以省略为 `super().__init__()`。

*  类的多态：

多态就是一个类继承了父类并重写父类的方法，即一个类的多种状态就是多态。对于父类中不需要的方法，子类可以选择重构。

多态的目的是为了保留子类中和父类名称相同的方法的功能，这样就可以避免全盘接收父类的方法。

示例：

结果：

hello！我是小白
    我的学号为2018014002，很高兴认识大家

上例中，父类中的 `speak` 函数与子类中的 `speak` 函数名称相同，但功能不一样，这就是类的多态。

*  多重继承：

一个子类继承多个父类，这就是多重继承。

将被继承的父类类名作为参数传入子类，从左到右依次继承。如果多个父类中有名称相同的方法，第一个父类中的该方法会起作用。

多重继承中，继承关系可以顺序延续，后续子类可以继承前驱父类。例如，A类继承B类，B类继承C类，因此A类也继承了C类。

用法：

class Parent1_ClassName(object):                #父类1
        父类1代码实现
    
    class Parent2_ClassName(object):                #父类2
        父类2代码实现
    
    class Parent3_ClassName(object):                #父类3
        父类3代码实现
    
    class Child_ClassName(Parent1_ClassName, Parent2_ClassName, Parent3_ClassName):                #子类
        子类代码实现

示例：

# coding:utf-8
    
    class Human(object):
        def speak(self):
            print('human can speak')
    
    
    class Person(object):
        def speak(self):
            print('hello world')
    
        def work(self):
            print('person work every week')
    
    
    class Student(Human, Person):
        def work(self):
            print('student\'s work is study')
    
    
    if __name__ == '__main__':
        stu = Student()
        stu.speak()
        stu.work()

结果：

human can speak
    student's work is study

*  类的高级函数 `__str__`：

`__str__` 函数的功能是，如果定义了 `__str__` 函数，当 `print` 当前实例化对象时，会返回该函数的 `return` 信息。

用法：

def __str__(self):
      return str_type

`__str__` 函数一般返回对于该类的描述信息。

*  类的高级函数 `__getattr__`：

`__getattr__` 函数的功能是，当调用的属性或方法不存在时，会返回该函数定义的信息。

用法：

def __getattr__(self, key):
      print(...)

参数 `key` 表示调用任意不存在的属性名称，返回值可以是任意类型，也可以不返回。

示例：

# coding:utf-8
    
    class Test(object):
        def __str__(self):
            return 'This is a test class'
    
        def __getattr__(self, item):
            print(f'This { item} is not exists')
    
    
    t = Test()
    print(t)
    t.abc

结果：

This is a test class
    This abc is not exists

*  类的高级函数 `__setattr__`：

`__setattr__` 函数的功能是拦截当前类中不存在的属性与值。

用法：

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

参数 `key` 表示当前的属性名，`value` 表示当前的参数对应的值，无返回值。

*  类的高级函数 `__call__`：

`__call__` 函数的功能是将一个类变成一个函数。

用法：

def __call__(self, *args, **kwargs):
        print(...)

可传任意参数，返回值可以是任意类型，也可以不返回。

示例：

# coding:utf-8
    
    class Test(object):
        def __str__(self):
            return 'This is a test class'
    
        def __getattr__(self, item):
            print(f'This { item} is not exists')
    
        def __setattr__(self, key, value):
            self.__dict__[key] = value
            print(self.__dict__)
    
        def __call__(self, *args, **kwargs):
            print('args is {}'.format(kwargs))
    
    
    t = Test()
    print(t)
    t.abc
    t.name = 'xiaobai'
    print(t.name)
    t(name='xiaobai')

结果：

This is a test class
    This abc is not exists
    {'name': 'xiaobai'}
    xiaobai
    args is {'name': 'xiaobai'}

--------------------