Python 实力方法、类方法、静态方法、私有方法

实践是检验真理的唯一标准：拷贝到pycharm一试便知。

四、实例方法【掌握】

1、创建
def test_01(self)
第一个参数必须是类实例对象，通常使用self来接收(见名知意)

2、调用实例方法
类里面：self.实例方法名称()
类外面：类实例.实例方法名称()

3、特点
只能通过类实例调用

4、使用场景
方法里面需要访问实例属性或实例方法的时候你就定义实例方法

五、类方法【掌握】

1、创建
通过@classmethod装饰器修饰的方法
第一个参数必须是类本身，一般使用cls类接收

2、调用类方法
类里面：类.类方法名() self.类方法名()
类外面：类.类方法名() 类实例.类方法名()

3、特点
1 类方法可以访问类属性、类方法
2 类方法不可以访问实例属性、实例方法
3 第一个参数必须是类本身，一般使用cls类接收

4、使用场景
方法不需要访问实例属性、实例方法时，就定义为类方法

总结四、五：类方法、实例方法【掌握】

类：
访问类属性：类.属性名称
访问类方法：类.方法名称()
使用场景：方法里面不需要访问实例属性、实例方法，就定义为类方法

类实例：
访问所有的属性：类实例.所有属性名称
访问所有的方法：类实例.所有方法名称()
使用场景：方法里面需要访问实例属性、实例方法，就定义实例方法

六、静态方法【了解】

1、创建
通过@staticmethod来修饰的方法
它没有默认的参数，不需要写任何参数，self、cls都不需要写

2、调用静态方法
类里面：类.静态方法名称()
类外面：类.静态方法名称() 类实例.静态方法名称()

3、特点
类和类实例都可以调用静态方法
不能访问类相关的属性和方法
不能访问实例相关的属性和方法

4、使用场景
方法内部，
既不需要使用类相关的属性和方法，
也不需要使用实例相关的属性和方法，
就定义为静态方法。



class TestDemo:
    age = 20  # 类属性

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

    # 实例方法
    def test_01(self):
        print("调用实例方法test_01")
        print("实例属性name：", self.name)
        print("类属性age：", self.age)
        # 访问实例方法
        self.test_01_sl()  # 类里面：self.实例方法名称()
        # 访问类方法
        self.test_03()  # 类里面：self.类方法名称()
        # 访问静态方法
        self.test_05()  # 类里面：self.静态方法名称()

    # 实例方法
    def test_01_sl(self):
        print("调用实例方法test_01_sl")

    # 类方法
    @classmethod
    def test_02(cls):
        print("调用类方法test_02")
        # 访问类属性
        print("类属性：cls.age：", cls.age)
        # 访问类方法
        cls.test_03()  # 类里面：类.类方法名()
        TestDemo.test_03()  # 类里面：类.类方法名()
        # 访问静态方法
        cls.test_05()  # 类里面：类.静态方法名称()
        TestDemo.test_05()  # 类里面：类.静态方法名称()

        # cls.test_01()  # 不能访问实例方法
        # print(cls.name) # 不能访问类实例属性

    # 类方法
    @classmethod
    def test_03(cls):
        print("调用类方法test_03")

    # 静态方法
    @staticmethod
    def test_04():
        print("调用静态方法test_04")
        TestDemo.test_05()  # 调用静态方法

    # 静态方法
    @staticmethod
    def test_05():
        print("调用静态方法test_05")


if __name__ == '__main__':
    cl = TestDemo("小明")

    # 不以括号结尾 打印的是内容地址 cl.test_01()
    print(cl.test_01)
    # <bound method TestDemo.test_01 of <__main__.TestDemo object at 0x000002018DFB8D10>>

    # 四、实力方法
    # 类外面：类实例.实例方法名称()
    cl.test_01()
    # 调用实例方法test_01
    # 实例属性name： 小明
    # 类属性age： 20
    # 调用实例方法test_01_sl
    # 调用类方法test_03
    # 调用静态方法test_05

    # 类外面：类不能访问实例方法
    TestDemo.test_01()
    # TypeError: TestDemo.test_01() missing 1 required positional argument: 'self'

    # 五、类方法
    # 类外面：类实例.类方法名()
    cl.test_02()
    # 调用类方法test_02
    # 类属性：cls.age： 20
    # 调用类方法test_03
    # 调用类方法test_03
    # 调用静态方法test_05
    # 调用静态方法test_05

    # 类外面：类.类方法名()
    TestDemo.test_02()
    # 调用类方法test_02
    # 类属性：cls.age： 20
    # 调用类方法test_03
    # 调用类方法test_03
    # 调用静态方法test_05
    # 调用静态方法test_05

    # 六、静态方法
    # 类外面：类实例.静态方法名称()
    cl.test_04()
    # 调用静态方法test_04
    # 调用静态方法test_05

    # 类外面：类.静态方法名称()
    TestDemo.test_04()
    # 调用静态方法test_04
    # 调用静态方法test_05

