局部变量：在函数内部定义的变量，只在函数内部起作用，函数执行结束，变量会自动删除
 即在一个函数内部定义的变量，只在本函数范围内有效
 全局变量：“在函数外定义的变量”，即从定义变量的位置到本源文件结束都有效
 即可以被程序所有对象或者函数引用　　
 当有外部变量时,main函数中的同名变量就是全局变量。如果没有外部变量，main函数里的变量依然是局部变量
 或者也可以直接在函数内部声明变量为全局变量
 
 
 
目的：增加函数间数据联系的渠道。由于同一文件中的所有函数都能引用全局变量的值
 因此如果在一个函数中改变了全局变量的值，就能影响到其他函数中全局变量的值，相当于各个函数之间有直接的传递渠道
 
 
a = 1
print('out: ',id(a))查看变量的id
def fun():
    global a
    a = 5
    print('in: ',id(a))
fun()
print(a)
print(id(a))
id是查看变量在内存中存放区域的编号
 

 
 此时函数内部定义的a是全局变量，所有的输出均为全局变量的信息
 
 
 此时函数外面的a是全局变量，所有的输出是全局变量的信息，局部变量只在函数内部起作用

1、循环语句中变量
public static void main(String args[]) {
	for(int i=0;i<10;i++) {
		int sum =3;
	}
		
	System.out.println(i+"  "+sum);

}
就上面最简单的程序说明吧，上面在for循环中定义了i和sum，但是出了循环，这两个变量就被丢弃了，显然i和sum的作用域就是for循环之中，可以预见在while，do-while中也是一样的，这里就不举例了。
2、if语句中的变量声明
int j =0;
if(j==0)
  int i =0;
如上图所，我创建了一个if语句，但是在if语句中创建一个对象，就会报错，而下面的语句却不会报错
int j =0;
if(j==0) {
   int i =0;
}
只是加了一个大括号，但是就不会报错了，这是因为if语句的作用域问题，if语句只作用于它之后的第一行语句（如果不加大括号的话），这样的话，当你创建变量i后，就退出了if语句，然后i就会被删除，相当于这i没有任何作用，是无效语句，这在java中是杜绝出现的
当然我们的主题是变量的作用域问题，显然if语句中变量的作用域也仅仅是在if语句之内
3、方法中的变量声明
这个就不用说了，比较常见

       变量定义以后，是有一定的使用范围，称之为变量的作用域。比如Java中，变量的使用范围是变量声明时所在的{}范围，而python的作用域对应的为同一个缩进。按着变量的使用范围给变量划分成如下两种：
 
           1.全局变量：就是在函数外部定义的变量
 
           2.局部变量：就是在函数内部定义的变量
 
1.全局函数和局部函数的作用域
 
  局部变量作用域：只能在被声明的函数内部访问，函数外部使用不了。
 
                            这也是不同函数里可以定义名称一样变量的原因
 
  全局变量作用域：可以在整个程序范围内访问，任意函数都可以访问
 
#1.局部变量，外部访问不了
def f1 (v1,v2): #参数也属于局部变量
    sum = v1+v2
    a = 5  #局部变量，函数外部访问不了
    return sum
--------------------------------
print(a) #报错，NameError: name 'a' is not defined
=====================================================================

#2.全部变量,函数里外都可以访问
a =3
def f3(v2):
  # a = a+1  注意：报错，因为局部作用域内只能引用全局域变量的值，而不能修改全局作用域的值。
  # b = a+1  则不会报错，引用全局变量的值，运算后给赋给局部变量b.
    return a+1   #外部的全局变量函数内部使用
print(f3(1))
=============结果如下======================
4
===================================-===================================
#3.如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的
sum =5
def f2(v2):
    sum =0
    while v2 < 10:
        sum += v2   #这里sum使用的是局部变量的初始值0，而不是全局sum=5
        v2 += 1
    return sum
print(sum)
print(f2(0))
===========结果如下=========================
5     
45
===========================================
 
注意：1. PYTHON的作用域由def、class、lambda等语句产生，if、try、for等语句并不会产生新的作用域，换句话说就是if,try,for等语句里面定义的变量并不会随着该语句执行结束而回收，而是可以到处引用的，if,try,for等语句内变量作用域实际范围受其所在 的def,class,lambda范围约束。
 
          2.当 Python 遇到一个变量的话他会按照这样的顺序进行搜索LEGB法则：本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）.具体什么是LEGB法则要等后面学完闭包后再讲，这里大致了解一下即可。
 
2.作用域的划分LEGB
 
1. L(local)局部作用域
 
      局部变量：包含在def关键字定义的语句块中，即在函数中定义的变量。每当函数被调用时都会创建一个新的局部作用域。Python中也有递归，即自己调用自己，每次调用都会创建一个新的局部命名空间。在函数内部的变量声明，除非特别的声明为全局变量，否则均默认为局部变量。有些情况需要在函数内部定义全局变量，这时可以使用global关键字来声明变量的作用域为全局。局部变量域就像一个 栈，仅仅是暂时的存在，依赖创建该局部作用域的函数是否处于活动的状态。所以，一般建议尽量少定义全局变量，因为全局变量在模块文件运行的过程中会一直存在，占用内存空间。
 注意：如果需要在函数内部对全局变量赋值，需要在函数内部通过global语句声明该变量为全局变量。
 
