局部变量：
定义在函数内部的变量(包括函数的参数)
全局变量：
定义在函数外部，模块内部的变量
python的作用域
作用域也叫命名空间，是访问变量时查找变量名的范围空间
python的四个作用域LEGB
作用域英文解释英文简写局部作用域(函数内)LocalL外部嵌套函数作用域Enclosing Function LocalE函数定义所在模块(文件)的作用域Global(module)GPython 内置模块的作用域BuiltinB
变量名的查找规则：
L ---> E ---> G ---> B
说明：
在默认的情况下，变量的赋值会创建或者改变本作用域变量
global 语句：
告诉解释器，global语句声明的一个或多个变量，这些变量的作用域为模块级的作用域，也称为全局变量
语法：
global 变量1，变量2，。。。
说明：     1.全局变量如果在函数内部被赋值，则必须经过全局声明，否则会被认为是局部变量
2.全局变量在函数内部不经过声明就可以直接访问
3.不能先声明局部变量，在用global声明为全局变量，此做法不符合语法规则
4.global变量列表里的变量名不能出现在此作用域的参数列表里
s = 0
def myadd(x, y):
global s
s += x + y
return x + y
print(myadd(1, 2))  # 3
print(myadd(100, 200))  # 300
print(s)   # 303

我写了下面的函数，它需要一个变量input_name。然后用户输入一些分配给input_name的值。我想知道使input_name可以在函数之外访问的最佳方式。我知道在一个函数内定义一个变量为全局变量，意味着它可以在函数之外使用。然而，在这种情况下，变量实际上是函数的一个参数，所以我不确定如何将其定义为全局变量。我很感激任何帮助，请找到下面的代码：
def input(input_name, prompt):
while True:
data = raw_input(prompt)
if data:
try:
input_name = int(data)
except ValueError:
print 'Invalid input...'
else:
if input_name >= 0 and input_name < 100:
print 'Congratulations'
break
input_name = 'Please try again: '
else:
print 'Goodbye!'
break
month = 0
day = 0
year = 0
century = 0
input(month, "Please enter the month (from 1-12, where March is 1 and February is 12): ")
input(day, "Please enter the day (from 1-31): ")
input(year, "Please enter the year (from 0 - 99, eg. 88 in 1988): ")
input(century, "Please enter the century (from 0 - 99, eg. 19 in 1988): ")
A = month
B = day
C = year
D = century

          
//  局部变量和全局变量  
 
定义变量可能有3种情况:  
1.在函数的开头定义  
2.在函数内的复合语句内定义  
3.在函数的外部定义  
 
在函数内定义的变量是局部变量，在函数之外定义的变量是全局变量  
 
为了便于区别全局变量和局部变量，在C程序设计人员中有一个习惯（但非规定），  
将全局变量名的第1个字母用大写表示。  
 
有一个一维数组，内放10个学生成绩，写一个函数，当主函数调用此函数后，  
能求出平均分、最高分和最低分。  
#include "stdafx.h"  
 
 
float Max=0,Min=0;  
int main()  
{  
    float average(float array[ ],int n);  
    float ave,score[10];  
    int i;  
    printf("Please enter 10 scores:");  
    for(i=0;i<10;i++)  
        scanf_s("%f",&score[i]);  
    ave=average(score,10);  
    printf("max=%6.2f\nmin=%6.2f\naverage=%6.2f\n",Max,Min,ave);  
    return 0;  
}  
 
float average(float array[ ],int n)  
{  
    int i;  
    float aver,sum=array[0];  
    Max=Min=array[0];  
    for(i=1;i<n;i++)  
    {  
        if(array[i]>Max)  
            Max=array[i];  
        else 
            if(array[i]<Min)  
                Min=array[i];  
        sum=sum+array[i];  
    }  
    aver=sum/n;  
    return(aver);  
}  
 
//  动态存储方式与静态存储方式  
变量的存储有两种不同的方式:  
静态存储方式和动态存储方式  
 
静态存储方式是指在程序运行期间由系统分配固定的存储空间的方式。  
动态存储方式是指在程序运行期间根据需要进行动态的分配存储空间的方式。  
 
动态存储区中存放以下数据:  
1.函数形式参数:在调用函数时给形参分配存储空间  
 
2.函数中定义的没有用关键字static声明的变量，即自动变量  
 
3.函数调用时的现场保护和返回地址等。  
 
在C语言中，每一个变量和函数都有两个属性: 数据类型 和 数据的存储类别 。  
C的存储类别包括4种:自动的(auto)、静态的(static)、寄存器的(register)、外部的(extern)  
 
//  局部变量的存储类别  
1.自动变量(auto 变量)  
 
