第一节：函数入门与定义函数

理解函数所谓函数，就是为一段实现特定功能的代码“取”个名字，以后即可通过该名字来执行（调用）这段代码从逻辑上看，函数相当于一个黑匣子定义函数的语法定义函数的三条铁律函数需要几个关键的、需要动态变换的数据，这些数据就应该定义成函数的参数函数需要传出去几个重要的数据（就是调用该函数的人希望得到的数据），这些数据应该定义成返回值函数内部的实现过程函数的语法：

函数的语法

# 定义函数，无参数def first():    # 之前学习的定义变量、赋值、运算、分支、循环等全部都可以写在函数里面    print('first 函数')    for i in range(5):        print(i)first()# 只要执行函数，函数体的代码就可以被重复的调用（复用）first()first()# 函数定义，有一个参数 namedef hello(name):    print('hello 函数')    print('您好，' + name)hello('python')hello('java')# 函数定义，有2个参数 name, agedef info(name, age):    print('info函数')    print('name参数', name)    print('age参数', age)info(python, 90)info(java, 70)# 定义函数，有返回值def max(a, b):    r = a if a > b else b    # 返回值    return r# 返回值的意思，当程序调用函数之后，会得到N个值x = max(10, 20)print(x)x = max(30, 20)print(x)# print也是个函数，函数的嵌套print(max(20, 50))

为函数提供文档只要把一段字符串放在函数声明之后、函数体之前，这段字符串就是函数的说明文档Python内置的help()函数查看其它函数的帮助文档通过函数的_doc_属性来查看函数的说明文档

# 自定义说明文档def test(a):    '''    test 函数的说明，这是一个简单的函数    a-代表什么意义    return- 代表什么意义    '''    # 空语句    passprint(test.__doc__)help(test)

第二节：多返回值函数与递归函数

多返回函数多返回值，本质就是返回元组程序即可返回元组，也可直接返回多个值（系统会自动将其封装成元组）获取多返回值函数的返回值时既可以用单个变量（元组）来获取也可以用多个变量获取（元组解包）

import random# 希望该函数返回三个随机的大写字符def test():    # 生成三个随机的大写字符    c1 = chr(random.randint(65,90))    c2 = chr(random.randint(65,90))    c3 = chr(random.randint(65,90))        # 以元组的形式返回    return(c1, c2, c3)    # 程序自动封装成元组    return c1, c2, c3# r就是一个元组r = test()print(r)print(test())# 多返回值函数，即可用多个变量来接收返回值，也可用单独变量来接收返回值c1, c2, c3 = test()print(c1)print(c2)print(c3)

递归函数函数体内调用它自身，被称为函数的递归函数递归包含了一种隐式的循环，它会重复执行某段代码，但是这种重复执行无需循环控制递归函数的注意点向已知的方向递归让递归有结束的时候，不要无限递归

# 无限递归的例子def foo():    print('111')    print('222')    foo()foo()# 计算N的阶乘def frac(n):    if n < 1:        print("n不能小于1")        return    elif n == 1:        return 1    else:        # n的阶乘总是等于上一个阶乘*n        # 函数调用自身        return frac(n-1) * n        # 该函数的结束点是n==1,因此要向n==1方向递归        print(frac(5))print(frac(6))

第三节：关键字参数与参数默认值

关键字参数Python函数的参数名不是无意义的，Python允许调用函数时通过名字来传入参数值调用函数时支持两种方式为参数指定值位置参数：必须按照顺序为每个参数指定参数值关键字参数（命名参数）：按参数名为参数指定参数值

def info(name, age, height):    print("name:", name)    print("age:", age)    print("height:", height)    # 位置参数，按照顺序传递参数info('fkjava', 24, 183)# 关键字参数（命名参数）# 关键字参数的优势是 1：不需要按照顺序 2：可读性更高info(age=34, name='java', height=179)# 混合使用info('python', height=178, age=45)# 混合使用错误：关键字参数必须位于位置参数的后面info(name='python', 178, 45)

