class：定义类

定义一个类使用class关键字实现：

1
2
3

class 类名：
  多个（≥0）类属性...
  多个（≥0）类方法...

无论是类属性还是类方法，对于类来说，它们都不是必需的。另外，类中属性和方法所在的位置是任意的，即它们之间并没有固定的前后次序。

类属性指的就是包含在类中的变量；类方法指的是包含类中的函数。换句话说，类属性和类方法其实分别是包含类中的变量和函数的别称。

Python 类是由类头（class类名）和类体（统一缩进的变量和函数）构成。

1
2
3
4
5
6
7

class TheFirstDemo:
  '''这是一个学习Python定义的第一个类'''
  # 下面定义了一个类属性
  add = 'hello'
  # 下面定义了一个say方法
  def say(self, content):
    print(content)

和函数一样，我们也可以为类定义说明文档，其要放到类头之后，类体之前的位置，如上面程序中第二行的字符串，就是TheFirstDemo这个类的说明文档。

另外分析上面的代码可以看到，我们创建了一个名为TheFirstDemo的类，其包含了一个名为add的类属性。注意，根据定义属性位置的不同，在各个类方法之外定义的变量称为类属性或类变量（如add属性）。

同时，TheFirstDemo类中还包含一个say()类方法，该方法包含两个参数，分别是self和content。content参数就只是一个普通参数，没有特殊含义，但self比较特殊，并不是普通的参数。

更确切地说，say()是一个实例方法，除此之外，Python 类中还可以定义类方法和静态方法。

事实上，我们完全可以创建一个没有任何类属性和类方法的类，换句话说，Python 允许创建空类：

1
2

class Empty:
  pass

可以看到，如果一个类没有任何类属性和类方法，那么可以直接用pass关键字作为类体即可。

init()类构造方法

在创建类时，我们可以手动添加一个__init__()方法，该方法是一个特殊的类实例方法，称为构造方法（或构造函数）。

构造方法用于创建对象时使用，每当创建一个类的实例对象时，Python 解释器都会自动调用它。

1
2

def __init__(self,...):
  代码块

另外，__init__()方法可以包含多个参数，但必须包含一个名为self的参数，且必须作为第一个参数。也就是说，类的构造方法最少也要有一个self参数。

1
2
3
4
5
6
7
8
9
10

class TheFirstDemo:
  '''这是一个学习Python定义的第一个类'''
  #构造方法
  def __init__(self):
    print("调用构造方法")
  # 下面定义了一个类属性
  add = 'test'
  # 下面定义了一个say方法
  def say(self, content):
    print(content)

注意，即便不手动为类添加任何构造方法，Python 也会自动为类添加一个仅包含self参数的构造方法。

仅包含self参数的__init__()构造方法，又称为类的默认构造方法。

1

zhangsan = TheFirstDemo()

这行代码的含义是创建一个名为zhangsan的TheFirstDemo类对象。运行代码可看到如下结果：

1

调用构造方法

显然，在创建zhangsan这个对象时，隐式调用了我们手动创建的__init__()构造方法。

在__init__()构造方法中，除了self参数外，还可以自定义一些参数，参数之间使用逗号进行分割。

1
2
3
4
5
6

class CLanguage:
  '''这是一个学习Python定义的一个类'''
  def __init__(self, name, add):
    print(name, "的英文名为:", add)
#创建 add 对象，并传递参数给构造函数
add = CLanguage("小明","xiaoming")

可以看到，虽然构造方法中有self、name、add3 个参数，但实际需要传参的仅有name和add，也就是说，self不需要手动传递参数。

类对象的创建和使用

类的实例化

对已定义好的类进行实例化：

1

类名(参数)

定义类时，如果没有手动添加__init__()构造方法，又或者添加的__init__()中仅有一个self参数，则创建类对象时的参数可以省略不写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class CLanguage :
  # 下面定义了2个类变量
  name = "小明"
  add = "xiaoming"
  def __init__(self, name, add):
    #下面定义 2 个实例变量
    self.name = name
    self.add = add
    print(name,"的英文名为：",add)
  # 下面定义了一个say实例方法
  def say(self, content):
    print(content)
# 将该CLanguage对象赋给clanguage变量
clanguage = CLanguage("小明","xiaoming")

在上面的程序中，由于构造方法除self参数外，还包含 2 个参数，且这 2 个参数没有设置默认参数，因此在实例化类对象时，需要传入相应的name值和add值（self参数是特殊参数，不需要手动传值，Python 会自动传给它值）。

类变量和实例变量，简单地理解，定义在各个类方法之外（包含在类中）的变量为类变量（或者类属性），定义在类方法中的变量为实例变量（或者实例属性）。

类对象的使用

定义的类只有进行实例化，也就是使用该类创建对象之后，才能得到利用。总的来说，实例化后的类对象可以执行以下操作：

• 访问或修改类对象具有的实例变量，甚至可以添加新的实例变量或者删除已有的实例变量；
• 调用类对象的方法，包括调用现有的方法，以及给类对象动态添加方法。

类对象访问变量或方法

使用已创建好的类对象访问类中实例变量的语法格式如下：

1

类对象名.变量名

使用类对象调用类中方法的语法格式如下：

1

对象名.方法名(参数)

1
2
3
4
5
6
7
8
9

#输出name和add实例变量的值
print(clanguage.name,clanguage.add)
#修改实例变量的值
clanguage.name="小红"
clanguage.add="xiaohong"
#调用clanguage的say()方法
clanguage.say("人生苦短，我用Python")
#再次输出name和add的值
print(clanguage.name,clanguage.add)

给类对象动态添加/删除变量

Python 支持为已创建好的对象动态增加实例变量：

1
2
3

# 为clanguage对象增加一个money实例变量
clanguage.money= 159.9
print(clanguage.money) # 159.9

动态删除使用del语句即可实现：

1
2
3
4

#删除新添加的 money 实例变量
del clanguage.money
#再次尝试输出 money，此时会报错
print(clanguage.money)

运行程序会发现，结果显示AttributeError错误：

1
2
3
4

Traceback (most recent call last):
  File "C:/Users/mengma/Desktop/1.py", line 29, in <module>
    print(clanguage.money)
AttributeError: 'CLanguage' object has no attribute 'money'

给类对象动态添加方法

Python 也允许为对象动态增加方法。以Clanguage类为例，由于其内部只包含一个say()方法，因此该类实例化出的clanguage对象也只包含一个say()方法。但其实，我们还可以为clanguage对象动态添加其它方法。

需要注意的一点是，为clanguage对象动态增加的方法，Python 不会自动将调用者自动绑定到第一个参数（即使将第一个参数命名为self也没用）。

1
2
3
4
5
6
7
8
9
10
11

# 先定义一个函数
def info(self):
  print("---info函数---", self)
# 使用info对clanguage的foo方法赋值（动态绑定方法）
clanguage.foo = info
# Python不会自动将调用者绑定到第一个参数，
# 因此程序需要手动将调用者绑定为第一个参数
clanguage.foo(clanguage)  # ①
# 使用lambda表达式为clanguage对象的bar方法赋值（动态绑定方法）
clanguage.bar = lambda self: print('--lambda表达式--', self)
clanguage.bar(clanguage) # ②

上面的第 8 行和第 10 行代码分别使用函数、lambda 表达式为clanguage对象动态增加了方法，但对于动态增加的方法，Python 不会自动将方法调用者绑定到它们的第一个参数，因此程序必须手动为第一个参数传入参数值，如上面程序中 ① 号、② 号代码所示。

有没有不用手动给self传值的方法呢？通过借助types模块下的MethodType可以实现：

1
2
3
4
5
6
7

def info(self,content):
  print("小明的英文名为：%s" % content)
# 导入MethodType
from types import MethodType
clanguage.info = MethodType(info, clanguage)
# 第一个参数已经绑定了，无需传入
clanguage.info("xiaoming")

可以看到，由于使用MethodType包装info()函数时，已经将该函数的self参数绑定为clanguage，因此后续再使用info()函数时，就不用再给self参数绑定值了。

self用法

在定义类的过程中，无论是显式创建类的构造方法，还是向类中添加实例方法，都要求将self参数作为方法的第一个参数。

1
2
3
4
5
6

class Person:
  def __init__(self):
    print("正在执行构造方法")
  # 定义一个study()实例方法
  def study(self,name):
    print(name,"正在学Python")

事实上，Python 只是规定，无论是构造方法还是实例方法，最少要包含一个参数，并没有规定该参数的具体名称。之所以将其命名为self，只是程序员之间约定俗成的一种习惯（大家一看到self，就知道它的作用）。

那么，self参数的具体作用是什么呢？打个比方，如果把类比作造房子的图纸，那么类实例化后的对象是真正可以住的房子。根据一张图纸（类），我们可以设计出成千上万的房子（类对象），每个房子长相都是类似的（都有相同的类变量和类方法），但它们都有各自的主人，那么如何对它们进行区分呢？

当然是通过self参数，它就相当于每个房子的门钥匙，可以保证每个房子的主人仅能进入自己的房子（每个类对象只能调用自己的类变量和类方法）。

其实 Python 类方法中的self参数就相当于 C++ 中的this指针。

也就是说，同一个类可以产生多个对象，当某个对象调用类方法时，该对象会把自身的引用作为第一个参数自动传给该方法，换句话说，Python 会自动绑定类方法的第一个参数指向调用该方法的对象。如此，Python 解释器就能知道到底要操作哪个对象的方法了。

因此，程序在调用实例方法和构造方法时，不需要手动为第一个参数传值。

1
2
3
4
5
6
7
8
9
10

class Person:
  def __init__(self):
    print("正在执行构造方法")
  # 定义一个study()实例方法
  def study(self):
    print(self, "正在学Python")
zhangsan = Person()
zhangsan.study()
lisi = Person()
lisi.study()

上面代码中，study()中的self代表该方法的调用者，即谁调用该方法，那么self就代表谁。因此，该程序的运行结果为：

1
2
3
4

正在执行构造方法
<__main__.Person object at 0x0000021ADD7D21D0> 正在学Python
正在执行构造方法
<__main__.Person object at 0x0000021ADD7D2E48> 正在学Python

另外，对于构造函数中的self参数，其代表的是当前正在初始化的类对象。

1
2
3
4
5
6
7
8

class Person:
  name = "xxx"
  def __init__(self,name):
    self.name=name
zhangsan = Person("zhangsan")
print(zhangsan.name) # zhangsan
lisi = Person("lisi")
print(lisi.name) # lisi

可以看到，zhangsan在进行初始化时，调用的构造函数中self代表的是zhangsan；而lisi在进行初始化时，调用的构造函数中self代表的是lisi。

值得一提的是，除了类对象可以直接调用类方法，还有一种函数调用的方式：

1
2
3
4
5
6
7
8
9

class Person:
  def who(self):
    print(self)
zhangsan = Person()
#第一种方式
zhangsan.who()
#第二种方式
who = zhangsan.who
who()#通过 who 变量调用zhangsan对象中的 who() 方法

运行结果为：

1
2

<__main__.Person object at 0x0000025C26F021D0>
<__main__.Person object at 0x0000025C26F021D0>

显然，无论采用哪种方法，self所表示的都是实际调用该方法的对象。

总之，无论是类中的构造函数还是普通的类方法，实际调用它们的谁，则第一个参数self就代表谁。

类属性和实例属性

无论是类属性还是类方法，都无法像普通变量或者函数那样，在类的外部直接使用它们。我们可以将类看做一个独立的空间，则类属性其实就是在类体中定义的变量，类方法是在类体中定义的函数。

在类体中，根据变量定义的位置不同，以及定义的方式不同，类属性又可细分为以下 3 种类型：

