14-3 keyword-only参数和参数解构

你有多自律，就有多自由。没有特别幸运，请先特别努力。失败不是因为跌倒，而是从来不敢奔跑！
别让过去决定你的未来！

外面=好附近最好有空格，在括号里面最好挨着一起写；
t = 1     ;(x=100)

# 打印值和返回值是两个概念；
print(1)
return(x)

1.参数槽(keyword-only参数)

特点：

1. 没缺省值必须得传参数
   2.*之后的参数，必须以关键字参数的形式传递，称之为参数槽

没缺省值必须得传参数
def fn(a,b,c):
  print(a,b,c)

fn(a=1,b=2,c=3)

*之后的参数，必须以关键字参数的形式传递，称之为参数槽；
def fn(*,a,b,c):
  print(a,b,c)

fn(a=1,b=2,c=3)

参数槽之坑：
1. *之后必须有参数
2. 非命名参数有默认值时，命名参数可以没有默认值
3. 默认参数应该在每段参数的最后
4. 使用参数槽时，不能使用可变位置参数，可变关键之参数必须放在命名参数之后

2.keyword-only的两种形式：
fn(*args,x,y):
fn(*,x,y):

1. keyword-only
def fn(*args,x):
    print(x)
    print(args) 

fn(3,5,x=7)  | 7   (3, 5)

2. keyword-only + 缺省值  可以改变这种用法；
def fd(*args,x=100):
    print(x)  
    print(args)    
#必须给出缺省值；
fd(3,5)   |     100   (3, 5)

3. **kwargs 只能放到最后（语法）
#可以理解为kwargs会截获所有的关键字参数，就算你写了x=5，x也永远得不到这个值，所以语法错误

def ff(**kwargs,x):    #错误形式
    print(x)
    print(kwargs)

keyword-only 参数的另一种形式：
add(*,x,y):
    print(x)
    print(y)

 最常用的函数标准形式：
def connect(host='localhost',port='3306',user='admin',passwd='admin',**kwargs):
    print(host,port)
    print(user,passwd)
    print(kwargs)

connect(db='cmdb')
--------------------------------
localhost 3306
admin admin
{'db': 'cmdb'}

connect(host='192.168.1.123',db='cmdb')
-----------------------------------------------------
192.168.1.123 3306
admin admin
{'db': 'cmdb'}

connect(host='192.168.1.123',db='cmdb',passwd='mysql')
-----------------------------------------------------------------------
192.168.1.123 3306
admin mysql
{'db': 'cmdb'}

2.函数参数解构

必须作为函数的参数时，才可以解构；
参数 必须是可迭代对象

1. 给函数提供实参的时候，可以在集合类型前使用或者*，把集合类型的结构解开，提取出所有元素作为函数的实参
2. 非字典类型使用*解构成位置参数（一维数组）
3. 字典类型使用**解构成关键字参数（二维数组）

def add(x,y):
    return(x+y)

add(4,5),add((4,5)[0],(4,5)[1]),add(*[4,5]),add(*(4,5)),add(*{4,5})
----------------------------------------------------------------------------------
(9, 9, 9, 9, 9)

add(*'45')   #作为函数的参数时，才可以解构；  
--------------------------
'45'

# 参数不能多也不能少；
add(*range(100,102))      |   201


# 函数参数为字典时 解构：
add(*{'x':100,'y':200})   # add('x','y')
--------------------------------------
'xy'

add(**{'x':100,'y':200})   # add(x=100,y=200)
---------------------------------------------------------
300

add(*{'a':100,'b':200})  #add('a','b')'
------------------
'ab'

def ad(x,y,**kwargs):
    return(x+y)
ad(**{'a':100,'b':200,'x':300,'y':400})  #add(a=100,b=200,x=300,y=400)

# 函数参数解构易错点：
def add(*iterable):  #(range(10),)
    result=0
    for x in iterable:
        result += x # 0+range(10)
    return(result)
----------------------------------------------------
add(*(1,2,3))

add(*range(10))    
# 1.错误写法:把元祖解构后，可迭代+加法
#add(range(10))   # range(10) 生成的是一个元祖；