python中类的方法

大家好，今天我们一起聊聊Python“类”之继承，说到这个题目，其实我不是特别喜欢，也纠结了几个小时，“所有官方的教程里面都是继承，可我认为在某些程度上遗传更贴切”，文章的封面也选了好久，最终决定了这张亲子图。正式讲之前，和大家聊聊这些，我想对于内容的理解应该会有所帮助。

首先，我们定义一个animal动物的类（就把自己当Python界的造物主吧，现在你正在创建animal）：

接下来想创造dog，dog也会eat和sleep，于是身为造物主的我们偷懒了，“eat和sleep，animal就有，能不能从它那儿继承过来”，当然可以啊，大家请看：

我们猜猜看，会输出什么结果，为什么dog类连初始化函数也没有，这样子可以吗？大家先看运行结果

dog继承了animal遗传给它的eat和sleep方法，并调用了animal的初始化方法，好吧，这么大的恩情，所以理所应当的，dog就是儿子，即子类，animal就是爹，即父类。

创造完dog，于是造物主的我们手又痒痒了，现在着手创建cat吧：

这回，又会有什么输出结果呢？

发现什么没，cat调用的是自己的初始化方法和eat方法，这就像拒绝继承皇位的王子，想靠自己的意志活出不一样的人生。这在Python里，叫做方法重载，也就是子类根据自己的需要，重写父类中的方法。

然后呢，再创造一个会飞的哺乳动物，蝙蝠bat：

bat类继承自animal类和bird类，在Python里，这叫做多重继承，就像小孩继承了父母双方的基因，既聪明又漂亮；bat类还生成自己独特的方法focus，下面我们一起看一下运行结果。

1、继承语法 class 子类名（父类名1，父类名2，...）：

2、子类可以创建自己独有的方法

3、方法调用时，子类先在本类中查找调用的方法，找不到才去父类中按次序找，即在父类1中找到了就不去父类2中找了，这一点可以从bat类的初始化方法中看出。

4、子类可以重写继承自父类中的方法，即方法重载，方法调用时，优先调用子类中重载过的方法，比如上述代码中的eat方法。

今天的Python大餐就先到这儿，大家回去好好消化，等着你的会是更美味可口，敬请享用。

写在之前

这几天的阅读量蜜汁低，是什么原因我也没搞清楚，如果你们觉得我哪里写的有问题，或者是哪里不好，欢迎后台或者微信告知我，先行谢过。

昨天的文章 详解类方法之绑定方法与非绑定方法 中写了方法中的绑定方法和非绑定方法，今天我们继续来学习剩下的「类方法」和「静态方法」。

类方法 & 静态方法

在开始之前，先让我们来看下面一段代码：

class Sample:language = "C++"def__init__(self): self.language = "python"defget_class_attr(cls):return cls.languageif __name__ == "__main__": print("sample.language:",Sample.language) r = get_class_attr(Sample) print("get class attribute:",r) f = Sample() print("instance attribute:",f.language)

上述代码在类 Sample 中，定义了一个属性 language = “C++”，这个是「类属性」；在初始化方法中，又定义了 self.language = “python”，这个是「实例属性」。

知道了这个，我们然后来分析一下函数 get_class_attr(cls)，在这个函数中参数用的是 cls，从函数体来看，要求它引用的对象应该具有属性 language，这说明，不是随随便便哪个对象都可以。很巧的是在前面定义的类 Sample 中就有 language 这个属性，于是在调用这个函数的时候，就直接将该类对象作为方法 get_class_attr() 的参数。

Sample.language 是要得到类属性的值，get_class_attr(Sample) 所返回的就是类 Sample 的属性 Sample.language 的值，所以对于上述例子来说，前面两个 print() 函数打印的结果应该是一样的。

f = Sample() 则是创建了一个实例，然后通过 f.language 访问实例属性。所以对于上述的代码的运行结果如下所示：

sample.language:C++getclassattribute:C++instanceattribute:python

不知道经过我上述的解释你是否明白了，如果没明白，建议你再仔细对比一下上述的运行结果和分析的过程。

在上述的例子中，比较特殊的函数应该是 get_class_attr(cls)，它是写在类的外面的，然而这个函数又只能调用前面写的那个类对象，因为不是所有对象都有那个特别的 language 属性，这种函数写在外面不利于后期的维护，我们应该避免这种情况的发生，而避免的方法就是把函数和类写在一起，所以就有了下面这种写法：

classsample:language = "C++"def__init__(self): self.language = "python" @classmethoddefget_class_attr(cls):return cls.languageif __name__ == "__main__": print("sample.language:",sample.language) r = sample.get_class_attr() print("get class attribute:",r) f = sample() print("instance attribute:",f.language) print("instance get_class_str:",f.get_class_attr())

在上面这个修改的代码中，出现了 @classmethod，这是一个装饰器，我们在函数的那部分讲到过。这里需要我们注意的是，@classmethod 所装饰的方法的参数中，第一个参数不是 self，这个和我们常规认识中的类的方法有所区别。这里使用了参数 cls，这是习惯的写法，当然用其它的也可以。让我们来看一下运行的结果：

