kwargspython

㈠ Logger.info(msg[ , *args[ , **kwargs] ] ),這是python API的一個方法，*知道表示什麼意思，[]什麼意思啊

C++中有重載，python的可以用這種方法實現可變參數。

先來看個例子：
def foo(*args, **kwargs):
print 'args = ', args
print 'kwargs = ', kwargs
print '---------------------------------------'

if __name__ == '__main__':
foo(1,2,3,4)
foo(a=1,b=2,c=3)
foo(1,2,3,4, a=1,b=2,c=3)
foo('a', 1, None, a=1, b='2', c=3)
輸出結果如下：
args = (1, 2, 3, 4)
kwargs = {}
---------------------------------------
args = ()
kwargs = {'a': 1, 'c': 3, 'b': 2}
---------------------------------------
args = (1, 2, 3, 4)
kwargs = {'a': 1, 'c': 3, 'b': 2}
---------------------------------------
args = ('a', 1, None)
kwargs = {'a': 1, 'c': 3, 'b': '2'}
---------------------------------------
可以看到，這兩個是python中的可變參數。*args表示任何多個無名參數，它是一個tuple；**kwargs表示關鍵字參數，它是一個dict。並且同時使用*args和**kwargs時，必須*args參數列要在**kwargs前，像foo(a=1, b='2', c=3, a', 1, None, )這樣調用的話，會提示語法錯誤「SyntaxError: non-keyword arg after keyword arg」。

呵呵，知道*args和**kwargs是什麼了吧。還有一個很漂亮的用法，就是創建字典：
def kw_dict(**kwargs):
return kwargs
print kw_dict(a=1,b=2,c=3) == {'a':1, 'b':2, 'c':3}
其實python中就帶有dict類，使用dict(a=1,b=2,c=3)即可創建一個字典了。

㈡ 在Python函數中使用關鍵字參數時，怎樣按輸入的順序輸出

**kwargs 是一個 Dictionary. Dictionary 是無序的。

要想輸出有序，可以想一個排序的key函數，使你對 kwargs 的排序與輸入時的順序一致。

一種方法是直接把變數名按字母表順序寫進去，不過這樣輸入的順序就固定了，我覺得不是你想要的。
還有一種方法如下，需要你在寫參數時另外加一個由其他參數名稱組成的 tuple。這個 Tuple 中元素的順序就是你輸入參數的順序。

def test(**kwargs):
order = kwargs.get('order_list','')
if order:
sorted_keys = sorted([x for x in kwargs if x != 'order_list'],key=order.index)
for key in sorted_keys:
print '{0} = {1}'.format(key,kwargs[key])
else:
for key in kwargs:
print '{0} = {1}'.format(key,kwargs[key])

test(a=3,b=3,g=0,v=99,order_list=('a','b','g','v'))

㈢ python中**是啥什麼意思

1、兩個值相加，然後返回值給符號左側的變數

舉例如下:

>>> a=1

>>> b=3

>>> a+=b（或者a+=3）

>>> a

4

2、用於字元串連接（變數值帶引號，數據類型為字元串）

>>> a='1'

>>> b='2'

>>> a+=b

>>> a

'12'

8、運算符優先順序

以下所列優先順序順序按照從低到高優先順序的順序；同行為相同優先順序。

Lambda #運算優先順序最低

邏輯運算符: or

邏輯運算符: and

邏輯運算符:not

成員測試: in, not in

同一性測試: is, is not

比較: <,<=,>,>=,!=,==

按位或: |

按位異或: ^

按位與: &

移位: << ,>>

加法與減法: + ,-

乘法、除法與取余: *, / ,%

正負號: +x,-x

具有相同優先順序的運算符將從左至右的方式依次進行，用小括弧()可以改變運算順序。

參考資料來源：網路-Python

㈣ python常見數據類型

一,python整數類型所表示的數據。

1,一般用以表示一類數值:所有正整數,0和負整數;

2,整型作為最常用的,頻繁參與計算的數據類型，在python3.5中解釋器會自動在內存中創建-5-3000之間的（包含5，不包含3000）整型對象，也就是說在該范圍內,相等都是同一個已經創建好的整型對象。范圍之外的即使相等也表示不同對象，該特性隨python版本而改變，不要過於依賴。

3,bool型繼承了int型，他是int的子類。

4,Python2中有長整型long，數值范圍更大，在python3中已取消，所有整型統一由int表示。

5,參與所有數值計算，數學運算，科學計算。這也是所有編程語言都有的數據類型，因為編程語言生而需要模擬人的思維，藉助數學方式，自動計算、更好的解決大量重復性的事務，因此數值類型、整數類型在編程語言中不可或缺。

6,支持二進制(0b\0B開頭),十進制,八進制(0o\0O),十六進制(0x\0X)

二，python整數和浮點型支持常規的數值運算

整數和浮點數都可參與的運算：+ - * / %（取余） //（整除） **（冪）

Python字元型：

python字元型表示的數據：
python3支持Unicode編碼，由字母、數字和符號組成的形式就叫字元串，更接近或者相同與人們文字元號表示，因此在信息表示和傳遞時它也是最受認可的形式。在程序編寫中也是非常常用，對應的可操作的方法也很多，很有意思。
字元串不可被修改，可以拼接等方法創建新字元串對象；
支持分片和下標操作；a[2:]
支持+拼接，*重復操作和成員關系in/not in；
表示形式：用單引號雙引號包含起來的符號；a = str(『sdfsdfsdf』) 或 r』\t\nabcd』 原始字元，Bytes：b』abcd』；
6,字元串屬於不可變數據類型，內部機制為了節省空間，相同的兩個字元串表示相同的一個對象。a = 『python』 b = 『python』 a is b :True

二, 字元串支持的運算方法

1,capitalize() :首字母大寫後邊的字母小寫 a = 『abcd』 b = a.capitalize() b:Abcd

2,casefold() lower():字母轉換為全小寫

3,center(width,fillchar) :居中，width填補的長度；fillchar添加的字元

a = a.center(10,』_』) //』____abcd____』 默認無fillchar填充空格

4,count(sub,star,end) :字母計數：sub要查詢的字元

5,encode(encoding=』utf-8』,errors=』strict』) 設置編碼

Errors :設置錯誤類型

6,endswith(suffix,star,end) : 若以suffix結尾返回True

7，expandtabs(8) :設置字元串中tab按鍵符的空格長度：』\tabcde』

8,find(sub,star,end) : 返回指定范圍內的字元串下標，未找到返回-1

9，index(sub,star,end) :返回指定范圍字元串下標未找到拋出異常

10，isalnum() :判斷字元串是否是字母或數字，或字母和數字組合

11，isalpha() :判斷是否全是字母

12，isdecimal() :判斷字元串是否是十進制數值

13，isdigit() :判斷字元串是否是數字

14，isidentifier() :判斷字元串中是否包含關鍵字

15，islower() :判斷是否全小寫

16，isnumeric() :判斷全是數字

17，isspace() :判斷是否是空格

18，isupper() 判斷是否大寫

19，istitle() :判斷是否首字母大寫

20，join(iterable) :把可迭代對象用字元串進行分割：a.join(『123』)

21,ljust(width,fillchar);rjust() :左對齊右對齊

22, upper() :將字元串改為大寫

23，split(sep=None,maxsplit=-1) :分割一個字元串，被選中字元在字元串中刪除

『ab1cd1efg』.split(『1』) :[『ab』,』cd』,』efg』]

三，字元串格式化：按照規格輸出字元串

format(*args,**kwargs) :args位置參數，kwargs關鍵字參數

『{0:.1f}』.format(123.468) :格式化參數，小數點後保留1位四捨五入

四，字元串操作符%

1，%s :格式化字元串 『abcd%sdef』%』dddd』

2，%d:格式化整數

3，%o格式化無符號八進制

4，%x格式化無符號十六進制

5，%f格式化定點數

6, %e: 科學計數法格式化定點數

7，%g 根據值大小自動選%f,%e

8, %G E X :大寫形式

五，格式化輔助命令：

m.n :m最小總寬度，n小數點後位數：』%12.4f』%23456.789

六，轉義字元：字元串前r避免轉義：r』\nhello\thi』

\n:換行符

\t:橫向製表符

\':'

\":"

\b:退格符

\r:回車

\v:縱向製表符

\f:換頁符

\o,\x:八進制和十六進制

\0:空字元串

Python列表list

一，Python的列表list類型表示的數據：

Python列表在cpython中被解釋為長度可變的數組，用其他對象組成的連續數組。

列表中元素可以是相同或不同的數據類型；
當列表元素增加或刪除時，列表對象自動進行擴展或收縮內存，保證元素之間沒有縫隙，總是連續的。
Python中的列表是一個序列，也是一個容器類型
創建列表：a = []; b = [1,』python』]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加單個元素：list.append(object); //a.append(『python』)

2,extend添加可迭代對象: list.extend(iterable); //a.extend(『abcde』/[1,2,3])

3,insert 插入元素：list.insert(index,object): 在index下標前插入元素//a.insert(2,』python』)

4,clear 清空所有元素：list.clear() //a.clear()

5,pop 刪除並返回一個元素：list.pop(index) //默認刪除默認一個元素

remove 刪除指定元素：list.remove(v) ,v元素不存在報錯 //a.remove(『c』)
7，count 返回這個值在列表中數量：list.count(value)

8, 淺拷貝一個新列表：list.()

9,sort:排序list.sort(reverse=False/True) :默認升序

排序函數：sorted(list)

10，reverse: 原地翻轉：list.reverse()

11，index(value,star,stop) :指定范圍內該值下標：list.index(2,0,5)

列表元素訪問：
下標訪問：list[1]
For循環遍歷
通過下標修改元素：list[2 ] = 『hello』
列表常用運算符：
1,比較運算符：從第一個元素開始對比

2，+ 拼接一個新列表：l1+ l2

3, 重復操作符：* ,多個列表拼接

成員關系操作符：in/ not in
邏輯運算符：and not or
列表常用的排序方法：
冒泡排序；選擇排序；快速排序；歸並排序

Python元組tuple

一，Python元組tuple數據類型表示的數據：

元組是受到限制的、不可改變的列表；
可以是同構也可以是異構；
元組是序列類型、是可迭代對象，是容器類型。
元組的創建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]

