38 py改變函數參數的值關鍵字參數和參數默認值函數中可變參

第五課：改變函數參數的值
一個python函數可以有任意多個參數，在一個函數的外部來定義變量，然后把變量作為參數傳入到函數內，并且在函數的內部來修改函數的參數值，函數結束之后，這些變量的值在如何變化呢？
給函數傳遞值有2種：1種是值傳遞，1種是引用傳遞 

# 改變函數參數的值
# 值傳遞（數值、字符串、布爾 這些都是值傳遞） 在函數的內部修改變量值，不改變原參數定義的參數值，解釋為： 這個在函數中不會改變原來定義(函數外部)的值   這是因為函數里面會有一個占的概念，外邊的變量的值會復制給 占 里面，對于 函數中的變量來說 并不是指的是同一個變量 在函數里修改的參數的變量的值其實是修改了函數的一個副本，和外邊的參數沒有直接關系 
# 引用傳遞（復合類型，列表、字典、以后要講的對象）  在函數的內部修改變量值，將會改變原參數定義的參數值， 具體的解釋為： 這個在函數中會改變原來定義(函數外部)的值 這里的引用和c語言的指針比較類似 
x = 100
s = 'hello world'
def test1(xx,ss):     # 將這2個變量變成參數傳給 函數test1 
    xx = 200
    ss = 'I love you.'
test1(x,s)            # 這一步是講外邊的定義的變量傳給函數    
print(x, s)             # 結果為  100 hello world 值沒有變化 還是和外邊定義的變量值是一樣的 這是因為 x s 都是值傳遞 
-------
復雜的類型
numList = [1,2,3,4,5]
numDict = {'a':1, 'b':2, 'c':3}
a = numList
a[1] = 4
print(numList)      # [1, 4, 3, 4, 5]  這一步是將numList的引用復制了一份給了a 那么這樣的numList 和 a 他們的引用(指針) 指向同一個地址空間，如果我們修改了a的值numList的值也就被修改了 這里的變量是存儲了列表和字典的引用 ；其實光看這個引用的話，其實就是把這個列表和字典的引用傳給函數中的值 在函數體內，所用的內存空間和外部的是一樣的，所以值就會根據函數體內的值的改變而改變。
def test2(nl,nd):
    nl[2] = 1234
    nd['c'] = 4321
test2(numList, numDict)   # 函數傳參 
print(numList)            # [1, 4, 1234, 4, 5]
print(numDict)              # {'a': 1, 'b': 2, 'c': 4321}
# 我們發現這里的輸出的值，改變了原先定義的列表和字典 這里叫做 引用傳遞 

輸出的結果為：
100 hello world     // 這個結果和原來定義的沒變   
[1, 4, 3, 4, 5]     // 這里類似于 引用 (指針)，值是會改變的 
[1, 4, 1234, 4, 5]
{'a': 1, 'b': 2, 'c': 4321}

-------------------------------------------------------------------
第六課：改變函數參數的值（案例）  // 這個例子很牛逼 
在 控制臺輸入一些數據，以逗號分隔的字符串 ， 然后把這些數據轉化為字典或者序列 
# 從控制臺輸入一些數據（以逗號分隔的字符串），然后保存到一個大的字典中     首先先用普通的方法實現，然后將一部分的代碼抽象處理，然后再用函數去實現  我們就是用復合類型的數據，將字典傳入函數，然后在函數的內部 修改字典的值，當函數結束的時候，保留在函數內部修改的效果 

data = {}                   # 首先定義個字典
data['d'] = {}              # d的放在字典
data['names'] = []          # names放在列表中 
print('請輸入字典數據，key和value之間用逗號分隔')    # 從控制臺輸入 
dictStr = input(':')                            # 從控制臺輸入
# 比如：我們輸入
# a,b,c,d
# {'a':'b','c':'d'}
list = dictStr.split(',')      # 利用逗號進行分割 
keys =[]                            # key 和 value 都取出來， 奇數的Wie  key   偶數為 values 
values =[]
for i in range(len(list)):
    if i % 2 == 0:
        keys.append(list[i])
    else:
        values.append(list[i])
print(keys)                     # ['a', 'b', 'c']
print(values)                       # ['1', '2', '3'] 
for values in zip(keys,values):       #  將第一個列表的第一個元組值轉化為 元組 
    print(values)
'''
('a', '1')
('b', '2')
('c', '3')
'''

輸出的結果為：
請輸入字典數據，key和value之間用逗號分隔
:a,1,b,2,c,3
['a', 'b', 'c']
['1', '2', '3']
('a', '1')
('b', '2')
('c', '3')
----------------------------- 
第二種方法:
data = {}
data['d'] = {}
data['names'] = []
print('請輸入字典數據，key和value之間用逗號分隔')
dictStr = input(':')
# a,b,c,d
# {'a':'b','c':'d'}
list = dictStr.split(',')      # 分隔符為 ，
keys =[]
values =[]
for i in range(len(list)):
    if i % 2 == 0:            # 偶數 分割   true為 key    false為 values 
        keys.append(list[i])         
    else:
        values.append(list[i]) 