• 类体中、所有函数之外：此范围定义的变量，称为类属性或类变量；
• 类体中，所有函数内部：以self.变量名的方式定义的变量，称为实例属性或实例变量；
• 类体中，所有函数内部：以“变量名=变量值”的方式定义的变量，称为局部变量。

类方法也可细分为实例方法、静态方法和类方法。

类变量（类属性）

类变量指的是在类中，但在各个类方法外定义的变量。

1
2
3
4
5
6
7

class CLanguage :
  # 下面定义了2个类变量
  name = "小明"
  add = "xiaoming"
  # 下面定义了一个say实例方法
  def say(self, content):
    print(content)

上面程序中，name和add就属于类变量。

类变量的特点是，所有类的实例化对象都同时共享类变量，也就是说，类变量在所有实例化对象中是作为公用资源存在的。类变量的调用方式有 2 种，既可以使用类名直接调用，也可以使用类的实例化对象调用。

1
2
3
4
5
6
7
8

#使用类名直接调用
print(CLanguage.name) # 小明
print(CLanguage.add) # xiaoming
#修改类变量的值
CLanguage.name = "小红"
CLanguage.add = "xiaohong"
print(CLanguage.name) # 小红
print(CLanguage.add) # xiaohong

可以看到，通过类名不仅可以调用类变量，也可以修改它的值。

当然，也可以使用类对象来调用所属类中的类变量。

1
2
3

clang = CLanguage()
print(clang.name)
print(clang.add)

注意，因为类变量为所有实例化对象共有，通过类名修改类变量的值，会影响所有的实例化对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

print("修改前，各类对象中类变量的值：")
clang1 = CLanguage()
print(clang1.name) # 小明
print(clang1.add) # xiaoming
clang2 = CLanguage()
print(clang2.name) # 小明
print(clang2.add) # xiaoming
print("修改后，各类对象中类变量的值：")
CLanguage.name = "小红"
CLanguage.add = "xiaohong"
print(clang1.name) # 小红
print(clang1.add) # xiaohong
print(clang2.name) # 小红
print(clang2.add) # xiaohong

显然，通过类名修改类变量，会作用到所有的实例化对象（例如这里的clang1和clang2）。

注意，通过类对象是无法修改类变量的。通过类对象对类变量赋值，其本质将不再是修改类变量的值，而是在给该对象定义新的实例变量。

值得一提的是，除了可以通过类名访问类变量之外，还可以动态地为类和对象添加类变量。

1
2
3

clang = CLanguage()
CLanguage.catalog = 13
print(clang.catalog) # 13

实例变量（实例属性）

实例变量指的是在任意类方法内部，以“self.变量名”的方式定义的变量，其特点是只作用于调用方法的对象。另外，实例变量只能通过对象名访问，无法通过类名访问。

1
2
3
4
5
6
7

class CLanguage :
  def __init__(self):
    self.name = "小明"
    self.add = "xiaoming"
    # 下面定义了一个say实例方法
  def say(self):
    self.catalog = 13

此CLanguage类中，name、add以及catalog都是实例变量。其中，由于__init__()函数在创建类对象时会自动调用，而say()方法需要类对象手动调用。因此，CLanguage类的类对象都会包含name和add实例变量，而只有调用了say()方法的类对象，才包含catalog实例变量。

1
2
3
4
5
6
7
8
9
10
11

clang = CLanguage()
print(clang.name) # 小明
print(clang.add) # xiaoming
#由于 clang 对象未调用 say() 方法，因此其没有 catalog 变量，下面这行代码会报错
#print(clang.catalog)
clang2 = CLanguage()
print(clang2.name) # 小明
print(clang2.add) # xiaoming
#只有调用 say()，才会拥有 catalog 实例变量
clang2.say()
print(clang2.catalog) # 13

通过类对象可以访问类变量，但无法修改类变量的值。这是因为，通过类对象修改类变量的值，不是在给“类变量赋值”，而是定义新的实例变量。

1
2
3
4
5
6
7
8
9
10
11
12

clang = CLanguage()
#clang访问类变量
print(clang.name) # 小明
print(clang.add) # xiaoming
clang.name = "小红"
clang.add = "xiaohong"
#clang实例变量的值
print(clang.name) # 小红
print(clang.add) # xiaohong
#类变量的值
print(CLanguage.name) # 小明
print(CLanguage.add) # xiaoming

显然，通过类对象是无法修改类变量的值的，本质其实是给clang对象新添加name和add这 2 个实例变量。

类中，实例变量和类变量可以同名，但这种情况下使用类对象将无法调用类变量，它会首选实例变量，这也是不推荐“类变量使用对象名调用”的原因。

另外，和类变量不同，通过某个对象修改实例变量的值，不会影响类的其它实例化对象，更不会影响同名的类变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class CLanguage :
  name = "小明"  #类变量
  add = "xiaoming"  #类变量
  def __init__(self):
    self.name = "小红"   #实例变量
    self.add = "xiaohong"   #实例变量
  # 下面定义了一个say实例方法
  def say(self):
    self.catalog = 13  #实例变量
clang = CLanguage()
#修改 clang 对象的实例变量
clang.name = "小李"
clang.add = "xiaoli"
print(clang.name) # 小李
print(clang.add) # xiaoli
clang2 = CLanguage()
print(clang2.name) # 小红
print(clang2.add) # xiaohong
#输出类变量的值
print(CLanguage.name) # 小明
print(CLanguage.add) # xiaoming

不仅如此，Python 只支持为特定的对象添加实例变量。例如，在之前代码的基础上，为clang对象添加money实例变量：

1
2

clang.money = 30
print(clang.money)

局部变量

除了实例变量，类方法中还可以定义局部变量。局部变量直接以“变量名=值”的方式进行定义：

1
2
3
4
5
6
7

class CLanguage :
  # 下面定义了一个say实例方法
  def count(self,money):
    sale = 0.8*money
    print("优惠后的价格为：",sale)
clang = CLanguage()
clang.count(100)

通常情况下，定义局部变量是为了所在类方法功能的实现。需要注意的一点是，局部变量只能用于所在函数中，函数执行完成后，局部变量也会被销毁。

实例方法、静态方法和类方法

类方法可分为类方法、实例方法和静态方法。采用@classmethod修饰的方法为类方法；采用@staticmethod修饰的方法为静态方法；不用任何修饰的方法为实例方法。

类实例方法

通常情况下，在类中定义的方法默认都是实例方法。类的构造方法理论上也属于实例方法，只不过它比较特殊。

1
2
3
4
5
6
7
8

class CLanguage:
  #类构造方法，也属于实例方法
  def __init__(self):
    self.name = "小明"
    self.add = "xiaoming"
  # 下面定义了一个say实例方法
  def say(self):
    print("正在调用 say() 实例方法")

实例方法最大的特点就是，它最少也要包含一个self参数，用于绑定调用此方法的实例对象（Python 会自动完成绑定）。实例方法通常会用类对象直接调用：

1
2

clang = CLanguage()
clang.say() # 正在调用 say() 实例方法

当然，Python 也支持使用类名调用实例方法，但此方式需要手动给self参数传值。

1
2
3

#类名调用实例方法，需手动给 self 参数传值
clang = CLanguage()
CLanguage.say(clang) # 正在调用 say() 实例方法

类方法

类方法和实例方法相似，它最少也要包含一个参数，只不过类方法中通常将其命名为cls，Python 会自动将类本身绑定给cls参数（注意，绑定的不是类对象）。也就是说，我们在调用类方法时，无需显式为cls参数传参。

和self一样，cls参数的命名也不是规定的（可以随意命名），只是 Python 程序员约定俗称的习惯而已。

和实例方法最大的不同在于，类方法需要使用@classmethod修饰符进行修饰：

1
2
3
4
5
6
7
8
9

class CLanguage:
  #类构造方法，也属于实例方法
  def __init__(self):
    self.name = "小明"
    self.add = "xiaoming"
  #下面定义了一个类方法
  @classmethod
  def info(cls):
    print("正在调用类方法", cls)

如果没有＠classmethod，则 Python 解释器会将info()方法认定为实例方法，而不是类方法。

类方法推荐使用类名直接调用，当然也可以使用实例对象来调用（不推荐）。

1
2
3
4
5

#使用类名直接调用类方法
CLanguage.info()
#使用类对象调用类方法
clang = CLanguage()
clang.info()

类静态方法

静态方法，其实就是函数，和函数唯一的区别是，静态方法定义在类这个空间（类命名空间）中，而函数则定义在程序所在的空间（全局命名空间）中。

静态方法没有类似self、cls这样的特殊参数，因此 Python 解释器不会对它包含的参数做任何类或对象的绑定。也正因为如此，类的静态方法中无法调用任何类属性和类方法。

静态方法需要使用@staticmethod修饰：

1
2
3
4

class CLanguage:
  @staticmethod
  def info(name, add):
    print(name, add)

静态方法的调用，既可以使用类名，也可以使用类对象：

1
2
3
4
5

#使用类名直接调用静态方法
CLanguage.info("小明", "xiaoming")
#使用类对象调用静态方法
clang = CLanguage()
clang.info("小红", "xiaohong")

在实际编程中，几乎不会用到类方法和静态方法，因为我们完全可以使用函数代替它们实现想要的功能，但在一些特殊的场景中（例如工厂模式中），使用类方法和静态方法也是很不错的选择。

类调用实例方法

实例方法的调用方式有 2 种，既可以采用类对象调用，也可以直接通过类名调用。

通常情况下，我们习惯使用类对象调用类中的实例方法。但如果想用类调用实例方法，不能像如下这样：

1
2
3
4
5

class CLanguage:
  def info(self):
    print("我正在学 Python")
#通过类名直接调用实例方法
CLanguage.info()

运行上面代码，程序会报出如下错误：

1
2
3
4

Traceback (most recent call last):
  File "D:\python3.6\demo.py", line 5, in <module>
    CLanguage.info()
TypeError: info() missing 1 required positional argument: 'self'

其中，最后一行报错信息提示我们，调用info()类方式时缺少给self参数传参。这意味着，和使用类对象调用实例方法不同，通过类名直接调用实例方法时，Python 并不会自动给self参数传值。

self参数需要的是方法的实际调用者（是类对象），而这里只提供了类名，当然无法自动传值。

因此，如果想通过类名直接调用实例方法，就必须手动为self参数传值。

1
2
3
4
5
6

class CLanguage:
  def info(self):
    print("我正在学 Python")
clang = CLanguage()
#通过类名直接调用实例方法
CLanguage.info(clang)

可以看到，通过手动将clang这个类对象传给了self参数，使得程序得以正确执行。实际上，这里调用实例方法的形式完全是等价于clang.info()。

值得一提的是，上面的报错信息只是让我们手动为self参数传值，但并没有规定必须传一个该类的对象，其实完全可以任意传入一个参数：

1
2
3
4
5

class CLanguage:
  def info(self):
    print(self,"正在学 Python")
#通过类名直接调用实例方法
CLanguage.info("zhangsan")

运行结果为：

1

zhangsan 正在学 Python

可以看到，"zhangsan"这个字符串传给了info()方法的self参数。显然，无论是info()方法中使用self参数调用其它类方法，还是使用self参数定义新的实例变量，胡乱的给self参数传参都将会导致程序运行崩溃。

总的来说，Python 中允许使用类名直接调用实例方法，但必须手动为该方法的第一个self参数传递参数，这种调用方法的方式被称为“非绑定方法”。

用类的实例对象访问类成员的方式称为绑定方法，而用类名调用类成员的方式称为非绑定方法。

描述符

通过使用描述符，可以让程序员在引用一个对象属性时自定义要完成的工作。

本质上看，描述符就是一个类，只不过它定义了另一个类中属性的访问方式。换句话说，一个类可以将属性管理全权委托给描述符类。

