08函数-参数

1.函数简介

• 函数也是一个对象
• 函数用来保存一些可执行的代码，在需要时可以重复调用

# 函数中保存的代码不会立即执行，需要调用
'''
语法：
def fn(形参1，形参2...):
    代码块
'''
def fn():
    print('这是第一个函数')
# print(fn)   # <function fn at 0x0000000002882730>
fn()    # 这是第一个函数
# fn是函数对象，fn（）是函数调用

• 注意：函数名必须符合标识符命名规范（可以包含字母、数字、下划线，但不能以数字开头）

2.函数的参数

2.1形参和实参

• 形参（形式参数）定义形参就相当于在函数内部声明了变量，但是并不赋值
• 实参（实际参数）指定了形参，在调用函数时必须传递实参，实参将会给形参赋值，实参与形参数量应保持相同

# 定义一个函数可以用来求任意两个数的和
'''
赋值——是调用时赋值，或者定义时赋值
可以在定义函数时，在括号里面定义数量不等的形参
函数定义时有形参，调用时也得有实参否则报错
'''
def s(a,b):

    print(a+b)
s(5,6)  # 11
# s() # TypeError: s() missing 2 required positional arguments: 'a' and 'b'

2.2函数的传递方式

• 默认值——定义形参时，可以为形参指定默认值，但是若调用时有实参，则默认值被覆盖
• 位置传参——将对应位置的实参赋值给对应位置的形参
• 关键字传参——可以不按照形参的位置传递参数，只要是按照形参的名称对应赋值即可
• 混合使用位置参数与关键字参数——位置参数必须在关键字参数之前

'''
默认值，c=10这个默认值，如果函数调用时另外传递实参，则不调用默认值，调用实参
如果函数调用时不传递这个实参，则调用默认值
即不传递实参，默认值生效
'''
'''
参数的传递方式
位置传参
关键字传参
'''
# 位置参数：将对应位置的实参赋值给对应位置的形参
# 形如:fn(1,2,3)——>fn(a,b,c)
def fn( a, b, c=10):
    print('a =', a)
    print('b =', b)
    print('c =', c)
fn(4, 5, 6)
# 结果是：
# a = 4
# b = 5
# c = 6
fn(4, 5)
# 结果是：
# a = 4
# b = 5
# c = 10

# 关键字传参：不根据形参定义的顺序，而是根据形参名字来进行传参
# 形如:fn(b=4, c=5, a=6)——>fn(a,b,c)

fn(b=4, c=5, a=6)
# 结果是：
# a = 6
# b = 4
# c = 5
# 位置传参和关键字传参可以混合使用,并且关键字必须在后边
fn(1, 2, c=30)
# 结果是：
# a = 1
# b = 2
# c = 30
# fn(c=30, 1, 2)  #  SyntaxError: positional argument follows keyword argument
# fn(a=10, 2, 3)   #  SyntaxError: positional argument follows keyword argument

'''
原理：形参和实参，位置传参和关键字传参
举例:
import requests
headers={}
url=''
requests.request(url, headers=headers)
'''

3.不定长参数

• 用于位置传参的*args，在定义函数时，在一个形参前加上*,则这个形参可以获取多个实参（多个实参存入元组中），
• 带*的形参可以和关键字传参配合使用，但是只能有一个
• 带*的形参不能处理关键字传参，关键字传参可以用带**的形参
• 用于关键字传参的 **kwargs，获取的多个实参是存入字典中，key=关键字传参中的实参名，value=关键字传参中的实参值
• 带**的形参只能有一个，必须写在最后
• 装包–存入元组或字典
• 解包–遍历元组或字典

# 求任意个数的和

def fn(a,b):
    print(a+b)
fn(1, 2) # 3
'''
装包：
通过*b的形式传递位置参数，将所有实参存入元组b中
'''
def fn1(*b):
    print('b =', b, type(b))
fn1(1,2,3,4,5)      # b = (1, 2, 3, 4, 5) <class 'tuple'>
'''
解包：
遍历（通过*b存入元组中b）已经装包的实参，即遍历一个元组
'''
# 求任意个数的和
def s(*b):
    r=0 # 用来存储计算结果
    for i in b:
        r+=i
    print(b,'各元素累加结果为：', r)
s(1,3,54,6,6)   # (1, 3, 54, 6, 6) 各元素累加结果为： 70
'''
可以有多个参数，剩余元素统一装入*b
*b此类参数只能有一个
若*b不是最后一个参数，其后的参数必须使用关键字传参
*b形参，当实参都是关键字传参时，错误
**b将关键字实参装包人字典
即*形参不接收关键字参数，处理位置参数，**形参可以接收关键字参数，并处理
'''
def fn2(a,b,*c):
    print('a =', a)
    print('b =', b)
    print('c =', c)
fn2(1,3,4,6,7,8,8)
# 结果为：
# a = 1
# b = 3
# c = (4, 6, 7, 8, 8)
# *b不在最后位置，其后参数使用关键字传参
def fn3(a,*b,c):
    print('a =', a)
    print('b =', b)
    print('c =', c)
# fn3(1,3,4,6,7,8,8)  #  TypeError: fn3() missing 1 required keyword-only argument: 'c'
fn3(1,3,4,6,7,8,c=8)
# 结果是：
# a = 1
# b = (3, 4, 6, 7, 8)
# c = 8
# *b形参，当实参都是关键字传参时，错误
# fn3(a=1,b=3,c=8)    #TypeError: fn3() got an unexpected keyword argument 'b'
# **b将关键字实参装包人字典
def fn4(**b):
    print('b =', b, type(b))
fn4(a=1,b=2,c=3)    # b = {'a': 1, 'b': 2, 'c': 3} <class 'dict'>
def s1(a,c,**b):
    print('a =', a)
    print('b =', b)
    print('c =', c)
s1(c=3,b=6,d=0,e=5,a=1,f=8)
# 结果是：
# a = 1
# b = {'b': 6, 'd': 0, 'e': 5, 'f': 8}
# c = 3
s1(1,2,b=6,d=0,e=5)
# 结果是：
# a = 1
# b = {'b': 6, 'd': 0, 'e': 5}
# c = 2
'''
正规的写法：*args,**kwargs
def fn(*args,**kwargs):
    语句块
'''

4.参数的解包

• 用于位置传参的*args在装包解包过程是通过元组、列表
• 用于关键字传参的 **kwargs在装包解包过程是通过字典

'''
参数t为元组、列表时通过*t可以将t中的元素依次赋值给函数中的形参，元素个数与形参个数必须一致
参数t为字典时通过**t可以将t中的k-v中的value值依次赋值给函数中的形参，k-v个数与形参个数必须一致
'''
def fn(a,b,c):
    print('a =', a)
    print('b =', b)
    print('c =', c)
# t=[1,2,3]
t={'a':1, 'b':2, 'c':3}
print(type(t))
# fn(t[0],t[1],t[2])
# fn(*t)
fn(**t)