函数中的：局部变量，全局变量 类中的：类变量和成员变量。

最新推荐文章于 2022-12-15 20:57:15 发布
最新推荐文章于 2022-12-15 20:57:15 发布
阅读量284 收藏
点赞数 2
文章标签： 类、局部变量、成员变量、全局变量、类变量
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjinyyzyq/article/details/85100695
版权

最好别让类变量和成员变量具有相同的名字， 以区别。：这应该是最好的解决方案

== 无论是对于任何变量、在内层变量未重新赋值的前提下，可以将外层变量的值优先赋值给同名的局部变量==
== 全局变量具有==
1 入侵性 可入侵赋值给局部变量
2 可阻拦性 可被内部赋值阻拦

函数（局部、全局）

通常函数中的变量就可以认为是程序中的局部变量
我们可以将每个函数都是一个工厂，至于工厂中发生了什么我们是不用关心的
函数的调用->执行性质 决定了其存在的独立性。
通常情况下这种隔离不会被打破（在函数中定义global变量除外、一般情况下们也不会在自己的程序中加入这种易乱的变量）

非常规情况

1：代码如下
if __name__== '__main__':
    a = [1]
    def test():
        a.append(2)
    if __name__ == '__main__':
        print(a, id(a))
        test()
        print(a, id(a))
result:
[1] 140681844497672
[1, 2] 140681844497672

这里可以明显看到全局变量被局部变量给修改了

if __name__== '__main__':
    a = 1
    def test():
        global a
        a += 1
    def test_1(a):
        a += 5
        print(a)
    if __name__ == '__main__':
        print(a, id(a))
        test()
        print(a, id(a))
        test_1(2)
        print(a, id(a))
result:
1 94409945545248
2 94409945545280
7
2 94409945545280



if __name__== '__main__':
    a = 1
    b = 3
    def test():
        
        a = b+1
    def test_1(a):
        a += 5
        print(a)
    if __name__ == '__main__':
        print(a, id(a))
        test()
        print(a, id(a))
        test_1(2)
        print(a, id(a))
result:
1 94409945545248
1 94409945545248
7
1 94409945545248

产生上述两种不同的根本原因如下

链接: link

类（类变量、成员变量）

类在一定程度上自成体系，自己定义了一个小型生态圈；类是一种可以含有函数工厂的生态圈。

函数只是类的方法
类变量可以看成类生态圈中的全局变量
成员变量可以看成是方法中的局部变量
与函数中的局部变量和全局变量的关系类似：

In [109]: class A: 
     ...:     a = [1] 
     ...:     b = 1 
     ...:      
     ...:          
     ...:     def test(self): 
     ...:         self.a.append(2) 
     ...:         self.b += 2 
     ...:                                                                                                                                                                                                   

In [110]: A.a                                                                                                                                                                                               
Out[110]: [1]

In [111]: A.b                                                                                                                                                                                               
Out[111]: 1

In [112]: a = A()                                                                                                                                                                                           

In [113]: a.a                                                                                                                                                                                               
Out[113]: [1]

In [114]: a.b                                                                                                                                                                                               
Out[114]: 1

In [115]: a.test()                                                                                                                                                                                          

In [116]: a.a                                                                                                                                                                                               
Out[116]: [1, 2]

In [117]: a.b                                                                                                                                                                                               
Out[117]: 3

In [118]: A.a                                                                                                                                                                                               
Out[118]: [1, 2]

In [119]: A.b                                                                                                                                                                                               
Out[119]: 1

In [120]: b = A()                                                                                                                                                                                           

In [121]: b.a                                                                                                                                                                                               
Out[121]: [1, 2]

In [122]: b.b                                                                                                                                                                                               
Out[122]: 1

In [123]: A.a                                                                                                                                                                                               
Out[123]: [1, 2]

In [124]: A.b                                                                                                                                                                                               
Out[124]: 1