描述符是 Python 中复杂属性访问的基础，它在内部被用于实现 property、方法、类方法、静态方法和super类型。

描述符类基于以下 3 个特殊方法，换句话说，这 3 个方法组成了描述符协议：

• __set__(self, obj, type=None)：在设置属性时将调用这一方法；
• __get__(self, obj, value)：在读取属性时将调用这一方法；
• __delete__(self, obj)：对属性调用del时将调用这一方法。

其中，实现了setter和getter方法的描述符类被称为数据描述符；反之，如果只实现了getter方法，则称为非数据描述符。

实际上，在每次查找属性时，描述符协议中的方法都由类对象的特殊方法__getattribute__()调用（注意不要和__getattr__()弄混）。也就是说，每次使用类对象.属性（或者getattr(类对象，属性值)）的调用方式时，都会隐式地调用__getattribute__()，它会按照下列顺序查找该属性：

• 验证该属性是否为类实例对象的数据描述符；
• 如果不是，就查看该属性是否能在类实例对象的__dict__中找到；
• 最后，查看该属性是否为类实例对象的非数据描述符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#描述符类
class revealAccess:
  def __init__(self, initval = None, name = 'var'):
    self.val = initval
    self.name = name
  def __get__(self, obj, objtype):
    print("Retrieving",self.name)
    return self.val
  def __set__(self, obj, val):
    print("updating",self.name)
    self.val = val
class myClass:
  x = revealAccess(10,'var "x"')
  y = 5
m = myClass()
print(m.x)
m.x = 20
print(m.x)
print(m.y)

运行结果为：

1
2
3
4
5
6

Retrieving var "x"
10
updating var "x"
Retrieving var "x"
20
5

从这个例子可以看到，如果一个类的某个属性有数据描述符，那么每次查找这个属性时，都会调用描述符的__get__()方法，并返回它的值；同样，每次在对该属性赋值时，也会调用__set__()方法。

注意，虽然上面例子中没有使用__del__()方法，但也很容易理解，当每次使用del类对象.属性（或者 delattr(类对象，属性)）语句时，都会调用该方法。

property()函数

我们一直在用“类对象.属性”的方式访问类中定义的属性，其实这种做法是欠妥的，因为它破坏了类的封装原则。正常情况下，类包含的属性应该是隐藏的，只允许通过类提供的方法来间接实现对类属性的访问和操作。

因此，在不破坏类封装原则的基础上，为了能够有效操作类中的属性，类中应包含读（或写）类属性的多个getter（或setter）方法，这样就可以通过“类对象.方法(参数)”的方式操作属性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class CLanguage:
  #构造函数
  def __init__(self,name):
    self.name = name 
  #设置 name 属性值的函数 
  def setname(self,name):
    self.name = name
  #访问nema属性值的函数
  def getname(self):
    return self.name
  #删除name属性值的函数
  def delname(self):
    self.name="xxx"
clang = CLanguage("小明")
#获取name属性值
print(clang.getname()) # 小明
#设置name属性值
clang.setname("Python教程") # Python教程
print(clang.getname())
#删除name属性值
clang.delname()
print(clang.getname()) # xxx

Python 中提供了property()函数，可以实现在不破坏类封装原则的前提下，让开发者依旧使用“类对象.属性”的方式操作类中的属性。

1

属性名=property(fget=None, fset=None, fdel=None, doc=None)

其中，fget参数用于指定获取该属性值的类方法，fset参数用于指定设置该属性值的方法，fdel参数用于指定删除该属性值的方法，最后的doc是一个文档字符串，用于说明此函数的作用。

注意，在使用property()函数时，以上 4 个参数可以仅指定第 1 个、或者前 2 个、或者前 3 个，当前也可以全部指定。也就是说，property()函数中参数的指定并不是完全随意的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class CLanguage:
  #构造函数
  def __init__(self,n):
    self.__name = n
  #设置 name 属性值的函数
  def setname(self,n):
    self.__name = n
  #访问nema属性值的函数
  def getname(self):
    return self.__name
  #删除name属性值的函数
  def delname(self):
    self.__name="xxx"
  #为name 属性配置 property() 函数
  name = property(getname, setname, delname, '指明出处')
#调取说明文档的 2 种方式
#print(CLanguage.name.__doc__)
help(CLanguage.name)
clang = CLanguage("小明")
#调用 getname() 方法
print(clang.name)
#调用 setname() 方法
clang.name="Python教程"
print(clang.name)
#调用 delname() 方法
del clang.name
print(clang.name)

运行结果为：

1
2
3
4
5
6
7

Help on property:

    指明出处

小明
Python教程
xxx

注意，在此程序中，由于getname()方法中需要返回name属性，如果使用self.name的话，其本身又被调用getname()，这将会先入无限死循环。为了避免这种情况的出现，程序中的name属性必须设置为私有属性，即使用__name（前面有 2 个下划线）。

当然，property()函数也可以少传入几个参数。

1

name = property(getname, setname)

这意味着，name是一个可读写的属性，但不能删除，因为property()函数中并没有为name配置用于函数该属性的方法。也就是说，即便CLanguage类中设计有delname()函数，这种情况下也不能用来删除name属性。

同理，还可以像如下这样使用property()函数：

1
2

name = property(getname) # name 属性可读，不可写，也不能删除
name = property(getname, setname,delname) # name属性可读、可写、也可删除，就是没有说明文档

封装

简单的理解封装，即在设计类时，刻意地将一些属性和方法隐藏在类的内部，这样在使用此类时，将无法直接以“类对象.属性名”（或者“类对象.方法名(参数)”）的形式调用这些属性（或方法），而只能用未隐藏的类方法间接操作这些隐藏的属性和方法。

封装机制保证了类内部数据结构的完整性，因为使用类的用户无法直接看到类中的数据结构，只能使用类允许公开的数据，很好地避免了外部对内部数据的影响，提高了程序的可维护性。

除此之外，对一个类实现良好的封装，用户只能借助暴露出来的类方法来访问数据，我们只需要在这些暴露的方法中加入适当的控制逻辑，即可轻松实现用户对类中属性或方法的不合理操作。

Python 类如何进行封装

Python 类中的变量和函数，不是公有的（类似public属性），就是私有的（类似private）。

但是，Python 并没有提供public、private这些修饰符。为了实现类的封装，Python 采取了下面的方法：

• 默认情况下，Python 类中的变量和方法都是公有的，它们的名称前都没有下划线（_）；
• 如果类中的变量和函数，其名称以双下划线__开头，则该变量（函数）为私有变量（私有函数）。

除此之外，还可以定义以单下划线_开头的类属性或者类方法（例如_name、_display(self)），这种类属性和类方法通常被视为私有属性和私有方法，虽然它们也能通过类对象正常访问，但这是一种约定俗称的用法。

注意，Python 类中还有以双下划线开头和结尾的类方法（例如类的构造函数__init__(self)），这些都是 Python 内部定义的，用于 Python 内部调用。我们自己定义类属性或者类方法时，不要使用这种格式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class CLanguage :
  def setname(self, name):
    if len(name) < 1:
      raise ValueError('名称长度必须大于1！')
    self.__name = name
  def getname(self):
    return self.__name
  #为 name 配置 setter 和 getter 方法
  name = property(getname, setname)
  def setadd(self, add):
    if add.startswith("http://"):
      self.__add = add
    else:
      raise ValueError('地址必须以 http:// 开头') 
  def getadd(self):
    return self.__add
  
  #为 add 配置 setter 和 getter 方法
  add = property(getadd, setadd)
  #定义个私有方法
  def __display(self):
    print(self.__name,self.__add)
clang = CLanguage()
clang.name = "百度"
clang.add = "http://www.baidu.com"
print(clang.name) # 百度
print(clang.add) # http://www.baidu.com

上面程序中，CLanguage将name和add属性都隐藏了起来，但同时也提供了可操作它们的“窗口”，也就是各自的setter和getter方法，这些方法都是公有的。

不仅如此，以add属性的setadd()方法为例，通过在该方法内部添加控制逻辑，即通过调用startswith()方法，控制用户输入的地址必须以http://开头，否则程序将会执行raise语句抛出ValueError异常。

通过此程序的运行逻辑不难看出，通过对CLanguage类进行良好的封装，使得用户仅能通过暴露的setter()和getter()方法操作name和add属性，而通过对setname()和setadd()方法进行适当的设计，可以避免用户对类中属性的不合理操作，从而提高了类的可维护性和安全性。

CLanguage类中还有一个__display()方法，由于该类方法为私有（private）方法，且该类没有提供操作该私有方法的“窗口”，因此我们无法在类的外部使用它。换句话说，如下调用__display()方法是不可行的：

1
2

#尝试调用私有的 display() 方法
clang.__display()

这会导致如下错误：

1
2
3
4

Traceback (most recent call last):
  File "D:\python3.6\1.py", line 33, in <module>
    clang.__display()
AttributeError: 'CLanguage' object has no attribute '__display'

继承

继承机制经常用于创建和现有类功能类似的新类，又或是新类只需要在现有类基础上添加一些成员（属性和方法），但又不想直接将现有类代码复制给新类。也就是说，通过使用继承这种机制，可以轻松实现类的重复使用。

举个例子，假设现有一个Shape类，该类的draw()方法可以在屏幕上画出指定的形状，现在需要创建一个Form类，要求此类不但可以在屏幕上画出指定的形状，还可以计算出所画形状的面积。要创建这样的类，笨方法是将draw()方法直接复制到新类中，并添加计算面积的方法。

1
2
3
4
5
6
7
8
9

class Shape:
  def draw(self,content):
    print("画",content)
class Form:
  def draw(self,content):
    print("画",content)
  def area(self):
    #....
    print("此图形的面积为...")

当然还有更简单的方法，就是使用类的继承机制。实现方法为：让Form类继承Shape类，这样当Form类对象调用draw()方法时，Python 解释器会先去 Form 中找以draw为名的方法，如果找不到，它还会自动去Shape类中找。如此，我们只需在Form类中添加计算面积的方法即可：

1
2
3
4
5
6
7

class Shape:
  def draw(self,content):
    print("画",content)
class Form(Shape):
  def area(self):
    #....
    print("此图形的面积为...")

上面代码中，class Form(Shape)就表示Form继承Shape。

Python 中，实现继承的类称为子类，被继承的类称为父类（也可称为基类、超类）。因此在上面这个样例中，Form是子类，Shape是父类。

子类继承父类时，只需在定义子类时，将父类（可以是多个）放在子类之后的圆括号里即可。

1
2

class 类名(父类1, 父类2, ...)：
  #类定义部分

注意，如果该类没有显式指定继承自哪个类，则默认继承 object 类（object 类是 Python 中所有类的父类，即要么是直接父类，要么是间接父类）。另外，Python 的继承是多继承机制（和 C++ 一样），即一个子类可以同时拥有多个直接父类。

“派生”和继承是一个意思，只是观察角度不同而已。换句话说，继承是相对子类来说的，即子类继承自父类；而派生是相对于父类来说的，即父类派生出子类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class People:
  def say(self):
    print("我是一个人，名字是：",self.name)
class Animal:
  def display(self):
    print("人也是高级动物")
#同时继承 People 和 Animal 类
#其同时拥有 name 属性、say() 和 display() 方法
class Person(People, Animal):
  pass
zhangsan = Person()
zhangsan.name = "张三"
zhangsan.say()
zhangsan.display()

运行结果为：

1
2

我是一个人，名字是： 张三
人也是高级动物

可以看到，虽然 Person 类为空类，但由于其继承自 People 和 Animal 这 2 个类，因此实际上 Person 并不空，它同时拥有这 2 个类所有的属性和方法。
没错，子类拥有父类所有的属性和方法，即便该属性或方法是私有（private）的。

