精华内容
下载资源
问答
  • python的类变量和成员变量

    万次阅读 多人点赞 2014-08-22 15:55:53
    先看看python的类变量和成员变量。见下面代码: class TestClass(object): val1 = 100 def __init__(self): self.val2 = 200 def fcn(self,val = 400): val3 = 300 self.val4 = val

    先看看下面代码:

    class TestClass(object):
        val1 = 100
        
        def __init__(self):
            self.val2 = 200
        
        def fcn(self,val = 400):
            val3 = 300
            self.val4 = val
            self.val5 = 500 
     if __name__ == '__main__':
        inst = TestClass()
         
        print TestClass.val1
        print inst.val1
        print inst.val2
        print inst.val3
        print inst.val4    
        print inst.val5
    这里,val1是类变量,可以由类名直接调用,也可以有对象来调用;

    val2是成员变量,可以由类的对象来调用,这里可以看出成员变量一定是以self.的形式给出的,因为self的含义就是代表实例对象;

    val3不是成员变量,它只是函数fcn内部的局部变量;

    val4和val5也都不是成员变量,虽是以self.给出,但并没有在构造函数中初始化。

    再看看下面的代码(#号后面的是运行结果):

        inst1 = TestClass()
        inst2 = TestClass()
         
        print TestClass.val1 # 100
        print inst1.val1     # 100
        
        inst1.val1 = 1000    
        print inst1.val1     # 1000
        print TestClass.val1 # 100
        
        TestClass.val1 =2000 
        print inst1.val1     # 1000
        print TestClass.val1 # 2000
        
        print inst2.val1     # 2000     
        
        inst3 = TestClass()  
        print inst3.val1     # 2000

    可以发现:python的类变量和C++的静态变量不同,区别在于python的对象使用类变量时,会进行一次内存拷贝。python中,类本身拥有自己的类变量(保存在内存),当对象第一次调用类变量时,会将当前类变量拷贝一份给这个对象,当前类变量的值是多少,这个对象拷贝得到的类变量的值就是多少;而且,通过对象来修改类变量,并不会影响其他对象的类变量的值,因为大家都有各自的副本,更不会影响类本身所拥有的那个类变量的值;只有类自己才能改变类本身拥有的类变量的值。


    有一点值得注意:对象的类变量是什么时候初始化的(从类的类变量拷贝过来)?通过上例中inst2.val1的打印结果是2000可以发现,对象的类变量并不是构造对象的时候初始化的,而是在第一次通过对象调用该类变量的时候从类变量当前的值拷贝过来的。此后便互不影响。




    展开全文
  • 本文实例形式讲解了python的类变量和成员变量用法,对于Python程序设计有一定的参考价值。分享给大家供大家参考。具体如下: 先看看下面这段代码: class TestClass(object): val1 = 100 def __init__(self): ...
  • python的类变量和成员变量用法

    千次阅读 2015-06-27 23:11:20
    本文实例形式讲解了python的类变量和成员变量用法,对于Python程序设计有一定的参考价值。分享给大家供大家参考。具体如下: 先看看下面这段代码: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ...

    本文实例形式讲解了python的类变量和成员变量用法:

    class TestClass(object):
      val1 = 100
       
      def __init__(self):
        self.val2 = 200
       
      def fcn(self,val = 400):
        val3 = 300
        self.val4 = val
        self.val5 = 500
     if __name__ == '__main__':
      inst = TestClass()
        
      print TestClass.val1
      print inst.val1
      print inst.val2
      print inst.val3
      print inst.val4  
      print inst.val5

    这里,val1是类变量,可以由类名直接调用,也可以有对象来调用;
    val2是成员变量,可以由类的对象来调用,这里可以看出成员变量一定是以self.的形式给出的,因为self的含义就是代表实例对象;
    val3不是成员变量,它只是函数fcn内部的局部变量;
    val4和val5也都不是成员变量,虽是以self.给出,但并没有在构造函数中初始化。

    再看看下面的代码(#号后面的是运行结果):

    inst1 = TestClass()
    inst2 = TestClass()
     
    print TestClass.val1 # 100
    print inst1.val1   # 100
     
    inst1.val1 = 1000 
    print inst1.val1   # 1000
    print TestClass.val1 # 100
     
    TestClass.val1 =2000
    print inst1.val1   # 1000
    print TestClass.val1 # 2000
     
    print inst2.val1   # 2000   
     
    inst3 = TestClass() 
    print inst3.val1   # 2000
    可以发现:python的类变量和C++的静态变量不同,并不是由类的所有对象共享。类本身拥有自己的类变量(保存在内存),当一个TestClass类的对象被构造时,会将当前类变量拷贝一份给这个对象,当前类变量的值是多少,这个对象拷贝得到的类变量的值就是多少;而且,通过对象来修改类变量,并不会影响其他对象的类变量的值,因为大家都有各自的副本,更不会影响类本身所拥有的那个类变量的值;只有类自己才能改变类本身拥有的类变量的值



    展开全文
  • Python的类变量可以通过类和实例名字进行访问而成员变量只能通过实例名来访问,局部变量只能在方法体内被使用。http://blog.csdn.net/lc_910927/article/details/38757363类变量和成员变量虽然名字相同但是存储的...

    Python的类变量可以通过类和实例名字进行访问而成员变量只能通过实例名来访问,局部变量只能在方法体内被使用。

    http://blog.csdn.net/lc_910927/article/details/38757363

    类变量和成员变量虽然名字相同但是存储的地址不是相同的。

    # -*- coding: utf-8 -*-
    class A():
        privatestring="aa"
        def __init__(self,value,privatevalue):
            self.name=value
            self.privatestring=privatevalue
        def change_privatestring(value):
            A.privatestring=value
    AAA=A("AA","BB")
    print(A.privatestring)
    print(AAA.privatestring)
    print(A.change_privatestring("CCC"))
    print(A.privatestring)
    print(AAA.privatestring)
    print(A.__dict__)
    print(AAA.__dict__)

    输出结果:

    /usr/bin/python3.5 /home/liusenubuntu/PycharmProjects/sentence/segment/privatelearn.py
    aa
    BB
    None
    CCC
    BB
    {'__module__': '__main__', '__init__': <function A.__init__ at 0x7fb1fefad8c8>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__dict__': <attribute '__dict__' of 'A' objects>, 'change_privatestring': <function A.change_privatestring at 0x7fb1fefadae8>, 'privatestring': 'CCC', '__doc__': None}
    ----------------------
    {'name': 'AA', 'privatestring': 'BB'}
    
    Process finished with exit code 0
    

    类变量是全局变量,一次修改,所有实例化对象的值全部修改
    跟Java进行对比:

    package classlearn;
    
    public class Node {
        public static int a=1;
    }
    package classlearn;
    
    public class TestNode {
    public static void main(String[] args) {
        Node nodeA=new Node();
        nodeA.a=2;
        System.out.println(nodeA.a);
        Node nodeB=new Node();
        System.out.println(nodeB.a);
        Node nodeC=new Node();
        System.out.println(nodeC.a);
    }
    }
    

    实验结果:

    2
    2
    2
    
    # -*- coding: utf-8 -*-
    class A():
        privatestring="aa"
        def __init__(self,value):
            self.name=value
        def change_privatestring(value):
            A.privatestring=value
    AAA=A("AA")
    print(A.privatestring)
    print(AAA.privatestring)
    BBB=A("BB")
    A.change_privatestring("BBB")
    print(A.privatestring)
    print(AAA.privatestring)
    print(BBB.privatestring)
    print(AAA.change_privatestring("CCC"))

    输出结果:

    /usr/bin/python3.5 /home/liusenubuntu/PycharmProjects/sentence/segment/privatelearntwo.py
    aa
    aa
    BBB
    BBB
    BBB
    Traceback (most recent call last):
      File "/home/liusenubuntu/PycharmProjects/sentence/segment/privatelearntwo.py", line 16, in <module>
        print(AAA.change_privatestring("CCC"))
    TypeError: change_privatestring() takes 1 positional argument but 2 were given
    
    Process finished with exit code 1
    

    普通方法不能被实例化对象调用。

    展开全文
  • Python的类变量和成员变量

    万次阅读 多人点赞 2015-07-07 10:21:40
    本文实例形式讲解了python的类变量和成员变量用法,对于Python程序设计有一定的参考价值。分享给大家供大家参考。具体如下: 先看看下面这段代码: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 ...

    本文实例形式讲解了python的类变量和成员变量用法,对于Python程序设计有一定的参考价值。分享给大家供大家参考。具体如下:

    先看看下面这段代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    class TestClass(object):
      val1 = 100
       
      def __init__(self):
        self.val2 = 200
       
      def fcn(self,val = 400):
        val3 = 300
        self.val4 = val
        self.val5 = 500
     if __name__ == '__main__':
      inst = TestClass()
        
      print TestClass.val1
      print inst.val1
      print inst.val2
      print inst.val3
      print inst.val4 
      print inst.val5

    这里,val1是类变量,可以由类名直接调用,也可以有对象来调用;
    val2是成员变量,可以由类的对象来调用,这里可以看出成员变量一定是以self.的形式给出的,因为self的含义就是代表实例对象;
    val3不是成员变量,它只是函数fcn内部的局部变量;
    val4和val5也都不是成员变量,虽是以self.给出,但并没有在构造函数中初始化。

    再看看下面的代码(#号后面的是运行结果):

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    inst1 = TestClass()
    inst2 = TestClass()
     
    print TestClass.val1 # 100
    print inst1.val1   # 100
     
    inst1.val1 = 1000 
    print inst1.val1   # 1000
    print TestClass.val1 # 100
     
    TestClass.val1 =2000
    print inst1.val1   # 1000
    print TestClass.val1 # 2000
     
    print inst2.val1   # 2000  
     
    inst3 = TestClass()
    print inst3.val1   # 2000
    可以发现:python的类变量和C++的静态变量不同,并不是由类的所有对象共享。类本身拥有自己的类变量(保存在内存),当一个TestClass类的对象被构造时,会将当前类变量拷贝一份给这个对象,当前类变量的值是多少,这个对象拷贝得到的类变量的值就是多少;而且,通过对象来修改类变量,并不会影响其他对象的类变量的值,因为大家都有各自的副本,更不会影响类本身所拥有的那个类变量的值;只有类自己才能改变类本身拥有的类变量的值
    展开全文
  • python 的类中主要会使用的两种变量:类变量与成员变量。类变量是类所有实例化对象共有的,而成员...后来联想到java的类有类变量也有实例变量,因此翻阅了相关资料,发现python也有类似的类变量和实例变量,下面来看看详
  • class Member(): num=0 #类变量,可以直接用类调用,或用实例对象调用 ... self.x=x #实例变量(成员变量),需要它是在类构造函数内以self.开头来定义 self.y=y self.fuc(self.x,self.y) def a...
  • 后来联想到java的类有类变量也有实例变量,因此翻阅了相关资料,发现python也有类似的类变量和实例变量,下面来看看详细的介绍。 看下面的示例代码: class A: x = 0 def __init__(self): self.y = 0 x就是类...
  • Python 类变量和成员变量 类与对象方法 我们已经讨论了类与对象功能部分,现在我们来看一下它数据部分。事实上,它们只是与类和对象名称空间 绑定 普通变量,即这些名称只在这些类与对象前提下有效。 有...
  • 讲的是类变量和成员变量的影响原因,但原文并没有讲明详细原因,只是讲清楚了类变量与成员变量影响的结论,由于前几日看了《Python学习手册》这本书了解了一下Python的数据储存机制,然后自己想并且试验了一下,大致...
  • 主要帮助大家理解java和python类变量以及类的成员变量,用实例进行解析,感兴趣朋友可以参考一下
  • #encoding:utf-8 class TestClass(object): classval1 = 100 #类变量 def __init__(self): self.memval2 = 200 #成员变量 def memfuntion(self,val = 400): localval3 = 300 #函数内部局部变量 self.nmval
  • python类变量和成员变量、局部变量总结 转载自:https://www.cnblogs.com/clarenceyang/p/9685543.html 作者: 勿忘-前行 class Member(): num=0 #类变量,可以直接用类调用,或用实例对象调用 def __init__(self,...

空空如也

空空如也

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

python的类变量和成员变量

python 订阅