python优势之通过一段代码来了解python的强大之处
晚上闲暇之余随意翻了一下博客，看到https://www.jianshu.com/p/69bf0ed0b5cc作者提到了一段代码，刚开始看没啥感觉，仔细深入后引起了我的注意。里面使用了python最简单的语法，确产生了最神奇的效果，代码的世界太神奇了！先贴一下源码吧
1、什么是可变参数，什么是关键字参数
2、使用了什么基础的python语法
3、为什么这段代码能引起我的注意
```python
def transfer_kwargs(*args):
kwargs = {}
for arg in args:
k, v = map(lambda x: x.strip(), arg.split('.', 1))
if '.' in v:
item = kwargs.setdefault(k, {}) # step1
values = v.split('.')
for j in values[:-2]:
item = item.setdefault(j, {}) # step2
item[values[-2]] = values[-1] # step3
else:
kwargs.update({k: v})
print(kwargs)
if __name__ == '__main__':
info1 = '1.2.3.4.5'
info2 = 'a.b.c.d.f'
transfer_kwargs(info1, info2)
输出:
>>>{'1': {'2': {'3': {'4': '5'}}}, 'a': {'b': {'c': {'d': 'f'}}}}
```
这段代码总共13行代码，确实现了复杂的功能，将简单的字符复杂化，当然也有其他的方法可以实现这种功能，本文就此函数进行一个概要的分析：
### 1、什么是可变参数，什么是关键字参数
*args是可变参数，args接收的是一个tuple；使用了可变参数入参，使的入参变量可以多个。如我们可以这样运行函数
```python
if __name__ == '__main__':
info1 = '1.2.3.4.5'
info2 = 'a.b.c.d.f'
info3 = 'e.f.g.h.i.j.k'
info4 = 'a1.b1.c1.d1.f1'
transfer_kwargs(info1, info2,info3, info4)
输出:
>>>{'a': {'b': {'c': {'d': 'f'}}}, '1': {'2': {'3': {'4': '5'}}}, 'a1': {'b1': {'c1': {'d1': 'f1'}}}, 'e': {'f': {'g': {'h': {'i': {'j': 'k'}}}}}}
```
说到可变参数，就不得提一下关键字参数；**kwargs是关键字参数，kwargs接收的是一个dict，入参内容可以实现扩大化，可变参数加关键字参数入参=万能参数，此处不再累述。
### 2、使用了什么基础的python语法
#### 2.1 map(function, iterable, …)
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。实例如下：
```python >>>def square(x) : # 计算平方数 ... return x ** 2 ... >>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 [1, 4, 9, 16, 25] >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] # 提供了两个列表，对相同位置的列表数据进行相加 >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) [3, 7, 11, 15, 19] ```
#### 2.2 lambda [arg1 [,arg2,…..argn]]:expression
python的匿名函数，lambda只是一个表达式，函数体比def简单很多；lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去；lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数；虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率，实例如下：
```python
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
输出结果：
相加后的值为 : 30
相加后的值为 : 40
```
#### 2.3 str.strip([chars])
Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列；该方法只能删除开头或是结尾的字符，不能删除中间部分的字符，实例如下：
```python #!/usr/bin/python # -*- coding: UTF-8 -*- str = "00000003210Runoob01230000000"; print str.strip( '0' ); # 去除首尾字符 0 str2 = " Runoob "; # 去除首尾空格 print (str2.strip()); 输出结果： 3210Runoob0123 Runoob ```
#### 2.4 str.split(str=””, num=string.count(str)).
Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串。实例如下：
```python
#!/usr/bin/python
# -*- coding: UTF-8 -*-
txt = "Google#Runoob#Taobao#Facebook"
# 第二个参数为 1，返回两个参数列表
x = txt.split("#", 1)
print(x)
输出结果：
['Google', 'Runoob#Taobao#Facebook']
```
#### 2.5 dict.setdefault(key, default=None)
Python 字典 setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值；这两种方法有什么区别呢，看实例：
```python
if __name__ == '__main__':
info5 ={'age': 18, 'name': 'Jack'}
info6 = {'age': 18, 'name': 'Jack'}
print(info5.get("sex",'男'))
print(info6.setdefault("sex",'男'))
print(info5)
print(info6)
以上实例输出结果为：
男
男
{'age': 18, 'name': 'Jack'}
{'age': 18, 'name': 'Jack', 'sex': '男'}
```
通过实例可以发现dict.setdefault(key, default=None)使用取出一个不存在的键的值(返回默认键的值，并且将新的键值保存在字典中)
#### 2.6 values[:-2]
values[start:end:step],其中start:起始索引，从0开始，-1表示结束；end：结束索引；step：步长，end-start，步长为正时，从左向右取值。步长为负时，反向取值。注意切片的结果不包含结束索引，即不包含最后的一位，-1代表列表的最后一个位置索引。
values[:-2]默认起始位置为0，步长为1，结束索引为倒数第二个字符。实例如下：
``` if __name__ == "__main__": a = [1,2,3,4,5] print(a[:-2]) 输出结果为： [1, 2, 3] ```
### 3、为什么这段代码能引起我的注意
整段代码主要是对一定秩序的字符串做稍微的嵌套处理，如效果：
```
if __name__ == '__main__':
info1 = '1.2.3.4.5'
info2 = 'a.b.c.d.f'
transfer_kwargs(info1, info2)
输出结果：
{'1': {'2': {'3': {'4': '5'}}}, 'a': {'b': {'c': {'d': 'f'}}}}
```
函数体内有一串封尾代码，item[values[-2]] = values[-1]，去除这段代码后的结果为
```
{'1': {'2': {'3': {}}}, 'a': {'b': {'c': {}}}}
```
换句话说函数体的其他部分主要实现的是嵌套功能，遍历列表（排除最后一个值，这个值是用来最后面的封尾处理的字典建4或c的值）。这种简单的嵌套，使的最开始时每个字典的key对应的值是{}。直到结尾的4和c对应的值是5和d。
```
for j in values[:-2]:
item = item.setdefault(j, {})
```
分析到这一步了相信大家都能将代码看懂，就不过多累述了，在对这段代码的分析后我找到以下这么几点，作为吸引我的关键所在：
1 python的一个简单语法可以实现很多复杂操作，而多个简单语法混合可以达到奇妙的效果。如本文提及到的函数。
2 整段代码没有任何的冗余，夹杂着循坏语句、条件语句恰到好处的实现了复杂的功能。
3 扩展了一些基本语法的知识item.setdefault(j, {})这个方法第一次看到，完美解决了在get语法上的缺陷
python代码，因简单而复杂
基础语法2实例引用自[菜鸟教程](https://www.runoob.com/python)