首页手记 python强势来袭-0028-面向对象回旋踢~不得不...

python强势来袭-0028-面向对象回旋踢~不得不说的特性~

标签：

Python

前面的章节中，我们已经学习过面向对象的基本操作、面向对象的三大特征的详细操作，对于面向对象有了一个初步的了解和认知。
本节内容会针对面向对象的程序设计进行一部分的扩展和补充，方便我们在项目开发过程中的操作能更加的全面和完善。

0. 本节内容

0.1 类型属性和对象成员属性

0.2 对象属性的外部声明和限制

0.3 多继承机制下的注意的问题

0.4 类的定制属性~魔法方法

0.5 特殊的类型：枚举

1. 类型属性和对象的成员属性

在之前的章节中，我们就类和对象已经学习过了如下内容

类型的定义
类型中属性的定义
类型中方法的定义
属性和方法的私有化操作

当类型在处理的过程中，我们知道在init()函数中可以初始化类的成员属性/变量，在创建对象的过程中，每个对象的成员属性都是互相独立且互不影响的；对象A是不能直接使用对象B的成员属性的值的，而是要通过对象B调用获取对象B的属性；
python的类型中，还提供了一种方式，可以直接定义类的属性，这样定义的属性是当前类型创建的所有对象所共享的，也可以直接通过类名称调用，这样的属性称为：类属性

类属性：是定义在类型中的公开的属性，可以让通过当前类型直接操作，可以是当前类型创建的所有对象共享的数据

# 创建一个Person类型
class Person(object):
    # 定义一个类属性:在线人数
    onlineCount = 100
    # 类型初始化的方法
    def __init__(self, name):
        self.__name = name
    # 属性访问方法
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name
# 创建Person类型的对象
p1 = Person("tom")
p2 = Person("jerry")

# 访问类属性
print(Person.onlineCount)    # 执行结果 100
print(p1.onlineCount)          # 执行结果 100
print(p2.onlineCount)          # 执行结果 100

# 通过类名称修改类属性
Person.onlineCount = 15
# 再次访问类属性
print(Person.onlineCount)    # 执行结果 15
print(p1.onlineCount)          # 执行结果 15
print(p2.onlineCount)          # 执行结果 15

# 切记不能通过对象修改类属性：下面的做法只是给p1对象添加了一个额外的成员属性onlineCount
p1.onlineCount = 200
# 再次访问类属性
print(Person.onlineCount)    # 执行结果 15
print(p1.onlineCount)          # 执行结果 200
print(p2.onlineCount)          # 执行结果 15

类和对象，注意：
类中可能会出现三种属性/变量

类属性：直接定义在类的内部，初始化函数的外部的属性，可以直接通过类名称访问或者修改，通过当前类创建的对象都可以共享/访问类的类属性

成员属性：定义在初始化函数__init__(self)中，每个通过当前类创建的对象都有自己独立的成员属性的数据，并且对象和对象之间的数据不会有任何影响

局部变量：在类的方法中的参数、方法中定义的变量都是局部变量，局部变量一旦方法执行完毕就会被回收

2. 对象属性的外部声明和限制

上面的代码中，我们使用p1.onlineCount=15发现没有修改类属性，而是给p1增加了一个成员属性，这是怎么回事呢？

观察下面的代码：

# 创建了一个空类型
class Person:
    pass

# 创建Person的对象
p = Person()
# 给对象p追加成员属性
p.name = "tom"
p.age = 19
p.gender = "男"
# 打印属性数据
print(p.name, p.age, p.gender)
# 执行结果：tom 19 男

在上述代码中，我们定义了一个空类型Person，在创建了Person的对象之后，可以在对象的引用变量上，给对象添加额外的成员属性【切记，这里添加的额外的成员属性仅限于当前的这个对象，其他对象上不会出现】

这样的操作方式，可以在一定程度上让代码的操作更加灵活，但是同时也降低了代码的可读性，试想一下~我们辛辛苦苦抽象定义好了类型Person，Person中已经出现了我们所有人知道的属性，结果在操作的过程中，朝阳群众A创建的Person对象多出来了2个其他人不知道的属性，朝阳群众B创建的Person对象又多出来了其他人不知道的3个属性，这是一件非常恐怖的事情，会让整个类型和对象的操作变得非常的混乱。

# 原始的Person类型，只有一个name属性
class Person:
    def __init__(self, name):
        self.__name = name
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name

