类中可以添加类属性（在“Python类对象、实例对象、类属性和实例属性等”中有详解）、初始化方法、实例方法、静态方法和类方法。

# 定义在类的外面的，称为函数
def eat():
    print('吃东西')
# 调用函数
eat()

class People:   # People就是类对象
    # 类属性：定义在类里面，方法之外的变量
    birth_place = '四川'

    # 初始化方法（构造方法）
    # 只要实例化对象的时候就会被自动调用，它是对数据进行初始化操作的
    def __init__(self,name,age):    #name,age是形参
        self.name = name    # self.name是实例属性，将局部变量name的值赋给实例属性
        self.age = age

    # 实例方法
    def display(self):  # self是对类当前实例的引用，用于访问类属性
        print(f'我的名字叫{self.name}，今年{self.age}岁，来自{self.birth_place}')
    def get_name(self):
        print(self.name)

    # 类方法，使用classmethod修饰的方法
    @classmethod
    def cm(cls):    # cls是class的缩写。
        print('我是类方法')

    # 静态方法，使用staticmethod修饰的方法
    @staticmethod
    def sm():        # 不允许写self
        print('我是静态方法')

people = People('张三',19)    # people是根据People类创建出来的。叫实例对象

print(People.birth_place)   # 访问类属性：类名.类属性名

print(people.age)   # 访问实例属性：对象名.属性名

people.display()    # 调用实例方法：对象名.方法名()

People.display(people)  # 还可以通过类名调用实例方法：类名.方法名(类的对象)，这里的类的对象就是方法定义处的self
# People.display(People('Alice',22)) 

people.get_name()

注意：在类的外面定义的称为函数，在类里面定义的称为方法。

类方法

用装饰器 @classmethod 标识的方法称为类方法。它使用类名直接调用（类名.类方法名(参数列表)，参数列表中不需要给 cls 传值，Python 解释器会帮我们传递这个参数），其中 cls 是 class 的缩写（cls 可以使用其他名称），且必须在第一个参数上，它传入的是 People 这个类对象，而不是实例对象。

1）在类的继承中，子类继承父类的类方法时，传入的 cls 是子类对象。

2）哪一个类调用，cls 就是哪一个类的引用。

3）类方法通常用于操作类属性和私有类属性。

4）在类方法中只能访问类属性（类中定义的变量），无法访问实例属性和实例方法。

5）类方法通过 cls.类属性 访问类属性，也可以使用 cls. 调用其他的类方法。

class People:
    place = '北京'  # 类属性

    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age

    # 类方法，使用classmethod修饰的方法
    @classmethod
    def people_from(cls):  # cls是class的缩写。传入的是类对象，而不是实例对象
        print(f'我来自{cls.place}，这是类方法')  # 我来自北京，这是类方法
        # 访问实例属性会报错
        # print(f'我叫{cls.name}，今年{cls.age}') # AttributeError: type object 'People' has no attribute 'name'


p = People('张三', 21)

# 调用类方法
People.people_from()

输出结果：我来自北京，这是类方法

6）类方法中除了 cls 这个特殊参数，还可以传其他的普通参数。

class People:
    place = '北京'    # 类属性
    @classmethod
    def cm(cls,str):    # cls是class的缩写。
        print(f'我来自{cls.place}，{str}是类方法')  # 我来自北京，普通参数是类方法

People.cm('普通参数')

输出结果：我来自北京，普通参数是类方法

7）使用类方法可以修改私有属性的值：

class Demo:
    # 私有属性
    __total = 10

    @classmethod
    def cm(cls,num):
        print(f'私有变量修改前是{cls.__total}') # 私有变量修改前是10
        cls.__total = num
        print(f'私有变量修改后是{cls.__total}') # 私有变量修改后是999

    def getTotal(self):
        print(self.__total)
        # return self.__total

aa = Demo()
bb = Demo()
aa.getTotal()   # 10
aa.cm(999)      # 调用类方法修改私有属性值
aa.getTotal()   # 999
# bb这个对象未调用类方法，获取的私有变量也是被修改后的值
# 如果将标识类方法的@classmethod注释掉，那么修改的就只是aa对象中的私有属性了，下面这句代码输出的就是10，而不是999
bb.getTotal()   # 999