sample.language:C++getclassattribute:C++instanceattribute:pythoninstanceget_class_str:C++

通过上面的运行结果我们可以看到，不管是通过类还是实例来执行 get_class_attr() 得到的结果都是类属性的值，这说明装饰器 @classmethod 所装饰的方法，它的参数 cls 引用的对象是类对象 Sample。

至此，「类方法」 的定义就出来了：类方法，就是在类里面定义的方法。该方法由装饰器 @classmethod 装饰，其第一个参数 cls 引用的是这个类对象，即将类本身作为作为引用对象传到这个方法里。

知道了类方法以后，我们可以用同样的思路理解另一个方法 「静态方法」，我们还是先来看一段代码：

import randomdefjudge(n):num = random.randint(1,100)return num - n > 0classSample:def__init__(self,name):self.name = namedefget_name(self,age):if judge(age):returnself.nameelse:return"the name is stupid"if __name__ == "__main__": s = Sample('rocky') name = s.get_name(23) print(name)

先看一下上面的代码，类 Sample 里面使用了外面的函数 judge(n)，这种类和函数的关系也是因为相互关联，所以后期的程序维护可能会出问题，于是为了便于维护，我们同样对程序进行了修改：

import randomclassSample:def__init__(self,name):self.name = namedefget_name(self,age):ifself.judge(age):returnself.nameelse:return"the name is stupid"@staticmethoddefjudge(n): num = random.randint(1,100)return num - n > 0if __name__ == "__main__": s = Sample('rocky') name = s.get_name(23) print(name)

同样是经过修改优化，将原来在类外面的函数放到了类里面。但是这不是简单的移动，还要在函数的前面加上 @staticmethod 装饰器，并且要注意的是，虽然这个函数在类的里面，但是跟别的方法是不一样的，它的第一个参数也不是 self，当我们要使用它的时候，可以通过实例调用，比如 self.judge(n)，也可以通过类调用这个方法，比如 sample.select(n)。

从上面的程序可以看出，尽管 judge(n) 位于类里面，但它确实一个独立的方法，与类本身没有关系，仅仅是为了免除前面所说的后期维护上的麻烦。但是它也有存在的道理，上面的例子就是一个典型的说明。

所以「静态方法」的定义也就出来了：在类的作用域里面，前面必须要加上一个 @staticmethod 装饰器，我们将这种方法命名为静态方法。

写在之后

方法是类的重要组成部分，本章所讲的类方法和静态方法让我们在使用类的时候有了更加便利的工具。

「方法」的这一块到这里就补充完了，之后我们将继续学习 OOP 的剩下两个特征：「多态」和「封装」，敬请期待。

如果你觉得本篇文章让你有所收获，欢迎点赞转发，你的支持是对我码字最大的动力，分享永远在路上，我们一起加油。

The end。

类属性和类方法

目标

类的结构 类属性和实例属性 类方法和静态方法

01. 类的结构

1.1 术语 —— 实例

1. 使用面相对象开发，第 1 步 是设计 类

2. 使用 类名() 创建对象，创建对象 的动作有两步：

1) 在内存中为对象 分配空间

2) 调用初始化方法 `__init__` 为 对象初始化

3. 对象创建后，内存 中就有了一个对象的 实实在在 的存在 —— 实例

因此，通常也会把：

1. 创建出来的 对象 叫做 类 的 实例

2. 创建对象的 动作 叫做 实例化

3. 对象的属性 叫做 实例属性

4. 对象调用的方法 叫做 实例方法

在程序执行时：

1. 对象各自拥有自己的 实例属性

2. 调用对象方法，可以通过 `self.`

访问自己的属性

调用自己的方法

结论

每一个对象 都有自己 独立的内存空间，保存各自不同的属性

多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用 传递到方法内部

1.2 类是一个特殊的对象

> `Python` 中 一切皆对象：

> `class AAA:` 定义的类属于 类对象

> `obj1 = AAA()` 属于 实例对象

在程序运行时，类 同样 会被加载到内存

在 `Python` 中，类 是一个特殊的对象 —— 类对象

在程序运行时，类对象 在内存中 只有一份，使用 一个类 可以创建出 很多个对象实例

除了封装 实例 的 属性 和 方法外，类对象 还可以拥有自己的 属性 和 方法

1. 类属性

2. 类方法

通过 类名. 的方式可以 访问类的属性 或者 调用类的方法

02. 类属性和实例属性

2.1 概念和使用

类属性 就是给 类对象 中定义的 属性

通常用来记录 与这个类相关 的特征

类属性 不会用于记录 具体对象的特征

示例需求

定义一个 工具类

每件工具都有自己的 `name`

需求 —— 知道使用这个类，创建了多少个工具对象？