二，python元組常用方法

1,index(value,star,stop) :指定范圍內該值下標：tuple.index(2,0,5)

2,count(value) ：值出現次數

三，支持運算：

1,比較運算符：從第一個元素開始對比

2，+ 拼接一個新元組：l1+ l2

3, 重復操作符：* ,多個元組拼接

4成員關系操作符：in/ not in

邏輯運算符：and not or
四，元組的訪問

下標操作；
For循環遍歷訪問。

Python字典類型

一,Python字典dict表示的數據：{key:value}

可根據關鍵字：鍵快速索引到對應的值；
字典是映射類型，鍵值對一一對應關系，不是序列；
字典元素是無序的；
字典是可迭代對象，是容器類型；
字典的創建：k = {}; k1={『keyword』:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)

二，字典的訪問：

通過key：k[『key』]

修改key對應的值：K[『key』] = value

For循環遍歷出來的是key；

For循環鍵值對：for I in d.items():

For 循環enumerate: for k,v in enumerate(k1):

In/not in 成員關系查詢鍵不支持查值

三，字典常用方法

get(key,de):獲取值：k.get(key,de) //若不存在則默認輸出de
pop(k,de):刪除一個鍵值對，不存在輸出de，未設置報錯；
keys() :返回字典所有key組成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value組成的序列：list(k.values())
items():返回鍵值對組成的元組為元素的序列：（類set）list(k.items())
update(e):更新字典：e可是字典或兩元素組成的單位元素序列：e=[(5,6),(7,8)];
k.update(e)

