class 类的小总结

一、类的变量

001、类的基本方法和变量

01、类里面有：
    类方法（实例方法）：分为"静态方法"和"类方法"，还有"成员方法"
    类变量（也叫静态变量）：每一个被创建的对象都有这个类变量，可以通过"obj.类变量名" 来访问
    实例变量(也叫字段)：每个对象在创建的时候，都需要__init__（self） 初始化，然后拥有这个类的实例变量
02、修改类的类变量需要用类来改变：
    Person.aper="修改类变量"   那么，对象访问这个类变量时（obj.aper），将会显示修改后的 "修改类变量"
03、修改实例变量可以用对象来改变，但是只针对"当前这个对象"  有用,比如：p1.name="小明"，则p1.name="小"，  p2.name="原来的实例变量名"  p2 还是显示原来创建对象时的名字

看下面的代码：

class Person:
    count=0
    aper="你好" # 这个是类变量
    def __init__(self,name,age): # 实例方法或则类方法
        self.name=name  # 实例变量，创建的对象都有这几个变量
        self.age=age
        Person.count+=1

    def dig(self): # 实例方法或成员方法
        aper="dog的你好"
        print("实力方法dig")



print(Person.count)
p1=Person("ming",12)
p1.aper="你不好"
# 通过对象访问 类变量和 实例变量
print(p1.name)
print(p1.aper)

Person.aper="你好的啊"

p2=Person("ok",24)
print(p2.aper)

print(Person.count)
结果显示：
''' 
0
ming
你不好
你好的啊
2
'''

002、类里面的方法的说明

01、类里面有：
    类方法（实例方法）：分为"静态方法"和"类方法"，还有"成员方法"
    
    类变量（也叫静态变量）：每一个被创建的对象都有这个类变量，可以通过"obj.类变量名" 来访问
    实例变量(也叫字段)：每个对象在创建的时候，都需要__init__（self） 初始化，然后拥有这个类的实例变量

A、成员方法：其实就是对象能直接方法 (obj.method（）) 访问

class Person:
    count=0
    aper="你好" # 这个是类变量
    def __init__(self,name,age): # 实例方法或则类方法
        self.name=name  # 实例变量，创建的对象都有这几个变量
        self.age=age
        Person.count+=1

    def dig(self): # 实例方法或成员方法
        aper="dog的你好"
        print("实力方法dig")
# 访问成员方法，也就是实例方法 dig()
p1=Person("ming",45)
p1.dig()  # 打印：  实力方法dig

B、静态方法（staticmethod），其实就是不用给他传递参数self，不需要使用成员变量，但是需要在这个方法上加上 @staticmethod 就是静态方法了,

关于访问静态方法,特别提醒

一般是使用   "类名.静态方法()"  访问，例如下面的
Person.func()  # 打印：  静态方法

p1.func() # 对象也可以访问. 但最好不要这么⼲. 以便于区分静态⽅法和实例⽅法

class Person:
    count=0
    aper="你好" # 这个是类变量
    def __init__(self,name,age): # 实例方法或则类方法
        self.name=name  # 实例变量，创建的对象都有这几个变量
        self.age=age
        Person.count+=1

    def dig(self): # 实例方法或成员方法
        aper="dog的你好"
        print("实力方法dig")
    
    @staticmethod  # 静态方法，不需要传值
    def func():
        print("静态方法")
        
# 访问静态方法：
Person.func()  #   # 打印：  静态方法

C、 类方法，在被调用的时候，也不需要传递值，但是会给其默认为一个参数 cls ，在传递的时候，自动将类传递给这个cls，同时需要在这个方法上加上 @classmethod 来说明这是一个 类方法

class Person:
    count=0
    aper="你好" # 这个是类变量
    def __init__(self,name,age): # 实例方法或则类方法
        self.name=name  # 实例变量，创建的对象都有这几个变量，对象可以直接访问
        self.age=age
        Person.count+=1

    def dig(self): # 实例方法或则类方法
        aper="dog的你好"
        print("实力方法dig")

    @staticmethod  # 静态方法
    def func():
        print("静态方法")

    @classmethod
    def func02(cls,a,b):
        print("类方法的类为：",cls)
        return a+b


p1=Person("ming",45)
# 通过对象访问 类方法,不建议使用对象反问类方法和静态方法，这样利于区分 实力方法和类方法，静态方法
print(p1.func02(1,2))  # 类方法的类为： <class '__main__.Person'>   3