```python

class Tool(object):

使用赋值语句，定义类属性，记录创建工具对象的总数

count = 0

def __init__(self, name):

self.name = name

针对类属性做一个计数+1

Tool.count += 1

创建工具对象

tool1 = Tool("斧头")

tool2 = Tool("榔头")

tool3 = Tool("铁锹")

知道使用 Tool 类到底创建了多少个对象?

print("现在创建了 %d 个工具" % Tool.count)

2.2 属性的获取机制（科普）

在 `Python` 中 属性的获取 存在一个 向上查找机制

因此，要访问类属性有两种方式：

1. 类名.类属性

2. 对象.类属性 （不推荐）

注意

如果使用 `对象.类属性 = 值` 赋值语句，只会 给对象添加一个属性，而不会影响到 类属性的值

03. 类方法和静态方法

3.1 类方法

类属性 就是针对 类对象 定义的属性

使用 赋值语句 在 `class` 关键字下方可以定义 类属性

类属性 用于记录 与这个类相关 的特征

类方法 就是针对 类对象 定义的方法

在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法

语法如下

```python

@classmethod

def 类方法名(cls):

pass

```

类方法需要用 修饰器 `@classmethod` 来标识，告诉解释器这是一个类方法

类方法的 第一个参数 应该是 `cls`

由 哪一个类 调用的方法，方法内的 `cls` 就是 哪一个类的引用

这个参数和 实例方法 的第一个参数是 `self` 类似

提示 使用其他名称也可以，不过习惯使用 `cls`

3. 通过 类名. 调用 类方法，调用方法时，不需要传递 `cls` 参数

4. 在方法内部

可以通过 `cls.` 访问类的属性

也可以通过 `cls.` 调用其他的类方法

示例需求

定义一个 工具类

每件工具都有自己的 `name`

需求 —— 在 类 封装一个 `show_tool_count` 的类方法，输出使用当前这个类，创建的对象个数

```python

@classmethod

def show_tool_count(cls):

"""显示工具对象的总数"""

print("工具对象的总数 %d" % cls.count)

```

> 在类方法内部，可以直接使用 `cls` 访问 类属性 或者 调用类方法

3.2 静态方法

在开发时，如果需要在 类 中封装一个方法，这个方法：

既 不需要 访问 实例属性 或者调用 实例方法

也 不需要 访问 类属性 或者调用 类方法

这个时候，可以把这个方法封装成一个 静态方法

语法如下

```python

@staticmethod

def 静态方法名():

pass

```

静态方法 需要用 修饰器 `@staticmethod` 来标识，告诉解释器这是一个静态方法

通过 类名. 调用 静态方法

```python

class Dog(object):

狗对象计数

dog_count = 0

@staticmethod

def run():

不需要访问实例属性也不需要访问类属性的方法

print("狗在跑...")

def __init__(self, name):

self.name = name

```

3.3 方法综合案例

需求

1. 设计一个 `Game` 类

2. 属性：

定义一个 类属性 `top_score` 记录游戏的 历史最高分

定义一个 实例属性 `player_name` 记录 当前游戏的玩家姓名

3. 方法：

静态方法 `show_help` 显示游戏帮助信息

类方法 `show_top_score` 显示历史最高分

实例方法 `start_game` 开始当前玩家的游戏

4. 主程序步骤

1) 查看帮助信息

2) 查看历史最高分

3) 创建游戏对象，开始游戏

案例小结

1. 实例方法 —— 方法内部需要访问 实例属性

实例方法 内部可以使用 类名. 访问类属性

2. 类方法 —— 方法内部 只 需要访问 类属性

3. 静态方法 —— 方法内部，不需要访问 实例属性 和 类属性

提问

如果方法内部 即需要访问 实例属性，又需要访问 类属性，应该定义成什么方法？

答案

应该定义 实例方法

因为，类只有一个，在 实例方法 内部可以使用 类名. 访问类属性

```python

class Game(object):

游戏最高分，类属性

top_score = 0

@staticmethod

def show_help():

print("帮助信息：让僵尸走进房间")

@classmethod

def show_top_score(cls):

print("游戏最高分是 %d" % cls.top_score)

def __init__(self, player_name):

self.player_name = player_name

def start_game(self):

print("[%s] 开始游戏..." % self.player_name)

使用类名.修改历史最高分

Game.top_score = 999

1. 查看游戏帮助

Game.show_help()

2. 查看游戏最高分

Game.show_top_score()

3. 创建游戏对象，开始游戏

game = Game("小明")

game.start_game()

4. 游戏结束，查看游戏最高分

Game.show_top_score()

``

前面

一篇

文章我介绍了python面向对象的基本知识，链接在最下面。初步解释了面向对象和面向对象的优点，今天就开始正式用代码来展现面向对象。

1、利用class创建类

Python中，创建类的语句是如下所示

先解释一下，class后面跟的是类名，括号里面是基类（也成为父类）python3中默认继承object。里面的函数称为方法（注意，严格来说，python中，位于类里面的def语句才能被称为方法，而在类外面定义的def只能被称为函数）。示例如下

2、定义类的属性，

我们讲了类是有属性的，那么如何定义类的属性，有以下两种种：

1、 直接在类里面定义，这里属性是位于类的变量空间里面，整个类中可以直接访问。

2、 在构造函数里面定义，这是对象的属性，访问时要通过self访问。

