python基础--函数进阶

1. 全局变量和局部变量

• 局部变量：

定义在函数内部的变量称为局部变量（函数的形参也是局部变量）
局部变量只能在函数内部使用
局部变量在函数调用时被自动创建

• 全局变量：

定义在函数外部的变量称为全局变量
全局变量，所有函数都可以直接访问，但函数内不能将其直接改变

# 局部变量和全局变量创建和销毁实例：
def myadd(x, y):
    m = x + y
    return m

x = 100
y = 200
z = myadd(x, y)
print(x, y, z)
a = 10
b = 20
z = myadd(a, b)
print(x, y, z)

100 200 300
100 200 30

2. 函数的嵌套：

函数嵌套是指在一个函数里用def语句来创建其他函数的情况

# 函数内部创建函数，并将其返回
def fn_outter():
    print("fn_outter被调用")

    def fn_inner():
        print("fn_inner被调用")

    fn_inner()  # 可以调用内部的fn_inner函数


fn_outter()
fn_inner()  # 调用是错误的，因为没有fn_inner这个变量名

fn_outter被调用
fn_inner被调用



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-4-80b60bddee2e> in <module>
     10 
     11 fn_outter()
---> 12 fn_inner()  # 调用是错误的，因为没有fn_inner这个变量名


NameError: name 'fn_inner' is not defined

def fn_outter():
    print("fn_outter被调用")

    def fn_inner():
        print("fn_inner被调用")

    return fn_inner


f = fn_outter()   # f绑定fn_inner这个函数
f()   # 调用

fn_outter被调用
fn_inner被调用

n = 100  # 全局变量

def f(a1, b):
    print(a1, b)
    n = 200  # 此函数内a, b, n 都为局部变量，只在函数调用时起作用（函数的形参也是局部变量）
    print(n)
    m = 300

f(100, 200)
print(n)
print(a1)  # 错的
print(m)  # 也是错的

100 200
200
100



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-10-95d18be325ac> in <module>
      9 f(100, 200)
     10 print(n)
---> 11 print(a1)  # 错的
     12 print(m)  # 也是错的


NameError: name 'a1' is not defined

3. python 的作用域：

作用域也叫名字空间，是访问变量时查找变量的范围空间

• Python的四个作用域 LEGB

局部作用域  Local function
外部嵌套函数作用域  Enclosing function local
全局作用域（文件作用域）  Global（Module）
Python内置模块作用域     Builtin（Python）

• 变量名查找的规则是：

局部变量 --> 外部嵌套函数变量 --> 全局作用域 --> 内置模块作用域

v = 100
def f1():
    v = 200
    print("f1内的V = ", v)


def f2():
    v = 300
    print("f2内的V = ", v)


f1()
f2()
print("全局的V = ", v)

f1内的V =  200
f2内的V =  300
全局的V =  100

• global 语句

1、告诉解释器，global语句声明的一个后多个变量，这些变量的作用域为模块级的作用域，也称为全局作用域
2、全局声明global将赋值变量映射到模块文件内部的作用

语法：global 变量1, 变量2,......

v = 100
def f1():
    global v  # 声明v为全局作用域的v
    v = 200   # 想要此语句对全局变量v进行修改


print(v)    # 100
f1()   # 调用
print(v)    # 200

100
200

3、全局变量如果要在函数内部改变绑定关系，则必须经过全局声明，否则会被认为是局部变量
4、全局变量在函数内部不经过声明就可以访问,不可改变
5、不能先声明局部变量，再用global声明为全局变量（此做发不符合规则）
6、global变量的列表里的变量名不能出现在此作用域的形参列表里

v = 100
def f1():
    v = 200
    global v

  File "<ipython-input-15-327fd9ccebc6>", line 7
SyntaxError: name 'v' is assigned to before global declaration

s = "ABC"
string = "hello"

def f1(string):
    global s
    s += string

print(s)  # 访问不等于可以改变
f1(string)
print(s)

global s

  File "<ipython-input-48-eab7406b633e>", line 15
SyntaxError: name 's' is used prior to global declaration

• nonlocal 语句

告诉解释器，声明的变量不是局部变量，也不是全局变量，而是外部嵌套函数内的变量

语法：nonlocal 变量1, 变量2,.....

1、nonlocal只能在被嵌套函数内部进行使用
2、当有两层或两层以上函数嵌套时，访问nonlocal变量只对最近一层的变量进行操作
3、nonlocal语句的变量列表中的变量名，不能出现在此函数的参数列表里

v = 100

def f1():
    v1 = 200
    def f2():
        global v
        v = 300  # 此时修改全局的v

        nonlocal v1
        v1 = 400  # 此时修改外部嵌套函数的作用域中的v
        print("f2的v值：", v1)
    f2()
    print("f1的v值：", v)

print("全局的v：", v)
f1()
print("全局的v：", v)

全局的v： 100
f2的v值： 400
f1的v值： 300
全局的v： 300

4. lambda 表达式

创建一个匿名函数对象，同def类似，但不提供函数名

语法：lambda [形参名1, 形参2, ...]: 只有一条表达式（语句也不能用）

def myadd(x, y):
    return x + y

myadd1 = lambda x, y : x + y
print("20+30 = ", myadd(20, 30))
print("3.1+4.2 = ", myadd1(3.1, 4.2))

20+30 =  50
3.1+4.2 =  7.300000000000001

1、lambda只是一个表达式，它用来创建一个函数对象，当lambda表达式执行时，返回的是冒号后表达式的值
2、lambda表达式创建的函数只能包含一条表达式
3、lambda比函数简单且可以随时创建和销毁，有利于减少程序的耦合度

练习：写一个lambda表达式，传入两个数x, y， 返回x的平方对y求余的值

mymod = lambda.....
print(mymod(4,5))
# 跟函数调用是一样的

x = int(input("请输入x:"))
y = int(input("请输入y:"))
z = lambda x, y: x**2 % y
print(z(x, y))

请输入x:2
请输入y:3
1

5. 内置函数(7)

• globals()

返回当前全局作用域内变量的字典

• locals()

返回当前局部作用域内变量的字典

a = 1
b = 2
c = 3

def fn(c, d):
    e = 300
    print("locals返回：", locals())
    print("globals返回：", globals())
    print("全局的c：", globals()['c'])
    print("局部的c：", locals()['c'])

fn(100, 200)

• eval() 函数

作用：把一个字符串当成一个表达式来执行，返回表达式执行后的结果
格式：eval(source, globals = None, local = None)

x = 100
y = 200
s = "x+y"   # s为字符串
v = eval(s)   # 把s绑定的字符串当成程序语句来执行
print(v)

gs = {"x":10, "y":20}
v = eval("x+y", gs)
print(v)

ls = {"x":1, "y":2}
v = eval("x+y", gs, ls)
print(v)

ls = {"x":1000}
v = eval("x+y", gs, ls)
print(v)

300
30
3
1020

• exec() 函数

作用：把一个字符串当成程序来执行
格式：exec(source, globals = None, local = None)

x = 100
y = 200
s = "z = x + y; print('hello', x, y, z)"
exec(s)

# 以上两句等同于此句的作用
z = x + y
print("hello", x, y, z)

hello 100 200 300
hello 100 200 300

注：globals参数和locals参数作用相同，用来设置执行的作用域

同名公众号：庄AC