Python进阶与拾遗3：Python中的类

最新推荐文章于 2021-03-14 14:27:42 发布
置顶 最新推荐文章于 2021-03-14 14:27:42 发布
阅读量286 收藏 1
点赞数 2
分类专栏： 进阶拾遗 Python 文章标签： python 类 计算机视觉 人工智能 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiongnima/article/details/114416092
版权

Python进阶与拾遗3：Python中的类


本篇博文，主要讲解Python中的类。Python是一门面向对象的编程语言，因此在所有的Python大型工程中，几乎都是使用 面向对象的形式进行程序的组织与编写。因此，会用到大量关于类与对象的知识，下面开始干货。

类的相关概念

类是什么

在Python中，类本身是一个对象，也是命名空间，支持多个对象的产生，命名空间的继承以及运算符重载。是产生多个实例的工厂。

类提供默认的行为

  1. class语句创建类对象并将其赋值给变量名，类在命名时一般以一个大写字母开头。
    class语句是可执行的语句，产生新的类，在文件导入时就会执行。
  2. class语句内的赋值语句创建类的属性。
    class语句内的顶层的赋值语句会产生类中的属性，类的属性可由变量名点号运算获取。
  3. 类属性提供对象状态和行为。
    类属性记录状态信息和行为，由类创建的所有实例共享。类中的def语句会生成方法。

实例对象是具体的元素

  1. 调用类会创建新的实例对象。每次类调用，会返回新的实例对象。
  2. 每个实例对象继承类的属性并获得了自己的命名空间。继承是在属性点号运算时发生，而且只查找连接对象的变量名。实例更改类的属性，只对实例自身有效。类更改类的属性，对所有实例均有效。
  3. 在方法内对self属性做赋值运算会产生每个实例自己的属性。对self属性的赋值运算，会创建或修改实例内的数据，而不是类的数据。
class FirstClass:
    def setdata(self, value):
        self.data = value
    def display(self):
        print(self.data)

def main():
    x = FirstClass()
    y = FirstClass()
    x.setdata(123)
    y.setdata("abc")
    x.display()
    y.display()

if __name__ == '__main__':
    main()
# 输出：
# 123
# abc

类通过继承进行定制

类继承是实现编写类层次结构的大门。

  1. 超类列在类开头的括号中。
  2. 类从超类中继承属性。超类中有属性就继承，没属性的话会自动创建。
  3. 实例会继承所有可读类的属性。寻找变量名时，Python会检查实例，然后是类，然后是所有超类。
  4. 点号属性运算会开启新的独立搜索。每个self.attr表达式都会开启对self及其上层的类的attr语句搜索。
  5. 逻辑的修改是通过创建子类，而不是修改超类。在子类中重新定义超类的变量名，子类就可以取代超类中的变量。
class FirstClass:
    def setdata(self, value):
        self.data = value
    def display(self):
        print(self.data)

class SecondClass(FirstClass):
    # display函数的覆盖，不是修改了FirstClass，而是对其完成了定制。
    def display(self):
        print('Current value = %s' % self.data)

def main():
    x = FirstClass()
    y = SecondClass()
    x.setdata(123)
    y.setdata("abc")
    x.display()
    y.display()

if __name__ == '__main__':
    main()
# 输出：
# 123
# Current value = abc

运算符重载

有关运算符重载的详细用法，也可参阅笔者博客Python进阶与拾遗4：Python中的运算符重载。

相关概念

  1. 双下划线命名方法__X__表示拦截运算，是运算符重载的标志。
  2. 当实例出现在内置运算时，这类方法会自动调用。比如，实例对象继承了__add__方法，当对象出现在+表达式内时，该方法会调用。
  3. 类可以覆盖多种内置类型运算。有几十种特殊运算符重载方法名称，几乎可截获并实现内置类型的所有运算。
  4. 运算符覆盖方法没有默认值，也不需要。如果没有定义或继承运算符重载方法，相应的运算在这类实例中并不支持。比如如果没有__add__，+表达式就会引发异常。
  5. 运算符可使得类与Python对象模型相集成。

运算符重载的例子

  1. 新的实例构造时，会调用__init__。
  2. 实例出现在表达式+中时，会调用__add__。
  3. 打印一个对象时，运行__str__。

运算符重载的用处

  1. __init__构造函数。用于每个类的初始化，这也是使用最多的运算符重载。
  2. 在实现本质为数学的运算时，可以使用运算符重载。比如矩阵类。
  3. 在传递内置类型(如列表，字典)可用的运算符函数，可能会使用运算符重载。
