Python 语法糖：你真的会用 Python 吗？

[TOC]

人生苦短，我用 Python！

作为一门以简洁、优美为代表的语言，Python 受到众多开发者的喜爱。相信有部分 Python 的开发者们，知道“Python 之禅”即“The Zen of Python”，通过 import this 语句就可以看到，Python 创建者对 Python 语言书写规范的建议：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

这篇文章，向大家介绍十个 Python 语法糖，意在帮助大家写出更加优美简洁的 Python 程序。

变量的交换

在 C语言等其他大部分语言中，变量的交换通常需要定义一个临时变量作为桥梁，但在 Python 语言中，下面的交换变量方式显得更加方便：

1
2
3
4
5
6
7
8
// C语言中的变量交换
int a = 1;
int b = 2;
int temp;

temp = a;
a = b;
b = temp;
1
2
3
4
# python 语言中的变量交换
a = 1
b = 2
b, a = a, b

字符串的格式化

通常在字符串的组合与拼接中，我们通常采用字符串和 + 号的形式将他们联系起来，你是否是这样的呢？

1
2
name = 'Peter'
print('Hello, I am ' + name)

但是，当变量很多时，这样的方式写会使程序变得十分的杂乱：

1
2
3
4
5
name = 'Peter'
country = 'China'
age = 17

print('Hello, My name is ' + name + ', I am ' + str(age) + ', I come from ' + country + '.')

就会显得十分的杂乱。因此，有下面几个解决措施：

format 函数

上面的代码，我们通过 format 以下面的形式进行解决：

1
2
3
4
5
name = 'Peter'
country = 'China'
age = 17

print('Hello, My name is{}, I am {} ,I come from {}.'.format(name, country, age))

我们将 {} 去临时替代将要使用的变量名称，而最终，它会和 format 中传入的参数值一一对应，这种方式也可以避免了不同类型变量的类型转换。

f-string 写法

对于 Python 3.6 即以上的版本，下面这种写法相信是对字符串最简单的写法：

1
2
3
4
5
name = 'Peter'
country = 'China'
age = 17

print(f'Hello, My name is{name}, I am {country} ,I come from {age}.')

我们只需要将字符串前写一个 ‘f ’， 花括号中的内容将会自动替换为其中的变量指定表达式的值。由于这里说明是表达式的值，意思是如果花括号中为{age+1}那字符串中也将会被自动替换为‘18’，这里甚至可以传进去一个函数，那么字符串中将会显示函数中的返回值。

Yield 语法

接下来是一个斐波那契数列的生成函数如下所示：

1
2
3
4
5
6
7
8
9
10
11
def fibonacci(n):
    a = 0
    b = 1
    nums = []
    for _ in range(n):
        nums.append(a)
        a, b = b, a + b
    return nums

for i in fibonacci(15):
    print(i)

这个程序的运行结果是打印出斐波那契数列的前十五个数。

通过 Python 的 yield 函数，下面的方式可以完整的替换上面的方式：

1
2
3
4
5
6
7
8
9
def fibonacci(n):
    a = 0
    b = 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for i in fibonacci(15):
    print(i)

在调用这个函数时，每当我们计算出一个元素，yield 就会立马将这个元素给送出去，这样做的好处，我们并不需要等待整个列表生成完毕时才将他产出，解决一些耗时问题时，可以很有帮助。

简要理解：yield就是 return 返回一个值，并且记住这个返回的位置，下次迭代就从这个位置后开始。

列表解析式

假如说，我们有一个列表，里面存放了各个水果的名称，我们想要将其中的每个名字的首字母大写，将使用下面的方式：

1
2
3
4
fruits = ['apple', 'pear', 'orange', 'banana', 'pineapple']

for i in range(len(fruits)):
    fruits[i] = fruits[i].upper

其实这里有一个更简单的方法：

1
2
3
fruits = ['apple', 'pear', 'orange', 'banana', 'pineapple']