2.E(enclosing)嵌套作用域
 
      E也包含在def关键字中，E和L是相对的，E相对于更上层的函数而言也是L。与L的区别在于，对一个函数而言，L是定义在此函数内部的局部作用域，而E是定义在此函数的上一层父级函数的局部作用域。主要是为了实现Python的闭包，而增加的实现。
 
3.G(global)全局作用域
 
       即在模块层次中定义的变量，每一个模块都是一个全局作用域。也就是说，在模块文件顶层声明的变量具有全局作用域，从外部开来，模块的全局变量就是一个模块对象的属性。
 注意：全局作用域的作用范围仅限于单个模块文件内
 
4.B(built-in)内置作用域
 
    系统内固定模块里定义的变量，即系统自带的的变量函数之类的。如预定义在builtin 模块内的变量。
 
globa  lVar = 100           #G

def test_scope():
    enclosingVar = 200    #E
    def func():
        localVar = 300    #L
print (__name__)            #B
 
2.局部变量声明为全局变量global
 
val =10
def f1(v1):
    val =5
    return val
print(val )  #结果是10，因为局部变量val作用域只是函数内
print(f1(1))  #5

#使用global将局部变量声明为全局变量
val =10
def f1(v1):
    global val
    val = 30
    return val
print(val )  #结果是10.虽然声明了global，但是函数要调用才会执行，才会更新val的值

============================================================================
val =10
def f1(v1):
    global val
    val = 30
    return val
f1(2)
print(val )  #结果是30.调用函数f1后，将val的值给刷新了。
 
统一声明：关于原创博客内容，可能会有部分内容参考自互联网，如有原创链接会声明引用；如找不到原创链接，在此声明如有侵权请联系删除哈。关于转载博客，如有原创链接会声明；如找不到原创链接，在此声明如有侵权请联系删除哈。

1.在JavaScript中定义变量有两种方式
 
ES6之前：var 变量名称;
 ES6开始：let 变量名称;
 
2.两种定义变量方式的区别
 
详细介绍见https://blog.csdn.net/Cao_Mary/article/details/89207605
 
2.1、是否能够定义同名变量
 
var可以定义，let不可以定义同名变量
 
2.2、是否能够先使用后定义
 
var可以先使用后定义（预解析），let不可以预解析
 
2.3、是否能被{}限制作用域
 
无论是通过var还是let定义在{}外面都是全局变量
 var放在{}内部还是全局变量，let放在{}内部则是局部变量
 无论是通过var还是let定义在局部作用域的都是局部变量
 
3.局部作用域、全局作用域、块级作用域
 
3.1、在任何地方都可以访问到的就是全局作用域。在JavaScript中{}外面的作用域，称之为全局作用域 
  
var和let变量在全局作用域中都是全局变量
 
3.2、只在固定的代码片段内可访问到的变量，例如函数内部。对应局部作用域(函数作用域)。在JavaScript中函数后面{}中的作用域，称之为“局部作用域” 
  
无论是通过var还是let定义在局部作用域的都是局部变量
 
3.3、任何一对花括号（｛和｝）中的语句集都属于一个块，在这之中定义的所有变量在代码块外都是不可见的，我们称之为块级作用域。在ES6中只要{}没有和函数结合在一起，那么应该是“块级作用域”。ES6之前没有块级作用域。 
  
块级作用域中，var定义的变量是全局变量，let定义的变量是局部变量
 
 
4.块级作用域和局部作用域区别
 
4.1、在块级作用域中通过var定义的变量是全局变量
 
		    {
                //块级作用域
                var num = 123;//全局变量
            }
            console.log(num);
 
4.2、在局部作用域中通过var定义的变量是局部变量
 
			function test() {
                var value = 666;//局部变量
            }
            test();
            console.log(value);//value is not defined
 
5、无论是在块级作用域还是局部作用域，省略变量前面的let或者var就会变成一个全局变量。
 
5.1、验证在块级作用域中
 
   	    {
               var num1 = 678;//全局变量
               let num2 = 678;//局部变量
               num3 = 678;//全局变量
           }
           console.log(num1);//678
           console.log(num2);//num2 is not defined
           console.log(num3);//678
 
5.1、验证在局部作用域中
 
 		   function f() {
                var num1 = 678;//局部变量
                let num2 = 123;//局部变量
                num3 = 456;//全局变量
            }
            f();
            console.log(num1);//num1 is not defined
            console.log(num2);//num1 is not defined
            console.log(num3);//456
 
6、案例
 
        var num1 = 123;//**全局变量**
        function f() {
            var num2 = 456//局部变量
        }
        function test() {
            num3 = 666;//局部作用域，没有var或者let修饰。**全局变量**
        }
        {
            var num4 = 789;//块级作用域、**全局变量**
        }
        {
            let num5 = 789;//块级作用域、let定义变量。局部变量
        }
        {
            let value7 = 123;
            {
                //注意点：在不同的作用域范围中，可以有同名变量
                let value7 = 456;//不会报错。
            }
        }