Python基础知识-函数

‘’’
函数：
英文名：function
就是一个具有特定功能的语法结构。
作用：提高代码的复用率，提高开发效率，减少后期成本。
特征：不调用不会执行，调用不受次数限制。

输出十行十列的********** ：
def = a1()
    j = 0
    while j < 10:
        i = 0        #输出一行*******.....
        while i < 10:
            print('*',end = '')
            i += 1
        print()      #输出一个换行
        j += 1       #变量自增
a1()

基本结构：

def 函数名()
    print('xxxxxxxx')
    实现函数功能的代码

定义函数例子：
    def aa():
        print('好多蚊子咬我')
    aa()

查看函数的数据类型：（函数的定义相当于变量赋值，函数名就是变量名）
print（type（函数名））
print（函数名）


函数名的定义：
    1. 推荐使用英文，可以使用拼音，不可以使用汉字
    2. 可以使用数字，但是不能是数字开头
    3. 不可以使用特殊字符，下划线除外。
    4. 函数名严格区分大小写
    5. 函数命名要有意义（不能乱写，记不住，不认识）
    6. 函数命名不能喝系统自带的内建函数名同名
    7. 函数名不能和系统保留的关键字冲突。

参数：
用于调整属性的值就是参数
带有参数的函数结构：
def 函数名(参数，参数，参数。。。。)
实现函数功能的代码xxxxxxxxx

列子：输出0-10之间的数字
def aa(b2):
    var = 0
    while var <= b2:
        print(var)
        var += 1
    aa(10)

形参：
在定义函数的括号中声明的变量名就是形参。

实参：
在调用函数的括号中传入的就是实参

定义一个带有参数的函数：
    def aa(bb,cc,dd):
        print('xxxxxx' + bb)
        print('xxxxxx' + cc)
        print('xxxxxx' + dd)
    aa('1','2','3')

注意：
1. 实参将值传递给形参的过程，本质上就是变量赋值操作
2. 实参传值给形参的时候按照位置编号传输
3. 实参必须根据形参的个数进行传值（普通参数）

参数的默认值：
def aa(bb=‘1’,cc=‘2’,dd=‘3’):
print(‘xxxxxx’ + bb)
print(‘xxxxxx’ + cc)
print(‘xxxxxx’ + dd)
aa() #不传入实参的情况下使用的是形参的默认值

注意：
1. 如果函数有默认值，没有传入实参，则使用默认值
2. 如果函数有默认值，传入了实参，则使用实参（变量的重新赋值）
3. 具有默认值的实参可以不传入实参也不会报错
4. 如果同时存在默认值和没有默认值的形参，没有默认值的形参放在有默认值的形参之前

关键字参数：
def aa(bb,cc,dd):
print(‘xxxxxx’ + bb)
print(‘xxxxxx’ + cc)
print(‘xxxxxx’ + dd)
aa(dd=‘3’,bb=‘1’,cc=‘2’)

 指定形参的实参的传递参数的格式就是关键字参数，关键字参数特指实参。
 作用：为了防止多个参数的传递顺序出现错误

收集参数： *
计算任意个数值的和的函数：
def aa(*bb):
j = 0 #声明一个累加和的变量
for i in bb: #计算所有数值的和
j = j + i
print(bb)
aa(1,2,3,4,5,6,7,8,9,10)

在普通形参之前添加一个 * 就可以使得当前形参可以接收多个传入的实参
注意：1. * 收集参数仅接收没有形参接收的普通实参
      2. * 收集参数只可以接收普通实参，不可以接收关键字参数

关键字收集参数： **
def aa(*qq)
print(qq) # 打印qq变量接收结果
print(‘xxxxxx’,qq.keys()) # 打印qq变量接收结果
print(‘xxxxxx’,qq,values()) # 打印字典的值
aa(bb=1,cc=2,dd=3) # 关键字参数

1. 关键字收集参数仅接收没有形参接收的关键字参数
2. 关键字收集参数只可以接收关键字实参，不可以接收不同实参

多种参数混合存在的情况：
1. 形参种类：
1. 普通形参 var
2. 收集参数 * var
3. 关键字 ** var
2. 实参种类：
1. 普通实参 99
2. 关键字实参 var = 99

#定义一个测试使用的函数
    def aa(bb,cc,dd,*ee,**ff)
        print(bb,cc,dd)          # 使用普通参数
        print(*ee)               # 使用收集参数
        print(**ff)              # 使用关键字收集参数
    aa('a','b','c',1,2,3,4,f1='x1',f2='x2',f3='x3')

