Python 面向对象 类属性和类方法

类属性和类方法

01. 类的结构

1.1 术语 —— 实例

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

 

因此，通常也会把：
a.创建出来的 对象 叫做 类 的 实例
b.创建对象的 动作 叫做 实例化
c.对象的属性 叫做 实例属性
d.对象调用的方法 叫做 实例方法

1.2 类是一个特殊的对象

Python 中 一切皆对象：
　　class AAA: 定义的类属于 类对象
　　obj1 = AAA() 属于 实例对象

**在程序运行时，类 同样 会被加载到内存
**在 Python 中，类 是一个特殊的对象 —— 类对象
**在程序运行时，类对象 在内存中 只有一份，使用 一个类 可以创建出 很多个对象实例
**除了封装 实例 的 属性 和 方法外，类对象 还可以拥有自己的 属性 和 方法
　　类属性
　　类方法
**通过 类名. 的方式可以 访问类的属性 或者 调用类的方法

 

02. 类属性和实例属性

2.1 概念和使用

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

 

2.2 属性的获取机制

要访问类属性有两种方式：
　　a.类名.类属性
　　b.对象.类属性 （不推荐）

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

 

03. 类方法和静态方法

3.1 类方法

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

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

******************

**类方法需要用 修饰器 @classmethod 来标识，告诉解释器这是一个类方法
**类方法的 第一个参数 应该是 cls
　　由 哪一个类 调用的方法，方法内的 cls 就是 哪一个类的引用
　　这个参数和 实例方法 的第一个参数是 self 类似
　　提示 使用其他名称也可以，不过习惯使用 cls
**通过 类名. 调用 类方法，调用方法时，不需要传递 cls 参数
**在方法内部
　　可以通过 cls. 访问类的属性
　　也可以通过 cls. 调用其他的类方法

 

3.2 静态方法
**在开发时，如果需要在 类 中封装一个方法，这个方法：
　　既 不需要 访问 实例属性 或者调用 实例方法
　　也 不需要 访问 类属性 或者调用 类方法
**这个时候，可以把这个方法封装成一个 静态方法

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

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

class Dog(object):
    
    # 狗对象计数
    dog_count = 0
    
    @staticmethod
    def run():
        
        # 不需要访问实例属性也不需要访问类属性的方法
        print("狗在跑...")

    def __init__(self, name):
        self.name = name

 

3.3 综合案例

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

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

 

PS: 实例方法、类方法、静态方法的区别与作用

实例方法
定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；
调用：只能由实例对象调用。

类方法
定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；
调用：类和实例对象都可以调用。

原则上，类方法是将类本身作为对象进行操作的方法。假设有个方法，且这个方法在逻辑上采用类本身作为对象来调用更合理，那么这个方法就可以定义为类方法。另外，如果需要继承，也可以定义为类方法。

如下场景：

假设我有一个学生类和一个班级类，想要实现的功能为：
    执行班级人数增加的操作、获得班级的总人数；
    学生类继承自班级类，每实例化一个学生，班级人数都能增加；
    最后，我想定义一些学生，获得班级中的总人数。

思考：这个问题用类方法做比较合适，为什么？因为我实例化的是学生，但是如果我从学生这一个实例中获得班级总人数，在逻辑上显然是不合理的。同时，如果想要获得班级总人数，如果生成一个班级的实例也是没有必要的。

class ClassTest(object):
    __num = 0

    @classmethod
    def addNum(cls):
        cls.__num += 1

    @classmethod
    def getNum(cls):
        return cls.__num

    # 这里我用到魔术方法__new__，主要是为了在创建实例的时候调用累加方法。
    def __new__(self):
        ClassTest.addNum()
        return super(ClassTest, self).__new__(self)


class Student(ClassTest):
    def __init__(self):
        self.name = ''

a = Student()
b = Student()
print(ClassTest.getNum())

静态方法
定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；
 调用：类和实例对象都可以调用。
 
 静态方法是类中的函数，不需要实例。静态方法主要是用来存放逻辑性的代码，逻辑上属于类，但是和类本身没有关系，也就是说在静态方法中，不会涉及到类中的属性和方法的操作。可以理解为，静态方法是个独立的、单纯的函数，它仅仅托管于某个类的名称空间中，便于使用和维护。

譬如，我想定义一个关于时间操作的类，其中有一个获取当前时间的函数。

import time

class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())


print(TimeTest.showTime())
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
print(nowTime)