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

 myadd = lambda x, y: x + y
 print(myadd)
 print("20 + 30 =", myadd(20, 30))
 #结果
 #<function <lambda> at 0x0000000001CECB70>
 #20 + 30 = 50

 print("100 + 200 =",(lambda x,y:x+y)(100,200))
 #100 + 200 = 300

 def operator(fn, x, y):
     return fn(x, y)

 operator((lambda a,b: a+b),100, 200)
 operator((lambda a,b: a*b),100, 200)
 #结果
 #
 #

练习：

 #求两个变量的最大值
 print((lambda x,y:x if x>y else y)(100,200))  #
 print((lambda x,y:x if x>y else y)(300,200))  #
 #
 def mymax(x,y):
     if x > y:
         return x
     return y

 mymax(200,300)
 #
 def mymax2(x,y):
     return max(x,y)

 #3
 def mymax3(x,y):
     return x if x>y else y

globals()  / locals() 函数

globals() 返回当前全局作用域内变量的字典；

locals()  返回单曲局部作用域内变量的字典；

 a = 1
 b = 2
 def fn(c, d):
     e = 300
     print("locals返回：",locals())
     print("globals返回：",globals())

 fn(100, 200)
 #locals返回： {'e': 300, 'c': 100, 'd': 200}
 #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}

 a = 1
 b = 2
 def fn(c, d):
     e = 300
     print("locals返回：",locals())
     print("globals返回：",globals())
     m = globals()  #全局变量
     m['b']=500

 fn(100,200)
 print(b)  #

eval() , exec()函数

eval() 函数：

作用： 把一个字符串当成一个表达式来执行，返回表达式执行后的结果；

eval() 格式：eval(source[, globals[, locals]]) -> value

例子：

 x = 100
 y = 200
 a = eval("x+y")
 print(a)  #

 s =  input("请输入一个字符串：")
 a = eval(s)
 print(a)
 #
 #
 #请输入一个字符串：x+y+x
 #

 local_score = {'x': 5, 'y':10}
 a = eval("x + y", None, local_score)
 print("a=",a)  #a=15
 z = 300
 a = eval("x * y + z", {'z': 3333},local_score)
 print(a)  #

exec()函数

作用：把一个字符串当做程序来执行

格式：exec(object[, globals[, locals]])    ；注：globals，locals的作用同eval

例子：

 x = 100
 y = 200
 s = "print('hello:',x,y)"
 exec(s)    #hello: 100 200
 #

 gs = {'x':10 , 'y':20}
 ls = {'x':1 , 'y':2}
 exec("z = x + y",gs,ls)
 print(ls)  #{'y': 2, 'z': 3, 'x': 1}
 print(gs)

练习：写一个程序解释执行器

 g = {}
 l = {}
 while True:
     s = input("请输入程序: >>>")
     if s == "break":
         break
     exec(s, g, l)

 #
 #请输入程序: >>>x = 100
 #请输入程序: >>>y = 100
 #请输入程序: >>>print( "x + y", x + y)
 #x + y 200
 #请输入程序: >>>break
 #

闭包   closure

概念：将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象称为闭包；

说明： 如果一个内嵌函数访问函数外部作用域的变量，则这个函数就是闭包

 def func(x):
     def fn(arg):
         return arg ** x
     return fn

 f1 = func(2)
 y = f1(100)
 print(y)   #
 #
 f2 = func(3)
 print(f2(3))  #
 #
 f3 = func(4)
 print(f3(2))  #

函数式编程

概念： 是指用一系列函数解决问题；

函数是一等公民；

函数式编程的好处：

1，每个函数完成细小的功能， 一系列函数的任意组合可以完成大问题；

2，函数仅接收输入并产生输出，不包含任何可能影响输出的内部状态；

函数的可重入性：

可重入性是指输入一定，则输出必须一定

例：

#不可重入的函数：

 y = 200
 def myadd(x):
     return x + y

 print(myadd(10)) #

 y = 300
 print(myadd(10))  #

#可重入的函数：

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

优点： 易于测试，易于调试，更高的生产率，模块化，逻辑可证

高阶函数：

什么是高阶函数：

满足下列条件中的一个的函数即为高阶函数：

1， 函数结束一个或多个函数作为参数传入

2，函数返回一个函数

python中内置（builtins）的高阶函数：

map， filter ， sorted

map函数：

map（func， *iterable）用函数和可迭代对象中的每个元素作为参数计算出新的可迭代对象，当最短的一个可迭代对象完成迭代后，此迭代生成结束；