3、构造函数__init__

类是由属性构成的，当我们在定义一个类的时候，我们需要对类的属性进行设置，这时候就用到了构造函数：__init__(self,[……])，我们在构造函数中的参数是赋值给self，因为在oop中，self就是实例对象，name、age、weight变成了状态信息。

我们接上面说为什么它继承object，通过dir()我们可以打印出他的属性，发现他继承了很多方法，在后面的使用中会比较方便。（这里涉及到了新式类和老式类的问题，在python3中全都是新式类，新式类更加强大）。

4、访问控制

Python不像Java中有明确的访问控制方法，说白了就是没有访问控制。不过有一套约定俗成的方法：全靠自觉

变量名前面无下划线，可以公开访问。

变量名前面带有一个下划线：类的私有属性。

变量名前面带有两个下划线：部分私有属性，类里面可以访问，实例化之后不能直接访问。

再说一遍：全靠自觉！其实它们无论怎样都是可以访问的。这样只是代码规范，方便以后的代码维护。

5、定义类的方法

函数和方法的区别：前面我讲过，python在类中的def才能被称为方法，因为函数和方法的区别就是它们是否依附于一个类。函数直接通过函数名调用，方法通过类实例化调用，方法是类的一个属性。

方法的访问控制和类的属性一样，也是没有，定义方法也就差不多，如下：

绑定方法：

你们可能注意到了，每个方法中 都有self，这个self是绑定类的，表示函数是类的属性。

self 变量用于在类实例方法中引用方法所绑定的实例。因为方法的实例在任何方法调用中总是作为第一个参数传递的，self 被选中用来代表实例。你必须在方法声明中放上 self(你可能已经注意到了这点),但可以在方法中不使用实例(self)。如果你的方法中没有用到 self , 那么请考虑创建一个常规函数，除非你有特别的原因。毕竟，你的方法代码没有使用实例，没有与类关联其功能，这使得它看起来更像一个常规函数。在其它面向对象语言中，self 可能被称为 this。

方法装饰器：

@classmenthod类方法，调用的时候用类名，不是先生成对象，由对象调用

@property像访问属性一样调用方法，就是指不用加括号了。

如下：我在上面的那个类里面加了两个方法，用了这两个修饰器。

使用方法如下：

上一篇：Python 入门基础之面向对象过程-面向过程概述

下一篇介绍类的继承、运算符重载（钩子）等。欢迎关注。

探究更多的类属性，在一些初学者的教程中，一般很少见。我之所以要在这里也将这部分奉献出来，就是因为本教程是“From Beginner to Master”。当然，不是学习了类的更多属性就能达到 Master 水平，但是这是通往 Master 的一步，虽然在初级应用中，本节乃至于后面关于类的属性用的不很多，但是，这一步迈出去，你就会在实践中有一个印象，以后需要用到了，知道有这一步，会对项目有帮助的。俗话说“艺不压身”。

__dict__

读者是否思考过一个问题：类或者实例属性，在 Python 中是怎么存储的？或者为什么修改或者增加、删除属性，我们能不能控制这些属性？

用 dir() 来查看一下，发现不管是类还是实例，都有很多属性，这在前面已经反复出现，有点见怪不怪了。不过，这里我们要看一个属性：__dict__，因为它是一个保存秘密的东西：对象的属性。

为了便于观察，我将上面的显示结果进行了换行，每个键值对一行。

对于类 Spring 的__dict__属性，可以发现，有一个键'season'，这就是这个类的属性；其值就是类属性的数据。

用这两种方式都能得到类属性的值。或者说 Spring.__dict__['season'] 就是访问类属性。下面将这个类实例化，再看看它的实例属性：

实例属性的__dict__是空的。有点奇怪？不奇怪，接着看：

这个其实是指向了类属性中的 Spring.season，至此，我们其实还没有建立任何实例属性呢。下面就建立一个实例属性：

>>> s.season = "the spring of instance"

>>>s.__dict__

{'season': 'the spring of instance'}

这样，实例属性里面就不空了。这时候建立的实例属性和上面的那个 s.season 只不过重名，并且把它“遮盖”了。这句好是不是熟悉？因为在讲述“实例属性”和“类属性”的时候就提到了。现在读者肯定理解更深入了。

此时，那个类属性如何？我们看看：

Spring 的类属性没有受到实例属性的影响。

按照前面的讲述类属性和实例熟悉的操作，如果这时候将前面的实例属性删除，会不会回到实例属性s.__dict__为空呢？

果然打回原形。

当然，你可以定义其它名称的实例属性，它一样被存储到__dict__属性里面：

诚然，这样做仅仅是更改了实例的__dict__内容，对 Spring.__dict__无任何影响，也就是说通过 Spring.lang 或者 Spring.__dict__['lang'] 是得不到上述结果的。

那么，如果这样操作，会怎样呢？

在类的__dict__被更改了，类属性中增加了一个'flower'属性。但是，实例的__dict__中如何？

没有被修改。我也是这么想的，哈哈。你此前这这么觉得吗？然而，还能这样：