关于Python的多继承

事实上，大部分面向对象的编程语言，都只支持单继承，即子类有且只能有一个父类。而 Python 却支持多继承（C++也支持多继承）。
和单继承相比，多继承容易让代码逻辑复杂、思路混乱，一直备受争议，中小型项目中较少使用，后来的 Java、C#、PHP 等干脆取消了多继承。

使用多继承经常需要面临的问题是，多个父类中包含同名的类方法。对于这种情况，Python 的处置措施是：根据子类继承多个父类时这些父类的前后次序决定，即排在前面父类中的类方法会覆盖排在后面父类中的同名类方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class People:
  def __init__(self):
    self.name = People
  def say(self):
    print("People类",self.name)
class Animal:
  def __init__(self):
    self.name = Animal
  def say(self):
    print("Animal类",self.name)
#People中的 name 属性和 say() 会遮蔽 Animal 类中的
class Person(People, Animal):
  pass
zhangsan = Person()
zhangsan.name = "张三"
zhangsan.say()

程序运行结果为：

1

People类 张三

可以看到，当Person同时继承People类和Animal类时，People类在前，因此如果People和Animal拥有同名的类方法，实际调用的是People类中的。

父类方法重写

在 Python 中，子类继承了父类，那么子类就拥有了父类所有的类属性和类方法。通常情况下，子类会在此基础上，扩展一些新的类属性和类方法。

但凡事都有例外，我们可能会遇到这样一种情况，即子类从父类继承得来的类方法中，大部分是适合子类使用的，但有个别的类方法，并不能直接照搬父类的，如果不对这部分类方法进行修改，子类对象无法使用。针对这种情况，我们就需要在子类中重复父类的方法。

举个例子，鸟通常是有翅膀的，也会飞，因此我们可以像如下这样定义个和鸟相关的类：

1
2
3
4
5
6
7

class Bird:
  #鸟有翅膀
  def isWing(self):
    print("鸟有翅膀")
  #鸟会飞
  def fly(self):
    print("鸟会飞")

但是，对于鸵鸟来说，它虽然也属于鸟类，也有翅膀，但是它只会奔跑，并不会飞。针对这种情况，可以这样定义鸵鸟类：

1
2
3
4

class Ostrich(Bird):
  # 重写Bird类的fly()方法
  def fly(self):
    print("鸵鸟不会飞")

可以看到，因为Ostrich继承自Bird，因此Ostrich类拥有Bird类的isWing()和fly()方法。其中，isWing()方法同样适合Ostrich，但fly()明显不适合，因此我们在Ostrich类中对fly()方法进行重写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Bird:
  #鸟有翅膀
  def isWing(self):
    print("鸟有翅膀")
  #鸟会飞
  def fly(self):
    print("鸟会飞")
class Ostrich(Bird):
  # 重写Bird类的fly()方法
  def fly(self):
    print("鸵鸟不会飞")
# 创建Ostrich对象
ostrich = Ostrich()
#调用 Ostrich 类中重写的 fly() 类方法
ostrich.fly()

运行结果为：

1

鸵鸟不会飞

显然，ostrich调用的是重写之后的fly()类方法。

如何调用被重写的方法

事实上，如果我们在子类中重写了从父类继承来的类方法，那么当在类的外部通过子类对象调用该方法时，Python 总是会执行子类中重写的方法。

这就产生一个新的问题，即如果想调用父类中被重写的这个方法，该怎么办呢？

Python 中的类可以看做是一个独立空间，而类方法其实就是出于该空间中的一个函数。而如果想要全局空间中，调用类空间中的函数，只需要在调用该函数时备注类名即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Bird:
  #鸟有翅膀
  def isWing(self):
    print("鸟有翅膀")
  #鸟会飞
  def fly(self):
    print("鸟会飞")
class Ostrich(Bird):
  # 重写Bird类的fly()方法
  def fly(self):
    print("鸵鸟不会飞")
# 创建Ostrich对象
ostrich = Ostrich()
#调用 Bird 类中的 fly() 方法
Bird.fly(ostrich)

程序运行结果为：

1

鸟会飞

此程序中，需要大家注意的一点是，使用类名调用其类方法，Python 不会为该方法的第一个self参数自定绑定值，因此采用这种调用方法，需要手动为self参数赋值。

通过类名调用实例方法的这种方式，又被称为未绑定方法。

super()函数

Python 中子类会继承父类所有的类属性和类方法。严格来说，类的构造方法其实就是实例方法，因此毫无疑问，父类的构造方法，子类同样会继承。

但我们知道，Python 支持多继承，如果子类继承的多个父类中包含同名的类实例方法，则子类对象在调用该方法时，会优先选择排在最前面的父类中的实例方法。显然，构造方法也是如此。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class People:
  def __init__(self,name):
    self.name = name
  def say(self):
    print("我是人，名字为：",self.name)
class Animal:
  def __init__(self,food):
    self.food = food
  def display(self):
    print("我是动物,我吃",self.food)
#People中的 name 属性和 say() 会遮蔽 Animal 类中的
class Person(People, Animal):
  pass
per = Person("zhangsan")
per.say()
#per.display()

运行结果，结果为：

1

我是人，名字为： zhangsan

上面程序中，Person 类同时继承 People 和 Animal，其中 People 在前。这意味着，在创建 per 对象时，其将会调用从 People 继承来的构造函数。因此我们看到，上面程序在创建 per 对象的同时，还要给 name 属性进行赋值。

但如果去掉最后一行的注释，运行此行代码，Python 解释器会报如下错误：

1
2
3
4
5
6

Traceback (most recent call last):
  File "D:\python3.6\Demo.py", line 18, in <module>
    per.display()
  File "D:\python3.6\Demo.py", line 11, in display
    print("我是动物,我吃",self.food)
AttributeError: 'Person' object has no attribute 'food'

这是因为，从 Animal 类中继承的 display() 方法中，需要用到 food 属性的值，但由于 People 类的构造方法“遮蔽”了Animal 类的构造方法，使得在创建 per 对象时，Animal 类的构造方法未得到执行，所以程序出错。

反过来也是如此，如果将第 13 行代码改为如下形式：

1

class Person(Animal, People)

则在创建 per 对象时，会给 food 属性传值。这意味着，per.display() 能顺序执行，但 per.say() 将会报错。

针对这种情况，正确的做法是定义 Person 类自己的构造方法（等同于重写第一个直接父类的构造方法）。但需要注意，如果在子类中定义构造方法，则必须在该方法中调用父类的构造方法。

在子类中的构造方法中，调用父类构造方法的方式有 2 种，分别是：

• 类可以看做一个独立空间，在类的外部调用其中的实例方法，可以向调用普通函数那样，只不过需要额外备注类名（此方式又称为未绑定方法）；
• 使用 super() 函数。但如果涉及多继承，该函数只能调用第一个直接父类的构造方法。

也就是说，涉及到多继承时，在子类构造函数中，调用第一个父类构造方法的方式有以上 2 种，而调用其它父类构造方法的方式只能使用未绑定方法。

在 Python 3.x 中，super()函数的语法格式：

1

super().__init__(...)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class People:
  def __init__(self,name):
    self.name = name
  def say(self):
    print("我是人，名字为：",self.name)
class Animal:
  def __init__(self,food):
    self.food = food
  def display(self):
    print("我是动物,我吃",self.food)
class Person(People, Animal):
  #自定义构造方法
  def __init__(self,name,food):
    #调用 People 类的构造方法
    super().__init__(name)
    #super(Person,self).__init__(name) #执行效果和上一行相同
    #People.__init__(self,name)#使用未绑定方法调用 People 类构造方法
    #调用其它父类的构造方法，需手动给 self 传值
    Animal.__init__(self,food)    
per = Person("zhangsan","熟食")
per.say() # 我是人，名字为： zhangsan
per.display() # 我是动物,我吃 熟食

可以看到，Person类自定义的构造方法中，调用People类构造方法，可以使用super()函数，也可以使用未绑定方法。但是调用Animal类的构造方法，只能使用未绑定方法。

__slots__：限制类实例动态添加属性和方法

了解了如何动态的为单个实例对象添加属性，甚至如果必要的话，还可以为所有的类实例对象统一添加属性（通过给类添加属性）。

那么，Python 是否也允许动态地为类或实例对象添加方法呢？答案是肯定的。我们知道，类方法又可细分为实例方法、静态方法和类方法，Python 语言允许为类动态地添加这 3 种方法；但对于实例对象，则只允许动态地添加实例方法，不能添加类方法和静态方法。

为单个实例对象添加方法，不会影响该类的其它实例对象；而如果为类动态地添加方法，则所有的实例对象都可以使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class CLanguage:
    pass
#下面定义了一个实例方法
def info(self):
    print("正在调用实例方法")
#下面定义了一个类方法
@classmethod
def info2(cls):
    print("正在调用类方法")
#下面定义个静态方法
@staticmethod
def info3():
    print("正在调用静态方法")
#类可以动态添加以上 3 种方法，会影响所有实例对象
CLanguage.info = info
CLanguage.info2 = info2
CLanguage.info3 = info3
clang = CLanguage()
#如今，clang 具有以上 3 种方法
clang.info()
clang.info2()
clang.info3()
#类实例对象只能动态添加实例方法，不会影响其它实例对象
clang1 = CLanguage()
clang1.info = info
#必须手动为 self 传值
clang1.info(clang1)

程序输出结果为：
正在调用实例方法
正在调用类方法
正在调用静态方法
正在调用实例方法

显然，动态给类或者实例对象添加属性或方法，是非常灵活的。但与此同时，如果胡乱地使用，也会给程序带来一定的隐患，即程序中已经定义好的类，如果不做任何限制，是可以做动态的修改的。

庆幸的是，Python 提供了__slots__属性，通过它可以避免用户频繁的给实例对象动态地添加属性或方法。

再次声明，__slots__只能限制为实例对象动态添加属性和方法，而无法限制动态地为类添加属性和方法。

__slots__属性值其实就是一个元组，只有其中指定的元素，才可以作为动态添加的属性或者方法的名称。举个例子：

1
2

class CLanguage:
    __slots__ = ('name','add','info')

可以看到，CLanguage类中指定了__slots__属性，这意味着，该类的实例对象仅限于动态添加name、add、info这 3 个属性以及name()、add()和info()这 3 个方法。

注意，对于动态添加的方法，__slots__限制的是其方法名，并不限制参数的个数。

1
2
3
4
5
6
7

def info(self,name):
    print("正在调用实例方法",self.name)
clang = CLanguage()
clang.name = "小明"
#为 clang 对象动态添加 info 实例方法
clang.info = info
clang.info(clang,"Python教程")

程序运行结果为：

1

正在调用实例方法 小明

还是在CLanguage类的基础上，添加如下代码并运行：

1
2
3
4
5
6

def info(self,name):
    print("正在调用实例方法",self.name)
clang = CLanguage()
clang.name = "小明"
clang.say = info
clang.say(clang,"Python教程")

运行程序，显示如下信息：

1
2
3
4

Traceback (most recent call last):
  File "D:\python3.6\1.py", line 9, in <module>
    clang.say = info
AttributeError: 'CLanguage' object has no attribute 'say'

显然，根据__slots__属性的设置，CLanguage类的实例对象是不能动态添加以 say 为名称的方法的。

__slots__属性限制的对象是类的实例对象，而不是类，因此下面的代码是合法的：

1
2
3
4
5

def info(self):
  print("正在调用实例方法")
CLanguage.say = info
clang = CLanguage()
clang.say()

程序运行结果为：

1

正在调用实例方法

当然，还可以为类动态添加类方法和静态方法，这里不再给出具体实例，读者可自行编写代码尝试。