七、私有方法

1、创建
通过双下划线进行定义def __test_02(self):

2、调用
在类里面：self.__test_02()
在类外面：不能被调用，强行访问
通过print(TestDemo.dict)获取私有方法属性名
通过实例.新属性名() 调用
cl._TestDemo__test_02()

3、特点
1 只能在当前类里面使用
2 不能被继承

4、使用场景
1 在类里面不希望被外部调用的方法就写成私有方法(属性也一样)

class TestDemo:
    # 实例方法
    def test_01(self):
        print("这是实例方法：test_01")
        self.__test_02()

    # 实例方法 - 私有方法
    def __test_02(self):
        print("这是私有方法：test_02")


if __name__ == '__main__':
    cl = TestDemo()
    print("获取私有方法属性名TestDemo.__dict__：", TestDemo.__dict__)
    # 获取私有方法属性名TestDemo.__dict__： {
    # '__module__': '__main__', 'test_01': <function TestDemo.test_01 at 0x0000021A75098AE0>,
    # '_TestDemo__test_02': <function TestDemo.__test_02 at 0x0000021A750CE480>,
    # '__dict__': <attribute '__dict__' of 'TestDemo' objects>,
    # '__weakref__': <attribute '__weakref__' of 'TestDemo' objects>,
    # '__doc__': None
    # }

    # # 通过原私有方法名调用
    # cl.__test_02()  # 不能在类外面调用
    # # 打印会报错
    # # AttributeError: 'TestDemo' object has no attribute '__test_02'. Did you mean: 'test_01'?

    # 通过获取新的私有方法名调用
    cl._TestDemo__test_02()  # 强行访问
    # 这是私有方法：test_02

    # 普通方法调用私有方法
    cl.test_01()
    # 这是实例方法：test_01
    # 这是私有方法：test_02

2 回帖

欢迎来到testingpai.com！

这是一个属于测试人员的小众社区，大家相互信任，以平等自由，热情奔放的价值观进行分享交流。希望大家能够找到与自己志同道合的伙伴，共同成长。

注册关于

请输入回帖内容 ...

xiaodingdang • 1 年前

你的七、私有方法 3、特点写的不对，Python中的私有方法可以被继承，但不能被直接访问或调用。

私有方法和属性只能在类内部被访问和调用，而在类外部无法直接访问。但是，在子类中可以继承父类的私有方法，而且可以通过调用其他非私有方法或公有方法来访问和间接调用父类的私有方法。

class Parent:
    def __private_method(self):
        print("This is a private method.")
      
    def public_method(self):
        print("This is a public method.")
        self.__private_method()
      
class Child(Parent):
    def call_private_method(self):
        self.__private_method()  # 无法直接调用
  
child = Child()
child.public_method()  # 输出 "This is a public method." 和 "This is a private method."
child.call_private_method()  # 报错：AttributeError: 'Child' object has no attribute '__private_method'

其他回帖

你的六、静态方法 3、特点写错了。

静态方法可以访问类相关的属性和方法，但是不能访问实例的相关属性和方法，因为静态方法与类的实例状态无关。

class MyClass:
    class_var = 10
  
    def __init__(self, instance_var):
        self.instance_var = instance_var
  
    @staticmethod
    def static_method():
        print(MyClass.class_var)  # 调用类属性
        MyClass.class_method()  # 调用类方法
  
    @classmethod
    def class_method(cls):
        print("This is a class method.")
  
my_instance = MyClass(20)
MyClass.static_method()  # 输出 "10" 和 "This is a class method."
my_instance.static_method()  # 输出 "10" 和 "This is a class method."

测试派 Give testers a home.