这个读者是否能解释？其实又回到了前面第一个出现 s.season 上面了。

通过上面探讨，是不是基本理解了实例和类的__dict__，并且也看到了属性的变化特点。特别是，这些属性都是可以动态变化的，就是你可以随时修改和增删。

属性如此，方法呢？下面就看看方法（类中的函数）。

结果跟前面讨论属性差不多，方法 tree 也在__dict__里面呢。

又跟前面一样。虽然建立了实例，但是在实例的__dict__中没有方法。接下来，执行：

在类(3)中有一部分内容阐述“数据流转”，其中有一张图，其中非常明确显示出，当用上面方式执行方法的时候，实例 t 与 self 建立了对应关系，两者是一个外一个内。在方法中 self.x = x，将 x 的值给了 self.x，也就是实例应该拥有了这么一个属性。

果然如此。这也印证了实例 t 和 self 的关系，即实例方法(t.tree('xiangzhangshu'))的第一个参数(self，但没有写出来)绑定实例 t，透过 self.x 来设定值，即给 t.__dict__添加属性值。

换一个角度：

这回方法中没有将 x 赋值给 self 的属性，而是直接 return，结果是：

是不是理解更深入了？

现在需要对 Python 中一个观点：“一切皆对象”，再深入领悟。以上不管是类还是的实例的属性和方法，都是符合 object.attribute 格式，并且属性类似。

当你看到这里的时候，要么明白了类和实例的__dict__的特点，要么就糊涂了。糊涂也不要紧，再将上面的重复一遍，特别是自己要敲一敲有关代码。（建议一个最好的方法：用两个显示器，一个显示器看本教程，另外一个显示器敲代码。事半功倍的效果。）

需要说明，我们对__dict__的探讨还留有一个尾巴：属性搜索路径。这个留在后面讲述。

不管是类还是实例，其属性都能随意增加。这点在有时候不是一件好事情，或许在某些时候你不希望别人增加属性。有办法吗？当然有，请继续学习。

__slots__

首先声明，__slots__能够限制属性的定义，但是这不是它存在终极目标，它存在的终极目标更应该是一个在编程中非常重要的方面：优化内存使用。

仔细看看 dir() 的结果，还有__dict__属性吗？没有了，的确没有了。也就是说__slots__把__dict__挤出去了，它进入了类的属性。

这里可以看出，类 Spring 有且仅有两个属性。

实例化之后，实例的__slots__与类的完全一样，这跟前面的__dict__大不一样了。

通过类，先赋予一个属性值。然后，检验一下实例能否修改这个属性：

看来，我们的意图不能达成，报错信息中显示，tree 这个属性是只读的，不能修改了。

因为前面已经通过类给这个属性赋值了。不能用实例属性来修改。只能：

用类属性修改。但是对于没有用类属性赋值的，可以通过实例属性：

但此时：

实例属性的值并没有传回到类属性，你也可以理解为新建立了一个同名的实例属性。如果再给类属性赋值，那么就会这样了：

当然，此时在给 t.flower 重新赋值，就会爆出跟前面一样的错误了。

这里试图给实例新增一个属性，也失败了。

看来__slots__已经把实例属性牢牢地管控了起来，但更本质是的是优化了内存。诚然，这种优化会在大量的实例时候显出效果。

大家好，今天我们一起聊聊Python“类”之继承，说到这个题目，其实我不是特别喜欢，也纠结了几个小时，“所有官方的教程里面都是继承，可我认为在某些程度上遗传更贴切”，文章的封面也选了好久，最终决定了这张亲子图。正式讲之前，和大家聊聊这些，我想对于内容的理解应该会有所帮助。

首先，我们定义一个animal动物的类（就把自己当Python界的造物主吧，现在你正在创建animal）：

接下来想创造dog，dog也会eat和sleep，于是身为造物主的我们偷懒了，“eat和sleep，animal就有，能不能从它那儿继承过来”，当然可以啊，大家请看：

我们猜猜看，会输出什么结果，为什么dog类连初始化函数也没有，这样子可以吗？大家先看运行结果

dog继承了animal遗传给它的eat和sleep方法，并调用了animal的初始化方法，好吧，这么大的恩情，所以理所应当的，dog就是儿子，即子类，animal就是爹，即父类。

创造完dog，于是造物主的我们手又痒痒了，现在着手创建cat吧：

这回，又会有什么输出结果呢？

发现什么没，cat调用的是自己的初始化方法和eat方法，这就像拒绝继承皇位的王子，想靠自己的意志活出不一样的人生。这在Python里，叫做方法重载，也就是子类根据自己的需要，重写父类中的方法。

然后呢，再创造一个会飞的哺乳动物，蝙蝠bat：

bat类继承自animal类和bird类，在Python里，这叫做多重继承，就像小孩继承了父母双方的基因，既聪明又漂亮；bat类还生成自己独特的方法focus，下面我们一起看一下运行结果。

1、继承语法 class 子类名（父类名1，父类名2，...）：

2、子类可以创建自己独有的方法

