lambda表达式与变量作用域

python程序设计叶明全版实验上机运行效果

1.

#c是局部变量
n = 1
def func(a,b):
    # global c #该句可解决运行错误
    c = a*b
    return c
if __name__ == "__main__":
    s = func("knock",2)
    print(c)      

## 2.

n = 1
def func(a,b):
    global n
    n = a*b
    return n
if __name__ == "__main__":
    s = func("knock",2)
    print(s) 

3.

global x
x = 20#函数外变量
def fun():
    x = 30#函数内变量
    x = x+20 #对函数内的x进行操作
    print("函数内变量x=",x)
    return x
if __name__ == "__main__":
    fun()
    x = x+40#对函数外的x进行操作
    print("函数外变量x=",x)  

## 4.

#求n的阶乘
def fact(n):
    if n==0:
        f = 1
    else:
        f = n*fact(n-1)
    return f
if __name__ == "__main__":
    n = int(input("请输入整数n(n>=0):"))
    print(n,"!=",fact(n))

## 5.

def test(x,alist):
    print("函数里的x的最初地址是：",id(x))
    print("函数里的alist的最初地址是：",id(alist))
    x += 1
    alist.append(3)
    print("加1操作后，函数里的x变量的值是：",x)#x的地址改变
    print("添加操作后，函数里的alist变量的值是：",alist)#alist的地址没有变
    print("加1操作后，函数里的x变量的地址是：",id(x))
    print("添加操作后，函数里alist变量的地址是：",id(alist))    
if __name__ == "__main__":
    alist = [1,2]
    x = 5
    print('最开始x的地址是',id(x))#最开始函数里的x的地址和函数外的x的地址是相同的
    print('最开始alist的地址是', id(alist))
    test(x, alist)
    print('最后函数外的x的值',x)#函数外x的值和函数里x的值不同
    print('最后函数外的alist的值',alist)#函数外的alist的值和函数里alist的值相同  
    print('最后函数外的x的地址',id(x))#函数外x的地址和函数里x的地址不同
    print('最后函数外的alist的地址',id(alist))#函数外的alist的地址和函数里alist的地址相同  

## 6.

#可变参数是指函数定义时标识带星（*）的参数，从而函数调用时允许向函数传递可变数量的实参
# *parameter：接收多个参数并放在一个元组中
# **parameter:接收多个关键参数并存放到一个字典中
def vfunc(a=0,*b):#*b是一个可变参数，不管传入值的类型是什么，他都是一个元组类型的
    print(type(b))
    for n in b:
        a += n
    return a
if __name__ == "__main__":
    print(vfunc(1,2,3,4,5))

7.

def afunc(t="",**b):
    print(type(b))
    for item in b.items():
        print(item)
        t += item[1]#把每个item元组的值取出来赋值给t并连接
    return t
if __name__ == "__main__":
    print(afunc(x="1",y="2",z="3"))

8.

# 匿名函数
# lambda[形参表]：表达式表
# 函数名 = lambda[形参表]：表达式表
# def 函数名([形参表])：
#     return 表达式表         
f = lambda x,y,z:x+y+z
g = lambda x,y=2,z=3:x+y+z
d = {"f1":(lambda:2+3),"f2":(lambda: 2*3),"f3":(lambda:2**3)}#d是一个字典，键相当于是函数名，值是匿名函数，且该匿名函数没有形参，直接是函数表达式
print(f(1,2,3),g(1))
print(type(d))
print(d["f1"](),d["f2"](),d["f3"]())#通过字典的键访问对应的值的函数。

9.

f = lambda x,y,z: x*y*z
print(f(3,4,5))
L = [(lambda x: x**2),(lambda x:x**3),(lambda x:x**4)]#把匿名函数放到列表中，有三个匿名函数
print(L[0](2),L[1](2),L[2](2))
print(type(L[0]))