亲宝软件园·资讯

展开

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

pujen_yuan 人气:0

晚上闲暇之余随意翻了一下博客,看到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)

加载全部内容

相关教程
猜你喜欢
用户评论