python怎么类

python中bool运算符按优先级顺序分别有or、and、not, 其中or、and为短路运算符

not先对表达式进行真值测试后再取反

not运算符值只有1个表达式，not先对表达式进行真值测试后再取反,返回的结果不是True就是False

or、and运算符返回的结果是操作符两边的表达式中的符合逻辑条件的其中一个表达式的结果

在其它语言中，比如C#，bool运算的结果肯定也是bool值;但是python中不是这样的，它返回的是满足bool运算条件的其中一个表达式的值。

x or y：

若 x为True,则结果为x;若x为False, 则结果为y。

x and y：

若 x为False,则结果为x;若x为True, 则结果为y。

or、and运算符是短路运算符

短路运算符的意思是，运算符左右的表达式的只有在需要求值的时候才进行求值。比如说x or y，python从左到右进行求值，先对表达式x的进行真值测试，如果表达式x是真值，根据or运算符的特性，不管y表达式的bool结果是什么，运算符的结果都是表达式x，所以表达式y不会进行求值。这种行为被称之为短路特性。

or、and运算符可以多个组合使用，使用的时候将以此从左到右进行短路求值，最后输入结果

表达式x or yand z，会先对x or y进行求值，然后求值的结果再和z进行求值，求值过程中依然遵循短路原则。

not运算符的优先级比or、and高，一起使用的时候，会先计算not，再计算or、and的值

not运算符的优先级比==、!=低，not a == b 会被解释为 not (a == b)， 但是a == not b 会提示语法错误。

找工作难？那是你没选对行业!

2017年【中公教育】特别推出2017年就业促进计划，500万就业基金助你成为IT达人

详情请戳：http//ujiuye/zt/jycj/?wt.bd=bgz

什么？海量IT学习资料白给你都不要？别想了，加群抢：584539956

前面

一篇

文章我介绍了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 入门基础之面向对象过程-面向过程概述

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

类属性和类方法

目标

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

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()

``

探究更多的类属性，在一些初学者的教程中，一般很少见。我之所以要在这里也将这部分奉献出来，就是因为本教程是“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面向对象的基本知识，链接在最下面。初步解释了面向对象和面向对象的优点，今天就开始正式用代码来展现面向对象。

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 入门基础之面向对象过程-面向过程概述

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

类属性和类方法

目标

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

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()

``