class FirstClass:
    def setdata(self, value):
        self.data = value
    def display(self):
        print(self.data)

class SecondClass(FirstClass):
    def display(self):
        print('Current value = %s' % self.data)

class ThirdClass(SecondClass):
    def __init__(self,value):
        self.data = value
    def __add__(self, other):
        return ThirdClass(self.data + other)
    def __str__(self):
        return '[ThirdClass: %s]' % self.data
    def mul(self, other):
        self.data *= other

def main():
    x = FirstClass()
    y = SecondClass()
    z = ThirdClass(3.1415926)
    x.setdata(123)
    y.setdata("abc")
    x.display()
    y.display()
    z.display()
    z_1 = z + 10
    print(x)
    print(y)
    print(z)
    print(z_1)

if __name__ == '__main__':
    main()
'''
输出：
123
Current value = abc
Current value = 3.1415926
<__main__.FirstClass object at 0x00000138DF5A94C0>
<__main__.SecondClass object at 0x00000138DF62E220>
[ThirdClass: 3.1415926]
[ThirdClass: 13.1415926]
'''

类的设计理念

  1. 继承。
    继承是基于Python中的属性查找的(X.name表达式)。
  2. 多态。
    在X.method方法中，method意义取决于X的类型。
  3. 封装。
    方法和运算符实现行为，数据隐藏默认是一种惯例。

类的编写步骤

本小节将从用例的角度出发分享类的编写步骤。一般来说，类名使用大写字母开头，而模块名使用小写字母开头。

步骤一：创建实例

使用构造函数

  1. 构造函数方法包含了每次创建一个实例的时候Python会自动运行的代码。
  2. 实例对象的属性，通过给类方法函数中的self属性赋值来创建。赋给实例属性初始值的主流方法是，在__init__构造函数方法中将其赋给self，并可选地提供默认值。
class Person:
    def __init__(self, name, job=None, pay=0):
        self.name = name
        self.job = job
        self.pay = pay

def main():
    # 两个实例对象都是命令空间对象，每一个都拥有各自类所创建的状态信息的独立副本。
    bob = Person('Bob Smith')
    sue = Person('Sue Jones', job='Teacher', pay=100000)
    print(bob.name, bob.pay)
    print(sue.name, sue.pay)

if __name__ == "__main__":
    main()
'''
输出：
Bob Smith 0
Sue Jones 100000
'''

步骤二：添加行为方法

编写方法

方法定义了处理那些类的实例的常规函数，实例是方法调用的主体，并且会自动传递方法给self参数。Python通过自动把实例传递给第一个参数从而告诉一个方法应该处理哪个实例，通常这个参数叫self。在调用时，有两种语法，可以通过实例进行方法调用，也可以通过类进行方法调用。

# 方法调用
Instance.method(args)
Class.method(instance, args)

class Person:
    def __init__(self, name, job=None, pay=0):
        self.name = name
        self.job = job
        self.pay = pay
    def lastName(self):
        return self.name.split()[-1]
    def giveRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))

def main():
    bob = Person('Bob Smith')
    sue = Person('Sue Jones', job='Teacher', pay=100000)
    print(bob.name, bob.pay)
    print(sue.name, sue.pay)
    print(bob.lastName(), sue.lastName())
    # print(Person.lastName(bob), Person.lastName(sue)) # 同理
    sue.giveRaise(.10)
    # Person.giveRaise(sue, .10) # 同理
    print(sue.pay)

if __name__ == "__main__":
    main()
'''
输出：
Bob Smith 0
Sue Jones 100000
Smith Jones
110000
'''

步骤三：运算符重载

  1. __init__构造函数就是最常用的运算符重载。
  2. 当方法在类的实例上运行的时候，方法截获并处理内置的操作。
class Person:
    def __init__(self, name, job=None, pay=0):
        self.name = name
        self.job = job
        self.pay = pay
    def lastName(self):
        return self.name.split()[-1]
    def giveRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))
    def __str__(self):
        return '[Person: %s, %s]' % (self.name, self.pay)

def main():
    bob = Person('Bob Smith')
    sue = Person('Sue Jones', job='Teacher', pay=100000)
    print(bob)
    print(sue)
    print(bob.lastName(), sue.lastName())
    sue.giveRaise(.10)
    print(sue)

if __name__ == "__main__":
    main()
'''
输出：
[Person: Bob Smith, 0]
[Person: Sue Jones, 100000]
Smith Jones
[Person: Sue Jones, 110000]
'''