# 朝阳群众A创建的对象
p = Person("老A")
p.age = 20
p.sex = "男"
# 朝阳群众B创建的对象
p = Person ("老B")
p.gender = "女"
p.address = "朝阳"
p.phone = "13838383838"

观察上述代码，两个人创建的对象，一团混乱，光是一个性别两个开发人员定义的扩展出来的成员变量都不一致，后续其他人在操作的时候都不知道应该调用什么属性来处理了。

python为了处理这样的问题，提供了一个特殊的类属性__slots__ ，该属性的值是一个元组，元组中定义了类中可以出现的所有成员属性的名称

# 创建一个Person类型
class Person:
    # 通过__slots__属性定义可以扩展的成员属性名称
    __slots__ = ("__name", "address", "age", "gender", "email")
    # 初始化方法
    def __init__(self, name):
        self.__name = name
    # 属性的set/get方法
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name
# 创建对象
p = Person("tom")
# 扩展属性
p.address = "朝阳"
p.age = 20
p.sex = "男"
# 执行结果
~ AttributeError: 'Person' object has no attribute 'sex'

通过上述代码就可以看到，python提供了一个__slots__类属性，属性的值是一个元组，元组中规范了可能出现在类的成员属性列表。

类在创建好对象之后，可以在对象上直接挂在属性，这在一定程度上对于程序处理的灵活度有所提升，但是同样的，过于灵活的代码都会极大的降低代码的可读性，所以python提供了__slots__这样的类属性进行规范，规范类属性中只能出现的成员属性的列表，防止恶意的扩展。

3. 多继承机制下的注意的问题

多继承机制，在操作的过程中，同样也是提高了代码的处理灵活性，很大程度的扩展了代码的功能

在使用多继承机制进行程序设计开发的过程中一定要注意一个问题：当前类继承了一个或者多个父类，当前类就同时继承了父类中的公开的属性和函数，如果不同的父类中出现相同的属性/函数，就需要明确执行的过程

# 定义一个类型Son
class Son(object):
    def fealty(self):
        print("孝顺父母")
# 常见一个类型Student
class Student(object):
    def fealty(self):
        print("尊师重道")

# 创建一个Person类型，继承自Son和Student
class Person(Son, Student):
    pass

# 创建对象，执行方法
p = Person()
p.fealty()
# 问题：这里的fealty()函数，会不会报错？如果不报错，怎么执行？
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 我们可以看到，在继承的两个父类中都出现了fealty()函数
# 这里执行时，按照类型定义时继承的顺序进行查找
#  查找到对应的函数立刻执行并且不再向后查询
# 上述案例中，继承顺序是（Son, Student）
# 首先在Son类型中查询是否有fealty()方法，查询到立刻执行。
# 执行结果：孝顺父母
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

上述案例中，我们看到一旦出现多重继承，就会出现这样继承的多个父类中出现了多个相同名称的变量或者方法的情况，使用的这些变量和方法的时候一定要注意一个原则，先继承谁就使用谁的变量或者方法！

4. 类的定制属性~魔法方法

上面的代码中，我们已经看到了，类似__slots__这样的变量在前后加了双下划线的，在python中会有特殊的含义，这里会继续介绍一些常见的在面向对象开发过程中出现的一些这样的魔法方法

4.1. 对象格式化打印输出【str()】

常规情况下，对象直接输出，会输出对象的描述信息，晦涩难懂

# 定义类型
class Person(object):
    def __init__(self, name):
        self.__name = name
# 创建对象
p = Person("jerry")
# 输出对象
print(p) 
# 执行结果：<__main__.Person object at 0x0000028727259550>

对当前类型进行如下改造

# 定义类型
class Person(object):
    def __init__(self, name):
        self.__name = name
    def __str__(self):
        return "i am a person, my name is " + self.__name
# 创建对象
p = Person("jerry")
# 输出对象
print(p) 
# 执行结果：i am a person, my name is jerry
p
# 执行结果：<__main__.Person object at 0x0000028727259550>

我们突然发现，直接打印对象，输出的结果竟然是我们在__str__()方法中定义的字符串。其实我们在使用使用对象的时候，就会默认调用对象的__str__()方法获取对象的字符串描述信息，这个__str__()方法是从object对象继承而来的，我们这里只是对它进行了方法重写。

另外，在命令行操作过程中，如果不用print()方法打印而是直接输入对象，会发现执行的结果又是让人晦涩难懂的东西了，在命令行直接使用对象调用的不是对象的__str__()方法，而是__repr__()方法，只需要简单的修改即可