输出结果：

10
私有变量修改前是10
私有变量修改后是999
999
10

Process finished with exit code 0

实例方法

一般来说，类中的方法默认是实例方法。在定义实例方法时，与静态方法和类方法不同，它不需要使用特殊的关键字进行标识。

参数：第一个参数必须是 self 参数，后面可跟其他参数也可不跟。

class Demo:
    def instace_method(self,s):
        print(f'{s}调用实例方法')


d = Demo()

# 通过实例对象调用实例方法：对象名.实例方法名()
d.instace_method('实例对象d')   # 实例对象d调用实例方法

# 通过类名调用实例方法，必须要传一个参数给self：类名.实例方法名(self)
Demo.instace_method(d,'类对象Demo')    # 类对象Demo调用实例方法

静态方法

使用 @staticmethod 修饰的方法，可以通过类名直接访问，也可以通过实例对象访问。注意静态方法中既不需要传递类对象（cls）也不需要传递实例对象（self）。所以在调用的时候也不会向函数传递任何特殊参数，他可以拥有普通参数。

如果既不需要使用实例对象（访问实例属性或者调用实例方法），也不需要使用类对象（访问类属性或者调用类方法），可以定义一个静态方法，这样子有利于减少内存占用。

class People:
    # 静态方法，使用staticmethod修饰的方法
    @staticmethod
    def run():  # 没有self或者cls这样的特殊参数，可以有普通参数
        print('那个人在跑步')
    @staticmethod
    def eat(str):   # 给静态方法传递一个普通参数
        print(f'他在吃{str}')

# 调用静态方法
People.run()
People.eat('汉堡包')

静态方法中不能访问实例属性和实例方法。

类方法、实例方法和静态方法的使用场景

类方法：方法内部只需要访问类属性，或者只需要调用其他类方法。

实例方法：方法内部需要访问实例属性，在实例方法中，也可以使用 类名.类属性名 来访问类属性。

静态方法：方法内部既不需要访问实例属性也不需要访问类属性。

初始化方法：用于给实例属性设置初始值。

初始化方法（__init__()）

在创建实例对象时，python 解释器会自动为对象在内存中分配内存空间，并通过初始化方法（__init__()，前后都是两个下划线）为对象的属性设置初始值。

__init__ 是对象的内置方法，专门用于定义一个类中有哪些属性。它的第一个参数同样是 self，表示实例对象的引用。

只要创建实例对象，就会自动调用 __init__() 方法，我们通过重写这个方法来完成初始化：

class Person:
    def __init__(self):
        print('我是初始化方法。')

# 使用类名()创建对象的时候，会自动调用__init__()初始化方法。
Tom = Person()

如果想要这个类创建的对象都拥有这个属性值，可以通过 self.属性名 = 初始化值 来定义属性：

class Person:
    def __init__(self):
        print('我是初始化方法。')
        self.name = 'Tom'    # name的初始值固定了

Tom = Person()
print(Tom.name)    # Tom
a = Person()
print(a.name)    # Tom

但是这样做，对象的属性值就固定了，要想对象的属性值灵活变化，可以通过参数传递来完成。

可以通过参数来设置属性的初始值，每个对象都自己的属性值：

class Person:
    def __init__(self,name,age):
        self.name = name   # self.name是实例属性，将局部变量name的值赋给实例属性，习惯上是实例属性名和局部变量名设置成一样的

        self.age = age

Tom = Person('Tom',21)
Alice = Person('Alice',19)

print(f'{Tom.name}今年{Tom.age}岁。')       # Tom今年21岁。
print(f'{Alice.name}今年{Alice.age}岁。')   # Alice今年19岁。

默认值参数

我们可以给形参设置默认值，这样创建对象的时候无论传不传参，都不会报错。

class Person:
    def __init__(self,name='张三',age=999):
        self.name = name
        self.age = age

Tom = Person('Tom',21)
print(f'{Tom.name}今年{Tom.age}岁。')       # Tom今年21岁。

# 不传参的话，程序不会报错，使用默认值
Alice = Person()
print(f'{Alice.name}今年{Alice.age}岁。')   # 张三今年999岁。