步骤四：通过子类定制行为

继承的意义

  1. 定制化的操作通过继承实现
  2. 在实现子类的定制行为时，应该尽量复用父类的版本，以免修改时工作量较大。这对未来维护代码意义重大。
class Person:
    def __init__(self, name, job=None, pay=0):
        self.name = name
        self.job = job
        self.pay = pay
    def lastName(self):
        return self.name.split()[-1]
    def giveRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))
    def __str__(self):
        return '[Person: %s, %s]' % (self.name, self.pay)

class Manager(Person):
    def giveRaise(self, percent, bonus=.10):
        Person.giveRaise(self, percent + bonus)

def main():
    bob = Person('Bob Smith')
    sue = Person('Sue Jones', job='Teacher', pay=100000)
    print(bob)
    print(sue)
    print(bob.lastName(), sue.lastName())
    sue.giveRaise(.10)
    print(sue)
    tom = Manager('Tom Jones', 'mgr', 50000)
    tom.giveRaise(.10)
    print(tom.lastName())
    print(tom)

if __name__ == "__main__":
    main()
'''
输出：
[Person: Bob Smith, 0]
[Person: Sue Jones, 100000]
Smith Jones
[Person: Sue Jones, 110000]
Jones
[Person: Tom Jones, 60000]
'''

多重继承

在多重继承类的对象搜索属性时，Python会由坐至右搜索类首行中的超类，直到找到相符者。

Python中的多态

多态是，针对同样名称的成员方法，对不同的实例使用不同的定制版本。

class Person:
    def __init__(self, name, job=None, pay=0):
        self.name = name
        self.job = job
        self.pay = pay
    def lastName(self):
        return self.name.split()[-1]
    def giveRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))
    def __str__(self):
        return '[Person: %s, %s]' % (self.name, self.pay)

class Manager(Person):
    def giveRaise(self, percent, bonus=.10):
        Person.giveRaise(self, percent + bonus)

def main():
    bob = Person('Bob Smith')
    sue = Person('Sue Jones', job='Teacher', pay=100000)
    print(bob)
    print(sue)
    print(bob.lastName(), sue.lastName())
    sue.giveRaise(.10)
    print(sue)
    tom = Manager('Tom Jones', 'mgr', 50000)
    tom.giveRaise(.10)
    print(tom.lastName())
    print(tom)

    print("==All three==")
    for object in (bob, sue, tom):
        object.giveRaise(.10)
        print(object)

if __name__ == "__main__":
    main()
'''
输出：
[Person: Bob Smith, 0]
[Person: Sue Jones, 100000]
Smith Jones
[Person: Sue Jones, 110000]
Jones
[Person: Tom Jones, 60000]
==All three==
[Person: Bob Smith, 0]
[Person: Sue Jones, 121000]
[Person: Tom Jones, 72000]
'''

步骤五：定制构造函数

  1. 如果子类定制了构造函数，那么创建子类实例时不会再执行父类的构造函数。
  2. 如果在子类中要执行父类的构造函数，可以通过父类的名称手动调用。
class Person:
    def __init__(self, name, job=None, pay=0):
        self.name = name
        self.job = job
        self.pay = pay
    def lastName(self):
        return self.name.split()[-1]
    def giveRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))
    def __str__(self):
        return '[Person: %s, %s]' % (self.name, self.pay)

class Manager(Person):
    def __init__(self, name, pay):
        Person.__init__(self, name, 'mgr', pay)
        # super().__init__(name, 'mgr', pay) # 同理
    def giveRaise(self, percent, bonus=.10):
        Person.giveRaise(self, percent + bonus)

def main():
    bob = Person('Bob Smith')
    sue = Person('Sue Jones', job='Teacher', pay=100000)
    print(bob)
    print(sue)
    print(bob.lastName(), sue.lastName())
    sue.giveRaise(.10)
    print(sue)
    tom = Manager('Tom Jones', 50000)
    tom.giveRaise(.10)
    print(tom.lastName())
    print(tom)

if __name__ == "__main__":
    main()
'''
输出：
[Person: Bob Smith, 0]
[Person: Sue Jones, 100000]
Smith Jones
[Person: Sue Jones, 110000]
Jones
[Person: Tom Jones, 60000]
'''

步骤六：使用内省工具