data['d'].update(dict(zip(keys,values)))       # 這一步的意思是 把元組轉化為字典 更新到d這個字典后面  

print('請輸入姓名，多個姓名之間用逗號分隔')
nameStr = input(':')
names = nameStr.split(',')
data['names'].extend(names)      # 把另外一個列表追加到一個列表的后面 

print(data)

輸出的結果為：
請輸入字典數據，key和value之間用逗號分隔
:a,1,b,2,c,3
請輸入姓名，多個姓名之間用逗號分隔
:majihui,zhaoshun
{'d': {'a': '1', 'b': '2', 'c': '3'}, 'names': ['majihui', 'zhaoshun']} 

如果我們有多個data這樣的字典，難道我們的代碼要復制10份嗎，下面引入 函數 ：我們把代碼進行抽象，放在一個函數里面 對重復使用的代碼。

第三種方法：函數的方法 
# 從控制臺輸入一些數據（以逗號分隔的字符串），然后保存到一個大的字典中
#  1.  初始化字典data
#  2.  從控制臺輸入以逗號分隔的字符串，并將其轉換為列表或字典
#  3.  輸出字典data

# 1.  初始化字典data
def init(data):
    data['d'] = {}
    data['names'] = []
# 2.  從控制臺輸入以逗號分隔的字符串，并將其轉換為列表或字典
# True：轉換為列表，False：轉換為字典
def inputListOrDict(flag,msg):
    print(msg)
    inputStr = input(':')
    list = inputStr.split(',')
    # 直接返回列表
    if flag:
        return list
    keys =[]
    values =[]
    result = {}
    for i in range(len(list)):
        if i % 2 == 0:
            keys.append(list[i])
        else:
            values.append(list[i])
    return dict(zip(keys,values))    

#  3.  輸出字典data
def outDict(data):
    for key in data.keys():
        print(key, ':', data[key])

// 把上面這3個 函數 封裝成一個模塊 dataman 我們要維護代碼的話，就只需要維護下面這幾個 就可以了 
from dataman import *

data1 = {}
data2 = {}
init(data1)
init(data2)

data1['d'].update(inputListOrDict(False, '請輸入字典數據'))
data1['names'].extend(inputListOrDict(True, '請輸入列表數據'))

data2['d'].update(inputListOrDict(False, '請輸入字典數據'))
data2['names'].extend(inputListOrDict(True, '請輸入列表數據'))

outDict(data1)
outDict(data2)

--------------------------------------------------------
課程七：函數中關鍵字參數和參數默認值
# 關鍵字參數和參數默認值 

# 位置參數    中 形參   值參      

# 混合使用位置參數和關鍵字參數 需要注意點
# 1. 關鍵字參數必須跟在位置參數后面
# 2. 同一個形參不能同時使用位置參數和關鍵字參數賦值

# 函數參數默認值，如果一個參數有默認值，那么該參數后面的所有的參數必須都有默認值，否則會拋出異常
def greet(name, greeting):                  # 函數里面有參數 一個參數叫name  一個參數叫 greeting   這2個叫形參 
    return '問候語：{}  姓名：{}'.format(greeting, name) 

print(greet('李寧', 'Hello'))    #  問候語：Hello  姓名：李寧       這里的 Hello 李寧 就表示的值參
print(greet('Hello', '李寧'))   # 問候語：李寧  姓名：Hello

# 解決參數的調用方式，解決參數的代碼的語言 通俗的講 就是解決調用的參數的時候，能一下子讓人看的懂 
# 關鍵字參數 可以不按照形參的輸入順序   本講的主要內容  

print(greet(name='李寧',greeting='Hello'))        # 關鍵字的參數就是形參的名字  在函數的內部和外部都可以使用，內部就是形參 外部就是一個變量 
print(greet(greeting = 'Hello', name='李寧'))

print(greet('Bill', greeting='Hello'))      # 關鍵字參數和位置參數混合使用   生產上建議用關鍵字參數，讓人一看代碼就明白 
# print(greet(name='Mike', 'Hello'))     # 這個會報錯 不行 為什么呢？
# 混合使用位置參數和關鍵字參數 需要注意點
# 1. 關鍵字參數必須跟在位置參數后面
# 2. 同一個形參不能同時使用位置參數和關鍵字參數賦值

# print(greet('Bill', name='Hello'))  

def fun(a,b,c = 123,d=4,e=12,f =20,g=40):  # 函數參數默認值，如果一個參數有默認值，那么該參數后面的所有的參數必須都有默認值，否則會拋出異常
    print(a,b,c,d,e,f,g)
