Python"鲜为人知"的特性，看完又涨新知识了

特别说明：

本文基于python 3.8

变量值交换

示例

等号右边是一个创建元组的表达式，等号左边解压（没有引用的）元组分别赋给名称（变量）a和b。赋完值后因为没有被其他名字引用，因此被标记之后被垃圾收集器回收，而绑定到a和b的值已经被交换了。
注意：多值赋值其实仅仅就是元组打包和序列解包的组合的过程

>>> a = 10
>>> b = 5
>>> a, b
(10, 5)

>>> a, b = b, a
>>> a, b
(5, 10)

链式比较操作

示例

这里的执行的过程并不是先比较：1 < x，返回True，然后再比较True < 10，当然这么做也是返回True（比较表达式True < 10，解释器会把True转换成1，False转换成0），这里解释器在内部会把这种链式的比较操作转换成：1 < x and x < 10

>>> x = 5
>>> 1 < x < 10
True
>>> 10 < x < 20 
False
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True

enumerate获取迭代的索引

用enumerate包装一个可迭代对象，可以同时使用迭代项和索引，在遍历的同时获取元素所在位置时非常方便。

示例

>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): 
            print(index, item)
...
0 a
1 b
2 c
3 d
4 e

条件赋值

python的条件赋值，类似于其他语言中的三目运算符

示例

# 这个表达式的意思就是:如果y等于那么就把3赋值给x,否则把2赋值给x, 条件中的括号是可选的,为了可读性可以考虑加上去.if else中的表达式可以是任何类型的,既可以函数,还可以类
x = 3 if (y == 1) else 2

# 如果y等于1,那么调用func1(arg1,arg2)否则调用func2(arg1,arg2)
(func1 if y == 1 else func2)(arg1, arg2)

# 如果y等于1,那么调用class1 (arg1,arg2)否则调用class2(arg1,arg2)
x = (class1 if y == 1 else class2)(arg1, arg2)

异常else语句块

try:
   try_this(whatever)
except SomeException as exception:
   # Handle exception
else:
    # do something
finally:
    # do something

# else语句块会在没有异常的情况下执行，先于finally，它的好处就是你可以明确知道它会在没有异常的情况下执行，如果是把else语句块放在try语句块里面就达不到这种效果。

函数参数解包

分别使用 * 和 ** 解包列表和字典，这是一种非常实用的快捷方式，因为list、tuple、dict作为容器被广泛使用。

示例

def draw_point(x, y):
    # do something

point_foo = (3, 4)
point_bar = {'y': 3, 'x': 2}
# 元组解包
draw_point(*point_foo)
# 字典解包
draw_point(**point_bar)

列表推导式

示例

# 获取可迭代对象中的偶数，快速生成一个列表
x = [n for n in iter if n%2==0]
>>> type(x)
<type 'list'>

生成器对象

生成器比列表推导式能带来更快的速度，也更能节省内存开销，它的值是按需生成，不需要像列表推倒式一样把整个结果保存在内存，适用于需要大量数据场景。

示例

# 你可以把生成器对象赋值给x，意味着可以对x进行迭代操作：
x=(n for n in arr if n%2==0)  # arr是可迭代对象
>>> type(x)
<type 'generator'>

# 它的好处就是不需要存储中间结果
for n in x:
  print(n)

字典推导式

示例


# 从Python3以后，可以直接用字典推导式语法，生成字典
list_data = [(a,1),(b,2)]
d = {key: value for (key, value) in list_data }

# 你也可以用任何方式的迭代器(元组,列表,生成器..)，只要可迭代对象的元素中有两个值，

小心可变的默认参数

示例

可变对象建议不要做函数的默认参数，不然容易出现异常的效果，如下：

>>> def foo(x=[]):
...     x.append(1)
...     print(x)
... 
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]

# 取而代之的是你应该使用一个None来替换可变对象，如：

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print(x)
>>> foo()
[1]
>>> foo()
[1]

装饰器

装饰器使一个函数或方法包装在另一个函数里头，可以在被包装的函数添加一些额外的功能，比如日志，还可以对参数、返回结果进行修改。装饰器有点类似Java中的AOP。下面这个例子是打印被装饰的函数里面的参数的装饰器。

示例

>>> from functools import wraps
>>> def print_args(function):
>>>     @wraps
>>>     def wrapper(*args, **kwargs):
>>>         print('Arguments:', args, kwargs)
>>>         return function(*args, **kwargs)
>>>     return wrapper

>>> @print_args
>>> def write(text):
>>>     print(text)

>>> write('foo')
Arguments: ('foo',) {}
foo
@是语法糖，它等价于：

>>> write = print_args(write)
>>> write('foo')
arguments: ('foo',) {}
foo