出品 | flyai
编译 | 林椿眄
编辑 | donna
python 已经成为机器学习及其他科学领域中的主流语言。它不但与多种深度学习框架兼容，而且还包含优秀的工具包和依赖库，方便我们对数据进行预处理和可视化操作。
据最新消息，到2019 年底，numpy 等很多科学计算工具包都将停止支持python 2版本，而 2018 年后 numpy 的所有新功能版本也都将只支持 python 3。
为了使初学者能够轻松地从 python 2 向 python 3 实现迁移，我收集了一些 python 3 的功能，希望对大家有所帮助。
使用 pathlib 模块来更好地处理路径
pathlib 是 python 3默认的用于处理数据路径的模块，它能够帮助我们避免使用大量的 os.path.joins语句：
from pathlib import path dataset = 'wiki_images'datasets_root = path('/path/to/datasets/') train_path = datasets_root / dataset / 'train'test_path = datasets_root / dataset / 'test'for image_path in train_path.iterdir(): with image_path.open() as f: # note, open is a method of path object # do something with an image
在python2中，我们需要通过级联字符串的形成来实现路径的拼接。而现在有了pathlib模块后，数据路径处理将变得更加安全、准确，可读性更强。
此外，pathlib.path含有大量的方法，这样python的初学者将不再需要搜索每个方法：
p.exists() p.is_dir() p.parts() p.with_name('sibling.png') # only change the name, but keep the folderp.with_suffix('.jpg') # only change the extension, but keep the folder and the namep.chmod(mode)p.rmdir()
使用pathlib还将大大节约你的时间。更多功能请查看：
官方文档 - 参考信息 - https://pymotw/3/pathlib/
类型提示(type hinting)成为python3中的新成员
下面是在编译器pycharm 中，类型提示功能的一个示例：
python 不只是一门脚本的语言，如今的数据流程还包括大量的逻辑步骤，每一步都包括不同的框架（有时也包括不同的逻辑）。
python3中引入了类型提示工具包来处理复杂的大型项目，使机器可以更好地对代码进行验证。而在这之前，不同的模块需要使用自定义的方式，对文档中的字符串指定类型 (注意：pycharm可以将旧的文档字符串转换成新的类型提示)。
下面是一个简单的代码示例，利用类型提示功能来处理不同类型的数据：
def repeat_each_entry(data): each entry in the data is doubled index = numpy.repeat(numpy.arange(len(data)), 2) return data[index]
上述代码对多维的 numpy.array、astropy.table 和 astropy.column、bcolz、cupy、mxnet.ndarray 等操作同样适用。
这段代码还可用于 pandas.series 操作，但是这种形式是错误的：
repeat_each_entry(pandas.series(data=[0, 1, 2], index=[3, 4, 5])) # returns series with nones inside
这仅仅是一段两行的代码。所以，复杂系统的行为是非常难预测的，有时一个函数就可能导致整个系统的错误。因此，明确地了解哪些类型方法，并在这些类型方法未得到相应参数的时候发出错误提示，这对于大型系统的运作是很有帮助的。
def repeat_each_entry(data: union[numpy.ndarray, bcolz.carray]):
如果你有一个很棒的代码库，诸如 mypy这样的类型提示工具将可能成为一个大型项目的集成流程中的一部分。不幸的是，类型提示功能还没办法强大到为 ndarrays/tensors 这种细粒度类型发出提示。或许，不久的将来我们就可以拥有这样全面的的类型提示工具，这将成为数据科学领域需要的强大功能。
从类型提示(运行前)到类型检查(运行时)
默认情况下，函数的注释对于代码的运行是没有影响的，它只是帮你指出每段代码所要做的工作。
在代码运行阶段，很多时候类型提示工具是不起作用的。这种情况你可以使用 enforce 等工具，强制性对代码进行类型检查，同时也可以帮助你调试代码。
@enforce.runtime_validationdef foo(text: str) -> none: print(text) foo('hi') # okfoo(5) # fails@enforce.runtime_validationdef any2(x: list[bool]) -> bool: return any(x)any ([false, false, true, false]) # trueany2([false, false, true, false]) # trueany (['false']) # trueany2(['false']) # failsany ([false, none, , 0]) # falseany2([false, none, , 0]) # fails
函数注释的其他用途
正如上面我们提到的，函数的注释部分不仅不会影响代码的执行，还会提供可以随时使用的一些元信息(meta-information)。
例如，计量单位是科学界的一个普遍难题，python3中的astropy包提供了一个简单的装饰器（decorator）来控制输入的计量单位，并将输出转换成相应的单位。
# python 3from astropy import units as u@u.quantity_input()def frequency(speed: u.meter / u.s, wavelength: u.m) -> u.terahertz: return speed / wavelength frequency(speed=300_000 * u.km / u.s, wavelength=555 * u.nm)# output: 540.5405405405404 thz, frequency of green visible light
如果你需要用python处理表格类型的科学数据，你可以尝试astropy包，体验一下计量单位随意转换的方便性。你还可以针对某个应用专门定义一个装饰器，用同样的方式来控制或转换输入和输出的计量单位。
通过 @ 实现矩阵乘法
下面，我们实现一个最简单的机器学习模型，即带 l2 正则化的线性回归 (如岭回归模型)，来对比 python2 和 python3 之间的差别：
# l2-regularized linear regression: || ax - b ||^2 + alpha * ||x||^2 -> min# python 2x = np.linalg.inv(np.dot(a.t, a) + alpha * np.eye(a.shape[1])).dot(a.t.dot(b))# python 3x = np.linalg.inv(a.t @ a + alpha * np.eye(a.shape[1])) @ (a.t @ b
在 python3 中，以@作为矩阵乘法符号使得代码整体的可读性更强，且更容易在不同的深度学习框架间进行转译：因为一些代码如 x @ w + b[none, :]在 numpy、cupy、pytorch 和 tensorflow 等不同库中都表示单层感知机。
使用 ** 作为通配符
python2 中使用递归文件夹的通配符并不是很方便，因此可以通过定制的 glob2 模块来解决这个问题。递归 flag 在 python 3.6 中得到了支持。
import glob# python 2found_images = \ glob.glob('/path*.jpg') \ + glob.glob('/path*.jpg') \ + glob.glob('/path***.jpg') # python 3found_images = glob.glob('/path*.jpg', recursive=true)
python3 中更好的选择是使用 pathlib：(缺少个import)
# python 3found_images = pathlib.path('/path/').glob('**/*.jpg')
python3中的print函数
诚然，print 在 python3 中是一个函数，使用 print 需要加上圆括弧()，虽然这是个麻烦的操作，但它还是具有一些优点：
使用文件描述符的简单句法：
print >>sys.stderr, critical error # python 2print(critical error, file=sys.stderr) # python 3
在不使用str.join情况下能够输出 tab-aligned 表格：
# python 3print(*array, sep='\t')print(batch, epoch, loss, accuracy, time, sep='\t')
修改与重新定义 print 函数的输出：
# python 3_print = print # store the original print functiondef print(*args, **kargs): pass # do something useful, e.g. store output to some file
在 jupyter notebook 中，这种形式能够记录每一个独立的文档输出，并在出现错误的时候追踪到报错的文档。这能方便我们快速定位并解决错误信息。因此我们可以重写 print 函数。
在下面的代码中，我们可以使用上下文管理器来重写 print 函数的行为：
@contextlib.contextmanagerdef replace_print(): import builtins _print = print # saving old print function # or use some other function here builtins.print = lambda *args, **kwargs: _print('new printing', *args, **kwargs) yield builtins.print = _printwith replace_print():
但是，重写print函数的行为，我们并不推荐，因为它会引起系统的不稳定。
print函数可以结合列表生成器或其它语言结构一起使用。
# python 3result = process(x) if is_valid(x) else print('invalid item: ', x)
f-strings 可作为简单和可靠的格式化
默认的格式化系统提供了一些灵活性操作。但在数据实验中这些操作不仅不是必须的，还会导致代码的修改变得冗长和琐碎。
而数据科学通常需要以固定的格式，迭代地打印出一些日志信息，所使用的代码如下：
# python 2print('{batch:3} {epoch:3} / {total_epochs:3} accuracy: {acc_mean:0.4f}±{acc_std:0.4f} time: {avg_time:3.2f}'.format( batch=batch, epoch=epoch, total_epochs=total_epochs, acc_mean=numpy.mean(accuracies), acc_std=numpy.std(accuracies), avg_time=time / len(data_batch) ))# python 2 (too error-prone during fast modifications, please avoid):print('{:3} {:3} / {:3} accuracy: {:0.4f}±{:0.4f} time: {:3.2f}'.format( batch, epoch, total_epochs, numpy.mean(accuracies), numpy.std(accuracies), time / len(data_batch) ))
样本输出为：
120 12 / 300 accuracy: 0.8180±0.4649 time: 56.60
python 3.6 中引入了格式化字符串 (f-strings)：
f# python 3.6+print(f'{batch:3} {epoch:3} / {total_epochs:3} accuracy: {numpy.mean(accuracies):0.4f}±{numpy.std(accuracies):0.4f} time: {time / len(data_batch):3.2f}')
另外，这对于查询语句的书写也是非常方便的：
query = finsert into station values (13, '{city}', '{state}', {latitude}, {longitude})
「true pision」和「integer pision」之间的明显区别
虽然说对于系统编程来说，python3所提供的改进还远远不够，但这些便利对于数据科学来说已经足够。
data = pandas.read_csv('timing.csv') velocity = data['distance'] / data['time']
python 2 中的结果依赖于『时间』和『距离』(例如，以米和秒为单位),关注其是否被保存为整数。
而在 python 3 中，结果的表示都是精确的，因为除法运算得到的都是精确的浮点数。
另一个例子是整数除法，现在已经作为明确的运算：
n_gifts = money // gift_price # correct for int and float arguments
值得注意的是，整除运算可以应用到python的内建类型和由numpy、pandas等数据包提供的自定义类型。
严格排序
下面是一个严格排序的例子：
# all these comparisons are illegal in python 33 < '3'2 < none(3, 4) < (3, none)(4, 5) < [4, 5]# false in both python 2 and python 3(4, 5) == [4, 5]
严格排序的主要功能有：
防止不同类型实例之间的偶然性排序。
sorted([2, '1', 3]) # invalid for python 3, in python 2 returns [2, 3, '1']
在处理原始数据时帮助我们发现存在的问题。此外，严格排序对none值的合适性检查是（这对于两个版本的 python 都适用）：
if a is not none: passif a: # wrong check for none pass
自然语言处理中的unicode编码
下面来看一个自然语言处理任务：
s = '您好'print(len(s))print(s[:2])
比较两个版本python的输出：
python2: 6\n
python3: 2\n 您好
再来看个例子：
x = u'со' x += 'co' # ok x += 'со' # fail
在这里，python 2 会报错，而 python 3 能够正常工作。因为我在字符串中使用了俄文字母，对于python2 是无法识别或编码这样的字符。
python 3 中的 strs 是 unicode 字符串，这对非英语文本的自然语言处理任务来说将更加地方便。还有些其它有趣的应用，例如：
'a'< type < u'a' # python 2: true'a' < u'a' # python 2: false
from collections import counter counter('mbelstück')
python 2: counter({'\xc3': 2, 'b': 1, 'e': 1, 'c': 1, 'k': 1, 'm': 1, 'l': 1, 's': 1, 't': 1, '\xb6': 1, '\xbc': 1})
python 3: counter({'m': 1, '': 1, 'b': 1, 'e': 1, 'l': 1, 's': 1, 't': 1, 'ü': 1, 'c': 1, 'k': 1})
对于这些，python 2 也能正常地工作，但 python 3 的支持更为友好。
保留词典和**kwargs 的顺序
cpython 3.6+ 的版本中字典的默认行为是一种类似 ordereddict 的类，但最新的 python3.7 版本，此类已经得到了全面的支持。这就要求在字典理解、json 序列化/反序列化等操作中保持字典原先的顺序。
下面来看个例子：
import json x = {str(i):i for i in range(5)} json.loads(json.dumps(x))# python 2{u'1': 1, u'0': 0, u'3': 3, u'2': 2, u'4': 4}# python 3{'0': 0, '1': 1, '2': 2, '3': 3, '4': 4}
这种保顺性同样适用于 python3.6 版本中的 **kwargs：它们的顺序就像参数中显示的那样。当设计数据流程时，参数的顺序至关重要。
以前，我们必须以这样繁琐的方式来编写：
from torch import nn # python 2 model = nn.sequential(ordereddict([ ('conv1', nn.conv2d(1,20,5)), ('relu1', nn.relu()), ('conv2', nn.conv2d(20,64,5)), ('relu2', nn.relu()) ])) # python 3.6+, how it *can* be done, not supported right now in pytorch model = nn.sequential( conv1=nn.conv2d(1,20,5), relu1=nn.relu(), conv2=nn.conv2d(20,64,5), relu2=nn.relu()) )
注意到了吗？名称的唯一性也会被自动检查。
迭代拆封
python3 中引入迭代式拆封功能，下面来看一段代码：
# handy when amount of additional stored info may vary between experiments, but the same code can be used in all casesmodel_paramteres, optimizer_parameters, *other_params = load(checkpoint_name)# picking two last values from a sequence*prev, next_to_last, last = values_history# this also works with any iterables, so if you have a function that yields e.g. qualities,# below is a simple way to take only last two values from a list *prev, next_to_last, last = iter_train(args)
默认的 pickle 引擎为数组提供更好的压缩
python3 中引入 pickle 引擎，为数组提供更好的压缩，节省参数空间：
# python 2import cpickle as pickleimport numpyprint len(pickle.dumps(numpy.random.normal(size=[1000, 1000])))# result: 23691675# python 3import pickleimport numpylen(pickle.dumps(numpy.random.normal(size=[1000, 1000])))# result: 8000162
这个小的改进节省了3倍的空间，而且运行阶段速度更快。实际上，如果不关心速度的话，类似的压缩性能也可以通过设置参数 protocol=2 来实现，但是用户经常会忽略这个选项或者�...