内省工具是特殊的属性与函数，允许我们访问对象实现的一些内部机制。
典型的内省工具：

  1. 实例的__class__属性提供了一个创建他的类的链接；类的__name__属性提供了类的名称，__bases__属性提供了超类。
  2. 实例的__dict__属性提供了一个字典，可以返回实例的每个属性。也可以调用dir函数，包含了继承的属性。
class Person:
    def __init__(self, name, job=None, pay=0):
        self.name = name
        self.job = job
        self.pay = pay
    def lastName(self):
        return self.name.split()[-1]
    def giveRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))
    def __str__(self):
        return '[Person: %s, %s]' % (self.name, self.pay)

class Manager(Person):
    def __init__(self, name, pay):
        Person.__init__(self, name, 'mgr', pay)
    def giveRaise(self, percent, bonus=.10):
        Person.giveRaise(self, percent + bonus)

def main():
    bob = Person('Bob Smith')
    tom = Manager('Tom Jones', 50000)
    tom.giveRaise(.10)

    print(list(bob.__dict__))
    print(dir(bob))

    print("------------------------------")

    print(tom.__dict__)
    print(dir(tom))

    print("------------------------------")

    print(Person.__dict__)
    print(Person.__name__)
    print(Person.__bases__)
    print(dir(Person))

    print("------------------------------")

    print(Manager.__dict__)
    print(Manager.__name__)
    print(Manager.__bases__)
    print(dir(Manager))

if __name__ == "__main__":
    main()
'''
输出：
['name', 'job', 'pay']
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'giveRaise', 'job', 'lastName', 'name', 'pay']
------------------------------
{'name': 'Tom Jones', 'job': 'mgr', 'pay': 60000}
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'giveRaise', 'job', 'lastName', 'name', 'pay']
------------------------------
{'__module__': '__main__', '__init__': <function Person.__init__ at 0x00000251D67CFF70>, 'lastName': <function Person.lastName at 0x00000251D67ED040>, 'giveRaise': <function Person.giveRaise at 0x00000251D67ED0D0>, '__str__': <function Person.__str__ at 0x00000251D67ED160>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
Person
(<class 'object'>,)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'giveRaise', 'lastName']
------------------------------
{'__module__': '__main__', '__init__': <function Manager.__init__ at 0x00000251D67ED1F0>, 'giveRaise': <function Manager.giveRaise at 0x00000251D67ED280>, '__doc__': None}
Manager
(<class '__main__.Person'>,)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'giveRaise', 'lastName']
'''

抽象超类

  1. 简单的做法可以使用assert语句或者NotImplementedError异常。
class Super_1:
    def delegate(self):
        self.action()
    def action(self):
        assert False, 'action must be defined'

class Super_2:
    def delegate(self):
        self.action()
    def action(self):
        raise NotImplementedError('action must be defined')

class Sub(Super_1):
    def action(self):
        print("This is the action")

def main():
    # X = Super_1()
    # X.delegate() # AssertionError: action must be defined

    # Y = Super_2()
    # Y.delegate() # NotImplementedError: action must be defined

    Z = Sub()
    Z.delegate()

if __name__ == "__main__":
    main()
'''
输出：
This is the action
'''
  1. 直接使用抽象超类，无法实例化。通过在方法头部使用修饰器语法实现。在Python 3.0及之后的版本中，需要导入模块，但是在python 2.6及之后的版本中，直接使用类属性就行。
from abc import ABCMeta, abstractmethod

class Super(metaclass=ABCMeta):
    def delegate(self):
        self.action()
    @abstractmethod
    def action(self):
        pass

class Sub(Super):
    def action(self):
        print("This is the action")


def main():
    # X = Super() # TypeError: Can't instantiate abstract class Super with abstract methods action
    # X.delegate()

    Y = Sub()
    Y.delegate()


if __name__ == "__main__":
    main()
'''
输出：
This is the action
'''

类的伪私有属性

  1. 约定俗成：Python中用一个单一的下划线来编写内部名称，比如_X，表示不应修改的变量(对编译器无意义)。
  2. class语句内开头有两个下划线，但结尾没有两个下划线的变量名，比如__X，会自动扩张，从而包含所在类的名称。
  3. 伪私有属性，在类的继承中很常见，多用于超类中有同名的属性。
class C1:
    def meth1(self): self.__x = 88
    def meth2(self): print(self.__x)

class C2:
    def metha(self): self.__x = 99
    def methb(self): print(self.__x)

class C3(C1, C2):
    pass

def main():
    I = C3()
    I.meth1()
    I.metha()
    print(I.__dict__)
    I.meth2()
    I.methb()