此外，__slots__属性对由该类派生出来的子类，也是不起作用的。例如如下代码：

1
2
3
4
5
6
7
8
9
10
11
12

class CLanguage:
  __slots__ = ('name','add','info')
#Clanguage 的空子类
class CLangs(CLanguage):
  pass
#定义的实例方法
def info(self):
  print("正在调用实例方法")
clang = CLangs()
#为子类对象动态添加 say() 方法
clang.say = info
clang.say(clang)

运行结果为：

1

正在调用实例方法

显然，__slots__属性只对当前所在的类起限制作用。

因此，如果子类也要限制外界为其实例对象动态地添加属性和方法，必须在子类中设置__slots__属性。

注意，如果为子类也设置有__slots__属性，那么子类实例对象允许动态添加的属性和方法，是子类中__slots__属性和父类__slots__属性的和。

type()函数：动态创建类

我们知道，type()函数属于 Python 内置函数，通常用来查看某个变量的具体类型。其实，type()函数还有一个更高级的用法，即创建一个自定义类型（也就是创建一个类）。

type() 函数的语法格式有 2 种：

1
2

type(obj) 
type(name, bases, dict)

以上这 2 种语法格式，各参数的含义及功能分别是：

• 第一种语法格式用来查看某个变量（类对象）的具体类型，obj 表示某个变量或者类对象。
• 第二种语法格式用来创建类，其中 name 表示类的名称；bases 表示一个元组，其中存储的是该类的父类；dict 表示一个字典，用于表示类内定义的属性或者方法。

1
2
3
4
5
6
7

#查看 3.4 的类型
print(type(3.4))
#查看类对象的类型
class CLanguage:
    pass
clangs = CLanguage()
print(type(clangs))

输出结果为：

1
2

<class 'float'>
<class '__main__.CLanguage'>

type()函数的另一种用法，即创建一个新类，先来分析一个样例：

1
2
3
4
5
6
7
8
9
10

#定义一个实例方法
def say(self):
    print("我要学 Python！")
#使用 type() 函数创建类
CLanguage = type("CLanguage",(object,),dict(say = say, name = "C语言中文网"))
#创建一个 CLanguage 实例对象
clangs = CLanguage()
#调用 say() 方法和 name 属性
clangs.say()
print(clangs.name)

注意，Python 元组语法规定，当(object,)元组中只有一个元素时，最后的逗号（,）不能省略。

可以看到，此程序中通过type()创建了类，其类名为CLanguage，继承自objects类，且该类中还包含一个say()方法和一个name属性。

运行上面的程序，其输出结果为：

1
2

我要学 Python！
C语言中文网

可以看到，使用type()函数创建的类，和直接使用class定义的类并无差别。事实上，我们在使用class定义类时，Python 解释器底层依然是用type()来创建这个类。

MetaClass元类

MetaClass元类，本质也是一个类，但和普通类的用法不同，它可以对类内部的定义（包括类属性和类方法）进行动态的修改。可以这么说，使用元类的主要目的就是为了实现在创建类时，能够动态地改变类中定义的属性或者方法。

不要从字面上去理解元类的含义，事实上MetaClass中的Meta这个词根，起源于希腊语词汇 meta，包含“超越”和“改变”的意思。

举个例子，根据实际场景的需要，我们要为多个类添加一个 name 属性和一个 say() 方法。显然有多种方法可以实现，但其中一种方法就是使用 MetaClass 元类。

如果在创建类时，想用MetaClass元类动态地修改内部的属性或者方法，则类的创建过程将变得复杂：先创建 MetaClass 元类，然后用元类去创建类，最后使用该类的实例化对象实现功能。

如果想把一个类设计成MetaClass元类，其必须符合以下条件：

• 必须显式继承自type类；
• 类中需要定义并实现__new__()方法，该方法一定要返回该类的一个实例对象，因为在使用元类创建类时，该__new__()方法会自动被执行，用来修改新建的类。

我们先尝试定义一个MetaClass元类：

1
2
3
4
5
6
7
8
9
10
11

#定义一个元类
class FirstMetaClass(type):
    # cls代表动态修改的类
    # name代表动态修改的类名
    # bases代表被动态修改的类的所有父类
    # attr代表被动态修改的类的所有属性、方法组成的字典
    def __new__(cls, name, bases, attrs):
        # 动态为该类添加一个name属性
        attrs['name'] = "C语言中文网"
        attrs['say'] = lambda self: print("调用 say() 实例方法")
        return super().__new__(cls,name,bases,attrs)

此程序中，首先可以断定 FirstMetaClass 是一个类。其次，由于该类继承自 type 类，并且内部实现了 new() 方法，因此可以断定 FirstMetaCLass 是一个元类。

可以看到，在这个元类的__new__()方法中，手动添加了一个 name 属性和 say() 方法。这意味着，通过 FirstMetaClass 元类创建的类，会额外添加 name 属性和 say() 方法。通过如下代码，可以验证这个结论：

1
2
3
4
5
6

#定义类时，指定元类
class CLanguage(object,metaclass=FirstMetaClass):
  pass
clangs = CLanguage()
print(clangs.name)
clangs.say()

可以看到，在创建类时，通过在标注父类的同时指定元类（格式为metaclass=元类名），则当 Python 解释器在创建这该类时，FirstMetaClass 元类中的 new 方法就会被调用，从而实现动态修改类属性或者类方法的目的。

运行上面的程序，输出结果为：

1
2

C语言中文网
调用 say() 实例方法

显然，FirstMetaClass元类的__new__()方法动态地为Clanguage类添加了name属性和say()方法，因此，即便该类在定义时是空类，它也依然有name属性和say()方法。

对于MetaClass元类，它多用于创建 API，因此我们几乎不会使用到它。

多态

我们都知道，Python 是弱类型语言，其最明显的特征是在使用变量时，无需为其指定具体的数据类型。这会导致一种情况，即同一变量可能会被先后赋值不同的类对象，例如：

1
2
3
4
5
6
7
8
9
10

class CLanguage:
  def say(self):
    print("赋值的是 CLanguage 类的实例对象")
class CPython:
  def say(self):
    print("赋值的是 CPython 类的实例对象")
a = CLanguage()
a.say()
a = CPython()
a.say()

运行结果为：

1
2

赋值的是 CLanguage 类的实例对象
赋值的是 CPython 类的实例对象

可以看到，a可以被先后赋值为CLanguage类和CPython类的对象，但这并不是多态。类的多态特性，还要满足以下 2 个前提条件：

• 继承：多态一定是发生在子类和父类之间；
• 重写：子类重写了父类的方法。

下面程序是对上面代码的改写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class CLanguage:
  def say(self):
    print("调用的是 Clanguage 类的say方法")
class CPython(CLanguage):
  def say(self):
    print("调用的是 CPython 类的say方法")
class CLinux(CLanguage):
  def say(self):
    print("调用的是 CLinux 类的say方法")
a = CLanguage()
a.say()
a = CPython()
a.say()
a = CLinux()
a.say()

程序执行结果为：

1
2
3

调用的是 Clanguage 类的say方法
调用的是 CPython 类的say方法
调用的是 CLinux 类的say方法

可以看到，CPython和CLinux都继承自CLanguage类，且各自都重写了父类的say()方法。从运行结果可以看出，同一变量a在执行同一个say()方法时，由于a实际表示不同的类实例对象，因此a.say()调用的并不是同一个类中的say()方法，这就是多态。

其实，Python 在多态的基础上，衍生出了一种更灵活的编程机制。继续对上面的程序进行改写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class WhoSay:
  def say(self,who):
    who.say()
class CLanguage:
  def say(self):
    print("调用的是 Clanguage 类的say方法")
class CPython(CLanguage):
  def say(self):
    print("调用的是 CPython 类的say方法")
class CLinux(CLanguage):
  def say(self):
    print("调用的是 CLinux 类的say方法")
a = WhoSay()
#调用 CLanguage 类的 say() 方法
a.say(CLanguage())
#调用 CPython 类的 say() 方法
a.say(CPython())
#调用 CLinux 类的 say() 方法
a.say(CLinux())

程序执行结果为：

1
2
3

调用的是 Clanguage 类的say方法
调用的是 CPython 类的say方法
调用的是 CLinux 类的say方法

此程序中，通过给WhoSay类中的say()函数添加一个who参数，其内部利用传入的who调用say()方法。这意味着，当调用WhoSay类中的say()方法时，我们传给who参数的是哪个类的实例对象，它就会调用那个类中的say()方法。

枚举类

一些具有特殊含义的类，其实例化对象的个数往往是固定的，比如用一个类表示月份，则该类的实例对象最多有 12 个。对于这些实例化对象个数固定的类，可以用枚举类来定义。

1
2
3
4
5
6

from enum import Enum
class Color(Enum):
  # 为序列值指定value值
  red = 1
  green = 2
  blue = 3

如果想将一个类定义为枚举类，只需要令其继承自enum模块中的Enum类即可。例如在上面程序中，Color类继承自Enum类，则证明这是一个枚举类。

在Color枚举类中，red、green、blue都是该类的成员（可以理解为是类变量）。注意，枚举类的每个成员都由 2 部分组成，分别为name和value，其中name属性值为该枚举值的变量名（如red），value代表该枚举值的序号（序号通常从 1 开始）。

和普通类的用法不同，枚举类不能用来实例化对象，但这并不妨碍我们访问枚举类中的成员。访问枚举类成员的方式有多种：

1
2
3
4
5
6
7
8
9
10

#调用枚举成员的 3 种方式
print(Color.red)
print(Color['red'])
print(Color(1))
#调取枚举成员中的 value 和 name
print(Color.red.value)
print(Color.red.name)
#遍历枚举类中所有成员的 2 种方式
for color in Color:
  print(color)

程序输出结果为：

1
2
3
4
5
6
7
8

Color.red
Color.red
Color.red
1
red
Color.red
Color.green
Color.blue

枚举类成员之间不能比较大小，但可以用==或者is进行比较是否相等：

1
2

print(Color.red == Color.green) # Flase
print(Color.red.name is Color.green.name) # Flase

需要注意的是，枚举类中各个成员的值，不能在类的外部做任何修改，也就是说，下面语法的做法是错误的：

1

Color.red = 4

除此之外，该枚举类还提供了一个__members__属性，该属性是一个包含枚举类中所有成员的字典，通过遍历该属性，也可以访问枚举类中的各个成员。

1
2

for name,member in Color.__members__.items():
  print(name,"->",member)

输出结果为：

1
2
3

red -> Color.red
green -> Color.green
blue -> Color.blue

值得一提的是，Python 枚举类中各个成员必须保证name互不相同，但value可以相同：

1
2
3
4
5
6
7

from enum import Enum
class Color(Enum):
  # 为序列值指定value值
  red = 1
  green = 1
  blue = 3
print(Color['green'])

输出结果为：

1

Color.red

可以看到，Color枚举类中red和green具有相同的值（都是 1），Python 允许这种情况的发生，它会将green当做是red的别名，因此当访问green成员时，最终输出的是red。

在实际编程过程中，如果想避免发生这种情况，可以借助@unique装饰器，这样当枚举类中出现相同值的成员时，程序会报ValueError错误。

1
2
3
4
5
6
7
8
9
10

#引入 unique
from enum import Enum,unique
#添加 unique 装饰器
@unique
class Color(Enum):
  # 为序列值指定value值
  red = 1
  green = 1
  blue = 3
print(Color['green'])

运行程序会报错：

1
2
3
4
5
6

Traceback (most recent call last):
  File "D:\python3.6\demo.py", line 3, in <module>
    class Color(Enum):
  File "D:\python3.6\lib\enum.py", line 834, in unique
    (enumeration, alias_details))