int f(int a)            //定义f函数,a为形参  
{  
    auto int b,c=3;     //定义b,c为自动变量  
    ...  
}  
 
其中,a是形参,b和c是自动变量,对c赋初值3  
执行完f函数后,自动释放a,b,c所占的存储单元  
实际上,关键字"auto"可以省略,不写 auto 则隐含指定为"自动存储类别",它属于动态存储方式  
程序中大多数变量属于自动变量。  
 
int b,c=3;  
与  
auto int b,c=3;  
等价。  
 
2.静态局部变量(static局部变量)  
考察静态局部变量的值  
#include "stdafx.h"  
 
 
int main()  
{  
    int f(int);                     //函数声明  
    int a=2,i;                      //自动局部变量  
    for(i=0;i<3;i++)  
        printf("%d\n",f(a));        //输出f(a)的值  
    return 0;  
}  
 
int f(int a)  
{  
    auto int b=0;                   //自动局部变量  
    static int c=3;                 //静态局部变量  
    b=b+1;  
    c=c+1;  
    return(a+b+c);  
}  
 
输出1到5的阶乘值  
#include "stdafx.h"  
 
 
int main()  
{  
    int fac(int n);  
    int i;  
    for(i=1;i<=5;i++)  
        printf("%d!=%d\n",i,fac(i));  
    return 0;  
}  
 
int fac(int n)  
{  
    static int f=1;  
    f=f*n;  
    return(f);  
}  
 
3.寄存器变量（register 变量）  
用关键字 register 作声明  
如:  
register int f;         //定义f为寄存器变量  
 
//  全局变量的存储类别  
1.在一个文件内扩展外部变量的作用域  
 
在定义点之前的函数需要应用该外部变量,则应该在应用之前用关键字 extern   
对该变量作"外部变量声明",表示把该外部变量的作用域扩展到此位置。  
 
调用函数,求3个整数中的大者  
#include "stdafx.h"  
 
 
int _tmain(int argc, _TCHAR* argv[])  
{  
    int max();  
    extern int A,B,C;  
    printf("Please enter three integer numbers:");  
    scanf_s("%d %d %d",&A,&B,&C);  
    printf("max is %d\n",max());  
    return 0;  
}  
 
int A,B,C;  
 
int max()  
{  
    int m;  
    m=A>B?A:B;  
    if(C>m)  
        m=C;  
    return(m);  
}  
 
2.将外部变量的作用域扩展到其他文件  
在任一个文件中定义外部变量Num，而在另外一文件中用extern对Num作"外部变量声明",  
即"extern Num"。  
 
给定b的值,输入a和m,求a*b和a的m次方的值  
#include "stdafx.h"  
 
 
int A;  
int main()  
{  
    int power(int);  
    int b=3,c,d,m;  
    printf("enter the number a and its power m:\n");  
    scanf_s("%d,%d",&A,&m);  
    c=A*b;  
    printf("%d * %d=%d\n",A,b,c);  
    d=power(m);  
    printf("%d * * %d=%d\n",A,m,d);  
    return 0;  
}  
 
extern int A;  
int power(int n)  
{  
    int i,y=1;  
    for(i=1;i<=n;i++)  
        y*=A;  
    return(y);  
}  
 
3.将外部变量的作用域限制在本文件中  
 
加上 static 声明、只能用于本文将的外部变量称为 "静态外部变量" 
用 static 声明一个变量的作用:  
a.对局部变量用 static 声明,把它分配在静态存储区,该变量在整个程序执行期间不释放,其所分配的空间始终存在  
b.对全局变量用 static 声明,则该变量的作用域只限于本文件模块(即被声明的文件中)  
 
//  存储类别小结  
对一个数据的定义，需要制定两种属性:数据类型和存储类别。  
 static int a;              //静态局部整型变量或静态外部整型变量  
 auto char c;               //自动变量,在函数内定义  
 register int d;            //寄存器变量,在函数内定义  
 
 可以用 extern 声明已定义的外部变量,例如:  
 extern b;                  //将已定义的外部变量b的作用域扩展至此  
 
(1)从作用域角度分,有局部变量和全局变量。它们采用的存储类别如下:  
局部变量    自动变量，即动态局部变量(离开函数，值就消失)  
            静态局部变量（离开函数，值仍保留）  
            寄存器变量(离开函数，值就消失)  
            （形式参数可以定义为自动变量或寄存器变量）  
全局变量    静态外部变量  
            外部变量（即非静态的外部变量，允许其他文件引用）  
 
