python基础之函数

函数

定义函数

因为我们的函数是实现某一个功能的代码块，所以你的函数名字一定要和你要实现的功能相关联且有意义。

def 函数名(参数):  #这里 def = define。 函数(参数）这个参数：专业名词：形参(形式参数) 定义函数的时候，指定函数需要传递多少个参数，以及参数的名称。
#参数分类：1.positional arguments: 位置参数: 按位置去找
#        2.keywork arguments: 关键字参数: 按关键字去找        
#        语句1
#        语句2
#        语句3
       return valu1，value2，value3
注意：1.这块只是定义，并没有去使用它，所以只有调用他的时候，它才执行一次定义，多次使用。
     2.python中不支持函数的重载: 同一函数名，不同的参数个数或者不同的参数类型   
      参数：可以没有，也可以是一个或多个，如果是多个用逗号分隔。
     3.传参时如果没有特别说明的话：
            可以使用位置参数这种形式去传参
            也可以使用关键字参数这种形式去传参
            也可以混合使用,但是有限制: 关键字参数必须跟在位置参数之后
     4.在传递参数时候，默认按照定义函数内参数顺序的去赋值。
     5.如果传递关键字参数，按对应key值传递参数,并且传递参数时，位置参数必须在关键字。参数只前传递参数，否则会报语法错误。
     6.若在定义的参数中关键字参数给值，在传递参数中若传递参数有值将会按照此值传递，若没有值，默认定义的关键字参数的值传递。
     7.如果使用了关键字参数的形式,等号左右两边不要加空格。     
这里我们先简单定义几个个：
def print_info():
    print("我爱Python")
print_info()
结果： 我爱python
def data_value():
    return 6, 6, 6 #这里默认返回以元组形式
data= data_value()
print(data)
结果：（6，6，6）
def default_value_function(arg1, arg2, arg3=3):
    print(arg1, arg2, arg3)
default_value_function(1, 2, 5)
default_value_function(1, 2)
arg_function(arg1=1, arg2=2)
结果：
1 2 5
1 2 3
2 args: 1 2


特殊参数：
*args：表示多个位置参数。（默认传递的多个参数打包为元组）。并且关于*args参数名不固定，可以任意名，但前必须加*。如*data，*test，*var等。
用途：在你定义函数的时候，如果不确定函数的位置参数的个数的时候，你可以*args
**kwargs：多个关键字参数。并且关键字参数必须放在位置参数之后。 kwargs把你传入的关键字参数打包成字典，必须且只能是关键字的形式去传参才可以纳入kwargs中。**kwargs中的kwargs这个名字不是固定的，你可以自己起一个名字但是**不能改变。
用途：在你不确定多个关键字参数的时候，你可以使用**kwargs来代替。


比较特殊的参数 
/, * 只是起到占位的作用，不需要实际的参数传入，就是这两个符号，不需要我们传参。
/: 它只是限定：在 / 之前的参数，必须以位置参数的形式传递。
*: 它也只是限定：在 * 之后的参数，必须以关键字参数的形式传递。
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
    print(pos1, pos2, pos_or_kwd, kwd1, kwd2)
f(1, 2, 3, kwd1=5, kwd2=6)
f(1, 2, pos_or_kwd=3, kwd1=5, kwd2=6)
结果：
1 2 3 5 6
1 2 3 5 6

lambda匿名函数

功能: lambda 关键字用于创建小巧的匿名函数
创建一个比较简单的函数(匿名函数)

语法格式: lambda 参数: 表达式(执行完后结果返回)
         参数可以是一个参数也可是多个参数

高阶函数

map

map(func, *iterables) --> map object
map(func(函数), *iterables(迭代的对象, *:多个可迭代对象))
简单迭代器的制作
from functools import reduce
map_obj = map(lambda x, y: (x,  y), [1, 2, 3], [4, 5, 6])
print(list(map_obj))
结果：
[(1, 4), (2, 5), (3, 6)]

reduce

reduce(function, sequence initial]) -> value
参数: 
function: 函数(有名字函数，lambda)
sequence: 序列, str, bytes, list, tuple
initial: 可选：初始化的意思
功能：从左到右：应用一个两个参数的函数， 累积地去计算我们序列中元素。
data = reduce(lambda x, y: x+y, list(range(1, 101)))
print(data)
结果：5050 #这也是一个计算前100个数之和的好方法。
data = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5], -3)
print(data)
结果：12 #当以上面形式出现时会先把后面的数放置第一次计算相加。

filter——过滤

filter(function or None, iterable（可迭代对象）) --> filter object

# 过滤掉其中的偶数，保留奇数
list_data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filter_obj = filter(lambda x: x % 2 != 0, list_data)
print(filter_obj, type(filter_obj))
print(list(filter_obj))
结果：[1, 3, 5, 7, 9]

sorted——排序

sorted方法和list中sort方法相似，但是list_data.sort() 是在原列表list_data上操作的
list中sort的方法，只能操作list。而且sorted:不依赖于列表，所以它可以操作其他的可迭代对象。
相似之处：就是它排序的原理一样

list_data = [1, 5, 6, 7, 2]
list_data.sort()
print(list_data)
new_list = sorted(list_data)
print(new_list)
结果：
[1, 2, 5, 6, 7]
[1, 2, 5, 6, 7]

zip

每一个可迭代对象中取出一个元素，然后把这些元素作为元组的元素，当其中一个可迭代对象结束时，那么结束操作

list_data = [1, 2]
list_data2 = [4, 5, 6]
list_data3 = [7, 8, 9, 10]
print(list(zip(list_data, list_data2, list_data3)))
结果:[(1, 4, 7), (2, 5, 8)]

函数的嵌套

注意：每次我们在用变量时，首先，在局部符号表里查找变量，然后，是外层函数局部符号表，再是全局符号表，全局符号表(模块中，函数外)， 最后是内置名称符号表(Python解释器中内置的， 比如__name__)。
因此，尽管可以引用全局变量和外层函数的变量，但最好不要在函数内直接赋值（除非是 global 语句定义的全局变量，或 nonlocal 语句定义的外层函数变量）。#global => 全局的， 我们可以在函数内部使用global来定义一个全局变量

def outer():
    print("outer")
    def inner():
        print("inner")
    inner()
outer()
结果：
outer
inner
输入：
def sum_data(n):
    if n == 1:
        return 1
    else:
        return sum_data(n - 1) + n
print(sum_data(100))
结果：
5050