类变量：定义在类里面，通过类名或对象名引用，如果是通过对象名引用，会先找有没有这个同名的实例变量，如果没有，引用到的才是类变量，类变量的更新，只能通过类名，形如 类名.a = 55 ，不要指望通过实例引用类变量来更新类变量

实例变量： 定义在方法里面的变量，一般在__init__里面，只能通过对象名引用，实例变量的增加、更新形式，形如self.a = 55 

实例变量（静态属性）【实例名.实例变量名】

1、实例变量是构造函数下的变量带self.变量

2、实例变量为每个实例本身独有，不可相互调用、新增、修改、删除，不可被类调用、新增、修改、删除

3、可以访问类变量

4、如果同时有类变量和实例变量，程序执行时，先访问实例变量，实例变量存在，会使用实例变量，实例变量不存在，会使用类变量

5、实例改类变量，不可修改，实际是在实例内存里创建了实例变量

6、新增、修改、删除实例变量n，不会影响到类变量n

7、a实例不能调用b实例的变量

8、实例变量可修改、新增、删除

类变量【类名.类变量名】

1、类变量在class内，但不在class的方法内，存在类的内存里

2、类变量是该类所有实例共享的变量，但是实例对象只能访问，不可修改，每个实例对象去访问同一个类变量都将得到相同结果【实例名.类变量名】

3、新增、修改、删除类变量n，不会影响到实例变量n

4、类无权访问实例名

5、类变量可修改、新增、删除

class Test(object):
    name='类的姓名' #类变量
    address='类的地址'
    def __init__(self,name,age,sex):
        self.name=name  #实例变量
        self.age=age
        self.sex=sex
    def test1(self):
        print(self.name,Test.address)
    def test2(self):
        pass
Test1=Test('test1实例的姓名',22,'男')
Test2=Test('test2实例的姓名',33,'女')
print(Test1.name,Test1.address)
print(Test2.name,Test2.address)
print(Test.name)
print(Test.age)

#实验证明
#1、实例变量为每个实例独有，不可相互调用、新增、修改、删除，不可被类调用、新增、修改、删除
#2、如果同时有类变量和实例变量，程序执行时，先访问实例变量，实例变量存在，会使用实例变量，实例变量不存在，会使用类变量
#3、类无法访问实例变量



"C:\Program Files\Python35\python.exe" C:/Users/wangli/PycharmProjects/Test/Test/test.py
test1实例的姓名 类的地址
Traceback (most recent call last):
test2实例的姓名 类的地址
  File "C:/Users/wangli/PycharmProjects/Test/Test/test.py", line 98, in <module>
类的姓名
    print(Test.age)
AttributeError: type object 'Test' has no attribute 'age'

Process finished with exit code 1

class Test(object):
    name='类的姓名' #类变量
    address='类的地址'
    def __init__(self,name,age):
        self.name=name  #实例变量
        self.age=age
    def test1(self):
        print(self.name,Test.address)
    def test2(self):
        pass
Test1=Test('test1实例的姓名',22)
print('新增test1实例变量address为：test1实例的地址')
Test1.address='test1实例的地址' #新增实例变量
print('新增后test1实例变量address：',Test1.address)
print('新增后类变量address：',Test.address,'\n')
print('修改前test1实例变量age：',Test1.age)
print('修改test1实例变量age22为11')
Test1.age=11
print('修改后test1实例变量age：',Test1.age,'\n')


print('新增类变量age为：30')
Test.age=30 #新增类变量
print('新增后test1实例变量age：',Test1.age)
print('新增后类变量age：',Test.age,'\n')

print('修改前类变量address：',Test.address)
print('修改类变量address类的地址为上海市')
Test.address='上海市'
print('修改后类变量address：',Test.address,'\n')

#实验证明
#1、实例变量可修改、新增、删除
#2、类变量可修改、新增、删除
#3、新增、修改、删除实例变量n，不会影响到类变量n
#4、新增、修改、删除类变量n，不会影响到实例变量n


"C:\Program Files\Python35\python.exe" C:/Users/wangli/PycharmProjects/Test/Test/test.py
新增test1实例变量address为：test1实例的地址
新增后test1实例变量address： test1实例的地址
新增后类变量address： 类的地址 