参数的默认值程序需要在定义函数的时候为一个或者多个形参指定默认值，这样调用函数时就可以省略该形参传入参数值，而是直接使用该形参的默认值为形参指定默认值的语法格式如下：形参名 = 默认值

# 定义带默认值的参数（一个参数有默认值）def info(age, name='python'):    print('age参数为：', age)    print('name参数为:', name)      # 为参数指定默认值之后，调用时候可省略指定的参数值，该参数使用默认值    info(23)info(45, 'abc')info(11, 'Java')# 混合方式info(19, name='bcd')# 定义带默认值的参数（两个参数有默认值）def info(age=19, name='python'):    print('age参数为：', age)    print('name参数为:', name)    info()info(20)# 如果你希望省略前面的参数指定参数值，后面的参数应该用关键字参数来传入参数info(name='go')

第四节：参数搜集和逆向参数收集

参数收集普通参数收集在形参前面加上一个星号(*),这样就意味着该参数可接收多个参数值，多个参数值被当成元组传入参数收集的本质就是一个元组：Python会将传给带*参数的多个值收集成一个元组Python允许个数可变的参数可以处于形参列表的任意位置，但是最多只能带一个支持“普通”参数收集的参数如果支持“普通”参数收集的形参位于前面，后面参数则需要使用关键字参数传值

# books参数支持收集，它可接受多个参数值def test(num, *books):    print("num:", num)    print("books:", books)# 将多个值自动封装成一个元组test(5, "go", "python", "java")def info(*names, msg):    for name in names:        print("%s, %s" % (name, msg))# 如果你要为参数收集后的参数传入参数值，需要用关键字参数 info("孙悟空", "猪八戒", "牛魔王", msg="欢迎大家") # 否则所有参数都会被参数收集成元组 info("孙悟空", "猪八戒", "牛魔王", "欢迎大家")

关键字参数收集在参数前面添加两个星号“**”，该参数支持关键字参数收集，收集的参数被当做dict处理一个函数可同时支持普通参数收集和关键字参数收集

# books参数支持普通参数收集，它可接受多个参数值，socres支持关键字参数收集def test(num, *books, **socres):    print("num:", num)    print("books:", books)    print("socres:", socres)test(20, 'fkjava', 'python', 'swift', 语文=89, 数学=93)def info(*names, msg, **socres):    for name in names:        print("%s, %s" % (name, msg))    print(socres)# 程序知道msg参数将是传给msg的，因此socres参数不会收集它# dict的参数收集，它只收集不能明确传入的关键字参数info("孙悟空", "猪八戒", "牛魔王", msg="欢迎大家", 语文=89, 数学=93) 

逆向参数收集在列表、元组前添加*，在字典之前添加**

def test(a, b):    print(a)    print(b)# 元组的逆向参数收集，以普通参数的形式为参数传入参数值vals = (20, 40)# 调用函数时，元组不能自动解包# 默认情况下，元组是一个整体test(vals)# 这个语句是错误的# *对元组自动解包（逆向参数收集）test(*vals)# 列表的逆向参数收集，以普通参数的形式为参数传入参数值msgs = ['aa', 'bb']test(*msgs)# 字典的逆向参数收集,以关键字参数的形式为参数传入参数值# 简单来说，**是将字典解析成关键字参数vals = {'a': 89, 'b': 93}test(**vals)

第五节：变量作用域

理解变量作用域根据定义变量的位置，变量的作用域分为两种：局部变量：在函数中定义的变量包括参数，都被成为局部变量全局变量：在函数外面、全局范围内定义的变量，被称为全局变量

# 全局变量a = 35def info():    # 局部变量    b = 'fkjava'    # 正确，局部变量只能在当前函数内访问    print(b)    # 正确，全局变量可以在任何函数内访问    print(a)    def info1():    # 局部变量    c = 'java'    print(c)    # 正确，全局变量可以在任何函数内访问    print(a)    # 错误，局部变量只能在定义局部变量的函数中使用    #print(b)    info()info1()

