python 类的总结

类的总结内容：

1. 私有属性、私有方法、内部交叉调用方法、属性调用
2. 类的继承
3. 类的一些实列化小细节
4. 类的修饰 @staticmethod @classmethod

1 私有属性、私有方法

       私有变量： 定义前加双下划线__.类内部调用前加self。
       私有方法:   定义前加双下划线__。
       私有方法和属性外部不能访问和更改。

class A():
    a='a是共有变量'    #公有变量：  能在外部使用和更改
    __b='b是私有变量'  #私有变量： 定义前加双下划线__.类内部调用前加self
    
    def __init__(self,c,d):  #类的初始话 
        self.c=c
        self.d=d
    #公有方法
    def f_a(self): #定义一个方法第一个参数必须是self 
        print(self.a) #调用公有属性
        print(self.__b) #调用私有属性
        self.__f()  #交叉调用私有方法
    #私有方法    
    def __f(self): #私有方法定义前加双下划线__
        print('__f私有方法')
    
a=A('c','d') #类需要实列化后才能使用
a.f_a()
	>>>a是共有变量
	>>>b是私有变量
	>>>__f私有方法
a.__b
    >>>AttributeError: 'A' object has no attribute '__b'

2. 类的继承

父类:用于被继承的类，称之为父类，也叫做基类，或者超类。

子类:继承其他类的类，称之为子类，也叫做派生类

类的继承 ,类可以通过继承来获得父类的公有属性和方法，不能继承私有.

子类和父类有相同的变量名，子类覆盖掉父类相同变量名。

查看继承的父类 类名.bases
print(B.bases)

class A():
    A_a='我是类A的公有属性'
    __A_b='我是类A的私有有属性'
    
    def A_f(self):
        return '我是类A的公有方法'
    def __forword(self):
        print("我是类A的私有方法")
 
        
class B(A):
    B_a='我是B类的公有变量'
    
b=B() 

print(b.A_a) #B类调用A类的公有属性
     >>>我是类A的公有属性
print(b.__A_b) #B类调用A类的私有属性
     >>>报错 AttributeError: 'B' object has no attribute '__A_b'

print(b.A_f()) #B类调用A类的公有方法
      >>>我是类A的公有方法
print(b.__forword()) #B类调用A类的私有方法
      >>>AttributeError: 'B' object has no attribute '__forword'
      
print(b.B_a)  #B类调用自己的属性
      >>>'我是B类的公有变量'

3.类的一些实列化小细节

属性可以不用实例化直接调用，
方法：类需实列化才能使用，但是可以直接不实例话调用变量,（类.变量）@staticmethod或@classmethod
实列化一次类里的函数就会调用执行一次。
类中不能直接调用函数，只有在函数中相互调用

class A():
    print('我在A类的开头')
    
    a='我是A类中的a变量'
    def aa(self):
        print("我在aa")    
    def ab(self):
        self.aa() #函数的交叉调用
        
    print('我在A类的结尾')
    
A.a 不用实例话直接调用类变量
   >>>我在A类的开头
   >>>我在A类的结尾
   >>>[out:]'我是A类中的a变量'

a=A()  #实列化一次类里就会执行调用一次
  >>>我在A类的开头
  >>>我在A类的结尾

a.ab() #函数的交叉调用
  >>>我在aa

4.类的修饰 @staticmethod @classmethod

1、@staticmethod或@classmethod，就可以不需要实例化，直接类名.方法名()来调用
2、带self的函数都需要实例化后才能在外部使用。a=A() a.foo1()    

传统self @staticmethod @classmethod 修饰方法的区别：

 传统的sefl函数需要实列化后才能使用，@staticmethod或@classmethod不需要实列化。
 传统的self函数可以直接使用 类.方法() 来调用@staticmethod或@classmethod函数

 @staticmethod 修饰的方法中不能交叉调用常规的self修饰的方法，可调用@classmethod的函数
 @staticmethod修饰的方法不是self作为第一个参数

 @classmethod  修饰的方法第一个参数cls代替 self   
 @classmethod  修饰的可以使用cls().f() 来交叉调用常规的self修饰的方法

class A(object):
    def foo1(self):
        print ("Hello 1")


      #静态的方法没有self传入参数,@staticmethod修饰的方法中不能调用常规的self修饰的方法
    @staticmethod
    def foo2(name): #@staticmethod没有self 参数
        print ("hello 2",name)
       #A.foo3('在foo2中调用foo3方法')
        
    @classmethod
    def foo3(cls,foo3_name): # @classmethod第一个参数不再是self
        print ("hello 3",foo3_name)
        #A.foo2('在foo3中使用cls()交叉调用foo2()函数')
        #cls().foo1()   #@classmethod调用传统的self方法
        
    def foo4(self):
        print('hell 4')
        self.foo1()
        A.foo2('staticmethod静态不使用self')   
        A.foo3('classmethod使用的标志是cls，而不是self')   
        
    @staticmethod    
    def foo22(foo22_name): # @classmethod第一个参数不再是self
        print ("hello 22",foo22_name)
        A.foo3('在foo22中使用调用foo3()函数')
    
    @classmethod
    def foo33(cls,foo33_name): # @classmethod第一个参数不再是self
        print ("hello 3",foo33_name)
        A.foo2('在foo3中使用cls()交叉调用foo2()函数')
        cls().foo1()   #@classmethod调用传统的self方法


a=A() #传统的self方法需要实例化后使用
a.foo1() #正常调用
   >>>Hello 1
a.foo4()
  >>>hell 4
  >>>Hello 1
  >>>hello 2 staticmethod静态不使用self
  >>>hello 3 classmethod使用的标志是cls，而不是self

#@staticmethod  @classmethod 不用实列化调用
#A.foo1() #报错
A.foo22('staticmethod静态不使用self')
  >>>hello 22 staticmethod静态不使用self
  >>>hello 3 在foo22中使用调用foo3()函数
A.foo33('classmethod使用的标志是cls，而不是self')
   >>>hello 3 classmethod使用的标志是cls，而不是self
   >>>hello 2 在foo3中使用cls()交叉调用foo2()函数
   >>>Hello 1