1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
一、内置函数
 
zip 函数:  zip ()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的
元素按顺序组合成一个 tuple ，每个 tuple 中包含的是原有序列中对应序号位置的元素，然后返回由
这些tuples组成的 list 。若传入参数的长度不等，则返回 list 的长度和参数中长度最短的对象相同。
在所有参数长度相同的情况下， zip ()与 map ()类似，没有参数的情况下 zip ()返回一个空 list
 
例子:
l1  =  [ 1 , 2 , 3 , 4 ]
l2  =  [ 'a' , 'b' , 'c' , 'd' ]
for  i  in  zip (l1,l2):
     print (i)
返回结果:[( 1 , 'a' ),( 2 , 'b' ),( 3 , 'c' ),( 4 , 'd' )]
 
filter 函数:  filter 函数是 Python 内置的另一个有用的高阶函数， filter ()函数接收一个函数
f和一个 list ，这个函数 f 的作用是对每个元素进行判断，返回  True 或  False ， filter ()
根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新 list .
例子:
def  add(n): return  n  /  2  = =  1
for  i  in  filter (add, [ 1 , 2 , 3 , 4 ]):
     print (i)         #打印2
     
map 函数:  map ()是 Python 内置的高阶函数，它接收一个函数 f 和一个  list ，并通过把函数f依次
作用在  list  的每个元素上，得到一个新的  list  并返回。
例子:
l  =  [ 1 , 2 , 3 , 4 ]
def  add(x):
     return  x + 1
for  i  in  map (add,l):
     print (i)
 
reduce 函数:  reduce ()函数接收的参数和  map ()类似，一个函数 f，一个 list ，但行为和  map ()不同，
reduce ()传入的函数 f 必须接收两个参数， reduce ()对 list 的每个元素反复调用函数f，
并返回最终结果值
例子:
from  functools  import  reduce
l  =  [ 1 , 2 , 3 , 4 , 5 ]
print ( reduce ( lambda  x,y: x + y, l,  10 ))      #参数10是可选参数，作为初始值
    
二、匿名函数 lambda
     1.lambda 只是一个表达式，函数体比 def 简单很多。
     2.lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
     3.lambda 表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
     
     例子:
     f  =  lambda  x,y: x + y         #x,y是参数，x+y是表达式，然后赋值给f
     print (f)         #返回f的内存地址
     print (f( 1 , 2 ))     #返回表达式的值
     
     l  =  [ 'alex' ,  'wupeiqi' ,  'yuanhao' ]
     res  =  map ( lambda  x: x  +  '_SB' , l)
     print (res)
     print ( list (res))
     
     nums  =  [ 2 , 4 , 6 , 9 ]
     res1  =  map ( lambda  x: x * * 2 , nums)
     print ( list (res1))
     
     
     
三、递归调用
     在函数调用过程中，直接或间接调用函数本身，这就是函数的递归调用
     例子:
     def  age(n):
         if  n  = =  1 :
             return  18
         return  age(n - 1 )  +  2
     print (age( 5 ))
     
     l  =  [ 1 ,  2 ,  10 , 33 , 53 , 71 , 73 , 75 , 77 , 85 , 101 , 201 , 202 , 999 , 11111 ]
     
     def  search(find_num,seq):
         if  len (seq)  = =  0 :
             print ( 'not exists' )
             return
         mid_index = len (seq) / / 2
         mid_num = seq[mid_index]
         print (seq,mid_num)
         if  find_num > mid_num:
             #in the right
             seq = seq[mid_index + 1 :]
             search(find_num,seq)
         elif  find_num < mid_num:
             #in the left
             seq = seq[:mid_index]
             search(find_num,seq)
         else :
             print ( 'find it' )
 
     search( 77 ,l)
     
四、包、模块
     import  spam
     
     import  导入模块做三件事
     1. 产生新的名称空间
     2. 以新建的名称空间为全局名称空间，执行文件代码
     3. 拿到一个模块名spam，指向spam.py产生的名称空间
     import  spam as x     #将spam用x代替，适合模块名过长时使用
     
     from  ...  import  ...
     优点: 方便、不用加前缀
     缺点: 容易跟当前的文件名称冲突
     
     包: 将有联系的模块组织到一起，有效避免模块名称冲突问题，让组织结构更加清晰。
     一个标准的应用程序结构:
     app /
         __init__.py         #__init__.py做一些初始化工作可以是空文件，也可以写一些初始配置
         a /
             __init__.py
             a.py
         b /
             __init__.py
             b.py
      from  app.a  import  a
      from  app.b.b  import  test     # "."左边必须是包名
      a.test()    
      test()
      
      可以将包加入sys.path环境变量的位置，或者把包所在的位置加入到环境变量