# 通过类访问 类方法
print(Person.func02(2,3))  # 类方法的类为： <class '__main__.Person'>    5

003、私有变量，对象不能直接访问

class Person:
    count=0
    aper="你好" # 这个是类变量
    def __init__(self,name,age,addr): # 实例方法或则类方法
        self.name=name  # 实例变量，创建的对象都有这几个变量
        self.age=age
        Person.count+=1
        self.__addr=addr

    def dig(self): # 实例方法或则类方法
        aper="dog的你好"
        print("实力方法dig")

    @staticmethod  # 静态方法
    def func():
        print("静态方法")

    @classmethod
    def func02(cls,a,b):
        print("类方法的类为：",cls)
        return a+b


p1=Person("小白",14,"大街一号")
# 对象访问实例变量 # 可以直接访问
print(p1.name)    # 小白
print(p1.age)     # 14
# 对象访问私有变量  # 会报错，不能访问
# print(p1.__addr)   # AttributeError: 'Person' object has no attribute 'addr'
# 类访问私有变量  # 也不能访问
print(Person("小黑",45,"大街34号").__addr)  # AttributeError: 'Person' object has no attribute '__addr'

A、通过公共方法来访问私有变量

class Person:
    count=0
    aper="你好" # 这个是类变量
    def __init__(self,name,age,addr): # 实例方法或则类方法
        self.name=name  # 实例变量，创建的对象都有这几个变量
        self.age=age
        Person.count+=1
        self.__addr=addr

    # 定义公共方法来访问私有变量
    def  gongg(self):
        print("公共方法访问私有变量")
        return self.__addr
    
    
    def dig(self): # 实例方法或则类方法
        aper="dog的你好"
        print("实力方法dig")

    @staticmethod  # 静态方法
    def func():
        print("静态方法")

    @classmethod
    def func02(cls,a,b):
        print("类方法的类为：",cls)
        return a+b
# 对象通过公共方法访问私有变量
p1=Person("小白",14,"大街一号")
print(p1.gongg())  # 打印： 公共方法访问私有变量     大街一号

# 类通过公共方法访问私有变量
print(Person("小黑",45,"大街34号").gongg())  # 打印：  公共方法访问私有变量   大街34号

004、私有方法 也就是单下划线的方法 def __func02(self): 这种。私有方法只能类中自己调用（方法之间互相调用）

class Person:
    count=0
    aper="你好" # 这个是类变量
    def __init__(self,name,age,addr): # 实例方法或则类方法
        self.name=name  # 实例变量，创建的对象都有这几个变量
        self.age=age
        Person.count+=1
        self.__addr=addr

    # 定义公共方法来访问私有变量
    def  gongg(self):
        print("公共方法访问私有变量")
        return self.__addr

    def dig(self): # 实例方法或则类方法
        aper="dog的你好"
        print("实力方法dig")

    @staticmethod  # 静态方法
    def func():
        print("静态方法")

    @classmethod
    def func02(cls,a,b):
        print("类方法的类为：",cls)
        return a+b

    # 定义私有方法
    def __func02(self):
        print("这个是私有方法")
p1=Person("小白",14,"大街一号")

# 对象访问私有方法,无法访问
print(p1.__func03)  # 报错：AttributeError: 'Person' object has no attribute '__func03'

# 类访问私有方法，无法访问
print(Person.__func03)  # AttributeError: type object 'Person' has no attribute '__func03'

B、同理需要访问的话，可以定义公共的成员方法来访问这个私有方法

class Person:
    count=0
    aper="你好" # 这个是类变量
    def __init__(self,name,age,addr): # 实例方法或则类方法
        self.name=name  # 实例变量，创建的对象都有这几个变量
        self.age=age
        Person.count+=1
        self.__addr=addr

    # 定义公共方法来访问私有变量
    def  gongg(self):
        print("公共方法访问私有变量")
        return self.__addr

    def dig(self): # 实例方法或则类方法
        aper="dog的你好"
        print("实力方法dig")

    @staticmethod  # 静态方法
    def func():
        print("静态方法")

    @classmethod
    def func02(cls,a,b):
        print("类方法的类为：",cls)
        return a+b

    # 定义私有方法
    def __func03(self):
        print("这个是私有方法")

    # 定义公共的开放方法来访问这个私有方法
    def open(self):
        return self.__func03()



p1=Person("小白",14,"大街一号")

# 对象通过开放方法来访问私有方法
p1.open()

# 类通过开放方法来访问私有方法
Person("ming",45,"四号街").open()