Python学习--类属性

01类的结构

1.1术语---实例

        1、使用面向对象开发，第一步是设计类

        2、使用类名（）创建对象，创建对象的动作有两步：

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

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

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

 因此，通常也会把：
        1、创建出来的对象叫做类的实例

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

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

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

结论：

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

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

1.2类是一个特殊的对象

        Python中一切皆对象：

                -class AAA:定义的类属于类对象

                -obj1 = AAA（）属于实例对象

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

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

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

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

        1、类属性

        2、类方法

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

02类属性和实例属性

2.1概念和使用

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

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

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

实例需求：

        -定义一个工具类

        -每件工具都有自己的name

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

Tool

name

__init__（self， name）

class Tool(object):
    count = 0   # 使用赋值语句，定义类属性

    def __init__(self, name):
        self.name = name
        Tool.count += 1


class Food(object):
    count = 0

    def __init__(self):
        self.name = None
        Food.count += 1


xiao = Tool("锤子")
ming = Tool("茄子")
cha = Tool("咖喱")
X1 = Food()
X2 = Food()
print(Tool.count)
print(Food.count)
print(X1.name)

2.2属性的获取机制

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

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

        1、类名 . 类属性

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

class Tool(object):
    count = 0

    def __init__(self, name):
        self.name = name
        Tool.count += 1


class Food(object):
    count = 0

    def __init__(self):
        self.name = None
        Food.count += 1


xiao = Tool("锤子")
ming = Tool("茄子")
cha = Tool("咖喱")
X1 = Food()
X2 = Food()
print(Tool.count)
print(Food.count)
Tool.count += 10                # 只有类引用自己的类属性，才能更改
X1.count += 10                  # 使用对象.类属性赋值，无法更改类属性的值，而该语句实际上是给X1
print(Tool.count)               # 增加了一个新的属性count，并为其赋值为10
print(Food.count)

注意：

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

03类方法和静态方法

3.1类方法

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

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

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

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

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

语法如下：

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

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

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

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

        2、这个参数和实例方法的第一个参数self类似

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

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

-在方法内部

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

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

示例需求：

       定义一个工具类

       每件工具都有自己的name        

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

Tool

name

show_tool_count（cls） __init__（self，name）

class Tool(object):
    count = 0

    def __init__(self, name):
        self.name = name
        Tool.count += 1

    @classmethod
    def show_tool_count(cls):
        print("工具对象使用的数量%d" % cls.count)


tool1 = Tool("斧头")
tool2 = Tool("剪刀")
Tool.show_tool_count()

3.2静态方法

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

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

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

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

语法如下：

@staticmethod
def 静态方法名（）：
    pass

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

-通过类名 . 调用静态方法

class Dog(object):
    
    def run(self):       # 该方法，既没有涉及到实例属性/方法，也没有设计到类属性/方法，过系统判断他是一个静态方法
        print("小狗要跑")

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）创建游戏对象，开始游戏

Game

play_name top_score

__init__(self, name) show_help() show_top_score（cls） start_game(self)

class Game(object):
    top_score = 0

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

    @staticmethod
    def show_help():
        print("此游戏仅仅用来记录分数")

    @classmethod
    def show_top_score(cls):
        print("当前最高分为%s" % cls.top_score)

    def start_game(self):
        print("%s开始游戏了。。。" % self.play_name)
        Game.top_score += 1


Game.show_help()
Game.show_top_score()
game1 = Game("小明")
game1.start_game()
Game.show_top_score()

案例小结：

        1、实例方法：方法内部需要访问实例属性

        2、类方法：方法内部只需要访问类属性

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

 提问：

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

答案：

        -应该定义 实例方法

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