day03.1-函数编程

python中函数的定义：

 def test (x,y):
     "The function definitions"
     z = x**y
     return z

 """
 def：定义函数的关键字
 test：函数名
 ()：内可定义形参
 z=x**y：函数功能实现代码块
 return：运算结果返回
 """

一. 函数的特征

    1. 当python中函数通过return语句返回多个值时，默认以元组方式打包后一次性返回。

2. 位置参数调用方式：实参与形参位置一一对应；如test(2,3)；

关键字参数调用方式：实参与形参位置不必一一对应，但需指定形参名与对应的实参值；如test(y=3,x=2)；

当两种调用方式混合使用时，位置参数调用必须位于关键字参数调用后面；如test(2,y=3)。

3. 默认参数：在函数定义时可以为其中某一参数赋予默认值；当调用该函数时，可以为默认参数传入实参，也可以使用默认值。如def test(x,type="mysql")。

4. 参数组：* 列表，** 字典。

 def test (x,*args):
     print(x)
     print(args)
     print(args[0])

 test(1,2,3,4,5,6)
 print("--"*20)
 test(1,[2,3,4,5,6])
 print("--"*20)
 test(1,*[2,3,4,5,6])

 """
 运行结果：
     1
     (2, 3, 4, 5, 6)
     2
     ----------------------------------------
     1
     ([2, 3, 4, 5, 6],)
     [2, 3, 4, 5, 6]
     ----------------------------------------
     1
     (2, 3, 4, 5, 6)
     2
 """

 def test (x,**kwargs):
     print(x)
     print(kwargs)

 test(1,y=2,z=3)
 print("--"*20)
 test(1,**{"y":2,"z":3})

 """
 运行结果：
     1
     {'y': 2, 'z': 3}
     ----------------------------------------
     1
     {'y': 2, 'z': 3}
 """

 def test (x,*args,**kwargs):
     print(x)
     print(args)
     print(kwargs)

 test(11,22,33,44,y=55,z=66)
 print("--"*20)
 test(11,*[22,33,44],**{"y":55,"z":66})

 """
 运行结果：
     11
     (22, 33, 44)
     {'y': 55, 'z': 66}
     ----------------------------------------
     11
     (22, 33, 44)
     {'y': 55, 'z': 66}
 """

 def test1(name,age,gender):
     print(name)
     print(age)
     print(gender)
 def test2(*args, **kwargs):
     test1(*args, **kwargs)    #args=("alex",18,"male")  kwargs={}
 test2("alex",18,"male")

 """
 运行结果：
     alex
     18
     male
 """     

5. 局部变量与全局变量

在子函数中定义的变量称为局部变量，局部变量只在子函数运行期间有效；在主函数中定义的变量称为全局变量，全局变量在整个程序运行期间都有效；

在子函数中声明、调用与修改全局变量，global 全局变量名；在子函数中声明、调用与修改上一级函数中变量，nonlocal 变量名；

 daxia = "令狐冲"
 print(daxia)    #在主函数中，访问全局变量daxia对应的值
 def test1():
     global daxia
     daxia = "风清扬"   #在子函数中，修改并访问全局变量值
 test1()
 print(daxia)       #检查test1修改后全局变量值

 """
 运行结果：
     令狐冲
     风清扬
 """

 def test1():
     daxia = "令狐冲"
     print(daxia)       #在子函数内部，访问局部变量daxia对应的值
     def test2():
         nonlocal daxia
         daxia = "风清扬"   #在子函数中，修改并访问上一级函数变量值
     test2()
     print(daxia)       #检查test2修改后局部变量值
 test1()

 """
 运行结果：
     令狐冲
     风清扬
 """ 

当局部变量与全局变量同名时，在子函数运行期间，局部变量有效，在子函数退出后，全局变量有效。

 daxia = "令狐冲"
 def test1 ():
     daxia = "李寻欢"
     print(daxia)      #在子函数内部，访问局部变量daxia对应的值
 test1()
 print(daxia)    #在主函数中，访问全局变量daxia对应的值

 """
 运行结果：
     李寻欢
     令狐冲
 """

6. 函数作用域由函数定义过程决定，与函数的调用过程无关。

二. 递归函数

    如果一个函数在内部调用自身，则这个函数就是递归函数。递归函数有以下特点：

1. 必须有一个明确的结束条件；

2. 每次进入更深一层递归时，问题规模比上一次递归应有所减少；

3. 递归执行效率不高，递归次数过多会导致内存溢出。

 def calc(n):
     print(n)
     if int(n/2)==0:
         return n
     res = calc(int(n/2))
     return res
 res = calc(10)
 print(res)

 """
 运行结果：
     10
     5
     2
     1
     1
 """

