精华内容
下载资源
问答
  • python类变量 实例变量

    2019-06-19 21:48:25
    [cp]Python 类变量 实例变量 ​​​[/cp]

    [cp]Python 

    类变量

    实例变量 ​​​[/cp]

    展开全文
  • 类变量: ​ 是可在类的所有实例之间共享...实例变量: 实例化之后,每个实例单独拥有的变量。 class Test(object): num_of_instance = 0 def __init__(self, name): self.name = name Test.num_of_ins

    类变量:

    ​ 是可在类的所有实例之间共享的值(也就是说,它们不是单独分配给每个实例的)。例如下例中,num_of_instance 就是类变量,用于跟踪存在着多少个Test 的实例。

    实例变量:

    实例化之后,每个实例单独拥有的变量。

    class Test(object):  
        num_of_instance = 0  
        def __init__(self, name):  
            self.name = name  
            Test.num_of_instance += 1  
      
    if __name__ == '__main__':  
        print Test.num_of_instance   # 0
        t1 = Test('jack')  
        print Test.num_of_instance   # 1
        t2 = Test('lucy')  
        print t1.name , t1.num_of_instance  # jack 2
        print t2.name , t2.num_of_instance  # lucy 2

    补充的例子

    class Person:
        name="aaa"
    
    p1=Person()
    p2=Person()
    p1.name="bbb"
    print p1.name  # bbb
    print p2.name  # aaa
    print Person.name  # aaa

    这里p1.name="bbb"是实例调用了类变量,这其实和上面第一个问题一样,就是函数传参的问题,p1.name一开始是指向的类变量name="aaa",但是在实例的作用域里把类变量的引用改变了,就变成了一个实例变量,self.name不再引用Person的类变量name了.

    可以看看下面的例子:

    class Person:
        name=[]
    
    p1=Person()
    p2=Person()
    p1.name.append(1)
    print p1.name  # [1]
    print p2.name  # [1]
    print Person.name  # [1]
    展开全文
  • 类变量: ​ 是可在类的所有实例之间共享的值(也就是说,它们不是单独分配给每个实例的...实例变量: 实例化之后,每个实例单独拥有的变量。 class Test(object): num_of_instance = 0 def __init...

    类变量:

    ​ 是可在类的所有实例之间共享的值(也就是说,它们不是单独分配给每个实例的)。例如下例中,num_of_instance 就是类变量,用于跟踪存在着多少个Test 的实例。

    实例变量:

    实例化之后,每个实例单独拥有的变量。

    class Test(object):  
        num_of_instance = 0  
        def __init__(self, name):  
            self.name = name  
            Test.num_of_instance += 1  
      
    if __name__ == '__main__':  
        print Test.num_of_instance   # 0
        t1 = Test('jack')  
        print Test.num_of_instance   # 1
        t2 = Test('lucy')  
        print t1.name , t1.num_of_instance  # jack 2
        print t2.name , t2.num_of_instance  # lucy 2

    补充的例子

    class Person:
        name="aaa"
    
    p1=Person()
    p2=Person()
    p1.name="bbb"
    print p1.name  # bbb
    print p2.name  # aaa
    print Person.name  # aaa

    这里p1.name="bbb"是实例调用了类变量,这其实和上面第一个问题一样,就是函数传参的问题,p1.name一开始是指向的类变量name="aaa",但是在实例的作用域里把类变量的引用改变了,就变成了一个实例变量,self.name不再引用Person的类变量name了.

    可以看看下面的例子:

    class Person:
        name=[]
    
    p1=Person()
    p2=Person()
    p1.name.append(1)
    print p1.name  # [1]
    print p2.name  # [1]
    print Person.name  # [1]

    转载于:https://www.cnblogs.com/xuxueqin/p/8065988.html

    展开全文
  • ref: http://c.biancheng.net/view/2283.html https://www.cnblogs.com/crazyrunning/p/6945183.html ... 学过C++ 或java等强类型,编译型语言,再去学Python类设计时感觉非常不适应,因为Python...
    ref:
    http://c.biancheng.net/view/2283.html
    https://www.cnblogs.com/crazyrunning/p/6945183.html
    https://cloud.tencent.com/developer/article/1527548

    学过C++ 或java等强类型,编译型语言,再去学Python类设计时感觉非常不适应,因为Python是在太自由了,让人无所适从,来Python定义类变量、实例对象变量的定义方式、作用域、访问方法的不同吧。

    Python变量的本质:被赋值
    1 普通python变量(非类相关变量)很容易理解,在被赋值后即变量存在,可读可写
    2 Python类的变量(类变量和实例对象变量)以某种方式在某地方被赋值,即存在,可被读写

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

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

    在类体中,根据变量定义的位置不同,以及定义的方式不同,类属性又可细分为以下 3 种类型:

        类体中、所有函数之外:此范围定义的变量,称为类属性或类变量;
        类体中,所以函数内部:以“self.变量名”的方式定义的变量,称为实例属性或实例变量;
        类体中,所有函数内部:以“变量名=变量值”的方式定义的变量,称为局部变量。


    类变量(类属性)

    类变量指的是在类中,但在各个类方法外定义的变量。
     类变量的特点是,在类的所有实例之间共享的变量,也就是说,类变量在所有实例化对象中是作为公用资源存在的,不是单独分配给每个实例的。类方法的调用方式有 2 种,既可以使用类名直接调用,也可以使用类的实例化对象调用。
      注意,因为类变量为所有实例化对象共有,通过类名修改类变量的值,会影响所有的实例化对象。
      python独特的动态语言的灵活性,还可以随时随地动态地为类和对象添加类变量。

    实例变量(实例属性)

    实例变量指的是在任意类方法内部,以“self.变量名”的方式定义的变量,其特点是实例化之后,每个实例单独拥有一份的变量,只作用于调用方法的对象。另外,实例变量只能通过对象名访问,无法通过类名访问。
    通过类对象访问类变量(instance.__class__.value),通过类对象修改类变量的值 (instance.value)很可能是定义新的实例变量。
    Python还支持为特定的实例对象添加实例变量,在类体外,运行的时候。这种场景新增的特定的实例变量只对该特定实例对象生效,其他实例对象不受影响。

    局部变量

    除了实例变量,类方法中还可以定义局部变量,注意局部变量只存在于def内,在def内定义的不带self的变量。和前者不同,局部变量直接以“变量名=值”的方式进行定义,例如:

        class CLanguage :
            # 下面定义了一个say实例方法
            def count(self,money):
                sale = 0.8*money
                print("优惠后的价格为:",sale)
        clang = CLanguage()
        clang.count(100)

    通常情况下,定义局部变量是为了所在类方法功能的实现。需要注意的一点是,局部变量只能用于所在函数中,函数执行完成后,局部变量也会被销毁。

    class student():
        age = 0   # 注意这里class内函数外的age/name:python语言跟其他语言不同的是,这里定义的是类变量,而其他语言定义的是实例变量
        name = 'stu'
        # age,name是类变量
        def __init__(self,age,name):
            self.age = age
            self.name = name
        # 访问实例变量(用self.age  self.name)
    
    student1 = student(18,'hello')
    print(student1.name)
    # 打印实例变量,输出hello
    print(student.name)  
    # 打印类变量,输出stu
    
    In [2]: class Student():
       ...:     name = "张三"
       ...:     age = 0
       ...:     def __init__(self, name, age):
       ...:         name = name
       ...:         age = age
       ...:         
    
    In [3]: student = Student("李四", 19)
    
    In [4]: student.name
    Out[4]: '张三'
    
    In [5]: Student.name
    Out[5]: '张三'
    
    
    是实例变量和类变量的区别问题。
    
    我们接着看看对象student的变量有哪些:
    In [6]: student.__dict__
    Out[6]: {}
    
    为空!
    
    为什么为空呢?(暂时思考下)
    我们再看看类Student的变量:
    In [7]: Student.__dict__
    Out[7]:
    mappingproxy({'__dict__': <attribute '__dict__' of 'Student' objects>,
                  '__doc__': None,
                  '__init__': <function __main__.Student.__init__>,
                  '__module__': '__main__',
                  '__weakref__': <attribute '__weakref__' of 'Student' objects>,
                  'age': 0,
                  'name': '张三'})

    这里我们要说一下实例变量的查找机制:
    当在实例变量中查找不到某一变量时候,就会去类变量里查找,当再查找不到的时候就会在父类中查找,因此输出的name为张三。
    之所以为空,是因为我们实例化对象的时候为指明实例变量的保存。现在修改一下实例化函数。

    
    In [10]: class Student():
        ...:     name = "张三"
        ...:     age = 0
        ...:     def __init__(self, name, age):
        ...:         self.name = name
        ...:         self.age = age
        ...:         
        ...:         
        ...:         
    
    In [11]: student = Student("李四", 19)
    
    In [12]: student.name
    Out[12]: '李四'
    
    In [13]: Student.name
    Out[13]: '张三'

    我们传入的self只和实例化的对象有关和类无关,代表实例。
    如何在实例方法中调用类变量呢?
     

    In [14]: class Student():
        ...:     name = "张三"
        ...:     age = 0
        ...:     sums = 123
        ...:     def __init__(self, name, age):
        ...:         self.name = name
        ...:         self.age = age
        ...:         print(Student.sums)
        ...:         print(self.__class__.sums)
        ...:         
        ...:         
        ...:         
        ...:         
    
    In [15]: student = Student('李四', 19)
    123
    123
    
    
    class Person():
        person = 'alive' #这是类变量
        def __init__(self,name ,age):
            self.name = name #这是实例变量
            self.age = age   #这是实例变量
            self.gender = '男' #这是实例变量
            #a = 456     # 这种写法a是def内的局部变量,不是类属性,不是实例属性,类外引用都会报错
        place = ['地球','中国'] #这是类变量
    
    # 若要在def内定义类属性,只有两种方式,如下:
    >>> class Person():
        person = 'alive' #这是类变量
        def __init__(self,name ,age):
            self.name = name #这是实例变量
            self.age = age   #这是实例变量
            self.gender = '男' #这是实例变量
            Person.a = 456     #不能写这里,会出错
            self.__class__.b = 'hello'
    
            
    >>> p1 = Person('wa', 18)
    >>>
    >>> p1.b
    'hello'
    >>> p1.a
    456
    >>> Person.a
    456
    >>> Person.b
    'hello'
    >>>
    class aa:
        w = 10
    
        def __init__(self):
            self.x = 11
            self.y = 12
    
        def add(self):
            return self.x + self.y
    
    
    a = aa()
    print (a.add())  //输出23
    
    # 下边两条指令各起何作用?结果是输出两个 20 么?还是两个13?还是?
    aa.w = 20  # 修改类变量w值
    a.w = 13  # 新增实例变量w
    print (aa.w, a.w)  //输出20 13,注意:原因是当类变量与实例变量同名时,实例方式访问时会优先访问实例变量
    
    # 程序继续增加如下,怎样理解这t和q呢?他们是实例变量
    a.t = 14
    a.q = 15
    print (a.t, a.q)  //输出14 15
    
    # 程序继续增加如下,怎样理解这m和n呢?他们是类变量
    aa.m = 30
    aa.n = 40
    print (aa.m, aa.n)  //输出30 40
    
    # 好了再来个提升吧
    # 程序继续增加,下列三个print语句都能正确执行么?为何?
    b = aa()
    print (b.x, b.y)  //正确输出11 12
    print (b.t, b.q) //出错,因为不是一个实例了
    print (b.m, b.n) //正确输出30 40


    实例变量(静态属性)【实例名.实例变量名】

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

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

    3、可以访问类变量

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

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

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

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

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

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

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

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

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

    4、类无权访问实例名

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

    展开全文
  • Python类变量实例变量区别 深入理解python类的实例变量和类变量   Python变量的本质:被赋值1 普通python变量(非类相关变量)很容易理解,在被赋值后即变量存在,可读可写2 Python类的变量(类变量...
  • Python类变量实例变量Demo参考 Demo class A(object): va = 10 def foo(self): print (A.va) #打印类变量 print (self.va) #使用self.类变量方式访问类变量 self.va = 40 #对实例变量赋值 与类变量同名而已...
  • python类变量实例变量 https://blog.csdn.net/qq_37315403/article/details/81539340 类变量 类的所有实例对象之间共享的变量,但是实例对象只能访问,不可修改。每个实例对象去访问同一个类变量都将得到相同结果...
  • import random class artell(): def _init_(self,hp,wpn): self.hp = 10 .............. robot = artell() robot.hp = robot.hp -1 (变量初始化,实例化后怎么修改)
  • python类变量实例变量,顾名思义,类变量是指跟类的变量,而实例变量,指跟类的具体实例相关联的变量,具体体现为self.x 等。实际要注意的类变量实例变量之间的关联。和类方法可以通过类也可以通过实例访问...
  • 实例变量类变量实例变量是对于每个实例都独有的属性,类变量是一个类所有实例共享的属性 class DogClass(): address = 'Beijing' # address就是一个类变量 def __init__(self, name): self.name = name # ...
  • 今天在看python的类和实例的时候,突然发现了一个以前遗漏的点,也就是类变量实例变量。首先需要理解一下类变量实例变量的概念。 类全局变量:在类中定义,对类和由类生成的实例生效,如果通过方法对类变量...
  • 在Father类中有两个变量: num是类变量,d是实例变量。因此在num可以通过类名进行访问,而d不能通过类名访问,但可以通过实例访问d(self是代表类的实例化,因此是可以通过self访问d的) class Father(): num = ...
  • Python类变量实例变量(类属性和实例属性) 目录 类变量(类属性) 实例变量(实例属性) 局部变量 转载:http://c.biancheng.net/view/2283.html 无论是类属性还是类方法,都无法向普通变量或者函数那样...
  • python类的变量类型分为:类变量实例变量(也叫它成员变量)、局部变量 举个栗子: class Test: var01 = "我是类变量" def __init__(self): var02 = "我是实例变量" def myfunction(self): var03 = ...
  • 在Java中,静态变量 (在Python中叫属性) 和实例变量 (在Python中叫数据属性) 两者都是紧跟在定义之后定义的 ;在Python中,只有属性可以定义在这里,数据属性定义在__init__方法中。 属性可以作为...
  • 类变量 不可变变量作为类变量:对于INT,STRING这种不可变变量,如果将其作为...实例变量 不管是可变变量还是不可变变量,只要是放在构造函数中,则都是传值。即各个对象拥有自己的对象属性。 示例代码及说明 cl...
  • Python类变量实例变量学习笔记

    万次阅读 2020-06-19 16:51:39
    class A: # aa为类变量 aa = 1 # xy为实例变量 def __init__(self, x, y): ... # 这里面xy就是实例变量,aa为类变量,a.aa会优先查找对象的变量,找不到则向上查询类变量 print(a.aa, a.x, a.y)
  • 类变量:可在类的所有实例之间共享的值(也就是说,它们不是单独分配给每个实例的)。 实例变量:实例化之后,每个实例单独拥有的变量。 ...Python类的变量(类变量和实例对象变量)以...Python类变量被赋值 (1)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,684
精华内容 1,873
关键字:

python类变量实例变量

python 订阅