目录
- 全局变量、局部变量
- globals和locals函数
- 函数变量、函数作为参数
- 函数作为返回值
- 函数的嵌套
- python作用域
- global语句
- nonlocal语句
- lambda表达式
- eval与exec函数
1. 全局变量、局部变量
全局变量和局部变量 :
局部变量 : 定义在函数内部的变量,称做局部变量(函数的形参也是局部变量)
局部变量只能在函数内部使用
局部变量在函数调用时才能够被创建,在函数调用之后会自动销毁
全局变量 : 定义在函数外部,模块内部的变量称为全局变量
所有函数都可以直接访问全局变量(但函数内部不能将其直接赋值)
说明 :
在函数内首次对变量赋值是创建局部变量,再次为该变量赋值是修改局部变量的绑定关系
在函数内部的赋值语句不会对全局变量造成影响
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个模块范围内访问
eg :
a = 100
b = 200
d = 400
def fx(c):
d = 300
print(a,b,c,d) #c,d变量是函数内私有
fx(200) #>>>100 200 200 300
print('a=',a) #>>>a= 100
print('b=',b) #>>>b= 200
print('c=',c) #>>>出错,不能直接访问函数内部变量
print('d=',d) #>>>b= 400 访问全局变量 d,且函数内部d赋值没有影响全局变量的赋值
2. globals和locals函数
globals() : 返回当前全局作用域内变量的字典
locals() : 返回当前局部作用域内变量的字典
eg :
a = 1
b = 2
c = 3
def f1(c,d):
e = 300
print('locals()返回:',locals())
#>>> locals()返回: {'c': 100, 'd': 200, 'e': 300}
print('globals()返回:',globals())
print(c) #>>>100 ；f1(100,200) 赋值
print(globals()['c']) #>>>3 得到全局变量c的值
f1(100,200)
3. 函数变量、函数作为参数
***函数名是变量,在创建函数时,绑定被创建的函数
eg :
def f1():
print('f1被调用')
fx = f1 # 创建变量fx 绑定f1()
fx() #等同于 f1()
***一个函数可以作为另一个函数的参数传递
eg1 :
def f1():
print('调用f1')
def f2():
print('调用f2')
def fx(fn):
print(fn)
fn()
fx(f1)
#>>><function f1 at 0x000000000305F158>
#>>>调用f1
fx(f2)
#>>><function f2 at 0x0000000001FDC1E0>
#>>>调用f2
eg2:
def fx(a,fn):
return fn(a)
L = [5,9,4,6]
print('最大值是:',fx(L,max)) #L->a ; max->fn ;fn(a) 同 max(L)
print('最小值是:',fx(L,min))
4. 函数作为返回值
函数可以返回另一个函数,(即:另一个函数可以返回一个函数)
eg: #示意函数作为函数的返回值
def get_fx():
s = input('请输入您要做的事:')
if s== '求最大' :
return max
elif s == '求和' :
return sum
elif s == '求最小' :
return min
L = [2,4,6,8,10]
print(L)
f1 = get_fx()
print(f1(L))
eg：
'''
写一个计算器解释执行器:
已知有如下函数:
def myadd(x, y): # 计算两个数相加
return x + y
def mymul(x, y): # 计算两个数相乘
return x * y
def get_op(s): # s 代表操作字符串:'加','乘'
此处自己实现
主函数:
def main():
while True:
s = input('请输入计算公式: ')#如:10 加 20
L = s.split() #字符串切割
a, s, b = L
a, b = int(a), int(b)
fn = get_op(s)
print("结果是: ", fn(a, b)) # 结果是30
'''
def myadd(x, y): # 计算两个数相加
return x + y
def mymul(x, y): # 计算两个数相乘
return x * y
def get_op(s) :# s 代表操作字符串:'加','乘'
if s == '加':
return myadd
elif s == '乘':
return mymul
# 主函数:
def main():
while True:
s = input('请输入计算公式: ')#如:10 加 20
L = s.split()
a, s, b = L
a, b = int(a), int(b)
fn = get_op(s)
print("结果是: ", fn(a, b)) # 结果是30
main()
5. 函数的嵌套
函数的嵌套是指一个函数里用def语句来创建其他的函数
eg :
def fn_outer() :
print('fn_outer被调用')
def fn_inner() :
print('fn_inner被调用')
fn_inner()
fn_inner()
print('fn_outer调用结束')
fn_outer()
#>>>fn_outer被调用；fn_inner被调用；fn_inner被调用；fn_outer调用结束
fn_inner() #>>>NameError,fn_inner是局部变量,不能外部访问
6. python作用域
作用域 也叫 名字空间,是访问变量时,查找变量名的范围空间
python的四个作用域 LEGB
局部作用域 Local function L
外部嵌套函数作用域 Enclosing Function Locals E
函数定义所在模块 Global(Mudule) G
(文件)的作用域
python内置模块的作用域 Builtin(python) B
变量名的查找规则 :
L ---> E ---> G ---> B
在默认情况下,对变量名赋值会创建或改变本作用域内的变量
eg :演示
v=100 #全局作用域 G
def fun1() :
v = 200 #外部嵌套函数的作用域 E
print('fun1内的v=',v)
def fun2() :
v = 300 #局部作用域 L
print('fun2内的v=',v)
fun2()
fun1()
print('v=',v)
#fun1内的v= 200
#fun2内的v= 300
#v= 100
7. global语句
global 语句 :
作用 :
1.global语句声明的一个或多个变量,这些变量的作用域为模块级的作用域,
也称作全局变量
2.全局声明(global)将赋值变量映射到模块内部的作用域
语法 :
global 变量1 变量2
说明 :
1.全局变量如果要在函数内部被赋值,则必须经过全局声明(否则会被认为是局部变量)
2.全局变量在函数内部不经过声明就可以直接访问
3.不能先声明局部的变量,再用global声明为全局变量,此做法不符合规则
4.global变量列表里的变量不能出现在此作用域内的形参列表里
eg :
v = 100
def fn():
global v
v = 200
fn()
print('v=',v) #200
8. nonlocal语句
nonlocal 语句 :
作用 :
告诉解释器,nonlocal生命的变量不是局部变量,也不是全局变量
而是外部嵌套函数内的变量
语法 :
nonlocal 变量名1 变量名2
说明 :
1.nonlocal语句只能在被嵌套函数内部进行使用
2.访问nonlocal变量将对外部嵌套函数的作用域的变量进行操作
3.当有两层或两层以上的函数嵌套时,
访问nonlocal变量对最近一层的变量进行操作
4.nonlocal语句的变量列表里的变量名,不能出现在此函数的参数列表中
eg1 :#示意nonlocal的用法
var = 100
def f1() :
var = 200
print('f1里的var=',var)
def f2() :
nonlocal var
var = 300
print('f2里的var=',var)
f2()
print('f2调用结束后的var值为',var)
f1()
print('全局的var = ',var)
#f1里的var= 200
#f2里的var= 300
#f2调用结束后的var值为 300
#全局的var = 100
eg2 :
def f1() :
v = 100
def f2():
v=200
def f3():
nonlocal v
v += 1
f3()
print('f2最后的v = ',v)
f2()
print('f1最后的v = ',v)
f1()
#f2最后的v = 201
#f1最后的v = 100
9. lambda表达式
lambda表达式(又称匿名函数)
作用:创建一个匿名函数对象,同def类似,但不提供函数名
语法: lambda [参数1,参数2,...] : 表达式 #只能写一行表达式
[] 里的内容可以省略
说明:
1.lambda 只是一个表达式,它用来创建一个函数对象
2.当lambda表达式调用时,先执行冒号后(:)的表达式,并返回表达式的结果的引用
3.lambda表达式创建的函数只能包含一条'表达式'
4.lambda比函数简单,且可以随时创建和销毁,有利于减少程序的偶合度
eg:
myadd = lambda x, y:x+ y
print('2+3=',myadd(2,3))
eg2:
(lambda x : x**2 + 5)(2)
#>>>9
#写一个lambda表达式判断一个数2次方+1是否能被5整除，
#能返回True反正False
fx = lambda x : True if (x**2+1)%5 == 0 else False
fx2 = lambda x : (x**2+1)%5 == 0 # 比较运算本身就返回T，F
fx(2) #>>>True fx(4) #>>>False
#写一个lambda表达式求两个变量的最大值:
fx = lambda x,y : x if x>y else y
fx(2,3)#>>>3 fx(4,2)#>>>4
#读以下代码
def fx(f,x,y):
print(f(x,y))
fx((lambda a,b:a+b),100,200)#>>>print((100+200))>>>300
fx((lambda a,b:a*b),3,4)#>>>print((3*4))>>>12
10. eval与exec函数
***eval()函数 : 表达式
格式: eval(source, global = None , locals = None)
作用:把一个字符串当成一个表达式来执行,返回表达式执行后的结果
如果该字符串不是一个表达式,就会出错
eg:
x = 100
y = 200
a = eval('x+y')
print(a)
-------------------------------------------------------
***exec()函数 : 字符串
格式:exec(source, global = None , locals = None)
作用:把一个字符串当成程序来执行
eg:
x = 100
y = 200
s = 'z = x+y; print(z); del z; print("z 已删除")'
exec(s) #执行s绑定的语句
#>>> 300
#>>> z 已删除
-------------------------------------------------------
eval() 和 exec() 的两个参数 globals 和 locals
此两个参数是用来设置'表达式'或'程序'运行的全局变量和局部变量
eg:
x = 100
y = 200
s = 'print(x, y, x+y)'
exec(s) #100 200 300
exec(s,{'x':10, 'y':20}) #10,20,30
exec(s,{'x':10}, {'x':1,'y':2}) #1 2 3
exec(s,{'x':10}, {'y':2}) #10 2 12
练习
'''定义一个函数myfun,用于实现两个参数的相关信息
def myfun (a, b):
....
1)打印两个参数的最大值
2)打印两个参数的和
3)打印两个参数的积(相乘)
4)打印从a开始到b结束的所有偶数
'''
def myfun(a,b):
print('两数最大值为 :',a if a>b else b)
print('两数和为 :', a + b)
print('两数积为 :', a * b)
L = []
for i in range(a,b):
if i % 2 == 0 :
L.append(i)
print('[a,b)内的偶数有:',L)
myfun(100,200)
'''猴子吃桃:
有一只猴子摘了很多淘,
第一天吃了全部桃子的一半,感觉不饱又吃了一个
第二天吃了剩下的一半,感觉不饱又吃了一个
...以此类推
到第十天发现只剩一个了
请问第一天摘了多少桃子
'''
1015
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