例：

 #例
 def power2(x):
     return x ** 2
 #生成一个迭代器，此迭代器可以生成1-9的自然数的平方；
 #1,4,9,16...
 mit = map(power2, range(1,10))
 print(mit) #<map object at 0x000000000219C4E0>  map生成一个可迭代对象
 for x in mit:
     print(x, end=' ')

 #1 4 9 16 25 36 49 64 81

练习：生成一个迭代器，此迭代器可以生成 1*4 ， 2*3 ， 3*2， 4*

 def fn(x,y):
     return x * y

 mit2 = map(fn, [1,2,3,4], [4,3,2,1])
 #for x in mit2:
 #    print(x, end=' ')
 a = [x for x in mit2 ]
 print(a) #[4, 6, 6, 4]

练习：

 #给出一个数n，写一个函数计算 1+2**2+3**3+ ...+ n*n的和；
 #用pow， sum， map ，range函数
 n = int(input("Please enter:"))
 def func(x):
     return pow(x, x)

 s1 = sum(map(func, range(1, n)))
 print(s1)

 #
 def mysum(n):
     def power(x):
         #return x ** x
         return pow(x, x)
     mit = map(power, range(1, n + 1))
     return sum(mit)

 print(mysum(10))
 #
 def mysum(n):
     return sum(map(lambda x:pow(x,x),range(1, n + 1)))

 print(mysum(10))
 #
 def mysum(n):
     return sum(map(pow, range(1, n + 1),range(1, n + 1)))

 print(mysum(10))

 #求 1**9 +2**8 + ....+ 9**1的和；
 def mysum(n):
     return sum(map(lambda x,y:pow(x, y),range(1,n + 1),range(n, 0,-1)))

 print(mysum(9))  #

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]

 def isadd(x):  #如果为奇数返回True
     return x % 2 ==1

 L = [x for x in filter(isadd,range(10))]
 print(L)  #[1, 3, 5, 7, 9]

sorted 函数

作用： 将原可迭代对象的数据进行排序，生成排序后的列表；

格式：sorted(iterable, key=None, reverse=False) --> new sorted list

说明： key函数用来提供一个值，这个值将作为排序的依据；

例子：

 L = [5, -2, -3, 0, 1, -4]
 L1 = sorted(L)
 print(L1)  #[-4, -3, -2, 0, 1, 5]
 L2 = sorted(L, reverse=True)
 print(L2)  #[5, 1, 0, -2, -3, -4]
 L3 = sorted(L, key=abs)
 print(L3)  #绝对值[0, 1, -2, -3, -4, 5]
 names = ['Tom', 'Jack', 'Xiaoli', 'Ming']
 s1 = sorted(names)
 print(s1) #['Jack', 'Ming', 'Tom', 'Xiaoli']
 s2 = sorted(names, key=len)
 print(s2) #'Tom', 'Jack', 'Ming', 'Xiaoli']
 s3 = sorted(names, reverse=True)
 print(s3)  #['Xiaoli', 'Tom', 'Ming', 'Jack']
 #思考
 #排序依次：'moT'  'kcaJ'  'gniM'   'iloaiX'
 #           3      2         0        1
 def k(x):
     return x[::-1]

 s5 = sorted(names, key=k)
 print(s5) #['Ming', 'Xiaoli', 'Jack', 'Tom']
 #
 s6 = sorted(names,key=lambda x:x[::-1])
 print(s6) #['Ming', 'Xiaoli', 'Jack', 'Tom']

递归函数 recursion

函数直接或间接的调用自身

例子：

 def f():
     print("hello")
     f()

 f() #调用函数
 print("调用完成")

说明：递归一定要控制递归层数，当符合某一个条件时要终止递归调用几乎所有的递归都能用while循环来替代；

优点： 可以把问题简化，让思路更清晰，代码更简洁；

缺点：递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果；

 #计算阶乘
 #循环实现
 def myfac(x):
     r = 1
     for i in range(1, x + 1):
         r *= i
     return r

 print("5的阶乘：", myfac(5)) #

 #
 def func(n):
     if n == 1:
         return 1
     return n * func(n - 1)

 print("5!=", func(5)) #5!= 120

练习：

 #1,用filter函数将1~100之间的所有素数prime放入到列表中打印出来
 def p(x):
     if x <= 1:
         pass
     else:
         return  x % 2 == 1

 L = filter(p, range(1,101))
 #print(L)
 L1 = []
 for x in L:
     L1.append(x)
     #print(x, end=' ')
 print(L1)
 #
 #[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]