第十八章 参数

#1.
#A:Python中函数传递参数的途径:统一是通过按引用传递，只是当传入的参数在函数中被指向另一个对象的时候，不会修改被传入的参数
import sys
def fun0(a):
    a = 10              #a已经指向了另一个对象
    pass

def fun1(a):
    a.append(10)        #在原处修改a
    a = 10              #a已经指向了另一个对象

value = 1
L0 = [1, 2]
fun0(value)             #value = 1
fun0(L0)                #L0 = [1, 2]
fun1(L0)                #L0 = [1, 2, 10]

#2.
#A:位置:在默认情况下，参数是通过位置进行匹配的，匹配顺序为从左至右
#B:关键字参数:通过在调用时候使用参数的变量名
#C:默认参数:为没有传入值的参数定义参数值
#D:可变参数:收集任意多基于位置或者关键字的参数，以*开头
#E:可变参数解包:传递任意多的基于位置和关键字的参数,调用者能够使用*去将参数集合打散，分成参数
#F:Keyword-Only参数:参数必须按照名称传递
def Fun(*a):return a
value = Fun(1, 2, 3)        #value = (1, 2, 3)

def Fun(**a):return a
value = Fun(a = 1, b = 2)   #value = {'a': 1, 'b': 2}

dic = {'a': 1, 'b': 2}
value = Fun(**dic)          #value = {'a': 1, 'b': 2}
try:
    value = Fun(dic)
except:
    pass                    #运行至此

#3.
#A:在函数调用中，参数必须以此顺序出现:任何位置参数，后面跟着任何关键字参数和*sequence形式的组合，后面跟着**dict的形式    sequence(序列)
#B:在函数头部，参数必须以此顺序出现:任何一般参数，紧跟着任何默认参数，后面是*name的形式，后面跟着任何name或者name = Keyword-only参数，后跟**name形式
#C:实际上，在函数调用的时候，类似B的规则也是成立的，当传递Keyword-only参数的时候，他们必须不位于**args之后，Keyword-only参数可以编写在*args之前或者之后，并且有可能包含在**args中
def Fun(a, *b, c = 'c', **d) : return a, b, c, d
value = Fun(1, *(2, 3), e = '1')            #value = (1, (2, 3), 'c', {'e': '1'})
value = Fun(1, *(2, 3), c = '1')            #value = (1, (2, 3), '1', {})
value = Fun(1, *(2, 3), value = 1, c = 2)   #value = (1, (2, 3), 2, {'value': 1})
value = Fun(1, 'abc', **dict(value = 1, c = 2))   #value = (1, ('abc',), 2, {'value': 1})

try:
    value = Fun(1, *(2, 3), a = '1')
except:
    pass                                    #运行至此

#4.
#A:*形式的解包
#B:**形式的解包:会以键/值对的形式解包一个字典，使其成为独立的关键字参数(注意点:字典的键值和函数参数名要匹配)
def Fun(a, b, c) : return a, b, c
value = Fun(*(1, 2, 3))                     #value = (1, 2, 3)

value = Fun(**{'a':'A', 'b':'B', 'c':'C'})  #value = ('A', 'B', 'C')
try:
    value = Fun(**{'A':'A', 'B':'B', 'C':'C'})
except:
    pass                                    #运行至此

try:
    value = Fun(**{'a':'A', 'b':'B', 'c':'C', 'd': 1})
except:
    pass                                    #运行至此

#关键字参数和*sequence形式的组合
value = Fun(1, c = 3, *(2,))                #value = (1, 2, 3)
value = Fun(1, *(2,), c = 3)                #value = (1, 2, 3)
value = Fun(1, 3, *(2,))                    #value = (1, 3, 2)
#value = Fun(1, b = 3, *(2,))               #位置参数必须在关键字参数之前

#5.
def Fun(a, *b, c) : return a, b, c
value = Fun(1, 'a', 'b', c = 2)             #value = (1, ('a', 'b'), 2)
try:
    value = Fun(1, 'a', 'b', 2)
except:
    pass                                    #运行至此

def Fun(a, *b, c = 0) : return a, b, c
value = Fun(1, 'a', 'b')                    #value = (1, ('a', 'b'), 0)

#b, c都必须按照关键字来传递
def Fun(a, *, b, c = 0) : return a, b, c
value = Fun(1, b = 'a')                     #value = (1, 'a', 0)
value = Fun(1, b = 'a', c = 3)              #value = (1, 'a', 3)
try:
    Fun(1, 2, b = '3', c = 4)
except:
    pass                                    #运行至此

#6.
import os
os.system("pause")