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}
#就會自動的把後面關鍵字參數轉化爲字典輸出