所有参数的排列问题：
1. 实参：普通实参在前，关键字在后
2. 形参：关键字收集参数一定在最后出现
         收集参数推荐在普通参数之后使用
   推荐顺序：普通参数，收集参数，关键字收集参数

函数的返回值：return（返回函数）
#定义一个计算两个数值和的函数
def aa(no1,no2):
bb = no1 + no2
return bb # 返回值语句
cc = aa(23,21)
print(cc)
print(cc * 10) # 返回的结果乘以10

函数执行完毕后可以得到一个结果，该结果可以被接收或者使用

函数划分的两大类：
1. 执行函数：
    函数执行之后没有任何结果可以在函数之外接收到（没有return语句的函数）
2. 具有返回值的函数：
    函数执行之后可以返回一个结果到函数之外被接收或者使用（具有return语句的函数）
3. return的另外一个作用：
    终止函数执行，函数运行过程中一旦执行了return语句，那么函数就会结束执行

函数文档：
查看函数的文档：
1. help(函数名)
例子：
help(print) # 查看print函数的文档

    2. 函数名.__doc__
       例子：
            print(print.__doc__)    # 查看print函数的文档

    3. 自定义函数文档
        函数文档的三个部分：
                            1.功能（这个函数是干什么用的）
                            2.参数（传入的值和类型）
                            3.返回值（得到的结果）
        例子：
            def aa(no1,no2):
                xxx                       #实际使用过程中用，三单引号
               :功能:xxxxxxx
               :参数1 no1:xxxxxxxx
               :参数2 no2:xxxxxxx
               :返回值:xxxxxxxxx
               xxx                       #实际使用过程中用，三单引号
                bb = no1 + no2
                return bb
            help(aa)                    #查看aa函数的的文档
        注意：1. 写函数文档的时候必须在定义完函数后第二行就可是写
              2. 必须缩进后才写，不可以顶头写
              3. 写完三引号后回车，系统会自动添加信息   

变量的作用域：变量的有效范围
分类：
1. 全局变量：在函数的内外都有效的变量就是全局变量
2. 局部变量：仅仅在函数内部有效的变量就是局部变量

全局变量：
mzj = ‘全身麻醉剂’
def zui(): # 声明一个函数（产生一个局部环境）
print(‘在函数内部调用变量mzj’,mzj) # 在函数中打印mzj变量
print(‘在嘴巴里面拔牙’)
print(‘在函数的外部调用mzj’,mzj) # 在函数外部打印mzj变量
zui()

注意：
    1. 在函数外部可以正常访问
    2. 在函数内部也可以访问

局部变量：
def zui()： # 定义一个函数相当于局部环境
mzj = ‘局部麻醉剂’ # 定义局部变量
print(‘在局部环境中调用变量mzj’,mzj) #在内部调用，这个可以访问
print(‘在嘴巴中拔牙’)
zui()
print(maj) # 在外部调用，这个无法访问

注意：
    1. 在函数外部不可以访问
    2. 在函数内部可以访问

将局部变量提升为全局变量：在函数内部使用 global 关键字可以提升为全局变量

将局部变量提升为全局变量：
    mzj = '99'
    def zui()
        global mzj                   # 提升为全局变量
        mzj = mzj + 1                # 修改全局变量
        print(mzj)
    zui()

真正的全局变量：
使用global 关键字对全局进行声明才可以在函数内部任意操作，否则在函数内部只能访问
不能修改

变量作用域链：

#使用了def的嵌套，global及nonlocal关键字函数

jia = ‘巨屌的家在：’ #创建了一个变量
def guo(): #创建了一个自定义函数名
print(jia) #调用了开头的变量并打印
print(‘中国’)
print(‘吃瓜群众：好厉害的国家!’)
print() #打印的时候加上一行空格

