python优势之通过一段代码来了解python的强大之处

晚上闲暇之余随意翻了一下博客，看到https://www.jianshu.com/p/69bf0ed0b5cc作者提到了一段代码，刚开始看没啥感觉，仔细深入后引起了我的注意。里面使用了python最简单的语法，确产生了最神奇的效果，代码的世界太神奇了！先贴一下源码吧
1、什么是可变参数，什么是关键字参数
2、使用了什么基础的python语法
3、为什么这段代码能引起我的注意

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；使用了可变参数入参，使的入参变量可以多个。如我们可以这样运行函数

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 函数返回值的新列表。实例如下：

>>>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++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率，实例如下：

#!/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() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列；该方法只能删除开头或是结尾的字符，不能删除中间部分的字符，实例如下：

#!/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 个子字符串。实例如下：

#!/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()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值；这两种方法有什么区别呢，看实例：

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🔚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实例引用自菜鸟教程