fruits = [fruit.upper() for fruit in fruits]

列表解析式在生成列表的过程中也可以有筛选的功能，假如我们要挑选所有首字母为 ‘a’ 的水果，我们可能会这样写：

1
2
3
4
5
6
fruits = ['apple', 'pear', 'orange', 'banana', 'pineapple']

filtered_fruit = []
for f in fruits:
    if f.startswith("a"):
    	filtered_fruit.append(f)

通过列表解析式的方式，我们可以很简洁的采用下面的方式代替：

1
2
3
fruits = ['apple', 'pear', 'orange', 'banana', 'pineapple']

fruits = [fruit for fruit in fruits if fruit.startswitch('a')]

Enumerate 函数

Python 对循环的技巧。

如果我们同时想获取循环项的索引值和元素的内容，我们可以通过采用enumerate函数的方法，具体使用可以见下所示;

1
2
3
4
fruits = ['apple', 'pear','orange', 'banana', 'pineapple']

for i, fruit in enumerate(fruits):
    print(i, fruit) # i 为索引值， fruit 为内容

遍历方法

对上一条的衍生。

反向遍历

如果我们想反向遍历一个列表，我们可以采用下面的方法，即设置一个 reversed() 函数。

1
2
3
4
fruits = ['apple', 'pear','orange', 'banana', 'pineapple']

for i, fruit in enumerate(reversed(fruits):
    print(i, fruit) # i 为索引值， fruit 为内容

按顺序遍历

如果我们想按照各个水果首字母在字典中的顺序，我们可以采用下面的方法，即设置一个 sorted() 函数。

1
2
3
4
fruits = ['apple', 'pear','orange', 'banana', 'pineapple']

for i, fruit in enumerate(sorted(fruits):
    print(i, fruit) # i 为索引值， fruit 为内容

字典的合并

在这里我们有两个字典，分别存放用户的用户名和密码，我们要将他们合并为同一个字典，Python 中不允许对字典直接相加。因此可以采用下面的方式：

1
2
3
4
5
6
7
a = {"tom": "112235", "xiaoming": "464323"}
b = {"tony": "156735", "xiaowang": "476587"}
c = {}
for key in a:
    c[key] = a[key]
for key in b:
    c[key] = b[key]

其实这里有更简单的 方法合并两个字典：

1
2
3
4
a = {"tom": "112235", "xiaoming": "464323"}
b = {"tony": "156735", "xiaowang": "476587"}

c = {**a, **b}

这里的两个 * 代表 Python 中的解包（unpacking），这里的 **a 和 **b 相当于将字典中的 a 和 b 中的内容直接填写到了这里。

三元运算符

在 Python 中我们常会用到下面的操作：根据某个条件的不同，将不同变量设置成不同的值

1
2
3
4
if score > 60:
    s = 'pass'
else:
    s = 'fail'

而我们使用三元运算符可以直接改为这样：

1
s = 'pass' if score > 60 else 'fail'

序列解包

假如我们需要将一个字符串通过空格分割得到多个字符串，我们可以采用下面的方法：

1
2
3
4
5
name = 'San Zhang'

str_list = name.split()
first_name = str_list[0]
last_name = str_list[1]

如果使用Python中的序列解包的方式，我们可以直接采用下面的方法：

1
2
name = 'San Zhang'
first_name, last_name = name.split()

这里被解包的序列不一定是列表，也可以是元组，甚至是 range.

With 语句

在 Python 中，我们可以通过 open 语句打开一个文件，但在打开使用后，我们要即时调用 close 函数，如果不关闭文件，程序将会一直调用文件进程直到程序退出为止：

1
2
3
f = open('test.txt', 'r')
s = f.read()
f.close()

使用Python中的with语句可以避免程序员忘记调用close语句，它可以在文件调用完，自动关闭。

1
2
with open('test.txt', 'r') as f:
    s = f.read()

参考视频：B站 奇乐编程学院