# 定义类型
class Person(object):
    def __init__(self, name):
        self.__name = name
    def __str__(self):
        return "i am a person, my name is " + self.__name
    # 将方法__str__赋值给__repr__
    __repr__ = __str__
# 创建对象
p = Person("jerry")
# 输出对象
print(p) 
# 执行结果：i am a person, my name is jerry
p
# 执行结果：i am a person, my name is jerry

4.2. 玩转自己~对象的应用直接调用【call()】

当我们创建好对象之后，可以将对象的引用变量当成方法执行会出现什么样的情况呢

# 定义类型
class Person(object):
    def __init__(self, name):
        self.__name = name
# 创建对象
p = Person("jerry")
# 直接执行
p()
# 执行结果：TypeError: 'Person' object is not callable

肯定是不能这么干的~，所以出现错误：Person对象不是一个可执行的东东

但是可以进行如下的改造

# 定义类型
class Person(object):
    def __init__(self, name):
        self.__name = name
    def __call__(self):
        print("一种快捷执行对象中某些初始化操作的特殊方法__call__")
# 创建对象
p = Person("jerry")
# 直接执行
p()
# 执行结果：一种快捷执行对象中某些初始化操作的特殊方法__call__

此时又发现，这样直接将引用变量当成方法执行又变的可行了。
__call__()方法，主要用于对象快捷执行而存在的一个魔术方法，方便进行对象中某些重要数据的初始化整理工作等。

在python中，还有一系列的魔法方法，可以让一个类具有各种特殊的处理功能，如__iter__()方法，让一个类创建的对象可以像列表那样进行数据的迭代；__getitem__()函数可以在迭代的基础上进行索引取值等操作，

5. 特殊的类型：枚举

某些情况下，在我们项目开发过程中，会针对一些不会改变的数据进行标记，~常见的做法就是通过定义常量的情况进行处理，如：在一个员工管理系统中，针对一年十二个月发放工资，这里的十二个月需要进行标记~每个月的天数、绩效这些都不一定一致，可以按照下面的方式进行处理：

# 通过列表中定义一堆的变量来表示12个月份
month = ["JAN", "FAB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"]
# 但是列表表示的方式，列表中的数据并不是非常的安全，有可能在操作的过程中被修改

# 通过元组中定义一堆的变量来表示12个月份
month = ("JAN", "FAB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC")
# 这样就比第一种方案简单多了，也方便后续的各种操作

# 通过类型中定义一堆的变量来表示12个月份
class Month(object): 
    "JAN" = 1
     "FAB" = 2
    "MAR" = 3
    "APR" = 4 
    "MAY" = 5 
    "JUN" = 6 
    "JUL" = 7 
    "AUG" = 8 
    "SEP" = 9 
    "OCT" = 10 
    "NOV" = 11
    "DEC" = 12
# 这样更加正式一些，不过写起来确实挺麻烦，后续的操作也不怎么友好

5.1. 使用枚举

上述代码中，我们通过三种方式进行了枚举的定义和处理，但是每一种方式都多多少少存在一些遗憾，python中提供了一种特殊的类型：枚举，来处理这样定义常量的问题：

枚举的语法结构：是不是和上面我们使用元组的方式特别相像呢？！

from enum import Enum
# Month = Enum("枚举名称", (元组中的枚举值))
M = Enum("Month",  ("JAN", "FAB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"))
# 使用枚举
print(M.JAN)   #执行结果：Month.JAN
print(M.JAN.value) # 执行结果：1

通过将我们原始的条件判断，加上枚举操作，可以简化代码的同时提高代码的可读性
参考如下代码，明显第二种代码的可读性更高，更加方便我们的项目维护操作

if month == 1:
    print("1月份发放工资")
-------------------------------------------
if month = Month.JAN:
     print("1月份发放工资")

5.2. 自定义枚举

Python提供的枚举已经完全足够适用于我们项目中使用的各种场景了
如果枚举的细节处理程度还是不满足您的项目，可以通过python提供的方式进行自定义枚举的定义

# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
#  自定义枚举语法结构
# from enum import Enum, unique
#
# @unique
# class EnumName(Enum):
#     枚举元素
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
# 创建一个自定义枚举，用于定义一周中星期的每一天，方便做日志记录
from enum import Enum, unique

@unique
class Weekday(Enum):
    MON = 1
    TUE = 2
    WED = 3
    THU = 4
    FRI = 5
    SAT = 6
    SUN = 7
# 使用枚举，和常规的使用方式一致
if today == Weekday.SAT:
    print("提醒：今天是发送周报的日子，不要忘记哦")