Python 全局变量与global关键字
 
​ 在Python的变量使用中，经常会遇到这样的错误:
 
local variable 'a' referenced before assignment
 
它的意思是：局部变量“a”在赋值前就被引用了。
 ​ 比如运行下面的代码就会出现这样的问题：
 
a = 3
def Fuc():
    print (a)
    a = a + 1
Fuc()
 
​ 但是如果把 a = a + 1 这一句删除又不会出现上述问题了
 
a = 3
def Fuc():
    print (a)
Fuc()
 
​ 原来，在Python中，a=3 定义了全局变量a，作用域从定义处到代码结束，在 a=3 以下的函数中是可以引用全局变量a的，但如果要修改函数中与全局变量同名的变量，则函数中的该变量就会变成局部变量，在修改之前对该变量的引用自然会出现未分配或未定义的错误了。
 
​ 如果确定要引用并修改全局变量必须加上global关键字
 
a = 3
def Fuc():
	global a
    print (a)
    a=a+1
Fuc()
 
​ 注意要领：哪个函数需要修改全局变量，在函数中声明一下即可。
 
​ 但在 if _name_ == “main”：下，全局变量是一直保持的
 
a = 3
def Fuc():
    global a
    print (a)  # 1
    a = a + 1
if __name__ == "__main__":
    print (a)  # 2
    a = a + 1
    Fuc()
    print (a)  # 3
 
​ 输出如下（Python3环境下）：
 
3
4
5
 
三个print执行的顺序为：2, 1, 3 。
 
人生苦短，我用Python~

 
修饰对象：全局变量、函数
 
作用：
 
1、提示编译器在其他模块或者其他文件中查找该变量、函数的定义
 
2、可以引用定义在其他文件中的全局变量和函数
 
用法：先声明，再初始化，后调用。
 
1、声明形式：声明时要严格对应声明类型，变量对变量、数组对数组、指针对指针、函数对函数
 
1)extern + 变量类型 + 变量名            例子： extern int name;
 
2)extern + 函数返回值类型 + 函数名 例子： extern void func();
 
3)extern + 数组类型 + 数组名称                              例子： extern char arr[];
 
2、初始化：在被引用文件(原文件)中初始化，如果没有初始化，编译器自动初始化为0。
 
3、调用：直接使用变量名、函数名
 
1)例子： name = 2;
 
2)例子： func();
 
近义用法：
 
引用头文件。把需要引用的全局变量放到被引用文件(原文件)的头文件声明，在引用文件(引用外部变量的文件)抬头添加语句
 
include "*.h"
 
区别：
 
引用头文件的方法：可以引用原文件的变量和函数。
 
extern修饰的方法：仅引用原文件中特定的变量和函数。

全局变量
 定义在类中 方法外的变量叫做全局变量 全局变量所有方法均能够访问
 局部变量
 作用域从定义位置开始 到代码块结束
 static关键字
 static关键字修饰的变量是静态变量 使用类名.变量直接访问 当虚拟机启动时即加载变量到内存中不需要创建对象
 static关键字修饰的方法是静态方法 使用类名.方法直接访问 静态方法中不能访问成员变量
 类变量（静态变量）
 定义在类中 使用static 修饰其变量 访问时需要类名.变量名即可访问
 使用对象 也能访问其变量 当对象值改变 类变量值就会发生改变
 类变量也叫做静态变量
 成员变量
 在类中定义的变量，实例化对象时访问的变量 叫做成员变量 
 在静态方法中 无法访问成员变量 可以访问静态变量
 在成员方法中 可以访问成员变量也可以访问静态变量
 例子：
 
public class Demo {		
// 静态变量
	public static int a = 10;		
	// 成员变量	
	public int b = 20;		
	// 静态方法。	
	public static void show(){		
	System.out.println("静态方法");		
	//System.out.println(b);// 无法在静态方法中，访问成员变量。		
	System.out.println(a);// 可以在静态方法中，访问静态变量。	}		
	// 成员方法。	
	public void show2(){		
	System.out.println(b);// 成员方法可以访问成员变量		
	System.out.println(a);// 成员方法是可以访问静态变量的。				
	System.out.println("静态变量在成员方法中加20于："+(a+=20));
	}
}
 
值传递
 形式参数：
 在定义方法时声明的参数叫做形式参数
 实际参数：
 调用方法时 传入的实际值 叫做实际参数
 java中参数的传递：
 java中有两种值传递的方式：一种是变量传递 一种是对象的引用传递
 但是 要记得 java中只有一种传递 叫做值传递 如果是变量 传递的是变量值
 如果传递的是对象 则传递的是地址值
 例子：
 
public class Test { 	
	public static void main(String[] args) {		
	int a = 10;		
	int b = 20;		
	show(a,b);//实际参数				
	System.out.println("a的值是："+a); 	}		
	public static void show(int num1,int num2){// 形式参数	
	num1 = num1+num2;		
	System.out.println("方法中a的值是："+num1);	
	} 
	}

全局变量，顾名思义，就是全局都可以使用的变量。一般定义在函数之外，然后函数内部通过global关键字描述，以区分函数内部的普通变量。一般，需要用到全局变量的地方，我都会把这些函数写成一个类，然后通过类属性变量的方法公用一个变量。不过，很多时候用不着大动干戈去写类。
 
先看一个简单栗子：
 
a = 0  # initialize variable a
def coo():
    global a  # call a
    a += 1
    return a

for i in range(10):
    print(coo())
 
注意，变量只是一个普通变量，首先在函数外部进行初始化，然后在函数内部通过global关键字呼叫这个变量，就可以实现全局变量的功能了。看输出就知道了，变量a会随着函数coo()的不断运行也在不断变化。输出如下：
 
1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 当然，全局变量不仅仅是数，还可以是其他类型的数据结构，比如：
 
a = []
def coo():
    global a
    a += [1]
    return a

for i in range(10):
    print(coo())
 
输出如下：
 
[1]
 [1, 1]
 [1, 1, 1]
 [1, 1, 1, 1]
 [1, 1, 1, 1, 1]
 [1, 1, 1, 1, 1, 1]
 [1, 1, 1, 1, 1, 1, 1]
 [1, 1, 1, 1, 1, 1, 1, 1]
 [1, 1, 1, 1, 1, 1, 1, 1, 1]
 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]