变量字典获取变量字典globals():该函数返回全局范围内搜所有变量组成的“变量字典”locals():该函数返回当前局部范围内搜所有变量组成的“变量字典”vars(object):获取指定对象的范围内所有变量组成的“变量字典”，如果不传入object参数，vars()和locals()作用完全相同

# 全局变量a = 35name = 'java'def info():    # 局部变量    b = 'fkjava'    # 正确，局部变量只能在当前函数内访问    print(b)    # 正确，全局变量可以在任何函数内访问    print(a)        # 局部变量组成的数组    print(locals())    def info1():    # 局部变量    c = 'java'    print(c)    # 正确，全局变量可以在任何函数内访问    print(a)    # 错误，局部变量只能在定义局部变量的函数中使用    #print(b)        # 局部变量组成的数组    print(locals())# 全局变量组成的数组print(globals())  # locals获取当前范围内的所有局部变量# 因此你在全局范围调用locals函数的时候，它返回全部的全局变量# 简单来说，你在全局范围内，用globals和locals函数效果是一样的print(locals())   info()info1()

处理局部变量遮蔽全局变量全局变量默认可以在所有函数内访问如果在函数中定义了与全局变量同名的变量，此时就会发生局部变量的遮蔽（hide）全局变量的情形

# 解决方法一name = 'java'def info():    # 依然访问全局变量name    print(globals()['name'])    # 在函数内对变量赋值，变成了定义新的name变量    name = 'python'    print(name)    info()# 全局变量name没有改变print(name)# 解决方法二name = 'java'def info():    # 声明作用：该函数中的name始终使用全局变量    global name    # 依然访问全局变量name    print(name)    # 前面已经声明了name始终是全局变量    # 因此此处不是重新定义局部变量    name = 'python'    print(name)    info()# 全局变量name会被改变print(name)

第六节：局部函数

理解局部函数放在函数体内的函数称为局部函数在默认情况下，局部函数对外部是隐藏的，局部函数只能在其封闭（enclosing）函数内使用定义、使用局部函数

def foo():    print('foo函数')    # 嵌套函数：在其他函数内定义的函数    def bar():        for i in range(5):            print('bar函数')    # 只能在foo函数内调用bar函数    bar()# 在此处调用bar函数出错，局部函数只在它所在的封闭函数内有效# bar()foo()

封闭函数返回局部函数封闭函数可以返回局部函数，以便程序在其他作用域中使用局部函数如果封闭函数没有将局部函数返回出来，那么局部函数将只能在封闭函数内部调用

def foo():    print('foo函数')    # 嵌套函数：在其他函数内定义的函数    def bar():        for i in range(5):            print('bar函数')    # bar表示返回函数本身（函数也相当于一个值，是function类型的值）    # bar()表示调用（执行）函数    return bar    # foo函数的返回值时bar函数,因此此处是用变量r来保存bar函数r = foo()print(r)# 此时R引用bar函数本身，r的类型是functionprint(type(r))print('-' * 60)# 由于r是函数，因此程序可以调用它r()# 下面代码看上去有点诡异# foo函数调用之后返回bar函数，bar函数也可调用foo()()

局部函数的变量遮蔽局部函数内的变量也会遮蔽它所在的封闭函数的局部变量避免方法：可用nonlocal进行声明

def test():    name = 'fkjava'    def  info():        print('info 函数')                # 声明后面的name变量不是声明新的局部变量，而是引用所在封闭函数的局部变量        nonlocal name        print('name:', name)        # 默认情况下，下面代码是为info这个局部函数再次定义name局部变量        # 此时name局部变量就会遮蔽test函数的name变量        name = 'crazyit'        # 在没有用nonlocal声明之前，此时打印会出错，用nonlocal声明之后，程序正常        print('name:', name)    info()    print(name)test()

