Python_从零开始学习_(41) 类属性和类方法

迈不过友情╰ 2021-09-16 18:34 386阅读 0赞

**目录**

1.  类的结构

1.1  术语 ---- 实例

1.2  类是一个特殊的对象

2.  类属性和实例属性

2.1  概念和使用

2.2  属性的获取机制 (科普)

3.  类方法和静态方法

3.1  类方法

3.2  静态方法

3.3  方法综合案例

--------------------

## 1.  类的结构 ##

### 1.1  术语 ---- 实例 ###

1.  使用面向对象开发,  **第1步**  是设计 **类**
2.  使用 **类名() **创建对象,  **创建对象 **的动作有两步:  
      
    1) 在内存中为对象 **分配空间**  
      
    2) 调用初始化方法 \_\_init\_\_ 为 **对象初始化**
3.  对象创建后,  **内存 **中就有了一个对象的 **实实在在 **的存在 ---- **实例**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5kYW4xMTI3_size_27_color_FFFFFF_t_70][]

因此,  通常也会把:

1.  创建出来的 **对象 **叫做 **类 **的 **实例**
2.  创建对象的 **动作** 叫做 **实例化**
3.  **对象的属相 **叫做 **实例属性**
4.  **对象调用的方法 **叫做 **实例方法**

在程序执行时:

1.  对象各自拥有自己的 **实例属性**
2.  调用对象方法,  可以通过 self

*  访问自己的属性
 *  调用自己的方法

结论

*  **每一个对象** 都有自己 **独立的内存空间**. **保存各自不同的属性**
 *  **多个对象的方法.  在内存中只有一份, ** 在调用方法时,  **需要把对象的引用** 传递到方法内部

### 1.2  类是一个特殊的对象 ###

> Python 中一切皆对象:
> 
>  *  class Person:  定义的类属于 **类对象**
>  *  xiaoming = Person()  属于 **实例对象**

*  在程序运行时, **类 **同样 **会被加载到内存**
 *  在 Python 中, **类 **是一个特殊的对象 ---- **类对象**
 *  在程序运行时, **类对象 **在内存中 **只有一份,  **使用 **一个类 **可以穿检出 **很多个对象实例**
 *  除了封装 **实例 **的 **属性 **和 **方法 **外. **类对象 **还可以拥有自己的 **属性 **和 **方法**

1.  **类属性**
2.  **类方法**

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5kYW4xMTI3_size_27_color_FFFFFF_t_70 1][]

## 2.  类属性和实例属性 ##

### 2.1  概念和使用 ###

*  **类属性** 就是给 **类对象** 中定义的 **属性**
 *  通常用来记录 **与这个类相关 **的特征
 *  **类属性 不会用于 **记录 **具体对象的特征**

**实例需求**

*  定义一个 **工具类**
 *  每件工具都有自己的 name
 *  **需求 **\---- 知道使用这个类,  创建了多少个工具对象?

class Tool(object):
    
        # 使用赋值语句定义类属性, 记录所有工具对象的数量
        count = 0
    
        def __init__(self, name):
            self.name = name
    
            # 让类属性的值+1
            Tool.count += 1
    
    
    # 1. 创建工具对象
    tool1 = Tool("剪刀")
    tool2 = Tool("石头")
    tool3 = Tool("布")
    
    print(Tool.count)

### 2.2  属性的获取机制 (科普) ###

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5kYW4xMTI3_size_27_color_FFFFFF_t_70 2][]

*  因此,  要访问类属性有两种方式:

1.  **类名.类属性**
2.  **对象.类属性** (不推荐)

注意

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

## **3.  类方法和静态方法** ##

### **3.1  类方法** ###

*  **类属性 **就是针对 **类对象 **定义的属性
 *  使用 **赋值语句 **在 class 关键字下方可以定义 **类属性**
 *  **类属性 **用于记录 **与这个类相关 **的特征
 *  **类方法 **就是针对 **类对象 **定义的方法
 *  在 **类方法 **内部可以直接访问 **类属性 **或者调用其他的 **类方法**