ValueError: duplicate values found in <enum 'Color'>: green -> red

除了通过继承Enum类的方法创建枚举类，还可以使用Enum()函数创建枚举类。

1
2
3
4
5
6
7
8
9
10
11
12
13

from enum import Enum
#创建一个枚举类
Color = Enum("Color",('red','green','blue'))
#调用枚举成员的 3 种方式
print(Color.red)
print(Color['red'])
print(Color(1))
#调取枚举成员中的 value 和 name
print(Color.red.value)
print(Color.red.name)
#遍历枚举类中所有成员的 2 种方式
for color in Color:
  print(color)

Enum()函数可接受 2 个参数，第一个用于指定枚举类的类名，第二个参数用于指定枚举类中的多个成员。

如上所示，仅通过一行代码，即创建了一个和前面的Color类相同的枚举类。运行程序，其输出结果为：

1
2
3
4
5
6
7
8

Color.red
Color.red
Color.red
1
red
Color.red
Color.green
Color.blue

导入模块

import的用法主要有以下两种：
import 模块名1 [as 别名1], 模块名2 [as 别名2]，…：使用这种语法格式的import语句，会导入指定模块中的所有成员（包括变量、函数、类等）。不仅如此，当需要使用模块中的成员时，需用该模块名（或别名）作为前缀，否则 Python 解释器会报错。
from 模块名 import 成员名1 [as 别名1]，成员名2 [as 别名2]，…：使用这种语法格式的import语句，只会导入模块中指定的成员，而不是全部成员。同时，当程序中使用该成员时，无需附加任何前缀，直接使用成员名（或别名）即可。

注意，用[]括起来的部分，可以使用，也可以省略。

其中，第二种import语句也可以导入指定模块中的所有成员，即使用form模块名import ＊，但此方式不推荐使用。

import 模块名 as 别名

下面程序使用导入整个模块的最简单语法来导入指定模块：

1
2
3
4

# 导入sys整个模块
import sys
# 使用sys模块名作为前缀来访问模块中的成员
print(sys.argv[0])

上面第 2 行代码使用最简单的方式导入了sys模块，因此在程序中使用sys模块内的成员时，必须添加模块名作为前缀。

运行上面程序，可以看到如下输出结果（sys模块下的argv变量用于获取运行 Python 程序的命令行参数，其中argv[0]用于获取当前 Python 程序的存储路径）：

1

C:\Users\mengma\Desktop\hello.py

导入整个模块时，也可以为模块指定别名。例如如下程序：

1
2
3
4

# 导入sys整个模块，并指定别名为s
import sys as s
# 使用s模块别名作为前缀来访问模块中的成员
print(s.argv[0])

第 2 行代码在导入sys模块时才指定了别名s，因此在程序中使用sys模块内的成员时，必须添加模块别名s作为前缀。运行该程序，可以看到如下输出结果：

1

C:\Users\mengma\Desktop\hello.py

也可以一次导入多个模块，多个模块之间用逗号隔开。

1
2
3
4
5
6

# 导入sys、os两个模块
import sys,os
# 使用模块名作为前缀来访问模块中的成员
print(sys.argv[0])
# os模块的sep变量代表平台上的路径分隔符
print(os.sep)

上面第 2 行代码一次导入了 sys 和 os 两个模块，因此程序要使用 sys、os 两个模块内的成员，只要分别使用 sys、os 模块名作为前缀即可。在 Windows 平台上运行该程序，可以看到如下输出结果（os 模块的 sep 变量代表平台上的路径分隔符）：

1
2

C:\Users\mengma\Desktop\hello.py
\

在导入多个模块的同时，也可以为模块指定别名：

1
2
3
4
5

# 导入sys、os两个模块，并为sys指定别名s，为os指定别名o
import sys as s,os as o
# 使用模块别名作为前缀来访问模块中的成员
print(s.argv[0])
print(o.sep)

上面第 2 行代码一次导入了sys 和 os 两个模块，并分别为它们指定别名为 s、o，因此程序可以通过 s、o 两个前缀来使用 sys、os 两个模块内的成员。在 Windows 平台上运行该程序，可以看到如下输出结果：

1
2

C:\Users\mengma\Desktop\hello.py
\

from 模块名 import 成员名 as 别名

1
2
3
4

# 导入sys模块的argv成员
from sys import argv
# 使用导入成员的语法，直接使用成员名访问
print(argv[0])

第 2 行代码导入了sys模块中的argv成员，这样即可在程序中直接使用 argv 成员，无须使用任何前缀。

导入模块成员时，也可以为成员指定别名，例如如下程序：

1
2
3
4

# 导入sys模块的argv成员，并为其指定别名v
from sys import argv as v
# 使用导入成员（并指定别名）的语法，直接使用成员的别名访问
print(v[0])

第 2 行代码导入了sys模块中的argv成员，并为该成员指定别名v，这样即可在程序中通过别名v使用argv成员，无须使用任何前缀。

form...import导入模块成员时，支持一次导入多个成员：

1
2
3
4
5

# 导入sys模块的argv,winver成员
from sys import argv, winver
# 使用导入成员的语法，直接使用成员名访问
print(argv[0])
print(winver)

上面第 2 行代码导入了sys模块中的argv、 winver成员，这样即可在程序中直接使用argv、winver两个成员，无须使用任何前缀。运行该程序，可以看到如下输出结果（sys的winver成员记录了该 Python 的版本号）：

1
2

C:\Users\mengma\Desktop\hello.py
3.11

一次导入多个模块成员时，也可指定别名，同样使用as关键字为成员指定别名：

1
2
3
4
5

# 导入sys模块的argv,winver成员，并为其指定别名v、wv
from sys import argv as v, winver as wv
# 使用导入成员（并指定别名）的语法，直接使用成员的别名访问
print(v[0])
print(wv)

上面第 2 行代码导入了 sys 模块中的 argv、winver 成员，并分别为它们指定了别名 v、wv，这样即可在程序中通过 v 和 wv 两个别名使用 argv、winver 成员，无须使用任何前缀。

不推荐使用 from import 导入模块所有成员

在使用from...import语法时，可以一次导入指定模块内的所有成员（此方式不推荐）：

1
2
3
4
5

#导入sys 棋块内的所有成员
from sys import *
#使用导入成员的语法，直接使用成员的别名访问
print(argv[0])
print(winver)

上面代码一次导入了sys模块中的所有成员，这样程序即可通过成员名来使用该模块内的所有成员。该程序的输出结果和前面程序的输出结果完全相同。

需要说明的是，一般不推荐使用“from 模块 import”这种语法导入指定模块内的所有成员，因为它存在潜在的风险。比如同时导入module1和module2内的所有成员，假如这两个模块内都有一个foo()函数，那么当在程序中执行如下代码时：

1

foo()

上面调用的这个foo()函数到底是module1模块中的还是module2模块中的？因此，这种导入指定模块内所有成员的用法是有风险的。

但如果换成如下两种导入方式：

1
2

import module1
import module2 as m2

接下来要分别调用这两个模块中的foo()函数就非常清晰。

1
2
3
4
5
6
7
8
9

#使用模块module1 的模块名作为前缀调用foo()函数
module1.foo()
#使用module2 的模块别名作为前缀调用foo()函数
m2.foo()
或者使用 from...import 语句也是可以的：
#导入module1 中的foo 成员，并指定其别名为foo1
from module1 import foo as fool
#导入module2 中的foo 成员，并指定其别名为foo2
from module2 import foo as foo2

此时通过别名将 module1 和 module2 两个模块中的 foo 函数很好地进行了区分，接下来分别调用两个模块中 foo() 函数就很清晰：

1
2

foo1() #调用module1 中的foo()函数
foo2() #调用module2 中的foo()函数

自定义模块

Python 模块就是 Python 程序，换句话说，只要是 Python 程序，都可以作为模块导入。例如，下面定义了一个简单的模块（编写在 demo.py 文件中）：

1
2
3
4
5
6
7
8
9
10
11

name = "小明"
add = "xiaoming"
print(name,add)
def say():
    print("人生苦短，我学Python！")
class CLanguage:
    def __init__(self,name,add):
        self.name = name
        self.add = add
    def say(self):
        print(self.name,self.add)

可以看到，我们在 demo.py 文件中放置了变量（name 和 add）、函数（ say() ）以及一个 Clanguage 类，该文件就可以作为一个模板。

但通常情况下，为了检验模板中代码的正确性，我们往往需要为其设计一段测试代码，例如：

1
2
3
4
5
6
7

say()
clangs = CLanguage("小红","xiaohong")
clangs.say()
运行 demo.py 文件，其执行结果为：
小明 xiaoming
人生苦短，我学Python！
小红 xiaohong

通过观察模板中程序的执行结果可以断定，模板文件中包含的函数以及类，是可以正常工作的。

在此基础上，我们可以新建一个 test.py 文件，并在该文件中使用 demo.py 模板文件，即使用 import 语句导入 demo.py：

1

import demo

注意，虽然 demo 模板文件的全称为 demo.py，但在使用 import 语句导入时，只需要使用该模板文件的名称即可。

此时，如果直接运行 test.py 文件，其执行结果为：

1
2
3

小明 xiaoming
人生苦短，我学Python！
小红 xiaohong

可以看到，当执行 test.py 文件时，它同样会执行 demo.py 中用来测试的程序，这显然不是我们想要的效果。正常的效果应该是，只有直接运行模板文件时，测试代码才会被执行；反之，如果是其它程序以引入的方式执行模板文件，则测试代码不应该被执行。

要实现这个效果，可以借助 Python 内置的__name__变量。当直接运行一个模块时，name变量的值为__main__；而将模块被导入其他程序中并运行该程序时，处于模块中的__name__变量的值就变成了模块名。因此，如果希望测试函数只有在直接运行模块文件时才执行，则可在调用测试函数时增加判断，即只有当__name__ =='__main__'时才调用测试函数。

因此，我们可以修改 demo.py 模板文件中的测试代码为：

1
2
3
4

if __name__ == '__main__':
  say()
  clangs = CLanguage("小明","xiaoming")
  clangs.say()

显然，这里执行的仅是模板文件中的输出语句，测试代码并未执行。

自定义模块编写说明文档

我们知道，在定义函数或者类时，可以为其添加说明文档，以方便用户清楚的知道该函数或者类的功能。自定义模块也不例外。

为自定义模块添加说明文档，和函数或类的添加方法相同，即只需在模块开头的位置定义一个字符串即可。例如，为 demo.py 模板文件添加一个说明文档：

1
2
3
4
5
6
7

'''
demo 模块中包含以下内容：
name 字符串变量：初始值为“Python教程”
add    字符串变量：初始值为“http://c.biancheng.net/python”
say() 函数
CLanguage类：包含 name 和 add 属性和 say() 方法。
'''

在此基础上，我们可以通过模板的 doc 属性，来访问模板的说明文档。例如，在 test.py 文件中添加如下代码：

1
2

import demo
print(demo.__doc__)

程序运行结果为：
Python教程 http://c.biancheng.net/python

1
2
3
4
5

demo 模块中包含以下内容：
name 字符串变量：初始值为“Python教程”
add    字符串变量：初始值为“http://c.biancheng.net/python”
say() 函数
CLanguage类：包含 name 和 add 属性和 say() 方法。

导入模块的3种方式

即自定义 Python 模板后，在其它文件中用 import（或 from…import） 语句引入该文件时，Python 解释器同时如下错误：

1

ModuleNotFoundError: No module named '模块名'

意思是 Python 找不到这个模块名，这是什么原因导致的呢？要想解决这个问题，读者要先搞清楚 Python 解释器查找模块文件的过程。