(2)从变量存在的时间(生存期)来区分,有 动态存储和静态存储 两种类型  
动态存储    自动变量（本函数内有效）  
            寄存器变量（本函数内有效）  
            形式参数（本函数内有效）  
静态存储    静态局部变量（函数内有效）  
            静态外部变量（本文件内有效）  
            外部变量（用extern声明后，其他文件可应用）  
 
(3)从变量值存放的位置来区分  
内存中静态存储区    静态局部变量  
                    静态外部变量（函数外部静态变量）  
                    外部变量（可谓其他文件引用）  
内存中动态存储区    自动变量和形式参数  
CPU中的寄存器        寄存器变量  
 
(4)关于作用域和生存期的概念  
如果某一个变量在某个文件或函数范围内是有效的，就称该范围为该变量的作用域。  
如果一个变量值在某一时刻是存在的，则认为这一时刻属于该变量的生存期。  
 
(5)static 对局部变量和全局变量的作用不同  
对局部变量来说，它使变量由动态存储方式改变为静态存储方式  
而对全局变量来说，它使变量局部变化，但仍为静态存储方式。 
 
				
转载于:https://blog.51cto.com/290692/1162342

[第五章]函数对变量的作用

一个程序中的变量包括两类： 

1. 全局变量：全局变量指在函数之外定义的变量，在程序执行全过程有效。 

2. 局部变量 : 局部变量指在函数内部使用的变量，仅在函数内部有效，当函数退出时变量将不存在



>>>n  = 1 #n是全局变量
>>def func(a, b):
    c = a*b
    return c
>>>s = func("knock~", 2)
>>>print(c)
Traceback(most recent call last):
    File "<pyshell#6>", line1, in <module>
       print(c)
NameError:name 'c' is not defined

这个例子说明，当函数执行完退出后，其内部变量将被释放

如果函数内部使用了全局变量呢？例如：



>>>n  = 1 #n是全局变量
>>def func(a, b):
    n = b
    return a*b
>>>s = func("knock~", 2)
>>>print(s, n) #测试n值是否改变
knock~knock~ 1

函数func() 内部使用了变量n，并且将变量参数b赋值给了n,为何n值没有改变呢？因为函数func()有自己的空间，它将a=b语句理解为生成一个局部变量n，并将参数b赋值给它，此时func()函数没有将n当做全局变量。所以函数退出时，局部变量n被释放，全局变量n的值没有被改变。

如果希望让func()函数将n当做全局变量，需要在变量n使用前显式声明该变量为全局变量，代码如下：



>>>n  = 1 #n是全局变量
>>def func(a, b):
    global n
    n = b
    return a*b
>>>s = func("knock~", 2)
>>>print(s, n) #测试n值是否改变
knock~knock~ 2

如果此时的全局变量不是整数n，而是列表类型ls，该会怎样呢？理解如下代码：



>>>ls = [] #ls是全局列表变量
>>> def func(a, b):
    ls.append(b)
    return a*b
>>>s = func("knock~", 2)
>>>print(s, ls) #测试一下ls值是否改变
knock~knock~  [2]

TIP:列表等组合数据类型由于操作多个数据，所以它们在使用中有创建和引用的分别。当变量别赋值（[]或()，这个列表才被真实创建，否则只是对之前创建的列表的一次引用 

上述代码func()函数的ls.appen(b)语句执行时需要一个真实创建过的列表，此时func()函数专属的内存空间中没有已经创建过且名为ls的列表，因此，func()进一步去全局内存中寻找，自动关联全局ls列表，并且修改内容。当func()函数退出后，全局ls列表中的内容被修改。简单说，对于列表类型，函数可以直接使用全局列表而不需要采用global进行声明。 

如果func(c)函数内部存在一个真实创建过且名称为ls的列表，则func()函数将操作列表而不会修改全局变量，例如：



>>>ls = [] #ls是全局列表变量
>>> def func(a, b):
    ls = []
    ls.append(b)
    return a*b
>>>s = func("knock~", 3)
>>>print(s, ls) #测试一下ls值是否改变
knock~knock~ []

因此对上述做一个总结： 

1. 简单数据类型变量无论是否与全局变量重名，仅在函数内部创建和使用，函数退出后变量被释放，如有全局同名变量，其值不变。 

2. 简单数据类型变量在用global保留字声明后作为全局变量使用，函数退出后该变量保留且值被函数改变。 

3. 对于组合数据类型的全局变量，如果在函数内部没有别真实创建的同名变量，则函数内部可以直接使用并修改全局变量的值。 

4. 如果函数内部真实创建了组合数据类型的变量，无论是否有全局同名变量，函数仅对局部变量进行操作，函数退出后局部变量被释放，全局变量保持不变。