In [125]: b.test()                                                                                                                                                                                          

In [126]: b.a                                                                                                                                                                                               
Out[126]: [1, 2, 2]

In [127]: b.b                                                                                                                                                                                               
Out[127]: 3

In [128]: A.a                                                                                                                                                                                               
Out[128]: [1, 2, 2]

In [129]: A.b                                                                                                                                                                                               
Out[129]: 1

由于a.append函数并不改变变量a指向的内存地址，而是改变内存地址中的值(相当于在a所指的内存地址中的原值进行操作即对[]进行操作）

改变这种不同实例之间存在的相互影响最好事先进行初始化：即使用 init() 函数

In [34]: class A: 
    ...:      x = [] 
    ...:      y = 0 
    ...:      def __init__(self): 
    ...:          pass 
    ...:      def add(self): 
    ...:          self.x.append('1') 
    ...:          self.y+=1 
    ...: a=A()  
    ...: print (a.x,a.y) 
    ...: print (A.x,A.y) 
    ...: a.add() 
    ...: print (a.x,a.y) 
    ...: print (A.x,A.y) 
    ...: b=A()  
    ...: print (b.x,b.y) 
    ...: print (A.x,A.y)                                                        
[] 0
[] 0
['1'] 1
['1'] 0
['1'] 0
['1'] 0

不同实例之间相互干扰；如何接解决

In [35]: class A: 
    ...:      x = [] 
    ...:      y = 0 
    ...:      def __init__(self, x=[], y=0): 
    ...:          self.x = x 
    ...:          self.y = y 
    ...:           
    ...:      def add(self): 
    ...:          self.x.append('1') 
    ...:          self.y+=1 
    ...: a=A()  
    ...: print (a.x,a.y) 
    ...: print (A.x,A.y) 
    ...: a.add() 
    ...: print (a.x,a.y) 
    ...: print (A.x,A.y) 
    ...: b=A()  
    ...: print (b.x,b.y) 
    ...: print (A.x,A.y)                                                        
[] 0
[] 0
['1'] 1
[] 0
['1'] 0
[] 0

未解决
继续…

In [50]: class A: 
    ...:      x = [] 
    ...:      y = 0 
    ...:      def __init__(self, x=[], y=0): 
    ...:          self.x = x 
    ...:          self.y = y 
    ...:           
    ...:      def add(self): 
    ...:          self.x.append('1') 
    ...:          self.y+=1 
    ...: a=A()  
    ...: print (a.x,a.y) 
    ...: print (A.x,A.y) 
    ...: a.add() 
    ...: print (a.x,a.y) 
    ...: print (A.x,A.y) 
    ...: b=A([], 0)  
    ...: print (b.x,b.y) 
    ...: print (A.x,A.y)                                                        
[] 0
[] 0
['1'] 1
[] 0
[] 0
[] 0

解决->通过重新初始化赋值， 所以最好使用位置不赋值

In [51]: class A: 
    ...:      x = [] 
    ...:      y = 0 
    ...:      def __init__(self, x, y): 
    ...:          self.x = x 
    ...:          self.y = y 
    ...:           
    ...:      def add(self): 
    ...:          self.x.append('1') 
    ...:          self.y+=1 
    ...: a=A([], 0)  
    ...: print (a.x,a.y) 
    ...: print (A.x,A.y) 
    ...: a.add() 
    ...: print (a.x,a.y) 
    ...: print (A.x,A.y) 
    ...: b=A([], 0)  
    ...: print (b.x,b.y) 
    ...: print (A.x,A.y)                                                                                                                                                                                    
[] 0
[] 0
['1'] 1
[] 0
[] 0
[] 0

事实上In[35]未能解决是忽略了---------- 这里 ------------ 的改变

In [54]: def test(a=1, b=[]): 
    ...:     a += 1 
    ...:     b.append(2) 
    ...:      
    ...:     print(a, b) 
    ...:                                                                                                                                                                                                    

In [55]: test()                                                                                                                                                                                             
2 [2]

In [56]: test()                                                                                                                                                                                             
2 [2, 2]

In [57]: test()                                                                                                                                                                                             
2 [2, 2, 2]

In [58]: test()                                                                                                                                                                                             
2 [2, 2, 2, 2]

In [59]: test()                                                                                                                                                                                             
2 [2, 2, 2, 2, 2]

In [60]: test()                                                                                                                                                                                             
2 [2, 2, 2, 2, 2, 2]


In [73]: class Test(object): 
    ...:     ss = 9 
    ...:     cc = 59 
    ...:     def __init__(self): 
    ...:         self.ss = self.ss 
    ...:         self.cc = self.cc 
    ...:     @classmethod 
    ...:     def class_m(cls): 
    ...:         cls.ss += 1 
    ...:         cls.cc += 3 
    ...:         return cls.ss, cls.cc 
    ...:     @classmethod 
    ...:     def class_m_m(cls): 
    ...:         cls.ss += 9 
    ...:         cls.cc += 19 
    ...:         return cls.ss, cls.cc 
    ...:     def traditional_m(self): 
    ...:         print(self.ss, self.cc) 
    ...:         self.ss = self.ss*2 
    ...:         self.cc = self.cc*2 
    ...:         return self.ss, self.cc 
    ...:                                                                                                                                                                                                    

In [74]: Test.cc                                                                                                                                                                                            
Out[74]: 59

In [75]: Test.ss                                                                                                                                                                                            
Out[75]: 9

In [76]: t = Test()                                                                                                                                                                                         

In [77]: t.traditional_m()                                                                                                                                                                                  
9 59
Out[77]: (18, 118)

In [78]: t.ss                                                                                                                                                                                               
Out[78]: 18

In [79]: t.cc                                                                                                                                                                                               
Out[79]: 118

In [80]: t.class_m()                                                                                                                                                                                        
Out[80]: (10, 62)

In [81]: Test.cc                                                                                                                                                                                            
Out[81]: 62

In [82]: Test.class_m_m()                                                                                                                                                                                   
Out[82]: (19, 81)
yjinyyzyq
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入理解C++编程中的局部变量和全局变量
12-31
局部变量 在一个函数内部定义的变量是内部变量，它只在本函数范围内有效，也就是说只有在本函数内才能使用...例如，在f1函数中定义了变量b和c，倘若在f2函数中也定义变量b和c，它们在内存中占不同的单元，不会混淆。
全局变量 与 局部变量 赋值的问题
世范水晶
09-18 1335
   全局变量：      （1）在java中，类的全局变量(成员变量)不用初始化即可直接使用，JVM会自动初始化，原始变量如int char short long byte初始化为0，float double初始化为0.0，boolean初始化为false，对象初始化为null   局部变量        （2）方法中的局部变量，C必须在函数开始处声明所有要使用的变量，而java可在使用时...
java类的成员变量和方法内的局部变量
XCQiang的博客
01-10 761
1.变量在使用前必须进行初始化。 2.成员变量和局部变量初始化的区别：             在类内的成员变量：随着类的加载会有一个默认的初始值，不管这个变量在类中是否被赋值，如下例中a的默认初始值为0,而b为null；而只有当用Demo创建对象调用了这个类的构造器时才会自动将3赋值给a；可参考（https://www.zhihu.com/question/36643366）
Java：类变量和类函数（static）
qq_48510607的博客
04-29 815
java：类变量和类函数（static）
全局类对象、静态全局类对象、静态成员类对象、静态局部类对象 的构造和析构过程
code09的专栏
06-19 2206
// Test_VC6Dlg.h : header fileclass AClass{public:    AClass(const char* obj) {        sprintf(p,"%s",obj);        TRACE(p);        TRACE(" : Constructor/n");    };    ~AClass() { 
成员变量（类变量）与局部变量（函数变量）的区别
qq_44309181的博客
01-17 251
示例： public class Test{ int a;//成员变量，不初始化时默认值为0 public static void main(String[] args){ int b;//局部变量，必须初始化才可以使用，但是不初始化，这一行也不会报错，调用该变量时，会报错 System.out.println(a);//输出 0 System.out.println(b);//变...
Python语言基础：局部变量和全局变量.pptx
05-05
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。 对于全局变量和局部变量，即使变量名相同，但是因为定义在不同的作用...
从局部变量和全局变量开始全面解析Python中变量的作用域
09-21
无论是以类为基础的面相对象编程,还是单纯函数内部变量的定义,变量的作用域始终是Python学习中一个必须理解掌握的环节,下面我们从局部变量和全局变量开始全面解析Python中变量的作用域,需要的朋友可以参考下
Android中的全局变量与局部变量使用小结
09-03
主要介绍了Android中的全局变量与局部变量使用小结,全局变量顾名思义就是在整个的类中或者可在多个函数中调用的变量,也称为外部变量,局部变量则是特定过程或函数中可以访问的变量,需要的朋友可以参考下
C语言 全局变量和局部变量详解及实例
12-26
C语言 全局变量和局部变量详解 核心内容： 1、局部变量和全局变量 变量按照作用域分为：全局变量和局部变量 全局变量的作用域：从定义位置开始到下面整个程序结束。 局部变量的作用域：在一个函数内部定义的...
python中的类变量、成员变量和成员函数的局部变量使用
Rosun
10-16 2万+
#encoding:utf-8 class TestClass(object): classval1 = 100 #类变量 def __init__(self): self.memval2 = 200 #成员变量 def memfuntion(self,val = 400): localval3 = 300 #函数内部的局部变量 self.nmval
类中的变量
weixin_30572613的博客
06-02 133
类变量和类的属性： 如下代码所示： x=1class Test: x = 1 def __init__(self): self.y = 2 def create(): j=1 x即为类Test的变量，各个Test的实例中的x都是一样的，而y为Test的属性，每个Test实例的y都是独立的。 类...
在函数中使用全局变量
kalman2019的博客
12-15 5087
如何在函数中创建或使用全局变量？如何使用在其他函数中的一个函数中定义的全局变量？
C++编程入门系列之二十（C++程序设计必知：数据和函数）
赵小咖的博客
10-10 400
在结构化程序设计中，有人提出“数据结构+算法=程序设计”，数据结构就是数据的组织，算法是用函数实现的，可见数据和函数很早就被看作程序设计的重点了。面向对象程序设计中，这种观点应稍作一下修改：“数据结构+算法=对象”。就是数据和函数构成了类的对象。        面向对象程序设计中，数据用来描述对象的属性，函数是行为，用来处理数据。将数据和函数封装到一个类里，类中的函数成员可以访问数据成员，函
MATLAB基础学习（二）-变量类型与赋值
热门推荐
喵叫兽的博客
09-11 7万+
matlab解决问题的最基本思路是建立脚本文件，那么脚本文件的第一段就是定义一些变量，这和C语言等编程思想是一样的。matlab提供的变量类型很多，最基础的是三种：数值变量、符号变量、字符串，其他的类型还有cell、table等。这里仅说明最基础的变量类型。1.数值变量 matlab中所有的数值变量都是矩阵，赋值时，以方括号作为开头和结尾，以英文逗号或空格分割同行元素，以英文分号分割各列。...
20、static关键字：修饰局部变量、全局变量、类中成员变量、类中成员函数
最新发布
03-28
3. 修饰类中成员变量：当一个类中的成员变量被声明为静态时，它的作用域仍然是整个类，但是它不再是每个对象的独立变量，而是所有对象共享的变量。因此，对于所有对象来说，静态成员变量的值都是相同的，而且它们的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值