函数在程序开发过程中是不可或缺的，其实一个函数就是完成单一功能的代码块，可以想像如果整个程序都没有函数，代码都堆叠到一起，如果程序有个几万行，天呐，整个宇宙都要毁灭了。

基本函数使用

  1. 先看下边的例子
def do_something(message):
    print('我要做的事情是{}'.format(message))
do_something('学习') #  我要做的事情是学习

说明
def 是函数声明
do_something 是函数的名称
message 函数的参数 当然可以多个 以逗号分开就好
do_something(‘学习’) 调用函数 输出 我要做的事情是学习

  1. 带返回值的函数
def do_sum(a,b):
    return a+b
result = do_sum(3,4)
print(result) # 7

说明
return 是返回值关键字 这里是将 3 和 4的和 做为返回值
result = do_sum(3,4) 调用函数 并且将函数赋值给 result
def python中 def 是可执行语句 也就是说函数在调用前都是不存在的 我们只需要保证函数调用时有对应的声明就好

  1. 参数说明! python中函数的参数是可以带默认值的 当有值传入函数时就用传入的值覆盖默认值 例如
def do_home(name:'晨光'):
    print(name) # 
do_home('j_xb') # 此时输出 j_xb
do_home() # 此时输出 晨光
  1. 参数说明!! python 中的变量可以接受任意数据类型，那么参数也是可以接受任意数据类型 比如上边的do_sum方法 我们即可以传入 数值 数组 字符串 浮点数等等 这也是编程语言中 多态 的体现
    当然在便利的同时也有弊端 我们有时候要做类型判断 比如 字符串和 数组是不能相加的。
  2. 嵌套函数
    顾名思义就是函数里边再放函数 这里不展开说明 工作中不常用，据说在特定场景下可以提高程序的执行效率 以后遇到了会补进来。

函数变量作用域

  1. 全局变量 在函数中使用全局变量 默认会创建一个新的 变量覆盖原来的 如果要想修改 必须加上 global 关键字 如果只是访问是没有问题的 例如
money = 100
**1只访问**
def get_money():
    print(money)
get_money()
这里只是访问 程序没有任何问题

**2 修改**
改成 下边这样就不行了 
money = 100
def get_money():
    money += 10
    print(money)
get_money() 
程序报错 UnboundLocalError: local variable 'money' referenced before assignment 因为这里我们修改了全局变量  要想修改就必须加上 global关键字

**3 加上 global关键字**
money = 100
def get_money():
    global money
    money += 10
    print(money)
get_money() # 110
此时此刻我们的输出 是 110 成功的修改了全局变量
  1. 对于嵌套函数 同样的内部函数只能访问外部函数的变量 但是不能修改 如果要修改就必须加上 nonlocal 关键字 例如
**只访问**
def outer_func():
    time = 0
    def inner_func():
        print(time)
    inner_func()
outer_func() # 0

**修改 同样的会报错**
def outer_func():
    time = 0
    def inner_func():
        time += 1
        print(time)
    inner_func()
outer_func()

**添加 nonlocal 可以修改和访问**
def outer_func():
    time = 0
    def inner_func():
        nonlocal time
        time += 1
        print(time)
    inner_func()
outer_func()

nonlocal 如果 不加nonlocal 关键字 那么内部函数会覆盖完毕函数的变量

闭包

闭包其实和前边将的嵌套函数类似 闭包只是将内部函数 作为外部函数的返回值 下面看具体的例子

def closure(times):
    def inner_func(sub):
        return sub**times
    return inner_func
func = closure(2)
result = func(3)
print(result) # 9

说明
inner_func 作为 closure的返回值 这是closure的参数 2 可以被inner_func暂时记住 形成一个封闭的空间 这也可能是闭包的由来 程序中使用闭包可以提高程序的可读性 和简洁性。 比如上边的函数 我们可以计算任意数值的平方。

匿名函数

匿名函数的标示 lambda

  1. 简单使用
square = lambda x: x**2
print(square(5)) # 25

说明
lambda 是一个表达式 不是语句
表达式是一系列的公式去表达一个东西 语句是完成了一个功能 比如 赋值语句 条件语句 打印语句等

  1. 列表中使用
t = [2,3,4,1,5]
result = [(lambda x: x*x)(x) for x in t]
print(result) # [4, 9, 16, 1, 25]
  1. 作为函数参数
t1 = [(2,3),(4,1),(5,2),(3,4),(1,5)]
t1.sort(key=lambda x:x[1])
print(t1) # [(4, 1), (5, 2), (2, 3), (3, 4), (1, 5)]
按照数组中的元组 的 第一个元素排序
  1. map() filter() reduce() 三者使用简介
    map() 对一个iterable中的元素执行一个函数操作
t1 = [(2,3),(4,1),(5,2),(3,4),(1,5)]
obj = map(lambda x:x[0]+1,t1)
print(list(obj)) # [3, 5, 6, 4, 2]

reduce() 对一个集合做累积操作

from functools import reduce
t2 = [1,2,3,4,5]
obj = reduce(lambda x, y:x*y,t2)
print(obj)
python3 一定要导入 from functools import reduce

filter() 做过滤

l = [1, 2, 3, 4, 5]
new_list = filter(lambda x: x % 2 == 0, l) # [2, 4]
  1. 字典排序
d = {'mike': 10, 'lucy': 2, 'ben': 30}
d1 = sorted(d.items(),key=lambda x:x[1],reverse=False)
print(d1) # [('lucy', 2), ('mike', 10), ('ben', 30)]