clear():清空字典；
popitem()刪除某個鍵值對，若字典為空則報錯
() :淺拷貝
10, fromkeys(iterable,value=None):從可迭代對象創建字典

{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}

11,setdefault(k,d=None) :若key不存在則生成一個鍵值對

k.setdefault(『keyword』)

Python 集合set

集合表示的數據：
多個元素的無序組合，集合是無序的，集合元素是唯一的；
字典的鍵是由集合實現的；
集合是可迭代對象
集合創建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的訪問：
For 循環將集合所有元素全部訪問一遍，不重復

常用方法：
add(object):s.add(『hi』) 向集合添加一個元素
pop() :彈棧，集合為空則報錯：刪除任意一個元素；
clear():清空集合，返回一個空集合對象；
remove(object):刪除一個元素，不存在和報錯：s.remove(『hi』)
update(集合)：更新另一個集合，元素不存在則不更新；
() :淺拷貝
集合的運算：
交集：s1&s2;
差集,補集：s1-s2;
並集：s1|s2;
Issubset():判斷是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判斷是否是父集：s1.issuperset()
不可變集合：
Frozenset():返回一個空的不可變集合對象

Frozenset(iterable):

S = frozenset(iterable)

Python序列類型共同特性

一,序列類型共同特性

python序列類型有:str字元串,list列表,tuple元組
都支持下標索引，切片操作；
下標都是從0開始，都可通過下標進行訪問；
擁有相同的操作符
二，支持的函數：