修改前test1实例变量age： 22
修改test1实例变量age22为11
修改后test1实例变量age： 11 

新增类变量age为：30
新增后test1实例变量age： 11
新增后类变量age： 30 

修改前类变量address： 类的地址
修改类变量address类的地址为上海市
修改后类变量address： 上海市 


Process finished with exit code 0

1.类变量

下面介绍类变量的两种定义方式、两种读取方式、在类里面的调用方式

定义

1.类里定义的，与构造函数、普通函数是一个级别缩进的。（下面例子里的num）

2.在类外定义的，直接用类名.变量名新增类变量。（下面例子里的myvar）

读取

1.直接用类名的属性 获取：类名.类变量  （下面例子里的Member.num和Member.myvar）

2.先实例化类，实例化对象的属性 获取 ：实例对象.类变量 （下面例子里的M.num和M.myvar）

调用

1. 在类里面调用：类名.类变量，不能直接用类变量，即应为Member.num而不是num

# -*- coding: utf-8 -*-
class Member():
    num=2 #类变量,可以直接用类调用，或用实例对象调用
    def __init__(self,x,y):
        self.x=x  #实例变量（成员变量）,需要它是在类的构造函数内以self.开头来定义的
        self.y=y


    def add(self):
        total=2  #局部变量
        self.vara=3  # 虽是以self.给出，但并没有在构造函数中进行初始化
        self.varb=4
        fina=(self.x+self.y)*total
        return fina

    def fuc(self,a,b):
        self.varc=a #成员变量，他们在成员函数fuc()中定义
        self.vard=b
        self.x+=2
        self.y+=2
        self.vara+=3  
        self.varb+=Member.num

Member.myvar = 'huhuh'
print(Member.num,Member.myvar)

M=Member(1,2)
print(M.num,M.myvar)

2.实例（成员）变量

（1）构造函数里的成员变量：

定义：在__init__（self,成员变量）

读取：只能实例对象.成员变量，不能类名.成员变量，即只能M.x不能Member.x

调用：构造函数的成员变量，顾名思义：在类实例化的时候，就需要给该变量赋值。类里的普通函数可直接调用该变量，方式为：self.成员变量，

作用范围：类里面的全局变量，其值可以被其他函数修改

（2）普通函数里的成员变量

定义：在类里的普通函数def xxx（self,成员变量）

读取：只能实例对象.成员变量，不能类名.成员变量，即只能M.vara不能Member.vara

调用：方式为self.成员变量，只有在类实例化后调用该普通函数，此时，该成员变量才会生，看下面的例子：必须先调用add函数后，fuc函数里的self.vara和self.varb才会正常执行，不报错。

作用范围：类里面的全局变量，其值可以被其他函数修改

3.局部变量

局部变量相对就简单很多了，跟不在类里面的def函数的局部变量是一样的。

 作用范围：该函数内部

总结：成员函数

1.不同点

（1）构造函数里的成员变量，在类实例化之后，就可以使用

（2）在类里普通函数里的 成员变量，只能先调用该函数，才能使用该成员变量。

2.相同点：

（1）在类里，都是全局的

class A:
    # aa为类变量
    aa = 1
    # xy为实例变量
    def __init__(self, x, y):
        self.x = x
        self.y = y


if __name__ == '__main__':
    # a是实例A是一个类
    a = A(2, 4)
    # 这里面xy就是实例变量，aa为类变量，a.aa会优先查找对象的变量，找不到则向上查询类变量
    print(a.aa, a.x, a.y)
    print(A.aa)
    A.aa = 11
    print(a.aa)
    a.aa = 100
    print(a.aa)
    print(A.aa)

联系与区别

联系

Python类变量被赋值
（1）类的设计里，
class里def外，通过变量名能被赋值
def里通过类对象即类名字的点运算变量名可被赋值
（2）程序里
通过类对象(类名字)的点运算类名字也可被赋值
Python实例对象变量被赋值
（1）类的设计时
def里通过self点运算变量名能被赋值，不一定非在init里，其他已被调用的方法函数里也行
（2）程序里
通过实例对象的点运算变量名可被赋值

区别

类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象