python的调用类变量和实例变量、类方法和静态方法以及实例方法

一、Python中的变量和方法分类

• 类变量：定义在class中且method外，为类和所有实例共享，包括public和private类型，调用方法: 类名.变量名 或者 实例名.变量名；
• 实例变量：调用__init__(参数)方法去实例化对象时创建的变量，为当前实例所独享，调用方法: 实例名.变量名；
• 局部变量：定义在方法内部的变量，为方法所独享；
• 类方法：使用@classmethod注解，为类和所有实例共享，调用方法: 类名.方法名 或者 实例名.方法名；
• 静态方法：使用@staticmethod注解，与当前类和实例不存在所属关系，调用方法: 类名.方法名 或者 实例名.方法名；
• 实例方法-public：为当前实例独享，调用方法: 实例名.方法名；
• 实例方法-private：为当前实例独享，必须在其他的实例方法中调用，调用方法: 实例名.方法名。

二、Python中变量和方法的引用

2.1 测试源码

# 类名，其中参数object为被继承的父类，默认为object（python中object是其他所有类的父类）
class CharUtil(object):
    # 类变量--被所有实例共享
    int_1 = '1'
    ch_2 = '2'
    # private类型
    __float_3 = 1.23456

    # 构造方法
    def __init__(self, ch, a, b):
        # 实例变量--仅为当前实例所有
        self.ch = ch
        self.a = a
        self.b = b
        pass

    # 类方法，参数cls表示当前class，调用方法:类名.方法名，或者实例名.方法名
    @classmethod
    def test1(cls):
        print("调用类方法，打印类变量：{}, {}, {}".format(cls.int_1, CharUtil.ch_2, cls.__float_1))

    # 静态方法，可以无参数，调用方法:类名.方法名，或者实例名.方法名
    @staticmethod
    def char2Upper(c):
        newChar = c
        if 'a' <= c <= 'z':
            newChar = chr(ord(newChar) - 32)
        return newChar

    # 实例方法-private，必须在其他的实例方法中调用，调用方法：实例名.方法名，self即当前实例
    def __char2Lower(self, c):
        newChar = c
        if 'A' <= c <= 'Z':
            newChar = chr(ord(newChar) + 32)
        return newChar

    # 实例方法-public，调用方法：实例名.方法名
    def str2Lower(self, string):
        newStr = ''
        for ch in string:
            if 'A' <= ch <= 'Z':
                # 调用实例方法-private
                newStr += self.__char2Lower(ch)
            else:
                newStr += ch
        return newStr


# 普通方法（非类），调用方法：方法名(参数)
def char2Upper(c):
    newChar = c
    if 'a' <= c <= 'z':
        newChar = chr(ord(newChar) - 32)
    return newChar


# 调用普通方法，格式化输出
print(">>>>>> %.3f" % 1.123456)
print("调用普通方法: %s" % char2Upper('a'))
# 调用静态方法
print("调用静态方法: %s" % CharUtil.char2Upper('b'))
# 调用类方法
CharUtil.test1()
# 调用实例方法-public
charUtil = CharUtil('para1', 'para2', 'para3')
print("调用实例方法-public, new String is: {}".format(charUtil.str2Lower("EfG")))
print("实例变量: {}, {}, {}".format(charUtil.ch, charUtil.a, charUtil.b))

# 以上代码写在同一个python模块（即同一个.py文件），
# 一个python模块可以定义多个类和变量以及方法，
# 如果需要在其他python模块中引用该模块的类或变量或方法，
# 需要使用import将该模块或被引用的元素import进来。

2.2 测试结果

>>>>>> 1.123
调用普通方法: A
调用静态方法: B
调用类方法，打印类变量：1, 2
调用实例方法-public, new String is: efg
实例变量: para1, para2, para3

三、总结

3.1方法定义

• 类方法必须要添加至少1个参数，第1个参数必须是当前类对象，一般写为cls（表示class本身）；
• 静态方法可以不添任何参数；
• 实例方法必须添加至少1个参数，且第1个参数必须是self，表示当前实例；
• 构造方法__init__必须要添加至少1个参数，且第1个参数必须是self）self后的参数为实例变量；
• private类型的实例方法名和private类型的类变量名都以__开头，构造方法以__开头和结尾。

3.2 方法调用

• 实例化对象时传入的参数不包括self；
• 实例化对象时传入的参数个数必须与初始化方法__init__的self后的参数个数一致。

3.3 为什么需要类方法和静态方法

假设有1个Student类和1个Friend类，其中Friend类继承了Student类，现在需要实现以下功能：

• 每次实例化1个Fridend，Student人数都+1；
• 实例化若干个Friend，统计Student人数。

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

class Student(object):

  # private 类变量，学生人数
    __stuNum = 0

    def __init__(self):
        Student.addNum()

    # 类方法
    @classmethod
    def getStuNum(cls):
        return cls.__stuNum

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


class Fridend(Student):
    def __init__(self):
        super().__init__()


a = Fridend()
b = Fridend()
print(Student.getStuNum())