len(obj):返回對象長度；
list(iterable):將可迭代對象轉為列表；
tuple(iterable):將可迭代對象轉為元組；
str(ojb):將任何對象轉為字元串形式；
max(iterable): python3中元素要是同類型，python2中元素可異構：max([『a』,1])
min(iterable):和max類似；
sum(iterable,star=0),求可迭代對象和，默認star為0，元素不能為字元串
sorted(iterable,key=None,reverse=False)
s=[(『a』,3),(『b』,2),(『c』,9)]

sorted(s,key=lambda s:s[1]) //按照數字排序

reversed(sequence):翻轉序列，返回迭代器
enumerate(iterable):返回enumerate對象,其元素都是一個元組（下標，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]

序列類型的切片操作：

Slice:

L[index]; 訪問某個元素；

L[1:4]; 區間

L[star:stop:step]; 設置步長取區間元素

㈤ python這些參量縮寫的意思是什麼啊

*args，*kw，*kwargs這三個是都是位置參數，除了形參名不同，使用沒區別。

**args，**kw，**kwargs，這三個都是關鍵參數，除了形參名不同，使用沒區別。

例如：def func(a, b=None): pass 函數的a就是位置參數，b是關鍵參數。

此函數中傳入關鍵參數時，必須寫成 b=實參。但此函數只能傳2個參數，傳多傳少都會報錯。

如果形參前面加1個*意味著位置參數是不定長的，可傳入多個參數。

如果形參前面加2個*意味著關鍵參數是不定長的，可傳入多個關鍵參數。

def func(*args,**kwargs): pass 此函數可以傳入任意多個位置參數和關鍵參數而不會報錯。

㈥ 如何使用Python實現多進程編程