运行过程分析：

三. 匿名函数

匿名函数定义方法：lambda 形参：逻辑操作

lambda函数的返回结果为该函数的地址。

 func = lambda x,y:(x+1,y+1)    #将匿名函数的地址重新赋值给名为func的子函数
 n = func(10,11)    #通过名为func的子函数获取lambda函数的运行结果：(10+1,11+1)
 print(n)

 """
 运行结果：(11, 12)
 """

四. 高阶函数

    满足以下条件之一的函数称为高阶函数：

1. 函数接收的参数中包含函数名

 def foo(n):
     print(n)
 def bar(name):
     print("my name is",name)
     return name
 foo(bar("alex"))

 """
 运行结果：
     my name is alex
     alex
 结果分析：子函数bar()的运行结果作为foo()的输入，依次调用bar()与foo()
 """

2. 函数返回值中包含函数名

 def foo():
     print("from foo")
 def bar():
     print("from bar")
     return foo
 n = bar()     #通过调用函数bar()将子函数foo()的地址赋值给变量n
 n()     #相当于foo()

 """
 运行结果：
     from bar
     from foo
 """

 name = "alex"
 def bar():
     name = "rabin"
     def foo():
         print(name)
     return foo
 n = bar()     #通过调用函数bar()将子函数foo()的地址赋值给变量n
 print(n)
 n()     #相当于foo()

 """
 运行结果：
     <function bar.<locals>.foo at 0x000001CA041E16A8>
     rabin
 """

 def bar():
     name = "alex"
     def foo():
         name = "rabin"
         def tt():
             print(name)
         return tt
     return foo
 n = bar()     #通过调用函数bar()将子函数foo()的地址赋值给变量n
 print(n)
 m = n()      #相当于foo()，将子函数tt()的地址赋值给变量m
 print(m)
 m()     #相当于foo()

 """
 运行结果：
     <function bar.<locals>.foo at 0x0000021720DC76A8>
     <function bar.<locals>.foo.<locals>.tt at 0x0000021720DC7730>
     rabin
 """

五.   map函数

1. 函数调用：res = map(func,list)

2. 函数功能描述：对list序列中每个元素进行指定的func函数功能操作，输出序列中元素个数及位置保持不变。

3. 示例代码：

 num_list = [11,22,33,44,55]
 res = map(lambda x:x+1,num_list)
 print(list(res))

 """
 运行结果：[12, 23, 34, 45, 56]
 结果分析：对序列num_list中的每个元素值+1
 """

4. 等同功能函数实现代码：

 num_list = [11,22,33,44,55]
 def map_test(func,num_list):
     res = []
     for item in num_list:
         a = func(item)
         res.append(a)
     return res
 res = map_test(lambda x:x+1,num_list)
 print(list(res))

 """
 运行结果：[12, 23, 34, 45, 56]
 结果分析：对序列num_list中的每个元素值+1
 """

六. filter函数

1. 函数调用：filter(func,list)

2. 函数功能描述：遍历筛选出list序列中所有满足func逻辑的元素。

3. 示例代码：

 num_list = ["李寻欢","令狐冲","风清扬","李世民","萧峰"]
 res = filter(lambda x:x.startswith("李"),num_list)
 print(list(res))

 """
 运行结果：['李寻欢', '李世民']
 结果分析：筛选出序列num_list中以"李"开头的元素
 """

4. 等同功能函数实现代码：

 num_list = ["李寻欢","令狐冲","风清扬","李世民","萧峰"]
 def filter_test(func,num_list):
     res = []
     for item in num_list:
         if func(item):
             res.append(item)
     return res
 res = filter_test(lambda x:x.startswith("李"),num_list)
 print(list(res))

 """
 运行结果：['李寻欢', '李世民']
 结果分析：筛选出序列num_list中以"李"开头的元素
 """

七. reduce函数

1. 函数调用：reduce(func,list,initial=None)

2. 函数功能描述：对list序列中的每个元素进行func函数功能操作，输出元素个数发生变化

3. 示例代码：

 from functools import reduce
 num_list = [11,22,33,44]
 res = reduce(lambda x,y:x+y,num_list)
 print(res)

 """
 运行结果：110
 结果分析：计算序列num_list中所有元素之和
 """

4. 等同功能函数实现代码：

 num_list = [11,22,33,44]
 def reduce_test(func,num_list,init=None):
     if init is None:
         res = num_list.pop(0)
     else:
         res = init
     for item in num_list:
         res = func(res,item)
     return res
 res = reduce_test(lambda x,y:x+y,num_list)
 print(res)

 """
 运行结果：110
 结果分析：计算序列num_list中所有元素之和
 """