Python之路，第十一篇：Python入门与基础11
python3 函数2
全局变量：一直存在
局部变量：函数执行时存在，执行完毕后销毁；
lambda 表达式（又称匿名函数表达式）
作用： 创建一个匿名（无名）函数对象， 同 def 类似但不提供函数名；
语法： lambda [参数1 ，参数2， .......] :表达式 ； 注: [ ] 内部分表示可以省略；
语法说明： 1，lambda 只是一个表达式，它用来创建一个函数对象；
2， 当lambda 表达式执行（调用）时，返回的是冒号（：）后表达式的值；
3， lambda表达式创建的函数只能包含一条语句；
4，lambda比函数简单且可以随时创建和销毁；
5，lambda 有利于减少程序的耦合度；
例子：#def myadd(x,y):
return x + y
#可以写成 myadd = lambda x,y : x + y
1 myadd = lambda x, y: x + y 2 print(myadd) 3 print("20 + 30 =", myadd(20, 30)) 4 #结果 5 #<function <lambda> at 0x0000000001CECB70> 6 #20 + 30 = 50 7 8 print("100 + 200 =",(lambda x,y:x+y)(100,200)) 9 #100 + 200 = 300 10 11 def operator(fn, x, y): 12 return fn(x, y) 13 14 15 operator((lambda a,b: a+b),100, 200) 16 operator((lambda a,b: a*b),100, 200) 17 #结果 18 #300 19 #20000
练习：
1 #求两个变量的最大值 2 print((lambda x,y:x if x>y else y)(100,200)) #200 3 print((lambda x,y:x if x>y else y)(300,200)) #300 4 #1 5 def mymax(x,y): 6 if x > y: 7 return x 8 return y 9 10 mymax(200,300) 11 #2 12 def mymax2(x,y): 13 return max(x,y) 14 15 #3 16 def mymax3(x,y): 17 return x if x>y else y
globals() / locals() 函数
globals() 返回当前全局作用域内变量的字典；
locals() 返回单曲局部作用域内变量的字典；
1 a = 1 2 b = 2 3 def fn(c, d): 4 e = 300 5 print("locals返回：",locals()) 6 print("globals返回：",globals()) 7 8 9 fn(100, 200) 10 #locals返回： {'e': 300, 'c': 100, 'd': 200} 11 #globals返回： {'a': 1, '__spec__': None, '__name__': '__main__', 'fn': <function fn at 0x00000000004CCB70>, '__cached__': None, '__file__': 'C:/Users/hiber/PycharmProjects/ZiZhen/2018年5月/0510/函数2.py', 'b': 2, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, '__loader__': <_frozen_importlib.SourceFileLoader object at 0x000000000078C3C8>, '__doc__': None}
1 a = 1 2 b = 2 3 def fn(c, d): 4 e = 300 5 print("locals返回：",locals()) 6 print("globals返回：",globals()) 7 m = globals() #全局变量 8 m['b']=500 9 10 fn(100,200) 11 print(b) #500
eval() , exec()函数
eval() 函数：
作用： 把一个字符串当成一个表达式来执行，返回表达式执行后的结果；
eval() 格式：eval(source[, globals[, locals]]) -> value
例子：
1 x = 100 2 y = 200 3 a = eval("x+y") 4 print(a) #300 5 6 s = input("请输入一个字符串：") 7 a = eval(s) 8 print(a) 9 # 10 #300 11 #请输入一个字符串：x+y+x 12 #400
1 local_score = {'x': 5, 'y':10} 2 a = eval("x + y", None, local_score) 3 print("a=",a) #a=15 4 z = 300 5 a = eval("x * y + z", {'z': 3333},local_score) 6 print(a) #3383
exec()函数
作用：把一个字符串当做程序来执行
格式：exec(object[, globals[, locals]]) ；注：globals，locals的作用同eval
例子：
1 x = 100 2 y = 200 3 s = "print('hello:',x,y)" 4 exec(s) #hello: 100 200 5 #
1 gs = {'x':10 , 'y':20} 2 ls = {'x':1 , 'y':2} 3 exec("z = x + y",gs,ls) 4 print(ls) #{'y': 2, 'z': 3, 'x': 1} 5 print(gs)
练习：写一个程序解释执行器
1 g = {} 2 l = {} 3 while True: 4 s = input("请输入程序: >>>") 5 if s == "break": 6 break 7 exec(s, g, l) 8 9 # 10 #请输入程序: >>>x = 100 11 #请输入程序: >>>y = 100 12 #请输入程序: >>>print( "x + y", x + y) 13 #x + y 200 14 #请输入程序: >>>break 15 #
闭包 closure
概念：将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象称为闭包；
说明： 如果一个内嵌函数访问函数外部作用域的变量，则这个函数就是闭包
1 def func(x): 2 def fn(arg): 3 return arg ** x 4 return fn 5 6 7 f1 = func(2) 8 y = f1(100) 9 print(y) #10000 10 # 11 f2 = func(3) 12 print(f2(3)) #27 13 # 14 f3 = func(4) 15 print(f3(2)) #16
函数式编程
概念： 是指用一系列函数解决问题；
函数是一等公民；
函数式编程的好处：
1，每个函数完成细小的功能， 一系列函数的任意组合可以完成大问题；
2，函数仅接收输入并产生输出，不包含任何可能影响输出的内部状态；
函数的可重入性：
可重入性是指输入一定，则输出必须一定
例：
#不可重入的函数：
1 y = 200 2 def myadd(x): 3 return x + y 4 5 print(myadd(10)) #210 6 7 y = 300 8 print(myadd(10)) #310
#可重入的函数：
1 def add2(x,y): 2 return x + y
优点： 易于测试，易于调试，更高的生产率，模块化，逻辑可证
高阶函数：
什么是高阶函数：
满足下列条件中的一个的函数即为高阶函数：
1， 函数结束一个或多个函数作为参数传入
2，函数返回一个函数
python中内置（builtins）的高阶函数：
map， filter ， sorted
map函数：
map（func， *iterable）用函数和可迭代对象中的每个元素作为参数计算出新的可迭代对象，当最短的一个可迭代对象完成迭代后，此迭代生成结束；
例：
1 #例 2 def power2(x): 3 return x ** 2 4 #生成一个迭代器，此迭代器可以生成1-9的自然数的平方； 5 #1,4,9,16... 6 mit = map(power2, range(1,10)) 7 print(mit) #<map object at 0x000000000219C4E0> map生成一个可迭代对象 8 for x in mit: 9 print(x, end=' ') 10 11 #1 4 9 16 25 36 49 64 81
练习：生成一个迭代器，此迭代器可以生成 1*4 ， 2*3 ， 3*2， 4*
1 def fn(x,y): 2 return x * y 3 4 mit2 = map(fn, [1,2,3,4], [4,3,2,1]) 5 #for x in mit2: 6 # print(x, end=' ') 7 a = [x for x in mit2 ] 8 print(a) #[4, 6, 6, 4]
练习：
1 #给出一个数n，写一个函数计算 1+2**2+3**3+ ...+ n*n的和； 2 #用pow， sum， map ，range函数 3 n = int(input("Please enter:")) 4 def func(x): 5 return pow(x, x) 6 7 s1 = sum(map(func, range(1, n))) 8 print(s1)
1 #1 2 def mysum(n): 3 def power(x): 4 #return x ** x 5 return pow(x, x) 6 mit = map(power, range(1, n + 1)) 7 return sum(mit) 8 9 print(mysum(10)) 10 #2 11 def mysum(n): 12 return sum(map(lambda x:pow(x,x),range(1, n + 1))) 13 14 print(mysum(10)) 15 #3 16 def mysum(n): 17 return sum(map(pow, range(1, n + 1),range(1, n + 1))) 18 19 print(mysum(10))
1 #求 1**9 +2**8 + ....+ 9**1的和； 2 def mysum(n): 3 return sum(map(lambda x,y:pow(x, y),range(1,n + 1),range(n, 0,-1))) 4 5 6 print(mysum(9)) #11377
filter 函数
filter( function or None, iterable) --> filter object
作用： 筛选序列中数据，返回一个可迭代对象，此刻迭代对象将对iterable 进行筛选；
说明 ： function 将对iterable中的每个元素进行求值，返回False则将此数据丢弃，返回True， 则保留此数据；
例子： L = [x for x in range(10) ] #[0,1,2,3,4,5,6,7,8,9]
1 def isadd(x): #如果为奇数返回True 2 return x % 2 ==1 3 4 L = [x for x in filter(isadd,range(10))] 5 print(L) #[1, 3, 5, 7, 9]
sorted 函数
作用： 将原可迭代对象的数据进行排序，生成排序后的列表；
格式：sorted(iterable, key=None, reverse=False) --> new sorted list
说明： key函数用来提供一个值，这个值将作为排序的依据；
例子：
1 L = [5, -2, -3, 0, 1, -4] 2 L1 = sorted(L) 3 print(L1) #[-4, -3, -2, 0, 1, 5] 4 L2 = sorted(L, reverse=True) 5 print(L2) #[5, 1, 0, -2, -3, -4] 6 L3 = sorted(L, key=abs) 7 print(L3) #绝对值[0, 1, -2, -3, -4, 5] 8 names = ['Tom', 'Jack', 'Xiaoli', 'Ming'] 9 s1 = sorted(names) 10 print(s1) #['Jack', 'Ming', 'Tom', 'Xiaoli'] 11 s2 = sorted(names, key=len) 12 print(s2) #'Tom', 'Jack', 'Ming', 'Xiaoli'] 13 s3 = sorted(names, reverse=True) 14 print(s3) #['Xiaoli', 'Tom', 'Ming', 'Jack'] 15 #思考 16 #排序依次：'moT' 'kcaJ' 'gniM' 'iloaiX' 17 # 3 2 0 1 18 def k(x): 19 return x[::-1] 20 21 s5 = sorted(names, key=k) 22 print(s5) #['Ming', 'Xiaoli', 'Jack', 'Tom'] 23 # 24 s6 = sorted(names,key=lambda x:x[::-1]) 25 print(s6) #['Ming', 'Xiaoli', 'Jack', 'Tom']
递归函数 recursion
函数直接或间接的调用自身
例子：
1 def f(): 2 print("hello") 3 f() 4 5 f() #调用函数 6 print("调用完成")
说明：递归一定要控制递归层数，当符合某一个条件时要终止递归调用几乎所有的递归都能用while循环来替代；
优点： 可以把问题简化，让思路更清晰，代码更简洁；
缺点：递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果；
1 #计算阶乘 2 #循环实现 3 def myfac(x): 4 r = 1 5 for i in range(1, x + 1): 6 r *= i 7 return r 8 9 10 print("5的阶乘：", myfac(5)) # 11 12 # 13 def func(n): 14 if n == 1: 15 return 1 16 return n * func(n - 1) 17 18 19 print("5!=", func(5)) #5!= 120
练习：
1 #1,用filter函数将1~100之间的所有素数prime放入到列表中打印出来 2 def p(x): 3 if x <= 1: 4 pass 5 else: 6 return x % 2 == 1 7 8 9 L = filter(p, range(1,101)) 10 #print(L) 11 L1 = [] 12 for x in L: 13 L1.append(x) 14 #print(x, end=' ') 15 print(L1) 16 # 17 #[3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]
