python 基础知识点（蓝桥杯python科目个人复习计划10）

今日复习内容：函数相关知识点（接上一篇）

3.不定长参数

在python 中，有时需要一个函数处理多个数据，这时需要用到多值参数。在参数前面加一个*可以接收元组，加**可以接收字典，一般用*args存放元组参数，**kwargs存放字典参数。

（1）可变参数

可变参数：顾名思义就是传入的参数数量是可变的，传入的数量可以是任意多个，但也可以没有。

args 就是一个普通的形参，但如果你在args 前加了一个“*”，那么意义就不一样了，它有了特殊的意义：在python 中除了表示乘号，它是有魔法的。

这样设置形参，那么这个形参会将实参中所有的位置参数接收，放置在一个元组中，并将元组赋值给args 这个形参，这里起到魔法效果的是*，不是args。

举例1：

def funa(*args): # 接受多个值 都是以元组接收的
    print(args)
funa(1,2,3)

运行结果：

举例2：

def funa(*a):
    print(a)
    print(type(a))
funa('a', 'b', 'c')

运行结果：

（2） 关键字参数

**kwargs，同样**也是有魔法作用的，kwargs约定俗成使用作为形参。举例说明：**kwargs，是接受所有的关键字参数然后将其转换成一个字典赋值给kwargs这个形参。

关键字参数允许你传入0个或者任意个含参数名的参数，这些关键字参数会函数内部自动组装成一个dict。

举例1：

def funa(**kwargs):  # 关键字传参
    print(kwargs)
funa(a='ss',b=12) # 键等于值的形式

运行结果：

 

举例2：

def funa(**b):
    print(b)
    print(type(b))
funa(name='zs', age=18)

运行结果：

 

4.混合参数

但是**kwargs必须在*args后面

参数定义顺序：位置参数，默认参数，可变参数，关键字参数

如果很多个值都是不定长参数，在这种情况下，可以将缺省参数放到*args后面，但如果有**kwargs，那么**kwargs一定是最后的。

举例1：

# 位置参数、默认参数、可变参数组合
def fund(a, b=10, *c):                 # 必备 默认 可选 
    print(a, b, c)
fund(1, 2, 3, 4)

运行结果：

 

举例2：

def funa(a, *c, b=20):                 # 必备 可选 默认
    print(a, c, b)
    
funa(1, 2, 3, 4)

运行结果：

 

举例3：

def funa(a, b=20, *c, **d):
    print(c, d)
    print(a, b)
funa(1, 2, 3, 4, na='as', age=12)

运行结果：

 

练习题：

1.写一个函数，计算三个数的和

def funa(a,b,c):
    print(a + b + c)
funa(1,2,3)

运行结果：

 

2.写一个函数，计算三个数的平均值

def funa(a,b,c):
    print((a + b + c)/3)
funa(1,2,3)

运行结果：

 

注释一下：

# 写函数，接收n个数字，计算这些参数数字的和

# 1.定义函数

#  2.接收数字，不知道有多少个，用*args

# 3.计算累计和，需要两个数相加，想一下，是不是和之前循环的做法差不多

# 4.计算以后，返回结果

# 5.调用函数，需使用print

接下来再举个例子：

def funa(*args):
    sum2 = 0
    for i in args:
        sum2 += i
    return sum2
print(funa(3, 5, 4))

运行结果:

 

四.函数嵌套

1.之前我们讲过列表的嵌套，就是指一个列表中存在列表，可能那个列表中还有列表，同理，函数嵌套就是指函数里面还有函数。

2.一般在什么情况下使用函数嵌套？

   封装---数据隐藏

   贯彻DRY原则，使用函数嵌套，可以让我们在函数里避免代码重复

   闭包---闭包，装饰器这些高级代码与函数嵌套紧密相关，所有有必要先了解一下嵌套函数

   DRY---don't repect yourself,是指在程序设计及计算中避免重复代码，因为这样可能会降低代码的简洁性和灵活性，甚至某些代码直接会存在矛盾。 

  DRY更多的是一种架构设计思想，在软件开发过程中，万事万物皆可重复，大到标准，框架，开发流程；中到组件，接口；小到功能，代码均存在自我重复，而DRY提倡的是在软件开发过程中应该消除所有这些重复。

# 一般而言，当输出一些不带返回值的结果时会出现None

例子 ：嵌套调用，在一个函数里调用另一个函数

def funa():
    print('这是funa')
def funb():
    print('这是funb')
    funa()
funb()

运行结果：

 

例子2：嵌套定义，在一个函数中定义另一个函数

在外函数内部调用 内函数，即用函数名调用

def funa():
    def funb():
        print('这是funb')
    print('这是funa')
    funb() # 函数名调用内函数
funa()

运行结果：

 

例子3：可以用 return  调用内部函数

def funa():
    print('这是外部函数')
    def funb():
        print('这是内部函数')
    return funb()
funa()

运行结果：

 

如果在函数A中，调用了另一个函数B，那么先把函数B中的内容执行完之后才会回到上次函数A 执行的位置。

# 定义在其他函数内的函数叫做内部函数，内部函数所在的函数叫做外部函数。

应用：

# 打印自定义行数的横线
def funa():
    print('--'*20)
def funb(num):
    i = 0
    while i < num:
        funa()
        i += 1
funb(4)

运行结果：

 

for 循环：

# 1.横线格式
# 2.自定义行数（循环多少次）
def funa():
    print('---'*20)
def funb(a):
    for i in range(a):
        funa()
funb(3)

运行结果：

 

# 实现摇骰子的功能，打印N个骰子的点数和
import random
def play(n): 
    s1 = 0
    for i in range(n):
        s1 += random.randint(1, 6)
    return s1
result = play(2)
print(result)

运行结果：

 

OK，今天先写到这里，下次继续！