global与nonlocal总结作用大致相同，都是用来避免变量遮蔽区别：global用于声明访问全局变量。nonlocal用于声明访问局部函数所在封闭函数内的局部变量

第七节：案例实操-定义计算N的阶乘的函数

实现方法方法一：使用循环计算阶乘控制循环计数器从1循环到N让循环计数器与前一个结果相乘，直到循环计数器等于N就得到了N的阶乘

def fract():    r = 1    if n < 1:        print('n不能小于1')        return     else:         for i in range(1, n + 1):             r *= i         return rprint(fract(5))

方法二：运用递归计算阶乘经研究发现：N的阶乘等于N乘以N-1的阶乘，因此可借助于递归来实现N为1时，N的阶乘是1，保证递归有结束点

def fract():    if n < 1:        print('n不能小于1')        return     # 对于递归函数来说，必须保证在某个条件下，函数不再调用自身，递归结束     elif n == 1:         return 1     else:         # 递归：就是函数里面调用自身         return fract(n - 1) * n         print(fract(5))

方法三：调用reduce函数计算阶乘Python在functools模块提供了reduce()函数，该函数使用指定函数对序列对象进行积累可通过help(reduce)查看该函数的用法：reduce(function, sequence[, initial])

import functoolsdef fn(x, y):    return x * y    def fract():    if n < 1:        print('n不能小于1')        return    else:        '''        # fn(ele1, ele2)->r        # fn(r,ele3)->r        # fn(r,ele4)->r        '''        # 方法一：        return functools.reduce(fn, range(1, n + 1))                # 方法二：        # lambda x ,y: x * y 的本质就是一个函数        return functools.reduce(lambda x ,y : x * y, range(1, n + 1))print(fract(5))

第八节：案例实操-定义计算矩阵转置的函数

使用循环进行转置首先创建一个长度与原矩阵第一个元素长度相等的新列表使用遍历原矩阵的每个元素，再使用嵌套循环遍历每个元素，将列表中的元素添加到新列表对应的列表元素中

matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]'''# 转置就是行变列 列变行# 转置之前1  2  3  45  6  7  89 10 11 12# 转置之后1  5  92  6 103  7 114  8 12'''def printmatrix(m):    # 列表嵌套列表，因此ele也是列表    for ele in m:        # 打印一行        for e in ele:            print('%2d' % e, end=' ')     print(' ')     def transformmatrix(m) :    # m[0]有几个元素，说明原矩阵有多少列    # 列转成行    rt = [[] for i in m[0]]    for ele in m:        for i in range(len(ele)):            # rt[i]代表新矩阵的第i行            # ele[i]代表原矩阵当前行的第i列            rt[i].append(ele[i])     return rtprintmatrix(matrix)print('-' * 60)printmatrix(ransformmatrix(matrix))

使用zip()函数转置zip函数的作用正是合并多个序列：多个序列第一个元素合并成第一个元素，多个序列第二个元素合并成第二个元素......运用逆向函数收集即可

matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]def printmatrix(m):    # 列表嵌套列表，因此ele也是列表    for ele in m:        # 打印一行        for e in ele:            print('%2d' % e, end=' ')     print(' ')     def transformmatrix(m) :    # 逆向参数收集，将矩阵中多个列表转换成多个参数，传给zip    return list(zip(*m))printmatrix(matrix)print('-' * 60)printmatrix(ransformmatrix(matrix))

使用numpy模块转置numpy模块提供transpose函数执行转置，该函数的返回值是numpy的内置类型：array调用array的tolist()方法可将array转换成list列表

matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]def printmatrix(m):    # 列表嵌套列表，因此ele也是列表    for ele in m:        # 打印一行        for e in ele:            print('%2d' % e, end=' ')     print(' ')     def transformmatrix(m) :    # 使用numpy模块的transpose函数进行转置    import numpy    return numpy.transpose(m).tolist()printmatrix(matrix)print('-' * 60)printmatrix(ransformmatrix(matrix))