通常情况下，当使用 import 语句导入模块后，Python 会按照以下顺序查找指定的模块文件：
在当前目录，即当前执行的程序文件所在目录下查找；
到 PYTHONPATH（环境变量）下的每个目录中查找；
到 Python 默认的安装目录下查找。

以上所有涉及到的目录，都保存在标准模块 sys 的 sys.path 变量中，通过此变量我们可以看到指定程序文件支持查找的所有目录。换句话说，如果要导入的模块没有存储在 sys.path 显示的目录中，那么导入该模块并运行程序时，Python 解释器就会抛出 ModuleNotFoundError（未找到模块）异常。

解决“Python找不到指定模块”的方法有 3 种，分别是：

• 向 sys.path 中临时添加模块文件存储位置的完整路径；
• 将模块放在 sys.path 变量中已包含的模块加载路径中；
• 设置 path 系统环境变量。

1
2
3
4
5
6

#hello.py
def say ():
    print("Hello,World!")
#say.py
import hello
hello.say()

显然，hello.py 文件和 say.py 文件并不在同一目录，此时运行 say.py 文件，其运行结果为：

1
2
3
4

 Traceback (most recent call last):
  File "C:\Users\mengma\Desktop\say.py", line 1, in <module>
    import hello
ModuleNotFoundError: No module named 'hello'

可以看到，Python 解释器抛出了 ModuleNotFoundError 异常。接下来，分别用以上 3 种方法解决这个问题。

导入模块方式一：临时添加模块完整路径

模块文件的存储位置，可以临时添加到 sys.path 变量中，即向 sys.path 中添加 D:\python_module（hello.py 所在目录），在 say.py 中的开头位置添加如下代码：

1
2

import sys
sys.path.append('D:\\python_module')

注意：在添加完整路径中，路径中的 ‘' 需要使用 \ 进行转义，否则会导致语法错误。再次运行 say.py 文件，运行结果如下：

1

Hello,World!

可以看到，程序成功运行。在此基础上，我们在 say.py 文件中输出 sys.path 变量的值，会得到以下结果：

1

['C:\\Users\\mengma\\Desktop', 'D:\\python3.6\\Lib\\idlelib', 'D:\\python3.6\\python36.zip', 'D:\\python3.6\\DLLs', 'D:\\python3.6\\lib', 'D:\\python3.6', 'C:\\Users\\mengma\\AppData\\Roaming\\Python\\Python36\\site-packages', 'D:\\python3.6\\lib\\site-packages', 'D:\\python3.6\\lib\\site-packages\\win32', 'D:\\python3.6\\lib\\site-packages\\win32\\lib', 'D:\\python3.6\\lib\\site-packages\\Pythonwin', 'D:\\python_module']

该输出信息中，红色部分就是临时添加进去的存储路径。需要注意的是，通过该方法添加的目录，只能在执行当前文件的窗口中有效，窗口关闭后即失效。

导入模块方式二：将模块保存到指定位置

如果要安装某些通用性模块，比如复数功能支持的模块、矩阵计算支持的模块、图形界面支持的模块等，这些都属于对 Python 本身进行扩展的模块，这种模块应该直接安装在 Python 内部，以便被所有程序共享，此时就可借助于 Python 默认的模块加载路径。

Python 程序默认的模块加载路径保存在 sys.path 变量中，因此，我们可以在 say.py 程序文件中先看看 sys.path 中保存的默认加载路径，向 say.py 文件中输出 sys.path 的值，如下所示：

1

['C:\\Users\\mengma\\Desktop', 'D:\\python3.6\\Lib\\idlelib', 'D:\\python3.6\\python36.zip', 'D:\\python3.6\\DLLs', 'D:\\python3.6\\lib', 'D:\\python3.6', 'C:\\Users\\mengma\\AppData\\Roaming\\Python\\Python36\\site-packages', 'D:\\python3.6\\lib\\site-packages', 'D:\\python3.6\\lib\\site-packages\\win32', 'D:\\python3.6\\lib\\site-packages\\win32\\lib', 'D:\\python3.6\\lib\\site-packages\\Pythonwin']

上面的运行结果中，列出的所有路径都是 Python 默认的模块加载路径，但通常来说，我们默认将 Python 的扩展模块添加在 lib\site-packages 路径下，它专门用于存放 Python 的扩展模块和包。

所以，我们可以直接将我们已编写好的 hello.py 文件添加到 lib\site-packages 路径下，就相当于为 Python 扩展了一个 hello 模块，这样任何 Python 程序都可使用该模块。

移动工作完成之后，再次运行 say.py 文件，可以看到成功运行的结果：

1

Hello,World!

导入模块方式三：设置环境变量

PYTHONPATH 环境变量（简称 path 变量）的值是很多路径组成的集合，Python 解释器会按照 path 包含的路径进行一次搜索，直到找到指定要加载的模块。当然，如果最终依旧没有找到，则 Python 就报 ModuleNotFoundError 异常。

在 Windows 平台上设置环境变量
首先，找到桌面上的“计算机”（或者我的电脑），并点击鼠标右键，单击“属性”。此时会显示“控制面板\所有控制面板项\系统”窗口，单击该窗口左边栏中的“高级系统设置”菜单，出现“系统属性”对话框，如图 1 所示。

图 1 系统属性对话框

如图 1 所示，点击“环境变量”按钮，此时将弹出图 2 所示的对话框：

图 2 环境变量对话框

如图 2 所示，通过该对话框，就可以完成 path 环境变量的设置。需要注意的是，该对话框分为上下 2 部分，其中上面的“用户变量”部分用于设置当前用户的环境变量，下面的“系统变量”部分用于设置整个系统的环境变量。

通常情况下，建议大家设置设置用户的 path 变量即可，因为此设置仅对当前登陆系统的用户有效，而如果修改系统的 path 变量，则对所有用户有效。
对于普通用户来说，设置用户 path 变量和系统 path 变量的效果是相同的，但 Python 在使用 path 变量时，会先按照系统 path 变量的路径去查找，然后再按照用户 path 变量的路径去查找。

这里我们选择设置当前用户的 path 变量。单击用户变量中的“新建”按钮， 系统会弹出如图 3 所示的对话框。

图 3 新建PYTHONPATH环境变量

其中，在“变量名”文本框内输入 PYTHONPATH，表明将要建立名为 PYTHONPATH 的环境变量；在“变量值”文本框内输入 .;d:\python_ module。注意，这里其实包含了两条路径（以分号 ；作为分隔符）：
第一条路径为一个点（.），表示当前路径，当运行 Python 程序时，Python 将可以从当前路径加载模块；
第二条路径为 d:\python_ module，当运行 Python 程序时，Python 将可以从 d:\python_ module 中加载模块。

然后点击“确定”，即成功设置 path 环境变量。此时，我们只需要将模块文件移动到和引入该模块的文件相同的目录，或者移动到 d:\python_ module 路径下，该模块就能被成功加载。
在 Linux 上设置环境变量
启动 Linux 的终端窗口，进入当前用户的 home 路径下，然后在 home 路径下输入如下命令：
ls - a

该命令将列出当前路径下所有的文件，包括隐藏文件。Linux 平台的环境变量是通过 .bash_profile 文件来设置的，使用无格式编辑器打开该文件，在该文件中添加 PYTHONPATH 环境变量。也就是为该文件增加如下一行：
#设置PYTHON PATH 环境变量
PYTHONPATH=.:/home/mengma/python_module

Linux 与 Windows 平台不一样，多个路径之间以冒号（:）作为分隔符，因此上面一行同样设置了两条路径，点（.）代表当前路径，还有一条路径是 /home/mengma/python_module（mengma 是在 Linux 系统的登录名）。

在完成了 PYTHONPATH 变量值的设置后，在 .bash_profile 文件的最后添加导出 PYTHONPATH 变量的语句。

1
2

#导出PYTHONPATH 环境变量
export PYTHONPATH

重新登录 Linux 平台，或者执行如下命令：

1

source.bash_profile

这两种方式都是为了运行该文件，使在文件中设置的 PYTHONPATH 变量值生效。

在成功设置了上面的环境变量之后，接下来只要把前面定义的模块（Python 程序）放在与当前所运行 Python 程序相同的路径中（或放在 /home/mengma/python_module 路径下），该模块就能被成功加载了。
在Mac OS X 上设置环境变量
在 Mac OS X 上设置环境变量与 Linux 大致相同（因为 Mac OS X 本身也是类 UNIX 系统）。启动 Mac OS X 的终端窗口（命令行界面），进入当前用户的 home 路径下，然后在 home 路径下输入如下命令：
ls -a

该命令将列出当前路径下所有的文件，包括隐藏文件。Mac OS X 平台的环境变量也可通过，bash_profile 文件来设置，使用无格式编辑器打开该文件，在该文件中添加 PYTHONPATH 环境变量。也就是为该文件增加如下一行：
#设置PYTHON PATH 环境变盘
PYTHONPATH=.:/Users/mengma/python_module

Mac OS X 的多个路径之间同样以冒号（:）作为分隔符，因此上面一行同样设置了两条路径：点（.）代表当前路径，还有一条路径是 /Users/mengma/python_module。

在完成了 PYTHONPATH 变量值的设置后，在 .bash_profile 文件的最后添加导出 PYTHONPATH 变量的语句。
#导出PYTHON PATH 环境变量
export PYTHONPATH

重新登录 Mac OS X 系统，或者执行如下命令：
source.bash_profile

这两种方式都是为了运行该文件，使在文件中设置的 PYTHONPATH 变量值生效。

在成功设置了上面的环境变量之后，接下来只要把前面定义的模块（Python 程序）放在与当前所运行 Python 程序相同的路径中（或放在 Users/mengma/python_module 路径下），该模块就能被成功加载了。

__all__变量

事实上，当我们向文件导入某个模块时，导入的是该模块中那些名称不以下划线（单下划线“_”或者双下划线“__”）开头的变量、函数和类。因此，如果我们不想模块文件中的某个成员被引入到其它文件中使用，可以在其名称前添加下划线。

1
2
3
4
5
6
7
8
9
10
11
12

#demo.py
def say():
  print("人生苦短，我学Python！")
def CLanguage():
  print("小明")
def disPython():
  print("小红")
#test.py
from demo import *
say()
CLanguage()
disPython()

在此基础上，如果demo.py模块中的disPython()函数不想让其它文件引入，则只需将其名称改为_disPython()或者__disPython()。修改之后，再次执行test.py，其输出结果为：

1
2
3
4
5
6

人生苦短，我学Python！
小明：xiaoming
Traceback (most recent call last):
  File "C:/Users/mengma/Desktop/2.py", line 4, in <module>
    disPython()
NameError: name 'disPython' is not defined

显然，test.py文件中无法使用未引入的disPython()函数。

Python模块__all__变量

除此之外，还可以借助模块提供的__all__变量，该变量的值是一个列表，存储的是当前模块中一些成员（变量、函数或者类）的名称。通过在模块文件中设置__all__变量，当其它文件以from 模块名 import *的形式导入该模块时，该文件中只能使用__all__列表中指定的成员。
也就是说，只有以from 模块名 import *形式导入的模块，当该模块设有__all__变量时，只能导入该变量指定的成员，未指定的成员是无法导入的。

举个例子，修改 demo.py 模块文件中的代码：

1
2
3
4
5
6
7

def say():
  print("人生苦短，我学Python！")
def CLanguage():
  print("小明")
def disPython():
  print("小红")
__all__ = ["say","CLanguage"]

可见，__all__变量只包含say()和CLanguage()的函数名，不包含disPython()函数的名称。此时直接执行test.py文件，其执行结果为：

1
2
3
4
5
6

人生苦短，我学Python！
小明
Traceback (most recent call last):
  File "C:/Users/mengma/Desktop/2.py", line 4, in <module>
    disPython()
