python 实例方法、类方法、静态方法、私有方法详解_python类私有方法的使用场景

前言：在上vip课的时候，每次讲到实例方法、类方法、静态方法、私有方法的时候，很多同学而虽然上课能听懂，但是在实践的时候还是不能灵活使用。今天我们就来聊一聊这些方法到底有哪些特点，应该怎么使用。

一、实例方法

1. 实例方法的定义

   class TestDemo:
       #实例方法定义在类中
       def test_01(self):
           print("test_01是实例方法,定义在类中")
   1
   2
   3
   4
   '
   运行
   运行

2. 实例方法的调用

   class TestDemo:
       #实例方法定义在类中
       def test_01(self):
           print("test_01是实例方法,定义在类中.")
   
       def test_02(self):
           self.test_01() #在类里面调用：self.方法名()  self:类实例
   
   if __name__ == '__main__':
       cl = TestDemo()
       cl.test_02() #在类外面调用: 类实例.方法名()
   
   输出：
   test_01是实例方法,定义在类中.
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

3. 总结

   1、第一个参数必须是【实例对象】，该参数名一般约定为"self"
   2、通过它来传递实例的属性和方法（也可以传类的属性和方法）只能由实例对象调用
   3、类内部：self.函数名称()
   4、类外部：类名称().函数名称()
   5、使用场景：方法内部如果要使用实例属性或实例方法，就定义为实例方法
   1
   2
   3
   4
   5

二、类方法

1. 类方法的定义

   class TestDemo:
       @classmethod
       def test_01(cls):
           print("test_01是类方法,通过@classmethod修饰.")
   1
   2
   3
   4
   '
   运行
   运行

2. 类方法的调用

   class TestDemo:
       def __init__(self):
           self.name = "刘德华"
           self.age = 58
   
       @classmethod
       def test_01(cls):
           print("test_01是类方法,通过@classmethod修饰.")
           #print(cls.name) # 不能使用类实例属性
           #cls.test_03()   # 不能使用实例方法
   
       @classmethod
       def test_02(cls):
           print("test_02是类方法,通过@classmethod修饰.")
           TestDemo.test_01() # 在类内部类方法中调用，类.类方法名称()
   
       def test_03(self):
           self.test_02() # 在类内部实例方法中调用, self.类方法名称()
   
   if __name__ == '__main__':
       TestDemo.test_02() # 在类外部调用，类.类方法名称()
       TestDemo().test_02() # 在类外部调用，类实例.类方法名称()
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   '
   运行
   运行

3. 总结

   1、使用装饰器@classmethod
   2、第一个参数必须是当前【类本身】，该参数名一般约定为"cls"
   3、类方法可以被【类】+【类实例】调用
   4、类内部：self.方法名称()、类.方法名称()
   5、类外部：类.方法名称()、类实例.方法名称()
   6、不可以使用【实例属性】、【实例方法】
   7、使用场景：方法内部不需要使用实例属性和实例方法，适合定义类方法
   1
   2
   3
   4
   5
   6
   7

三、静态方法

1. 静态方法的定义

   class TestDemo:
       @staticmethod
       def test_04():
           print("test_04是静态方法，通过@staticmethod修饰")
   1
   2
   3
   4
   '
   运行
   运行

2. 静态方法的调用

   class TestDemo:
       city = "香港"
       def __init__(self):
           self.name = "刘德华"
           self.age = 58
   
       @classmethod
       def test_01(cls):
           print("test_01是类方法,通过@classmethod修饰.")
   
       @classmethod
       def test_02(cls):
           print("类方法中调用静态方法")
           TestDemo.test_04() # 类.方法名称()
   
       def test_03(self):
           print("实例方法中调用静态方法")
           self.test_04() # self.方法名称()
   
       @staticmethod
       def test_04():
           print("test_04是静态方法，通过@staticmethod修饰")
           # self.test_03() # 不能使用实例方法
           # print(self.name) # 不能使用实例属性
           # print(cls.city) #不能使用类属性,可以这样使用TestDemo.city
           # cls.test_02() # 不能使用类方法,可以这样使用TestDemo.test_02()
   
       @staticmethod
       def test_05():
           print("静态方法中调用静态方法")
           TestDemo.test_04() # 类.方法名称()
   
   if __name__ == '__main__':
       TestDemo.test_05() # 静态方法中调用静态方法,类外部调用静态方法
       TestDemo.test_02() # 类方法中调用静态方法
       TestDemo().test_03() # 实例方法中调用静态方法
   输出：
   静态方法中调用静态方法
   test_04是静态方法，通过@staticmethod修饰
   类方法中调用静态方法
   test_04是静态方法，通过@staticmethod修饰
   实例方法中调用静态方法
   test_04是静态方法，通过@staticmethod修饰
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43

3. 总结

   1、使用装饰器@staticmethod
   2、没有"self"和"cls"参数
   3、方法体中不能使用类和实例的任何属性和方法(指通过self,cls调用)
   3、调用：类和实例对象都可以调用
   1
   2
   3
   4

四、私有方法

1. 私有方法的定义

   class TestDemo:
       def __adds(self,*args):
           print('__adds是私有方法')
           return sum(*args)
   1
   2
   3
   4
   '
   运行
   运行

2. 私有方法的调用

   class TestDemo:
       def __adds(self,*args):
           print('__adds是私有方法')
           return sum(*args)
   
       def test_01(self,*args):
           result = self.__adds(args) # 类内部调用私有方法,self.方法名称()
           return result
   if __name__ == '__main__':
       cl = TestDemo()
       cl.test_01(1,2,3) #类外部调用实例方法，实例方法在类里面访问私有方法
       #cl.__adds(1,2,3) #类外部无法直接访问私有方法
       print(TestDemo.__dict__) #类属性中找到私有方法对应的属性名称
       TestDemo._TestDemo__adds(cl,[1,2,3])# 通过私有属性名称强行访问，不建议这么操作
   输出：
   __adds是私有方法
   {'__module__': '__main__', '_TestDemo__adds': <function TestDemo.__adds at 0x000001F8A2637288>, 'test_01': <function TestDemo.test_01 at 0x000001F8A26374C8>, '__dict__': <attribute '__dict__' of 'TestDemo' objects>, '__weakref__': <attribute '__weakref__' of 'TestDemo' objects>, '__doc__': None}
   __adds是私有方法
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18

3. 总结

   1、私有方法在类中通过__(双下划线开头)定义
   2、私有方法属于类中其他方法的辅助方法，一般不在类外部进行访问，只在类内部使用
   3、私有方法可以强行访问，但是不建议强行访问
   
   1
   2
   3
   4

ps: 一起学习，一起进步，有问题私信我