3、方法调用时，子类先在本类中查找调用的方法，找不到才去父类中按次序找，即在父类1中找到了就不去父类2中找了，这一点可以从bat类的初始化方法中看出。

4、子类可以重写继承自父类中的方法，即方法重载，方法调用时，优先调用子类中重载过的方法，比如上述代码中的eat方法。

今天的Python大餐就先到这儿，大家回去好好消化，等着你的会是更美味可口，敬请享用。

写在之前

这几天的阅读量蜜汁低，是什么原因我也没搞清楚，如果你们觉得我哪里写的有问题，或者是哪里不好，欢迎后台或者微信告知我，先行谢过。

昨天的文章 详解类方法之绑定方法与非绑定方法 中写了方法中的绑定方法和非绑定方法，今天我们继续来学习剩下的「类方法」和「静态方法」。

类方法 & 静态方法

在开始之前，先让我们来看下面一段代码：

class Sample:language = "C++"def__init__(self): self.language = "python"defget_class_attr(cls):return cls.languageif __name__ == "__main__": print("sample.language:",Sample.language) r = get_class_attr(Sample) print("get class attribute:",r) f = Sample() print("instance attribute:",f.language)

上述代码在类 Sample 中，定义了一个属性 language = “C++”，这个是「类属性」；在初始化方法中，又定义了 self.language = “python”，这个是「实例属性」。

知道了这个，我们然后来分析一下函数 get_class_attr(cls)，在这个函数中参数用的是 cls，从函数体来看，要求它引用的对象应该具有属性 language，这说明，不是随随便便哪个对象都可以。很巧的是在前面定义的类 Sample 中就有 language 这个属性，于是在调用这个函数的时候，就直接将该类对象作为方法 get_class_attr() 的参数。

Sample.language 是要得到类属性的值，get_class_attr(Sample) 所返回的就是类 Sample 的属性 Sample.language 的值，所以对于上述例子来说，前面两个 print() 函数打印的结果应该是一样的。

f = Sample() 则是创建了一个实例，然后通过 f.language 访问实例属性。所以对于上述的代码的运行结果如下所示：

sample.language:C++getclassattribute:C++instanceattribute:python

不知道经过我上述的解释你是否明白了，如果没明白，建议你再仔细对比一下上述的运行结果和分析的过程。

在上述的例子中，比较特殊的函数应该是 get_class_attr(cls)，它是写在类的外面的，然而这个函数又只能调用前面写的那个类对象，因为不是所有对象都有那个特别的 language 属性，这种函数写在外面不利于后期的维护，我们应该避免这种情况的发生，而避免的方法就是把函数和类写在一起，所以就有了下面这种写法：

classsample:language = "C++"def__init__(self): self.language = "python" @classmethoddefget_class_attr(cls):return cls.languageif __name__ == "__main__": print("sample.language:",sample.language) r = sample.get_class_attr() print("get class attribute:",r) f = sample() print("instance attribute:",f.language) print("instance get_class_str:",f.get_class_attr())

在上面这个修改的代码中，出现了 @classmethod，这是一个装饰器，我们在函数的那部分讲到过。这里需要我们注意的是，@classmethod 所装饰的方法的参数中，第一个参数不是 self，这个和我们常规认识中的类的方法有所区别。这里使用了参数 cls，这是习惯的写法，当然用其它的也可以。让我们来看一下运行的结果：

sample.language:C++getclassattribute:C++instanceattribute:pythoninstanceget_class_str:C++

通过上面的运行结果我们可以看到，不管是通过类还是实例来执行 get_class_attr() 得到的结果都是类属性的值，这说明装饰器 @classmethod 所装饰的方法，它的参数 cls 引用的对象是类对象 Sample。

至此，「类方法」 的定义就出来了：类方法，就是在类里面定义的方法。该方法由装饰器 @classmethod 装饰，其第一个参数 cls 引用的是这个类对象，即将类本身作为作为引用对象传到这个方法里。

知道了类方法以后，我们可以用同样的思路理解另一个方法 「静态方法」，我们还是先来看一段代码：

import randomdefjudge(n):num = random.randint(1,100)return num - n > 0classSample:def__init__(self,name):self.name = namedefget_name(self,age):if judge(age):returnself.nameelse:return"the name is stupid"if __name__ == "__main__": s = Sample('rocky') name = s.get_name(23) print(name)

先看一下上面的代码，类 Sample 里面使用了外面的函数 judge(n)，这种类和函数的关系也是因为相互关联，所以后期的程序维护可能会出问题，于是为了便于维护，我们同样对程序进行了修改：

import randomclassSample:def__init__(self,name):self.name = namedefget_name(self,age):ifself.judge(age):returnself.nameelse:return"the name is stupid"@staticmethoddefjudge(n): num = random.randint(1,100)return num - n > 0if __name__ == "__main__": s = Sample('rocky') name = s.get_name(23) print(name)

同样是经过修改优化，将原来在类外面的函数放到了类里面。但是这不是简单的移动，还要在函数的前面加上 @staticmethod 装饰器，并且要注意的是，虽然这个函数在类的里面，但是跟别的方法是不一样的，它的第一个参数也不是 self，当我们要使用它的时候，可以通过实例调用，比如 self.judge(n)，也可以通过类调用这个方法，比如 sample.select(n)。