NameError: name 'disPython' is not defined

显然，对于 test.py 文件来说，demo.py 模块中的 disPython() 函数是未引入，这样调用是非法的。

再次声明，__all__变量仅限于在其它文件中以“from 模块名 import *”的方式引入。也就是说，如果使用以下 2 种方式引入模块，则__all__变量的设置是无效的。

1. 以“import 模块名”的形式导入模块。通过该方式导入模块后，总可以通过模块名前缀（如果为模块指定了别名，则可以使用模快的别名作为前缀）来调用模块内的所有成员（除了以下划线开头命名的成员）。

   1 2 3 4 5 6 7 8 9 10 11 12 13

   #demo.py def say(): print("人生苦短，我学Python！") def CLanguage(): print("小明") def disPython(): print("小红") __all__ = ["say"] #test.py import demo demo.say() demo.CLanguage() demo.disPython()

   可以看到，虽然 demo.py 模块文件中设置有__all__变量，但是当以import demo的方式引入后，__all__变量将不起作用。

2. 以from 模块名 import 成员的形式直接导入指定成员。使用此方式导入的模块，__all__变量即便设置，也形同虚设。

   1 2 3 4 5 6

   from demo import say from demo import CLanguage from demo import disPython say() CLanguage() disPython()

包

实际开发中，一个大型的项目往往需要使用成百上千的 Python 模块，如果将这些模块都堆放在一起，势必不好管理。而且，使用模块可以有效避免变量名或函数名重名引发的冲突，但是如果模块名重复怎么办呢？因此，Python提出了包（Package）的概念。

简单理解，包就是文件夹，只不过在该文件夹下必须存在一个名为__init__.py的文件。

注意，这是 Python 2.x 的规定，而在 Python 3.x 中，__init__.py对包来说，并不是必须的。

每个包的目录下都必须建立一个__init__.py的模块，可以是一个空模块，可以写一些初始化代码，其作用就是告诉 Python 要将该目录当成包来处理。

注意，__init__.py不同于其他模块文件，此模块的模块名不是__init__，而是它所在的包名。例如，在settings包中的__init__.py文件，其模块名就是settings。

包是一个包含多个模块的文件夹，它的本质依然是模块，因此包中也可以包含包。

Python 库：相比模块和包，库是一个更大的概念，例如在 Python 标准库中的每个库都有好多个包，而每个包中都有若干个模块。

创建包，导入包

包其实就是文件夹，更确切的说，是一个包含__init__.py文件的文件夹。因此，如果我们想手动创建一个包，只需进行以下 2 步操作：

• 新建一个文件夹，文件夹的名称就是新建包的包名；
• 在该文件夹中，创建一个__init__.py文件（前后各有 2 个下划线‘_’），该文件中可以不编写任何代码。当然，也可以编写一些 Python 初始化代码，则当有其它程序文件导入包时，会自动执行该文件中的代码。

例如，现在我们创建一个非常简单的包，该包的名称为my_package，可以仿照以上 2 步进行：

• 创建一个文件夹，其名称设置为my_package；
• 在该文件夹中添加一个__init__.py文件，此文件中可以不编写任何代码。不过，这里向该文件编写如下代码：

  1 2 3 4

  ''' 创建第一个 Python 包 ''' print('python')

  可以看到，__init__.py文件中，包含了 2 部分信息，分别是此包的说明信息和一条print输出语句。

由此，我们就成功创建好了一个 Python 包。

创建好包之后，我们就可以向包中添加模块（也可以添加包）。这里给my_package包添加 2 个模块，分别是module1.py、module2.py，各自包含的代码分别如下所示：

1
2
3
4
5
6
7

#module1.py模块文件
def display(arc):
  print(arc)
#module2.py 模块文件
class CLanguage:
  def display(self):
    print("python")

现在，我们就创建好了一个具有如下文件结构的包：

1
2
3
4

my_package
     ┠── __init__.py
     ┠── module1.py
     ┗━━  module2.py

Python包的导入

包其实本质上还是模块，因此导入模块的语法同样也适用于导入包。无论导入我们自定义的包，还是导入从他处下载的第三方包，导入方法可归结为以下 3 种：

• import 包名[.模块名 [as 别名]]
• from 包名 import 模块名 [as 别名]
• from 包名.模块名 import 成员名 [as 别名]

用[]括起来的部分，是可选部分，即可以使用，也可以直接忽略。

注意，导入包的同时，会在包目录下生成一个含有__init__.cpython-36.pyc文件的__pycache__文件夹。

1) import 包名[.模块名 [as 别名]]

1
2

import my_package.module1
my_package.module1.display("java")

可以看到，通过此语法格式导入包中的指定模块后，在使用该模块中的成员（变量、函数、类）时，需添加“包名.模块名”为前缀。当然，如果使用as给包名.模块名”起一个别名的话，就使用直接使用这个别名作为前缀使用该模块中的方法了：

1
2

import my_package.module1 as module
module.display("python")

另外，当直接导入指定包时，程序会自动执行该包所对应文件夹下的__init__.py文件中的代码。

1
2

import my_package
my_package.module1.display("linux")

直接导入包名，并不会将包中所有模块全部导入到程序中，它的作用仅仅是导入并执行包下的__init__.py文件，因此，运行该程序，在执行__init__.py文件中代码的同时，还会抛出AttributeError异常（访问的对象不存在）：

1
2
3
4
5

python
Traceback (most recent call last):
  File "C:\Users\mengma\Desktop\demo.py", line 2, in <module>
    my_package.module1.display("linux")
AttributeError: module 'my_package' has no attribute 'module1'

我们知道，包的本质就是模块，导入模块时，当前程序中会包含一个和模块名同名且类型为module的变量，导入包也是如此：

1
2
3
4

import my_package
print(my_package)
print(my_package.__doc__)
print(type(my_package))

运行结果为：

1
2
3
4
5
6

python
<module 'my_package' from 'C:\\Users\\mengma\\Desktop\\my_package\\__init__.py'>

创建第一个 Python 包

<class 'module'>

2) from 包名 import 模块名 [as 别名]

1
2

from my_package import module1
module1.display("golang")

运行结果为：

1
2

python
golang

可以看到，使用此语法格式导入包中模块后，在使用其成员时不需要带包名前缀，但需要带模块名前缀。

当然，我们也可以使用as为导入的指定模块定义别名：

1
2

from my_package import module1 as module
module.display("golang")

同样，既然包也是模块，那么这种语法格式自然也支持from 包名 import *这种写法，它和import包名 的作用一样，都只是将该包的__init__.py文件导入并执行。

3) from 包名.模块名 import 成员名 [as 别名]

此语法格式用于向程序中导入“包.模块”中的指定成员（变量、函数或类）。通过该方式导入的变量（函数、类），在使用时可以直接使用变量名（函数名、类名）调用：

1
2

from my_package.module1 import display
display("shell")

运行结果为：

1
2

python
shell

当然，也可以使用as为导入的成员起一个别名：

1
2

from my_package.module1 import display as dis
dis("shell")

该程序的运行结果和上面相同。

另外，在使用此种语法格式加载指定包的指定模块时，可以使用 * 代替成员名，表示加载该模块下的所有成员。

1
2

from my_package.module1 import *
display("python")

查看模块

查看模块成员：dir()函数

通过dir()函数，我们可以查看某指定模块包含的全部成员（包括变量、函数和类）。注意这里所指的全部成员，不仅包含可供我们调用的模块成员，还包含所有名称以双下划线“__”开头和结尾的成员，而这些“特殊”命名的成员，是为了在本模块中使用的，并不希望被其它文件调用。

1
2

import string
print(dir(string))

程序执行结果为：

1

['Formatter', 'Template', '_ChainMap', '_TemplateMetaclass', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_re', '_string', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']

可以看到，通过dir()函数获取到的模块成员，不仅包含供外部文件使用的成员，还包含很多“特殊”（名称以 2 个下划线开头和结束）的成员，列出这些成员，对我们并没有实际意义。

1
2

import string
print([e for e in dir(string) if not e.startswith('_')])

程序执行结果为：

1

['Formatter', 'Template', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']

显然通过列表推导式，可在dir()函数输出结果的基础上，筛选出对我们有用的成员并显示出来。

查看模块成员：__all__变量

__all__变量也可以查看模块（包）内包含的所有成员。

1
2

import string
print(string.__all__)

程序执行结果为：

1

['ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace', 'Formatter', 'Template']

和dir()函数相比，__all__变量在查看指定模块成员时，它不会显示模块中的特殊成员，同时还会根据成员的名称进行排序显示。

不过需要注意的是，并非所有的模块都支持使用__all__变量，因此对于获取有些模块的成员，就只能使用dir()函数。

__doc__属性：查看文档

在使用dir()函数和__all__变量的基础上，虽然我们能知晓指定模块（或包）中所有可用的成员（变量、函数和类）：

1
2

import string
print(string.__all__)

程序执行结果为：

1

['ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace', 'Formatter', 'Template']

但对于以上的输出结果，对于不熟悉string模块的用户，还是不清楚这些名称分别表示的是什么意思，更不清楚各个成员有什么功能。

针对这种情况，我们可以使用help()函数来获取指定成员（甚至是该模块）的帮助信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#***__init__.py 文件中的内容***
from my_package.module1 import *
from my_package.module2 import *
#***module1.py 中的内容***
#module1.py模块文件
def display(arc):
  '''
  直接输出指定的参数
  '''
  print(arc)
#***module2.py中的内容***
#module2.py 模块文件
class CLanguage:
  '''
  CLanguage是一个类，其包含：
  display() 方法
  '''
  def display(self):
    print("http://c.biancheng.net/python/")

现在，我们先借助dir()函数，查看my_package包中有多少可供我们调用的成员：

1
2

import my_package
print([e for e in dir(my_package) if not e.startswith('_')])

程序输出结果为：

1

['CLanguage', 'display', 'module1', 'module2']

通过此输出结果可以得知，在my_package包中，有以上 4 个成员可供我们使用。接下来，我们使用help()函数来查看这些成员的具体含义（以 module1 为例）：

1
2

import my_package
help(my_package.module1)

输出结果为：

1
2
3
4
5
6
7
8
9
10
11

Help on module my_package.module1 in my_package:

NAME
    my_package.module1 - #module1.py模块文件

FUNCTIONS
    display(arc)
        直接输出指定的参数

FILE
    c:\users\mengma\desktop\my_package\module1.py

通过输出结果可以得知，module1实际上是一个模块文件，其包含display()函数，该函数的功能是直接输出指定的arc参数。同时，还显示出了该模块具体的存储位置。

值得一提的是，之所以我们可以使用help()函数查看具体成员的信息，是因为该成员本身就包含表示自身身份的说明文档（本质是字符串，位于该成员内部开头的位置）。无论是函数还是类，都可以使用__doc__属性获取它们的说明文档，模块也不例外。

1
2

import my_package
print(my_package.module1.display.__doc__)

其实，help()函数底层也是借助__doc__属性实现的。

如果使用help()函数或者__doc__属性，仍然无法满足我们的需求，还可以调用__file__属性，查看该模块或者包文件的具体存储位置，直接查看其源代码。

__file__属性：查看模块的源文件路径

当指定模块（或包）没有说明文档时，仅通过help()函数或者__doc__属性，无法有效帮助我们理解该模块（包）的具体功能。在这种情况下，我们可以通过__file__属性查找该模块（或包）文件所在的具体存储位置，直接查看其源代码。

1
2

import my_package
print(my_package.__file__) # C:\Users\mengma\Desktop\my_package\__init__.py

注意，因为当引入my_package包时，其实际上执行的是__init__.py文件，因此这里查看my_package包的存储路径，输出的__init__.py文件的存储路径。