fun(1,2,3,4,5)        # 1 2 3 4 5 20 40 

----------------------------------------------------------------------
第八課：函數中可變參數
// 什么是可變參數？
任意傳輸參數值是可變的，傳輸的參數的個數是不定的 可變參數的可變是表示參數的個數是可以變化的 
如何在一個函數中，定義可變參數
# 可變參數

# print(1,2,3,4,5,7,'a')
# 可變參數在函數內部的表現形式是一個元組
# 一般情況下，可變參數需要放在普通參數后面
# 如果可變參數后面還有普通參數，如果普通參數沒有默認值，為普通參數傳值
# 必須要使用關鍵字參數形式，如果有默認值，可以不傳值
def printParams(*params):    # 在函數中定義一個可變參數，需要在 參數的前面加一個* 就成為 可變參數 
    print(params)

printParams("hello", 1,True)        # ('hello', 1, True)  表現形式是一個元組  這里面的參數可以隨便的調整，

def printParams1(*params):
    for param in params:                            # 對每一個元組進行了for循環的迭代 
        print('<' + str(param) + '>', end = ' ')   # 需要提前轉化為字符串 因為有可以輸入的是數值，數值不可以和字符串直接相加 
printParams1('hello',1,2,3,False,40.1)              # <hello> <1> <2> <3> <False> <40.1>   我們得到了每一個值

print()
def printParams2(value, *params):         # 一般情況下，把可變參數放到 普通參數后面 也有不一般的情況下 后面講
    print('[' + str(value) + ']')
    for param in params:
        print('<' + str(param) + '>', end = ' ')
printParams2('hello',1,2,3,4)                        
# [hello]
# <1> <2> <3> <4>

#def printParams3(value1, *params, value2 = 20, value3=30):  解決方法1 在定義函數的時候加上默認值 
def printParams3(value1, *params, value2, value3):
    print('[' + str(value1) + ']')
    print('[' + str(value2) + ']')
    print('[' + str(value3) + ']')
    for param in params:
        print('<' + str(param) + '>', end = ' ')
printParams3('hello',1,2,3,4,5,value2 = 100, value3 = 200)       # 解決方法2 在輸出的時候，加上關鍵字參數

--------------------------------------------------------------------
第九課：將序列中的元素值作為函數對應的參數值傳遞    
# 將序列作為函數的參數值  并不是將一個序列看成一個整體，傳入函數的一個參數；而是將這個序列拆開，將每一個序列的元數值作為一個單獨的參數傳入函數的參數。

def printParams1(s1, s2):
    print(s1, s2)

printParams1("Hello", "World")
strList = ['Hello', 'World'] 
printParams1(*strList)       #  把列表前面加一個*  就會把列表中的參數的值拆開 到函數的每一個參數中   最后的值為： Hello World

def printParams2(*ss):      # 定義成可變參數，也是可以的 
    for s in ss:
        print('<{}>'.format(s), end = ' ')  

printParams2(*strList)        # <Hello> <World>
print()
printParams2(*'abcdefg')     # <a> <b> <c> <d> <e> <f> <g>     直接傳值 
print()
printParams2(*[1,2,3,4,5,6]) # <1> <2> <3> <4> <5> <6>     他會自動的把列表的值拆開 作為可變參數傳入 

def printParams3(**ss):          # 如何我們傳入字典呢？   傳入字典需要2 個 ** 
    for item in ss.items():     # 這里用 items 方法輸入 key value 
        print(item)             # 變量輸出 表現形式為 元組 
        print('{} = {}'.format(item[0], item[1]))
dict = {'a':10, 'b':20,'c':30}
printParams3(**dict)                           
printParams3(**{'name':'Bill','age':20})     
'''
a = 10
('b', 20)
b = 20
('c', 30)
c = 30
('name', 'Bill')
name = Bill
('age', 20)
age = 20 
'''

# 這個是不加2個**        和加2個** 是沒有本質的區別的   我操 
def printParams4(ss):
    for item in ss.items():
        print(item)
        print('{} = {}'.format(item[0], item[1]))
dict = {'a':10, 'b':20,'c':30}
printParams4(dict)
printParams4({'name':'Bill','age':20})

注意：
為函數傳遞可變參數值（單星和雙星參數）
單星和雙星 參數 ： 都是作為擴展參數用的  區別是什么呢？ 
*a     # 導入元組和列表的
**a    # 導入字典的 

def f1(a1,*a2):
    print(a1)
    print(a2)
f1(1,2,3,4,5)
輸出結果
1
(2, 3, 4, 5)

def f2(a1,**a2):
    print(a1)
    print(a2)
f2(1,aaa=111,bbb=222)
輸出的結果為：
1
{'aaa': 111, 'bbb': 222}
#就會自動的把后面關鍵字參數轉化為字典輸出