从上面的程序可以看出，尽管 judge(n) 位于类里面，但它确实一个独立的方法，与类本身没有关系，仅仅是为了免除前面所说的后期维护上的麻烦。但是它也有存在的道理，上面的例子就是一个典型的说明。

所以「静态方法」的定义也就出来了：在类的作用域里面，前面必须要加上一个 @staticmethod 装饰器，我们将这种方法命名为静态方法。

写在之后

方法是类的重要组成部分，本章所讲的类方法和静态方法让我们在使用类的时候有了更加便利的工具。

「方法」的这一块到这里就补充完了，之后我们将继续学习 OOP 的剩下两个特征：「多态」和「封装」，敬请期待。

如果你觉得本篇文章让你有所收获，欢迎点赞转发，你的支持是对我码字最大的动力，分享永远在路上，我们一起加油。

The end。

前面

一篇

文章我介绍了python面向对象的基本知识，链接在最下面。初步解释了面向对象和面向对象的优点，今天就开始正式用代码来展现面向对象。

1、利用class创建类

Python中，创建类的语句是如下所示

先解释一下，class后面跟的是类名，括号里面是基类（也成为父类）python3中默认继承object。里面的函数称为方法（注意，严格来说，python中，位于类里面的def语句才能被称为方法，而在类外面定义的def只能被称为函数）。示例如下

2、定义类的属性，

我们讲了类是有属性的，那么如何定义类的属性，有以下两种种：

1、 直接在类里面定义，这里属性是位于类的变量空间里面，整个类中可以直接访问。

2、 在构造函数里面定义，这是对象的属性，访问时要通过self访问。

3、构造函数__init__

类是由属性构成的，当我们在定义一个类的时候，我们需要对类的属性进行设置，这时候就用到了构造函数：__init__(self,[……])，我们在构造函数中的参数是赋值给self，因为在oop中，self就是实例对象，name、age、weight变成了状态信息。

我们接上面说为什么它继承object，通过dir()我们可以打印出他的属性，发现他继承了很多方法，在后面的使用中会比较方便。（这里涉及到了新式类和老式类的问题，在python3中全都是新式类，新式类更加强大）。

4、访问控制

Python不像Java中有明确的访问控制方法，说白了就是没有访问控制。不过有一套约定俗成的方法：全靠自觉

变量名前面无下划线，可以公开访问。

变量名前面带有一个下划线：类的私有属性。

变量名前面带有两个下划线：部分私有属性，类里面可以访问，实例化之后不能直接访问。

再说一遍：全靠自觉！其实它们无论怎样都是可以访问的。这样只是代码规范，方便以后的代码维护。

5、定义类的方法

函数和方法的区别：前面我讲过，python在类中的def才能被称为方法，因为函数和方法的区别就是它们是否依附于一个类。函数直接通过函数名调用，方法通过类实例化调用，方法是类的一个属性。

方法的访问控制和类的属性一样，也是没有，定义方法也就差不多，如下：

绑定方法：

你们可能注意到了，每个方法中 都有self，这个self是绑定类的，表示函数是类的属性。

self 变量用于在类实例方法中引用方法所绑定的实例。因为方法的实例在任何方法调用中总是作为第一个参数传递的，self 被选中用来代表实例。你必须在方法声明中放上 self(你可能已经注意到了这点),但可以在方法中不使用实例(self)。如果你的方法中没有用到 self , 那么请考虑创建一个常规函数，除非你有特别的原因。毕竟，你的方法代码没有使用实例，没有与类关联其功能，这使得它看起来更像一个常规函数。在其它面向对象语言中，self 可能被称为 this。

方法装饰器：

@classmenthod类方法，调用的时候用类名，不是先生成对象，由对象调用

@property像访问属性一样调用方法，就是指不用加括号了。

如下：我在上面的那个类里面加了两个方法，用了这两个修饰器。

使用方法如下：

上一篇：Python 入门基础之面向对象过程-面向过程概述

下一篇介绍类的继承、运算符重载（钩子）等。欢迎关注。

探究更多的类属性，在一些初学者的教程中，一般很少见。我之所以要在这里也将这部分奉献出来，就是因为本教程是“From Beginner to Master”。当然，不是学习了类的更多属性就能达到 Master 水平，但是这是通往 Master 的一步，虽然在初级应用中，本节乃至于后面关于类的属性用的不很多，但是，这一步迈出去，你就会在实践中有一个印象，以后需要用到了，知道有这一步，会对项目有帮助的。俗话说“艺不压身”。

__dict__

读者是否思考过一个问题：类或者实例属性，在 Python 中是怎么存储的？或者为什么修改或者增加、删除属性，我们能不能控制这些属性？

用 dir() 来查看一下，发现不管是类还是实例，都有很多属性，这在前面已经反复出现，有点见怪不怪了。不过，这里我们要看一个属性：__dict__，因为它是一个保存秘密的东西：对象的属性。