1.Process
創建進程的類：Process([group[,target[,name[,args[,kwargs]]]]])，target表示調用對象，args表示調用對象的位置參數元組。kwargs表示調用對象的字典。name為別名。group實質上不使用。
方法：is_alive()、join([timeout])、run()、start()、terminate()。其中，Process以start()啟動某個進程。
屬性：authkey、daemon（要通過start()設置）、exitcode(進程在運行時為None、如果為–N，表示被信號N結束）、name、pid。其中daemon是父進程終止後自動終止，且自己不能產生新進程，必須在start()之前設置。

例1.1：創建函數並將其作為單個進程
importmultiprocessing
importtime

defworker(interval):
n=5
whilen>0:
print("Thetimeis{0}".format(time.ctime()))
time.sleep(interval)
n-=1

if__name__=="__main__":
p=multiprocessing.Process(target=worker,args=(3,))
p.start()
print"p.pid:",p.pid
print"p.name:",p.name
print"p.is_alive:",p.is_alive()
結果
12345678p.pid:8736p.name:Process-1p.is_alive:TrueThetimeisTueApr2120:55:122015ThetimeisTueApr2120:55:152015ThetimeisTueApr2120:55:182015ThetimeisTueApr2120:55:212015ThetimeisTueApr2120:55:242015

例1.2：創建函數並將其作為多個進程
importmultiprocessing
importtime

defworker_1(interval):
print"worker_1"
time.sleep(interval)
print"endworker_1"

defworker_2(interval):
print"worker_2"
time.sleep(interval)
print"endworker_2"

defworker_3(interval):
print"worker_3"
time.sleep(interval)
print"endworker_3"

if__name__=="__main__":
p1=multiprocessing.Process(target=worker_1,args=(2,))
p2=multiprocessing.Process(target=worker_2,args=(3,))
p3=multiprocessing.Process(target=worker_3,args=(4,))

p1.start()
p2.start()
p3.start()

print("ThenumberofCPUis:"+str(multiprocessing.cpu_count()))
forpinmultiprocessing.active_children():
print("childp.name:"+p.name+"	p.id"+str(p.pid))
print"END!!!!!!!!!!!!!!!!!"
結果
1234567891011ThenumberofCPUis:4childp.name:Process-3p.id7992childp.name:Process-2p.id4204childp.name:Process-1p.id6380END!!!!!!!!!!!!!!!!!worker_1worker_3worker_2endworker_1endworker_2endworker_3

例1.3：將進程定義為類
importmultiprocessing
importtime

classClockProcess(multiprocessing.Process):
def__init__(self,interval):
multiprocessing.Process.__init__(self)
self.interval=interval

defrun(self):
n=5
whilen>0:
print("thetimeis{0}".format(time.ctime()))
time.sleep(self.interval)
n-=1

if__name__=='__main__':
p=ClockProcess(3)
p.start()
註：進程p調用start()時，自動調用run()
結果
12345thetimeisTueApr2120:31:302015thetimeisTueApr2120:31:332015thetimeisTueApr2120:31:362015thetimeisTueApr2120:31:392015thetimeisTueApr2120:31:422015

㈦ python函數的閉包怎麼理解

1. 閉包的概念
首先還得從基本概念說起，什麼是閉包呢？來看下維基上的解釋:

復制代碼代碼如下:

在計算機科學中，閉包（Closure）是詞法閉包（Lexical Closure）的簡稱，是引用了自由變數的函數。這個被引用的自由變數將和這個函數一同存在，即使已經離開了創造它的環境也不例外。所以，有另一種說法認為閉包是由函數和與其相關的引用環境組合而成的實體。閉包在運行時可以有多個實例，不同的引用環境和相同的函數組合可以產生不同的實例。
....

上面提到了兩個關鍵的地方： 自由變數 和 函數, 這兩個關鍵稍後再說。還是得在贅述下「閉包」的意思，望文知意，可以形象的把它理解為一個封閉的包裹，這個包裹就是一個函數，當然還有函數內部對應的邏輯，包裹裡面的東西就是自由變數，自由變數可以在隨著包裹到處游盪。當然還得有個前提，這個包裹是被創建出來的。

在通過Python的語言介紹一下，一個閉包就是你調用了一個函數A，這個函數A返回了一個函數B給你。這個返回的函數B就叫做閉包。你在調用函數A的時候傳遞的參數就是自由變數。
舉個例子：

復制代碼代碼如下:

def func(name):
def inner_func(age):
print 'name:', name, 'age:', age
return inner_func

bb = func('the5fire')
bb(26) # >>> name: the5fire age: 26

這裡面調用func的時候就產生了一個閉包——inner_func,並且該閉包持有自由變數——name，因此這也意味著，當函數func的生命周期結束之後，name這個變數依然存在，因為它被閉包引用了，所以不會被回收。
另外再說一點，閉包並不是Python中特有的概念，所有把函數做為一等公民的語言均有閉包的概念。不過像Java這樣以class為一等公民的語言中也可以使用閉包，只是它得用類或介面來實現。
更多概念上的東西可以參考最後的參考鏈接。
2. 為什麼使用閉包
基於上面的介紹，不知道讀者有沒有感覺這個東西和類有點相似，相似點在於他們都提供了對數據的封裝。不同的是閉包本身就是個方法。和類一樣，我們在編程時經常會把通用的東西抽象成類，（當然，還有對現實世界——業務的建模），以復用通用的功能。閉包也是一樣，當我們需要函數粒度的抽象時，閉包就是一個很好的選擇。
在這點上閉包可以被理解為一個只讀的對象，你可以給他傳遞一個屬性，但它只能提供給你一個執行的介面。因此在程序中我們經常需要這樣的一個函數對象——閉包，來幫我們完成一個通用的功能，比如後面會提到的——裝飾器。
3. 使用閉包
第一種場景 ，在python中很重要也很常見的一個使用場景就是裝飾器，Python為裝飾器提供了一個很友好的「語法糖」——@，讓我們可以很方便的使用裝飾器，裝飾的原理不做過多闡述，簡言之你在一個函數func上加上@decorator_func, 就相當於decorator_func(func):

復制代碼代碼如下:

def decorator_func(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper

@decorator_func
def func(name):
print 'my name is', name
# 等價於
decorator_func(func)

在裝飾器的這個例子中，閉包（wrapper）持有了外部的func這個參數，並且能夠接受外部傳過來的參數，接受過來的參數在原封不動的傳給func，並返回執行結果。
這是個簡單的例子，稍微復雜點可以有多個閉包，比如經常使用的那個LRUCache的裝飾器，裝飾器上可以接受參數@lru_cache(expire=500)這樣。實現起來就是兩個閉包的嵌套:

復制代碼代碼如下:

def lru_cache(expire=5):
# 默認5s超時
def func_wrapper(func):
def inner(*args, **kwargs):
# cache 處理 bala bala bala
return func(*args, **kwargs)
return inner
return func_wrapper

@lru_cache(expire=10*60)
def get(request, pk)
# 省略具體代碼
return response()

不太懂閉包的同學一定得能夠理解上述代碼，這是我們之前面試經常會問到的面試題。
第二個場景 ，就是基於閉包的一個特性——「惰性求值」。這個應用比較常見的是在資料庫訪問的時候，比如說：

復制代碼代碼如下:

# 偽代碼示意

class QuerySet(object):
def __init__(self, sql):
self.sql = sql
self.db = Mysql.connect().corsor() # 偽代碼
def __call__(self):
return db.execute(self.sql)
def query(sql):
return QuerySet(sql)
result = query("select name from user_app")
if time > now:
print result # 這時才執行資料庫訪問

上面這個不太恰當的例子展示了通過閉包完成惰性求值的功能，但是上面query返回的結果並不是函數，而是具有函數功能的類。有興趣的可以去看看Django的queryset的實現，原理類似。
第三種場景 ， 需要對某個函數的參數提前賦值的情況，當然在Python中已經有了很好的解決訪問 functools.parial,但是用閉包也能實現。

復制代碼代碼如下:

def partial(**outer_kwargs):
def wrapper(func):
def inner(*args, **kwargs):
for k, v in outer_kwargs.items():
kwargs[k] = v
return func(*args, **kwargs)
return inner
return wrapper

@partial(age=15)
def say(name=None, age=None):
print name, age
say(name="the5fire")
# 當然用functools比這個簡單多了
# 只需要： functools.partial(say, age=15)(name='the5fire')

看起來這又是一個牽強的例子，不過也算是實踐了閉包的應用。

㈧ python裡面args作為參數但是方法體裡面沒有調用，那這個args的作用是什麼

可以不寫，但是一般都需傳遞參數以增加函數的擴展性

㈨ 使用python時，作為參數的字典前放了**，是為什麼

關鍵字參數
python在參數名之前使用2個星號來支持任意多的關鍵字參數。
>>>
def
accept(**kwargs):
...
for
keyword,
value
in
kwargs.items():
...
print
"%s
=>
%r"
%
(keyword,
value)
...
>>>
accept(foo='bar',
spam='eggs')
foo
=>
'bar'
spam
=>
'eggs'
注意:kwargs是一個正常的python字典類型，包含參數名和值。如果沒有更多的關鍵字參數，kwargs就是一個空字典。

㈩ Python代碼中func(*args, **kwargs)是什麼意思

文檔里tutorial里有【貌似在function那節】
*popenargs意為一般的【表達無力
：）】參數
**kwargs意為key=value形式的參數
比方說：
def
func(*args,
**kwargs):
print
'args:
',
args
print
'kwargs:
',
kwargs
func('a',
'b',
'c',
x='d',
y='e',
z='f')
輸出為：
args:
('a',
'b',
'c')
kwargs:
{'y':
'e',
'x':
'd',
'z':
'f'}
以上