**语法如下**

@classmethod
    def 类方法名(cls):
        pass

*  类方法需要用 **修饰器 @classmethod **来标识,  **告诉解释器这是一个类方法**
 *  类方法的 **第一个参数 **应该是 cls

>  *  可以通过 cls. **访问类的属性**
>  *  也可以通过 cls. **调用其他的类方法**

实例需求

*  定义一个 **工具类**
 *  每件工具都有自己的 name
 *  **需求 **\---- 在 类 封装一个 show\_tool\_count 的类方法,  输出使用当前这个类,  创建的对象个数

class Tool(object):
    
        # 使用赋值语句定义类属性, 记录所有工具对象的数量
        count = 0
    
        @classmethod
        def show_tool_count(cls):
    
            print("工具对象的数量 %d" % cls.count)
    
        def __init__(self, name):
            self.name = name
    
            # 让类属性的值+1
            Tool.count += 1
    
    
    # 1. 创建工具对象
    tool1 = Tool("剪刀")
    tool2 = Tool("石头")
    tool3 = Tool("布")
    
    # 2. 输出工具对象的总数
    Tool.show_tool_count()

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

### **3.2  静态方法** ###

*  在开发时,  如果需要在 类 中封装一个方法,  这个方法:

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

*  这个时候,  可以把这个方法装成一个 **静态方法**

**语法如下**

@staticmethod
    def 静态方法名():
        pass

*  **静态方法 **需要用 **修饰器 @staticmethod** 来标识**,  **告诉解释器这是一个静态方法
 *  通过 **类名. **通过 **静态方法**

class Dog(object):
    
        @staticmethod
        def run():
            
            # 不访问实例属性/类属性
            print("小狗要跑...")
    
    
    # 通过类名. 调用静态方法 - 不需要创建对象
    Dog.run()

### 3.3  方法综合案例 ###

需求

1.  设计一个 Game 类
2.  属性:  
      
    定义一个 **类属性 **top\_score 记录游戏的 **历史最高分**  
      
    定义一个 **实例属性 **player\_name 记录 **当前游戏的玩家姓名**
3.  方法:  
      
    **静态方法 **show\_help 显示游戏帮助信息  
      
    **类方法 **show\_top\_score 显示历史最高分  
      
    **实例方法** start\_game 开始当前玩家的游戏
4.  主程序步骤  
      
    1) 查看帮助信息  
      
    2) 查看历史最高分  
      
    3) 创建游戏对象,  开始游戏

class Game(object):
    
        # 历史最高分
        top_score = 0
    
        def __init__(self, player_name):
            self.player_name = player_name
    
        @staticmethod
        def show_help():
            print("帮助信息: 让僵尸进入大门")
    
        @classmethod
        def show_top_score(cls):
            print("历史记录 %d" % cls.top_score)
    
        def start_game(self):
            print("%s 开始游戏了..." % self.player_name)
    
    
    # 1. 查看游戏的帮助信息
    Game.show_help()
    
    # 2. 查看历史最高分
    Game.show_top_score()
    
    # 3. 创建游戏对象
    game = Game("小明")
    
    game.start_game()

案例小结

1.  **实例方法** ---- 方法内部需要访问 **实例属性  
      
      实例方法 **内部可以使用 **类名. **访问类属性
2.  **类方法** ---- 方法内部 **只** 需要访问 **类属性**
3.  **静态方法** \---- 方法内部,  不需要访问 **实例属性 **和 **类属性**

提问

如果方法内部 既需要访问 **实例属性, ** 又需要访问 **类属性,  **应该定义什么方法?

答案

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5kYW4xMTI3_size_27_color_FFFFFF_t_70]: /images/20210726/74abc6c3fab246008cc89cb4e16b5865.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5kYW4xMTI3_size_27_color_FFFFFF_t_70 1]: /images/20210726/26a3ae9b9bfb4bf6b1759e7992f92378.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5kYW4xMTI3_size_27_color_FFFFFF_t_70 2]: /images/20210726/f6442c724fcb4b6499e9ac866907ef3c.png