为了便于观察，我将上面的显示结果进行了换行，每个键值对一行。

对于类 Spring 的__dict__属性，可以发现，有一个键'season'，这就是这个类的属性；其值就是类属性的数据。

用这两种方式都能得到类属性的值。或者说 Spring.__dict__['season'] 就是访问类属性。下面将这个类实例化，再看看它的实例属性：

实例属性的__dict__是空的。有点奇怪？不奇怪，接着看：

这个其实是指向了类属性中的 Spring.season，至此，我们其实还没有建立任何实例属性呢。下面就建立一个实例属性：

>>> s.season = "the spring of instance"

>>>s.__dict__

{'season': 'the spring of instance'}

这样，实例属性里面就不空了。这时候建立的实例属性和上面的那个 s.season 只不过重名，并且把它“遮盖”了。这句好是不是熟悉？因为在讲述“实例属性”和“类属性”的时候就提到了。现在读者肯定理解更深入了。

此时，那个类属性如何？我们看看：

Spring 的类属性没有受到实例属性的影响。

按照前面的讲述类属性和实例熟悉的操作，如果这时候将前面的实例属性删除，会不会回到实例属性s.__dict__为空呢？

果然打回原形。

当然，你可以定义其它名称的实例属性，它一样被存储到__dict__属性里面：

诚然，这样做仅仅是更改了实例的__dict__内容，对 Spring.__dict__无任何影响，也就是说通过 Spring.lang 或者 Spring.__dict__['lang'] 是得不到上述结果的。

那么，如果这样操作，会怎样呢？

在类的__dict__被更改了，类属性中增加了一个'flower'属性。但是，实例的__dict__中如何？

没有被修改。我也是这么想的，哈哈。你此前这这么觉得吗？然而，还能这样：

这个读者是否能解释？其实又回到了前面第一个出现 s.season 上面了。

通过上面探讨，是不是基本理解了实例和类的__dict__，并且也看到了属性的变化特点。特别是，这些属性都是可以动态变化的，就是你可以随时修改和增删。

属性如此，方法呢？下面就看看方法（类中的函数）。

结果跟前面讨论属性差不多，方法 tree 也在__dict__里面呢。

又跟前面一样。虽然建立了实例，但是在实例的__dict__中没有方法。接下来，执行：

在类(3)中有一部分内容阐述“数据流转”，其中有一张图，其中非常明确显示出，当用上面方式执行方法的时候，实例 t 与 self 建立了对应关系，两者是一个外一个内。在方法中 self.x = x，将 x 的值给了 self.x，也就是实例应该拥有了这么一个属性。

果然如此。这也印证了实例 t 和 self 的关系，即实例方法(t.tree('xiangzhangshu'))的第一个参数(self，但没有写出来)绑定实例 t，透过 self.x 来设定值，即给 t.__dict__添加属性值。

换一个角度：

这回方法中没有将 x 赋值给 self 的属性，而是直接 return，结果是：

是不是理解更深入了？

现在需要对 Python 中一个观点：“一切皆对象”，再深入领悟。以上不管是类还是的实例的属性和方法，都是符合 object.attribute 格式，并且属性类似。

当你看到这里的时候，要么明白了类和实例的__dict__的特点，要么就糊涂了。糊涂也不要紧，再将上面的重复一遍，特别是自己要敲一敲有关代码。（建议一个最好的方法：用两个显示器，一个显示器看本教程，另外一个显示器敲代码。事半功倍的效果。）

需要说明，我们对__dict__的探讨还留有一个尾巴：属性搜索路径。这个留在后面讲述。

不管是类还是实例，其属性都能随意增加。这点在有时候不是一件好事情，或许在某些时候你不希望别人增加属性。有办法吗？当然有，请继续学习。

__slots__

首先声明，__slots__能够限制属性的定义，但是这不是它存在终极目标，它存在的终极目标更应该是一个在编程中非常重要的方面：优化内存使用。

仔细看看 dir() 的结果，还有__dict__属性吗？没有了，的确没有了。也就是说__slots__把__dict__挤出去了，它进入了类的属性。

这里可以看出，类 Spring 有且仅有两个属性。

实例化之后，实例的__slots__与类的完全一样，这跟前面的__dict__大不一样了。

通过类，先赋予一个属性值。然后，检验一下实例能否修改这个属性：

看来，我们的意图不能达成，报错信息中显示，tree 这个属性是只读的，不能修改了。

因为前面已经通过类给这个属性赋值了。不能用实例属性来修改。只能：

用类属性修改。但是对于没有用类属性赋值的，可以通过实例属性：

但此时：

实例属性的值并没有传回到类属性，你也可以理解为新建立了一个同名的实例属性。如果再给类属性赋值，那么就会这样了：

当然，此时在给 t.flower 重新赋值，就会爆出跟前面一样的错误了。

这里试图给实例新增一个属性，也失败了。

看来__slots__已经把实例属性牢牢地管控了起来，但更本质是的是优化了内存。诚然，这种优化会在大量的实例时候显出效果。