def sheng():                                  #创建了一个嵌套在guo函数下面的新自建函数
    global jia                                #调用了jia的变量数据，并使用global关键字将jia在这个嵌套函数内提升为全局变量
    jia = '巨屌的家在中国的：'                #修改jia的数据
    print(jia)
    print('湖南省')
    print('吃瓜群众：好强大的省份!')
    print()

    def shi():                               #创建了一个嵌套在sheng函数下面的新自建函数
        global jia
        zhuangxiu = (30)                     #声明一个新的变量，留作下面的nonlocal关键字使用
        jia = '巨屌的家在湖南省的：'
        print(jia)
        print('邵阳市')
        print('吃瓜群众：好淫荡的市!')
        print()

        def xian():
            global jia
            nonlocal zhuangxiu               #使用nonlocal外部变量关键字将zhuangxiu变量的数据进行+2操作
            a = zhuangxiu
            jia = '巨屌家的新房子在：'
            print('巨屌家的新房子装修据说花了:',a+2,'万')
            print(jia)
            print('新邵县')
            print('吃瓜群众：好有钱的县!')
            print()


            def zhen():
                global jia
                jia = '巨屌的老家在：'
                print(jia)
                print('小塘镇')
                print('吃瓜群众：土豪镇!')
                print()

                def cun():
                    global jia
                    jia = '巨屌的别野据说就在：'
                    print(jia)
                    print('桂花村5组4号')
                    print('吃瓜群众：整个中国这家有个叫巨屌的最淫荡!')
                cun()                           #这里开始注意：想要使用自定义函数到结尾的时候，在对应的def位置加上对应的调用函数名
            zhen()
        xian()
    shi()
sheng()

guo()

变量的有效范围可以向函数内部层层传递，如果其它的函数内部没有使用global，可以访问变量
如果使用global，可以进行任何操作。

nonlocal: 外部变量关键字，使用方法跟global一样

    def outer():                     # 定义一个函数
        var = 55                     # 定义一个变量
        def inner():                 # 定义一个内部函数
            nonlocal var             # 当前变量var 不是全局变量也不是局部变量，可以叫做外部变量
            var = var + 1            # 在此处进行加1操作
            print(var)
        inner()                      # 调用inner函数
    outer()                          # 调用outer函数

递归函数：在当前函数当中调用当前函数本身的函数就是递归函数
例子1：
def digui(num):
print(num) # 打印num变量
if num > 0: # 检测num是否大于0
digui(num - 1) # 将num - 1 传递给函数
else:
print(’--------’) # 输出一行横线分割
print(num)
digui(3) # 调用函数

例子2：
def digui(num):
    print(num[0:i])
    if i < len(num):
        digui(num[i:])
    else:
        print('---------')
    print(num[0:i])
i=1
digui('巨屌不巨不如切了')

例子3：
def digui(num):
    print(num)
    if i < len(num):
        digui(num[i:])
    else:
        print('---------')
    print(num)
i=1
digui('巨屌不巨不如切了')

注意：
1. 局部变量：每次调用的变量都对当前调用有效
2. 函数中num是否有过变化？num每次都是第一次和第三次的输出一致
3. 递下去归上来就是递归函数

偏函数：functools
Python中偏函数作用是为了修改一个函数的默认值，而设置的一种特殊函数
作用：修改函数的默认值，产生一个新的函数，功能和原函数一样，只是默认值不一样。

# print函数内，end表示换行,(print,end = '')表示不换行操作
列子：使用偏函数修改print的默认值
    import functools                               # import 是函数的工具模块（）
    print2= functools.partial(print,end = '')      # 函数功能其它功能完全一样，end的默认值不一样
    print2('@@@@@@@@@@')
    print2('##########')
    print2('$$$$$$$$$$')

lambda表达式：
是函数的另外一种表达方式而已，实际上还是函数。
格式：
变量名 = lambda.参数… : 实现函数功能的代码。
普通函数例子：
def aa(no1,no2):
bb = no1 + no2
return bb
cc = aa(60,70)
print(cc)

    lanbda列子：
        a1 = lambda no1 , no2 : no1 + no2       #lambda表达自带return功能（返回值）
        var = a1(60,70)
        print(var)


注意：功能比较单一，只能实现简单的数据运算或者判断无法使用循环或者复杂的操作

带分支的格式：
    变量名 = lambda.参数，参数...... : 真值 if 条件表达式 else 假值

    普通函数例子：
        def aa(sex):
            if sex == '男':
                return 'man'
            else:
                return 'woman'
        bb = aa('男')
        print(bb)

    带有分支结构的lambda表达式：
        aa2 = lambda sex :'man' if sex == '男' else 'woman'
        bb = aa2('男')
        print(bb)

在lambda表达式中调用其它函数：
    获取并且打印数据类型的函数：
        printtype = lambda var : print(type(var))
        printtype('小明')

‘’’