if __name__ == "__main__":
    main()
'''
输出：
{'_C1__x': 88, '_C2__x': 99}
88
99
'''

以上，欢迎各位读者朋友提出意见或建议。

欢迎阅读笔者后续博客，各位读者朋友的支持与鼓励是我最大的动力！

written by jiong
时穷节乃见，
一一垂丹青。

jiongnima
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python 进阶(三)：Python使用ORM框架SQLAlchemy操作Oracle数据库
06-24
本文主要介绍Python使用ORM框架SQLAlchemy操作Oracle数据库。 1. 安装Oracle Instant Client 2. 安装依赖库 使用以下命令来安装SQLAlchemy和cx_Oracle库: pip install SQLAlchemy pip install cx_Oracle 3.创建...
Python 进阶（五）：数据库操作之 SQLite
12-14
SQLite 是一个进程内的库，可以自给自足、无服务器、无需配置、支持事务，Python 可以通过 sqlite3 模块与 SQLite3 集成（3 是版本号），Python 2.5.x 以上版本内置了 sqlite3 模块，我们可以直接
Python进阶与拾遗5：Python中的新式类
jiongnima的博客
03-13 628
本篇博文主要总结了，Python中的新式类，欢迎阅读与分享。
Python进阶与拾遗8：Python中的异常处理
jiongnima的博客
03-14 384
本篇博文主要总结了，Python中的异常处理，欢迎阅读与分享。
Python进阶与拾遗1：Python中的模块
jiongnima的博客
02-27 292
本篇博文主要总结了，Python中的模块用法，分享了模块使用的一些注意事项与小技巧，欢迎阅读与分享。
Python进阶与拾遗2：Python中的包
jiongnima的博客
02-28 284
本篇博文主要总结了，Python中的包用法，欢迎阅读与分享。
Python 进阶（七）： Word 基本操作
12-22
写入2.1 标题2.2 段落2.3 表格2.4 图片2.5 样式3. 读取 1. 概述 Word 是一个十分常用的文字处理工具，通常我们都是手动来操作它，本节我们来看一下如何通过 Python 来操作。 Python 提供了 python-docx 库，该库...
Python 进阶（九）：JSON 基本操作
12-22
Python 标准库的 json 模块可以用来处理 JSON 格式数据的基本操作。 2. 使用 json 模块主要提供了 dump、dumps、load、loads 方法对 JSON 数据进行编解码。 2.1 dumps json 模块的 dumps 方法可以将 Python 对象转为...
Python进阶.pdf
04-11
Python进阶
Python基础与拾遗2：Python中的字符串与字符串格式化
jiongnima的博客
02-02 626
本篇博文主要总结了，Python中的字符串与字符串格式化，欢迎阅读与分享。
Python基础与拾遗9：Python中的函数与作用域
jiongnima的博客
02-09 444
本篇博文主要总结了，Python中的函数与作用域，体现了Python语言中的特色，欢迎阅读与分享。
Python基础与拾遗1：Python中的数字
jiongnima的博客
01-30 408
本篇博文主要总结了，Python中的数字用法，欢迎阅读与分享。
Python进阶与拾遗4：Python中的运算符重载
jiongnima的博客
03-07 389
本篇博文主要总结了，Python中的运算符重载，欢迎阅读与分享。
Python基础与拾遗8：Python中的迭代器与解析
jiongnima的博客
02-06 380
本篇博文主要总结了，Python中的迭代器与解析，体现了Python语言中的特色，欢迎阅读与分享。
Python基础与拾遗4：Python中的字典
jiongnima的博客
02-05 326
本篇博文主要总结了，Python中的字典与相关操作，欢迎阅读与分享。
Python基础与拾遗3：Python中的列表
jiongnima的博客
02-03 305
本篇博文主要总结了，Python中的列表与相关操作，欢迎阅读与分享。
Python基础与拾遗5：Python中的元组
jiongnima的博客
02-06 283
本篇博文主要总结了，Python中的元组与相关操作，欢迎阅读与分享。
Python基础与拾遗7：Python中的数据类型总结
jiongnima的博客
02-06 272
本篇博文主要总结了，Python中的数据类型，欢迎阅读与分享。
python 进阶书籍
最新发布
09-13
《Python进阶之路》是一本非常值得推荐的Python进阶书籍。这本书由一位经验丰富的Python大牛所著，作者拥有超过20年的Python开发经验。这本书涵盖了许多Python进阶知识点，如元编程、动态属性、属性描述符、异步处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值