小白学习笔记之Python函数（二）

不定长参数

定义函数时，可以在形参前边加一个*，这样这个形参可以获取到所有的实参
带*号的形参只能有一个，属于位置参数，可以和其他参数配合使用，传递为一个元祖

def s(*a):  #*a===>一个（1，2，5）的元祖

    # 定义一个变量来保存结果
    r = 0
    # 遍历元祖，并将元祖中的数进行相加
    for n in a:
        r += n
    print(r)
s(1,2,5)

带**号的形参只有⼀个，属于关键字参数，并且必须写在所有参数的后⾯，传递为一个字典

def fn3(b,c,**a):  #**a是一个字典{'d':2,'e':20,'f':30}

    print('a =',a)
    print('b =', b)
    print('c =', c)

fn3(b=1,d=2,c=3,e=20,f=30)

参数的解包

def fn4(a,b,c):

    print('a =',a)
    print('b =',b)
    print('c =',c)

# t = (10,20,30)
# fn4(*t)
#或者
d = {'a':1,'b':2,'c':3}
fn4(**d)

函数的返回值

返回值就是函数执⾏以后返回的结果
return来指定函数的返回值
一旦执行return，函数就结束了 return可以跟任意的对象

def s(*a):

    # 定义一个变量来保存结果
    r = 0
    # 遍历元祖，并将元祖中的数进行相加
    for n in a:
        r += n
    # print(r)
    return r  #这里的r是返回值来保存运算结果并返回
r = s(1,2,5) #这里的r是对象来接收返回值
print(r + 3) #返回值可将函数当值来做运算

如果仅仅写一个return 或者没有写return 相当于 return None

def fn2():
    # return
r = fn2()
print(r) #None

return一旦执行函数自动结束

def fn3():

    print('python')
    return
    print('abc')

r = fn3()
print(r) #python和None 没有abc

文档字符串

在函数中使用文档字符串是可以给你自定义的函数起一个说明的作用 此时可以配合help（）函数使用，可以查询其他函数的用法

def fn(a:int,b:str,c:bool)->int:

    '''
    这个函数的功能就是一个文档字符串在函数中的使用说明

    参数
    a,作用,类型,默认值...
    b,作用,类型,默认值...
    c,作用,类型,默认值...

    返回值
    '''
    return 1

help(fn)

函数的作用域

全局作用域

所有函数以外的区域都是全局作⽤域

在全局作用域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进行访问

a = 20  #全局变量，处于全局作用域
print('函数外部 a = ',a)
def fn3():
# 如果希望在函数内部修改全局变量，则需要使用一个关键字global，来声明变量
     global a
     a = 100
     print('函数内部 a =',a)
fn3()
print('函数外部！！！！ a = ',a)

函数作用域（局部）

def fn2():
    def fn3():
        a = 40 #局部变量，只作用于fn3()函数作用域内，函数外部是无法访问的
        print('fn3中 a =',a)

    return fn3()

fn2() # fn3中 a = 40

命名空间

命名空间就是一个字典 是一个专门用来存储变量的
locals()来获取当前作用域的命名空间 返回是一个字典
如果在全局作⽤域中调⽤locals()则获取全局命名空间，如果在函数作⽤域中调⽤locals()则获取函数命名空间，如果在函数作⽤域中调⽤globals()则获取全局命名空间

a = 20
scope = locals()
print(scope)
print(a) #20
print(scope['a']) #20

def fn4():
    a = 50
    g = globals()
    print(g) #返回的字典中不存在{a：50}，因为a是局部变量，不在全局作用域中
fn4()

递归函数

概述

递归是解决问题的⼀种⽅式，它的整体思想，是将⼀个⼤问题分解为⼀个个的⼩问题，直到问题⽆法分解时，再去解决问题

条件

1. 基线条件 问题可以被分解为最⼩问题，当满⾜基线条件时，递归就不执⾏了
2. 递归条件 可以将问题继续分解的条件
   递归简单理解就是自己调用自己，递归式函数就是在函数中自己调用自己

def fn4(n,i):
    # 参数 n 做幂运算的数字 i 做幂运算的次数

    # 1.基线条件
    if i == 1:
        # 求1次幂
        return n
    # 2.递归条件 10 * 10 ** 3
    return n * fn4(n,i-1) # 10 ** 3

print(5 ** 3) #125
print(fn4(5,3)) #125