网站性能检测评分
注：本网站页面html检测工具扫描网站中存在的基本问题，仅供参考。
python中的in
python（十八）中断和异常处理 营销视频课程
一、break
二、continue
三、异常处理
循环我们已经用的很多了，括while和for...in。while循环在条件不满足时结束，for循环遍历完序列后结束。如果在循环条件仍然满足或序列没有遍历完的时候，想要强行跳出循环，就需要用到break语句。
while True:
a = raw_input()
if a == 'end':
break
上面的程序不停接受用户输入。当用户输入一行“end”时，程序结束。
for i in range(10):
a = raw_input()
if a == 'exit':
break
上面的程序接受用户10次输入，当用户输入一行“exit”时，程序提前结束。
break是彻底地跳出循环，而continue只是略过本次循环的余下内容，直接进入下一次循环。
在我们前面写的那个统计分数的程序里，如果发现有成绩不足60分，就不记入总成绩。当然，你可以用if判断来实现这个效果。但我们今天要说另一种方法：continue。
for score in data[1:]:
point = int(score)
if point
continue
sum += point
注意：无论是continue还是break，其改变的仅仅是当前所处的最内层循环的运行，如果外层还有循环，并不会因此略过或跳出。
在程序运行时，如果我们的代码引发了错误，python就会中断程序，并且输出错误提示。
比如我们写了一句：
print int('0.5')
运行后程序得到错误提示：
Traceback (most recent call last):
File "C:/Python27/test.py", line 1, in
print int('0.5')
ValueError: invalid literal for int() with base 10: '0.5'
意思是，在test.py这个文件，第1行，print int('0.5')这里，你拿了一个不是10进制能够表示的字符，我没法把它转成int值。
上面的错误可以避免，但在实际的应用中，有很多错误是开发者无法控制的，例如用户输入了一个不合规定的值，或者需要打开的文件不存在。这些情况被称作“异常”，一个好的程序需要能处理可能发生的异常，避免程序因此而中断。
例如我们去打开一个文件：
f = file('non-exist.txt')
print 'File opened!'
f.close()
假如这个文件因为某种原因并没有出现在应该出现的文件夹里，程序就会报错：
IOError: [Errno 2] No such file or directory: 'non-exist.txt'
程序在出错处中断，后面的print不会被执行。
在python中，可以使用try...except语句来处理异常。做法是，把可能引发异常的语句放在try-块中，把处理异常的语句放在except-块中。
把刚才那段代码放入try...except中：
try:
f = file('non-exist.txt')
print 'File opened!'
f.close()
except:
print 'File not exists.'
print 'Done'
当程序在try内部打开文件引发异常时，会跳过try中剩下的代码，直接跳转到except中的语句处理异常。于是输出了“File not exists.”。如果文件被顺利打开，则会输出“File opened!”，而不会去执行except中的语句。
但无论如何，整个程序不会中断，最后的“Done”都会被输出。
在try...except语句中，try中引发的异常就像是扔出了一只飞盘，而except就是一只灵敏的狗，总能准确地接住飞盘。
sciencen. 科学
writtenadj. 书面的, 写成文字的 vbl. 写, 著述
windown. 窗户
behaviorn. 行为,举止
definitionn. 定义, 阐释，清晰度
以上每天用一点时间，练习并写出练习过程这样是对于学习的一个及时反馈重在坚持！
在Python 2.7即将停止支持时，我们为你准备了一份3.x迁移指南 流量视频课程
机器之心编译
目前，Python 科学栈中的所有主要项目都同时支持 Python 3.x 和 Python 2.7，不过，这种情况很快即将结束。去年 11 月，Numpy 团队的一份声明引发了数据科学社区的关注：这一科学计算库即将放弃对于 Python 2.7 的支持，全面转向 Python 3。Numpy 并不是唯一宣称即将放弃 Python 旧版本支持的工具，pandas 与 Jupyter notebook 等很多产品也在即将放弃支持的名单之中。对于数据科学开发者而言，如何将已有项目从 Python 2 转向 Python 3 成为了正在面临的重大问题。来自莫斯科大学的 Alex Rogozhnikov 博士为我们整理了一份代码迁移指南。
Python 3 功能简介
Python 是机器学习和其他科学领域中的主流语言，我们通常需要使用它处理大量的数据。Python 兼容多种深度学习框架，且具备很多优秀的工具来执行数据预处理和可视化。
但是，Python 2 和 Python 3 长期共存于 Python 生态系统中，很多数据科学家仍然使用 Python 2。2019 年底，Numpy 等很多科学计算工具都将停止支持 Python 2，而 2018 年后 Numpy 的所有新功能版本将只支持 Python 3。
为了使 Python 2 向 Python 3 的转换更加轻松，我收集了一些 Python 3 的功能，希望对大家有用。
使用 pathlib 更好地处理路径
pathlib 是 Python 3 的默认模块，帮助避免使用大量的 os.path.joins：
from pathlib importPath
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
Python 2 总是试图使用字符串级联（准确，但不好），现在有了 pathlib，代码安全、准确、可读性强。
此外，pathlib.Path 具备大量方法，这样 Python 新用户就不用每个方法都去搜索了：
p.exists()
p.is_dir()
p.parts()
p.with_name('sibling.png')# only change the name, but keep the folder
p.with_suffix('.jpg')# only change the extension, but keep the folder and the name
p.chmod(mode)
p.rmdir()
pathlib 会节约大量时间，详见：
文档：https://docs.python.org/3/library/pathlib.html；
参考信息：https://pymotw/3/pathlib/。
类型提示（Type hinting）成为语言的一部分
PyCharm 中的类型提示示例：
Python 不只是适合脚本的语言，现在的数据流程还包括大量步骤，每一步都包括不同的框架（有时也包括不同的逻辑）。
类型提示被引入 Python，以帮助处理越来越复杂的项目，使机器可以更好地进行代码验证。而之前需要不同的模块使用自定义方式在文档字符串中指定类型（注意：PyCharm 可以将旧的文档字符串转换成新的类型提示）。
下列代码是一个简单示例，可以处理不同类型的数据（这就是我们喜欢 Python 数据栈之处）。
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 提供细粒度类型，但是或许我们很快就可以拥有这样的提示工具了，这将是 DS 的伟大功能。
类型提示 → 运行时的类型检查
默认情况下，函数注释不会影响代码的运行，不过它也只能帮你指出代码的意图。
但是，你可以在运行时中使用 enforce 等工具强制进行类型检查，这可以帮助你调试代码（很多情况下类型提示不起作用）。
@enforce.runtime_validation
def foo(text: str)->None:
print(text)
foo('Hi')# ok
foo(5)# fails
@enforce.runtime_validation
def any2(x:List[bool])->bool:
return any(x)
any ([False,False,True,False])# True
any2([False,False,True,False])# True
any (['False'])# True
any2(['False'])# fails
any ([False,None,"",0])# False
any2([False,None,"",0])# fails
函数注释的其他用处
如前所述，注释不会影响代码执行，而且会提供一些元信息，你可以随意使用。
例如，计量单位是科学界的一个普遍难题，astropy 包提供一个简单的装饰器（Decorator）来控制输入量的计量单位，并将输出转换成所需单位。
# Python 3
from 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 正则化的线性回归：
# l2-regularized linear regression: || AX - b ||^2 + alpha * ||x||^2 ->min
# Python 2
X = np.linalg.inv(np.dot(A.T, A)+ alpha * np.eye(A.shape[1])).dot(A.T.dot(b))
# Python 3
X = np.linalg.inv(A.T @ A + alpha * np.eye(A.shape[1]))@(A.T @ b)
下面 Python 3 带有 @ 作为矩阵乘法的符号更具有可读性，且更容易在深度学习框架中转译：因为一些如 X @ W + b[None, :] 的代码在 numpy、cupy、pytorch 和 tensorflow 等不同库下都表示单层感知机。
使用 ** 作为通配符
递归文件夹的通配符在 Python2 中并不是很方便，因此才存在定制的 glob2 模块来克服这个问题。递归 flag 在 Python 3.6 中得到了支持。
import glob
# Python 2
found_images = \
glob.glob('/path*.jpg') \
+ glob.glob('/path*.jpg') \
+ glob.glob('/path***.jpg')
# Python 3
found_images = glob.glob('/path*.jpg', recursive=True)
python3 中更好的选择是使用 pathlib：
# Python 3
found_images = pathlib.Path('/path/').glob('**/*.jpg')
Print 在 Python3 中是函数
Python 3 中使用 Print 需要加上麻烦的圆括弧，但它还是有一些优点。
使用文件描述符的简单句法：
print>>sys.stderr,"critical error"# Python 2
print("critical error", file=sys.stderr)# Python 3
在不使用 str.join 下输出 tab-aligned 表格：
# Python 3
print(*array, sep='\t')
print(batch, epoch, loss, accuracy, time, sep='\t')
修改与重新定义 print 函数的输出：
# Python 3
_print =print# store the original print function
defprint(*args,**kargs):
pass# do something useful, e.g. store output to some file
在 Jupyter 中，非常好的一点是记录每一个输出到独立的文档，并在出现错误的时候追踪出现问题的文档，所以我们现在可以重写 print 函数了。
在下面的代码中，我们可以使用上下文管理器暂时重写 print 函数的行为：
@contextlib.contextmanager
def 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= _print
with replace_print():
上面并不是一个推荐的方法，因为它会引起系统的不稳定。
print 函数可以加入列表解析和其它语言构建结构。
# Python 3
result = process(x)if is_valid(x)elseprint('invalid item: ', x)
f-strings 可作为简单和可靠的格式化
默认的格式化系统提供了一些灵活性，且在数据实验中不是必须的。但这样的代码对于任何修改要么太冗长，要么就会变得很零碎。而代表性的数据科学需要以固定的格式迭代地输出一些日志信息，通常需要使用的代码如下：
# Python 2
print('{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)
))
样本输出：
12012/300 accuracy:0.8180±0.4649 time:56.60
f-strings 即格式化字符串在 Python 3.6 中被引入：
# 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 = f"INSERT INTO STATION VALUES (13, '{city}', '{state}', {latitude}, {longitude})"
「true pision」和「integer pision」之间的明显区别
对于数据科学来说这种改变带来了便利（但我相信对于系统编程来说不是）。
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
注意，该运算可以应用到内建类型和由数据包（例如，numpy 或 pandas）提供的自定义类型。
严格排序
# All these comparisons are illegal in Python 3
3<'3'
2 (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 isnotNone: pass if a:# WRONG check for None pass 自然语言处理的 Unicode s ='您好' print(len(s)) print(s[:2]) 输出： Python 2: 6\n Python 3: 2\n 您好. x = u'со' x +='co'# ok x +='со'# fail Python 2 在此失败了，而 Python 3 可以如期工作（因为我在字符串中使用了俄文字母）。 在 Python 3 中 strs 是 Unicode 字符串，对非英语文本的 NLP 处理更加方便。 还有其它有趣的方面，例如： 'a'< type < u'a'# Python 2: True 'a'< u'a'# Python 2: False from collections importCounter 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（在 3.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} 它同样适用于**kwargs（在 Python 3.6+版本中）：它们的顺序就像参数中显示的那样。当设计数据流程时，顺序至关重要，以前，我们必须以这样繁琐的方式来编写： 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()) ) 注意到了吗？名称的唯一性也会被自动检查。 迭代地拆封 # handy when amount of additional stored info may vary between experiments, but the same code can be used in all cases model_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 引擎为数组提供更好的压缩 # Python 2 import cPickle as pickle import numpy print len(pickle.dumps(numpy.random.normal(size=[1000,1000]))) # result: 23691675 # Python 3 import pickle import numpy len(pickle.dumps(numpy.random.normal(size=[1000,1000]))) # result: 8000162 节省 3 倍空间，而且速度更快。实际上，类似的压缩（不过与速度无关）可以通过 protocol=2 参数来实现，但是用户...
Python中集合（set）类型的详细解释及操作 推广视频课程
一、集合（set）类型的含义：
Set是一个无序不重复元素集，与列表和元组不同，集合是无序的，无法通过数字进行索引。
注意：下面所举例子在python3.6,IDE为pycharm2016.1中通过。
创建集合：用set（）函数，或直接赋值。
例子：
x=set('Nike MM')
y=set(['w','a','m','a'])
print(x)
print(y)
输出：
{'M', 'N', 'e', 'k', ' ', 'i'}
{'w', 'm', 'a'}
可以看到，在输出中，是用一对｛｝号包住，里面重复的元素被去除。
再看一个例子：
s={'11','22','33'}
print(s)
print(type(s))
s={}
{'33', '11', '22'}
在定义不，不能用s={}，这关创建的实际上是一个字典类型。
二、有关集合的操作：
1．增加操作
a=set('python')
a.add('why')
print(a)
b=set('python')
b.update('why')
print(b)
{'n', 'p', 'y', 'h', 'o', 't', 'why'}
{'n', 'p', 'y', 'h', 'o', 'w', 't'}
可能看到：add是单个元素的添加，并没有把元素再分拆为单个字符。Update是批量的增加，增加的元素如果是一个字符串（实际上，在Python中字符串也是一个系列），是作为一个系列增加的。在输出结果中，两个函数都是无序的，并且无重复，也非添加到尾部。
2．删除操作（remove,discard,pop）
例子1：
a=set('abcdefghijk')
a.remove('a')
a.remove('w')
输出 ：
Traceback (most recent call last):
{'h', 'k', 'e', 'd', 'g', 'c', 'f', 'i', 'b', 'j'}
File "D:/python/temp3.py", line 4, in
KeyError: 'w'
例子2：
a.discard('a')
a.discard('w')
{'f', 'h', 'd', 'e', 'b', 'k', 'i', 'j', 'c', 'g'}
例子3：
b=a.pop()
print(b,type(b))
{'k', 'd', 'h', 'c', 'b', 'j', 'g', 'i', 'e', 'f'}
a
从以上例子可以看到，remove方法删除指定无素，如果要删除的元素的不在集合中，则报错；discard方法删除指定元素，如果要删除物元素不在集合中，则不报错，pop方法删除任意元素，并可将这个元素赋值给一个变量，但集合并没有把这个元素移除。
3.清空（clear）
例子:
a.clear()
set()
4.交集&，并集|，差集-，对称差集^，子集（被包含）<=，父集(包含)>=
a=set(['a','b','c','d','e','f'])
b=set(('d','e','f','g','h','i'))
d=set('def')
print('交集：',a.intersection(b))
print('交集：',a & b)
print('并集：',a.union(b))
print('并集：',a | b)
print('差集:',a.difference(b))
print('差集:',a-b)
#对称差集:
#把两个集合中相同的元素去掉，然后
#两个集合中剩下的元素组成一个新的集合
print('对称差集:',a.symmetric_difference(b) )
print('对称差集:',a ^ b )
print('子集：',a.issubset(d) )
print('子集：',a<=d )
print('父集：',a.issuperset(d) )
print('父集：',a>=d )
交集： {'f', 'e', 'd'}
并集： {'c', 'e', 'd', 'b', 'f', 'a', 'g', 'i', 'h'}
差集: {'a', 'c', 'b'}
对称差集: {'a', 'c', 'g', 'b', 'i', 'h'}
子集： False
父集： True
5．集合的其它一些操作
#如果a和d没有交集，返回True，有则返回False
print(a.isdisjoint(d) ) 输出：False
print(a print(a>d) 输出：True print（a!=b） 输出：True print(a.copy()) 输出：{'f', 'e', 'b', 'a', 'd', 'c'} #复制一个集合 print('a' in a) 输出：True #测试元素是否在集合中 print('a' not in a) 输出：False #测试元素是否不在集合中 print(len(a)) 输出：6 #返回集合的长度 6．集合计算： （1） #从a中减去a和b的交集，即从a集合中删除和b集合中相同的元素 a.difference_update(b) 即等于：a=a-b 或a-=b print(a) 输出：{'a', 'b', 'c'} （2） #修改a集合，仅仅保持a与b的交集，如果没有交集，则a变为空集合set() a.intersection_update(b) 即等于：a=a&b 或a&=b print(a ) 输出：{'e', 'd', 'f'} (3) #a集合中增加‘在b集合中除去a和b交集剩下的元素’ a.symmetric_difference_update(b) 即等于：a=a^b 或 a^=b print(a) 输出：{'i', 'g', 'a', 'c', 'b', 'h'}
揭秘 Python 中的 enumerate() 函数 互联网视频课程
如何以去写以及为什么你应该使用Python中的内置枚举函数来编写更干净更加Pythonic的循环语句？
Python的enumerate函数是一个神话般的存在，以至于它很难用一句话去总结它的目的和用处。但是，它是一个非常有用的函数，许多初学者，甚至中级Pythonistas是并没有真正意识到。简单来说，enumerate是用来遍历一个可迭代容器中的元素，同时通过一个计数器变量记录当前元素所对应的索引值。
让我们来看一个示例：
正如你所看到的，这个循环遍历了names列表的所有元素，并通过增加从零开始的计数器变量来为每个元素生成索引。
[如果您想知道上面例子中使用的f'...'字符串语法，这是Python 3.6及更高版本中提供的一种新的字符串格式化技巧。]
用那么为什么用enumerate函数去保存运行中的索引很有用呢？range(len(...))方法来保存运行中每个元素的索引，同时再用for通过巧妙地使用enumerate函数，就像我在上面的"names"例子中写的那样，你可以使你的循环结构看起来更Pythonic和地道。你不再需要在Python代码中专门去生成元素索引，而是将所有这些工作都交给enumerate函数处理即可。这样，你的代码将更容易被阅读，而且减少写错代码的影响。（译者注：写的代码越多，出错几率越高，尽量将自己的代码看起来简洁，易读，Pythonic，才是我们的追求）
修改起始索引
另一个有用的特性是，enumerate函数允许我们为循环自定义起始索引值。enumerateOK，这段代码演示的就是如何将Python的函数默认0起始索引值修改为1（或者其他任何整形值，根据需求去设置不同值）enumerate你可能想知道enumerate函数背后是如何工作的。事实上他的部分魔法是通过Python迭代器来实现的。意思就是每个元素的索引是懒加载的（一个接一个，用的时候生成），这使得内存使用量很低并且保持这个结构运行很快。在上面这个代码片段中，正如你所见，我使用了和前面一样的示例代码。但是，调用enumerate函数并不会立即返回循环的结果，而只是在控制台中返回了一个enumerate对象。
正如你所看到的，这是一个"枚举对象"。它的确是一个迭代器。就像我说的，它会在循环请求时懒加载地输出每个元素。
为了验证，我们可以取出那些"懒加载"的元素，我计划在这个迭代器上调用Python的内置函数list
>>>list(enumerate(names))
[(0,'Bob'),(1,'Alice'),(2,'Guido')]
对于输入list中的每个enumerate迭代器元素，迭代器会返回一个形式为（index，element）的元组作为list的元素。在典型的for-in循环中，你可以利用Python的数据结构解包功能来充分利用这一点特性：
for index, element in enumerate(iterable):
# ...
总结：Python中的enumerate函数-关键点
enumerate是Python的一个内置函数。你应该充分利用它通过循环迭代自动生成的索引变量。
索引值默认从0开始，但也可以将其设置为任何整数。
enumerate函数是从2.3版本开始被添加到Python中的，详情见PEP279。
Python的enumerate函数可以帮助你编写出更加Pythonic和地道的循环结构，避免使用笨重且容易出错的手动生成索引。
为了充分利用enumerate的特性，一定要研究Python的迭代器和数据结构解包功能。
题图：pexels，CC0授权。
数据科学工具 Jupyter Notebook 教程 in Python 行业视频课程
更多腾讯海量技术文章，请关注腾讯云技术社区：https://cloud.tencent/community
作者：张耀琦
简单介绍
Jupyter 是一个笔记本，这个笔记本可以编写和执行代码，分析数据，嵌入内容，以及共享可重复性的工作。Jupyter Notebook （以前成为iPython Notebook）可以在一个简单的笔记本中轻松分享代码，数据，图标以及说明。发布格式也比较灵活：PDF， HTML，ipynb，dsahboards，slides，等等。代码单元是基于输入和输出格式。例如：
安装
有多种方式可以安装 Jupyter Notebook:
使用 pip 安装。在终端中输入 $ pip install jupyter
Windows用户可以使用 setuptools 安装。
* Anaconda 和 Enthought 可以下载 Jupyter Notebook的桌面版。
nteract 可以通过一个桌面应用在 notebook 环境中工作。
Microsoft Azure 提供对 Jupyter Notebook 的托管访问。
Domino Data Lab 提供基于web的notebook。
tmpnb 为个人用户启动一个临时在线的notebook。
主观观点：Windows 下常用Anaconda ，但并不是说 Mac 和 Linux用户就不需要了，个人觉得 Anaconda 都应该尝试一下，启动和管理库都很方便。
入门指南
安装 notebook 之后，在终端中输入 $ jupyter notebook 来启动。此时将在 localhost 打开浏览器到notebook的URL，默认是 http://127.0.0.1:8888。Windows 用户打开Command Prompt. 可以在一个dashboard 中看到所有的notebook，打开很方便。当编码和发布的时候，Notebook具有相同的优势。有所有的选项，移动代码，运行cell，更改 kernel，并且运行 NB的时候使用 Markdown
有用的命令
Tab Completion： Jupyter 支持tab 自动补全！可以键入object_name.
Help： 提供介绍和功能概述。
Quick Reference：运行后打开快速参考。
Keyboard Shortcuts：Shift-Enter将运行一个cell, Ctrl-Enter将在空间内运行cell, Alt-Enter 将运行cell，并在下面插入一个cell. 更多的快捷键请看 here。
语言
本教程的主要内容是讨论在 Jupyter notebooks 中执行python 代码。也可以使用 Jupyter notebooks 来执行 R 语言的代码。
Package 管理
在Jupyter安装 package时，需要在shell中安装，或者运行感叹号前缀，例如：
!pip install packagename
如果已经编辑了代码，可能需要 reload submodules。IPython 自带重载机制。可以在执行新行之前重新加载所有更改的模块。
%load_ext autoreload%autoreload 2
本教程使用到的一些package：
Pandas：通过网址导入数据，创建数据框架，可以很简单的处理数据，进行分析和绘图。请参阅使用 Panda的例子：https://plot.ly/pandas/。
NumPy：用于科学计算的package，用于代数，随机数生成，与数据库集成和管理数据的工具。请参阅使用 Numpy 的例子：https://plot.ly/numpy/。
SciPy：一个基于Python的数学、科学和工程库。
Plotly：用于制作交互式，达到出版品质图表的图形库。更多统计，科学，3D图表等，请参阅：https://plot.ly/python
如果使用的是Anaconda 在Environments中可以发现，前三个库都已经默认帮你下载安装好了。然后把过滤条件改为All，搜Plotly，安装即可。非常方便
Import 数据
可以使用 pandas 的 read_csv() 函数来导入数据。下面的示例中，导入了一个 hosted on github 的csv，并使用Plotly将数据展示在一个table中。(table using Plotly)
plotly.plotly.iplot() 函数是在线的，需要先设置账号和key，具体请参阅：https://plot.ly/python/getting-started/
使用dataframe.column_title 来索引 dataframe：
pandas大多数的函数也适用于整个 dataframe。例如，调用 std() 计算每列的标准差
内联绘图
可以使用 Plotly’s python API ，通过调用 plotly.plotly.iplot() 或者离线工作的时候使用 plotly.offline.iplot() 。在notebook中绘制，可以将数据分析和绘图保存在一个位置。下面是一个可以交互的绘图。转到 Plotly getting started 页面，了解如何设置凭据。通过调用 iplot 自动生成内嵌 iframe 的交互式版本：
绘制多个轨道，并使用 Plotly语法，自定义颜色和标题，来对图标进行样式化。还可以进行控制，将 sharing 设置为 public , private, 或者 secret。
现在notebook中显示了交互式图标。将鼠标悬停在图标上来查看每一栏的值，单击并拖动来放大到特定部分，或单击图例以隐藏/显示轨道。
绘制交互式地图
Plotly 现在集成了 Mapbox。下面的例子，将绘制世界分级统计图。
import plotly.plotly as pyimport pandas as pddf = pd.read_csv('https://raw.githubusercontent/plotly/datasets/master/2014_world_gdp_with_codes.csv')data = [ dict( type = 'choropleth', locations = df['CODE'], z = df['GDP (BILLIONS)'], text = df['COUNTRY'], colorscale = [[0,"rgb(5, 10, 172)"],[0.35,"rgb(40, 60, 190)"],[0.5,"rgb(70, 100, 245)"], [0.6,"rgb(90, 120, 245)"],[0.7,"rgb(106, 137, 247)"],[1,"rgb(220, 220, 220)"]], autocolorscale = False, reversescale = True, marker = dict( line = dict ( color = 'rgb(180,180,180)', width = 0.5 ) ), colorbar = dict( autotick = False, tickprefix = '$', title = 'GDPBillions US$'), ) ]layout = dict( title = '2014 Global GDPSource: CIA World Factbook', geo = dict( showframe = False, showcoastlines = False, projection = dict( type = 'Mercator' ) ))fig = dict( data=data,layout=layout )py.iplot( fig, validate=False,filename='d3-world-map' )
3D绘图
使用Numpy和Plotly，可以在Notebook中绘制交互式3D图。
import plotly.plotly as pyfrom plotly.graph_objs import *import numpy as nps = np.linspace(0, 2 * np.pi, 240)t = np.linspace(0, np.pi, 240)tGrid, sGrid = np.meshgrid(s, t)r = 2 + np.sin(7 * sGrid + 5 * tGrid) # r = 2 + sin(7s + 5t)x = r * np.cos(sGrid) * np.sin(tGrid) # x = r * con(s) * sin(t)y = r * np.sin(sGrid) * np.sin(tGrid) # y = r * sin(s) * sin(t)z = r * np.cos(tGrid) # z = r * cos(t)surface = Surface(x = x, y = y, z = z)data = Data([surface])layout = Layout( title = 'ParametricPlot', scene = Scene( xaxis = XAxis( gridcolor = 'rgb(255, 255, 255)', zerolinecolor = 'rgb(255, 255, 255)', showbackground = True, backgroundcolor = 'rgb(230, 230, 230)' ), yaxis = YAxis( gridcolor = 'rgb(255, 255, 255)', zerolinecolor = 'rgb(255, 255, 255)', showbackground = True, backgroundcolor = 'rgb(230, 230, 230)' ), zaxis = ZAxis( gridcolor = 'rgb(255, 255, 255)', zerolinecolor = 'rgb(255, 255, 255)', showbackground = True, backgroundcolor = 'rgb(230, 230, 230)' ) ))fig = Figure(data = data, layout = layout)py.iplot(fig, filename = 'parametric_plot')
绘制动画
查看Plotly的 animation documentation ，来了解如果在Jupyter notebook中创建内联动画，比如：
Plot 控件和IPython 小部件
给内联图表添加 silder, button, 和 dropdown：
import plotly.plotly as pyimport numpy as npdata = [dict( visible = False, line = dict(color = '00CED1', width = 6), name = 'v = ' + str(step), x = np.arange(0, 10, 0.01), y = np.sin(step * np.arange(0, 10, 0.01))) for step in np.arange(0, 5, 0.1)]data[10]['visible'] = Truesteps = []for i in range(len(data)): step = dict( method = 'restyle', args = ['visible', [False] * len(data)], ) step['args'][1][i] = True # Toggle i'th trace to "visible" steps.append(step)sliders = [dict( active = 10, currentvalue = {"prefix": "Frequency: "}, pad = {"t": 50}, steps = steps)]layout = dict(sliders = sliders)fig = dict(data = data, layout = layout)py.iplot(fig, filename = 'Sina Wave Slider')
此外，IPython widgets 可以给notebook添加 silder， widget， 搜索框等。更多信息请参阅 widget docs 。为了让其他人能够访问你的工作，他们需要IPython，或者你可以使用基于云的NB选项。
运行R代码
IRkernel是Jupyter的R内核，允许在Jupyter笔记本中编写和执行R代码。 检查 IRkernel文档 以获取一些简单的安装说明。 安装IRkernel后，通过调用 $ jupyter notebook 打开Jupyter Notebook，并使用“新建”下拉列表选择一个R笔记本。
完整实例地址：https://plot.ly/~chelsea_lyn/14069
附加嵌入功能
IPython.display可以嵌入其他功能，如视频。 例如，从YouTube：
LaTeX
可以通过将数学内容用$$包住，来将LaTeX嵌入notebook中，然后将该单元格作为Markdown cell 运行。 例如，下面的 cell 是 $ c = sqrt {a ^ 2 + b ^ 2} $，(左右应该是双dollar符号，但这里打双dollar，km就出错无法保存文章了==)但Notebook会呈现表达式。
或者可以在python的输出中展示，请参阅：here
导出和发布 notebook
可以将Notebook导出为HTML，PDF，.py，.ipynb，Markdown和reST文件。 也可以将NB 转换成幻灯片。 可以在Plotly上发布Jupyter notebook。 只需访问 plot.ly并选择右上角的 + Create 按钮。 选择 notebook 并上传Jupyter notebook（.ipynb）文件！ 上传的笔记本将存储在你的 Plotly organize folder 中，并托管在一个唯一的链接，能快速和简单分享。下面是一些例子：
https://plot.ly/~chelsea_lyn/14066
https://plot.ly/~notebook_demo/35
https://plot.ly/~notebook_demo/85
https://plot.ly/~notebook_demo/128
Publishing Dashboards
发布交互式图形的用户也可以使用 Plotly’s dashboarding tool 工具来绘制和拖放界面。 这些 dashboards 可以发布，嵌入和共享。
Publishing Dash Apps
对于希望传播和生产Python应用程序的用户，dash 是Flask，Socketio，Jinja，Plotly和 boiler plate CSS and JS的集合，用于通过Python数据分析后端轻松创建数据可视化Web应用程序。
Jupyter Gallery
对于更多Jupyter教程，请查看 Plotly’s python documentation：所有文档都是用jupyter notebook 编写的，可以自行下载并运行，或者查看 user submitted examples!
Python程序员最常犯的10个错误，你中招了吗？ 行业视频课程
大数据文摘作品
编译：什锦甜、Gao Ning、小鱼
Python简介
Python是一种具有动态语义的、面向对象的解释型高级编程语言。因其内置了高级数据结构，并支持动态类型和动态绑定，使用Python进行快速应用程序开发十分便利。同时作为一门脚本语言，它兼容部分现有的组件和服务。Python还支持模块和各种库的扩展，有助于实现模块化编程和提高代码复用率。
关于本文
刚接触这门语言的新手可能会对Python简洁灵活的语法有些不适应，或是低估了Python强大的性能。鉴于此，本文列出了Python开发人员常犯的10个小错误，资深程序猿也难免会中招哦。
本文供Python高级开发人员参考，Python小白可以参考下面这篇文章：
http://onlamp/pub/a/python/2004/02/05/learn_python.html
常见错误1：滥用表达式作为函数参数的默认值
Python允许开发者指定函数参数的默认值，这也是Python的一大特色，但当默认值可变时，可能会给开发者带来一些困扰。例如下面定义的函数：
>>> def foo(bar=[]): # bar is optional and defaults to [] if not specified... bar.append("baz") # but this line could be problematic, as we'll see...... return bar
看出bug了吗？那就是在每次调用函数前没有对可变参数进行赋值，而认为该参数就是默认值。比如上面的代码，有人可能期望在反复调用foo()时返回'baz'，以为每次调用foo()时，bar的值都为[]，即一个空列表。
但是，让我们来看看代码运行结果：
>>> foo()["baz"]>>> foo()["baz", "baz"]>>> foo()["baz", "baz", "baz"]
嗯？为什么每次调用foo()后会不断把"baz"添加到已有的列表，而不是新建一个新列表呢？答案就是，函数参数的默认值仅在定义函数时执行一次。因此，仅在第一次定义foo()时，bar初始化为默认值（即空列表），此后，每次调用foo()函数时，参数bar都是第一次初始化时生成的列表。
常见的解决方案：
>>> def foo(bar=None):... if bar is None: # or if not bar:... bar = []... bar.append("baz")... return bar...>>> foo()["baz"]>>> foo()["baz"]>>>foo()["baz"]
常见错误2：错误地使用类变量
代码示例：
>>> class A(object):... x = 1...>>> class B(A):... pass...>>> class C(A):... pass...>>> print A.x, B.x, C.x1 1 1
运行结果没问题。
>>> B.x = 2>>> print A.x, B.x, C.x1 2 1
结果也正确。
>>> A.x = 3>>> print A.x, B.x, C.x3 2 3
什么鬼？我们只改变了A.x.，为什么C.x 也变了？
在Python中，类变量是以字典形式进行内部处理，遵循方法解析顺序（Method Resolution Order ，MRO）。因此，在上述代码中，因为在类C中没有找到属性x，它就会从父类中查找x的值（尽管Python支持多重继承，但上述代码只存在一个父类A）。换句话说，C没有独立于类A的属于自己的x。因此，C.x实际上指的是A.x。除非处理得当，否则就会导致Python出现错误。
如果想更深入了解Python的类特性，请戳：
https://toptal/python/python-class-attributes-an-overly-thorough-guide
常见错误3：错误指定异常代码块的参数
假设你有如下代码：
>>> try:... l = ["a", "b"]... int(l[2])... except ValueError, IndexError: # To catch both exceptions, right?... pass...Traceback (most recent call last):File "
这里的问题是except语句不接受以这种方式指定的异常列表。在Python2.x中，except Exception语句中变量e可用来把异常信息绑定到第二个可选参数上，以便进一步查看异常的情况。因此，在上述代码中，except语句并没有捕捉到IndexError异常；而是将出现的异常绑定到了参数IndexError中。
想在一个except语句同时捕捉到多个异常的正确方式是，将第一个参数指定为元组，并将要捕捉的异常类型都写入该元组中。为了方便起见，可以使用as关键字，Python 2 和Python 3都支持这种语法格式：
>>> try:... l = ["a", "b"]... int(l[2])... except (ValueError, IndexError) as e: ... pass...>>>
常见错误4：错误理解Python中变量的作用域
Python变量作用域遵循LEGB规则，LEGB是Local，Enclosing，Global，Builtin的缩写，分别代表本地作用域、封闭作用域、全局作用域和内置作用域，这个规则看起来一目了然。事实上，Python的这种工作方式较为独特，会导致一些编程错误，例如：
>>> x = 10>>> def foo():... x += 1... print x...>>> foo()Traceback (most recent call last):File "
问题出在哪？
上面的错误是因为在作用域内对变量赋值时，Python自动将该变量视为该作用域的本地变量，并对外部定义的同名变量进行了屏蔽。因此，原本正确的代码，在某个函数内部添加了一个赋值语句后，却意外收到了UnboundLocalError的报错信息。
关于UnboundLocalError更多内容请戳：
https://docs.python.org/2/faq/programming.html#why-am-i-getting-an-unboundlocalerror-when-the-variable-has-a-value
在使用列表时，Python程序员更容易掉入此类陷阱，例如：
>>> lst = [1, 2, 3]>>> def foo1():... lst.append(5) # This works ok......>>> foo1()>>> lst[1, 2, 3, 5]>>> lst = [1, 2, 3]>>> def foo2():... lst += [5] # ... but this bombs!...>>> foo2()Traceback (most recent call last):File "
奇怪，为什么foo1正常运行，而foo2崩溃了呢？
原因和上一个案例中出现的问题相似，但这里的错误更加细微。函数foo1没有对变量lst进行赋值操作，而函数foo2有赋值操作。
首先， lst += [5]是lst = lst + [5]的缩写形式，在函数foo2中试图对变量lst进行赋值操作（Python将变量lst默认为本地作用域的变量）。但是，lst += [5]语句是对lst变量自身进行的赋值操作（此时变量lst的作用域是函数foo2），但是在函数foo2中还未声明该变量，所以就报错啦！
常见错误5:在遍历列表时修改列表
下面代码中的错误很明显：
>>> odd = lambda x : bool(x % 2)>>> numbers = [n for n in range(10)]>>> for i in range(len(numbers)):... if odd(numbers[i]):... del numbers[i] # BAD: Deleting item from a list while iterating over it...Traceback (most recent call last):File "
有经验的程序员都知道，在Python中遍历列表或数组时不应该删除该列表（数组）中的元素。虽然上面代码的错误很明显，但是在编写复杂代码时，资深程序员也难免会犯此类错误。
幸好Python集成了大量经典的编程范式，如果运用得当，可以大大简化代码并提高编程效率。简单的代码会降低出现上述bug的几率。列表解析式（list comprehensions）就是利器之一，它将完美避开上述bug，解决方案如下：
>>> odd = lambda x : bool(x % 2)>>> numbers = [n for n in range(10)]>>> numbers[:] = [n for n in numbers if not odd(n)] # ahh, the beauty of it all>>> numbers[0, 2, 4, 6, 8]
更多有关列表解析式的详细内容，请戳：https://docs.python.org/2/tutorial/datastructures.html#tut-listcomps
常见错误6：不理解Python闭包中的变量绑定
代码示例：
>>> def create_multipliers():... return [lambda x : i * x for i in range(5)]>>> for multiplier in create_multipliers():... print multiplier(2)...
你以为运行结果会是：
02468
但实际输出结果是：8
8888
惊不惊喜！
这种情况是由于Python延迟绑定（late binding）机制造成的，也就是说只有在内部函数被调用时才会搜索闭包中变量的值。所以在上述代码中，每次调用create_multipliers()函数中的return函数时，会在附近作用域中查询变量i的值。（此时，return中循环已结束，所以i值为4）。
常见解决方案：
>>> def create_multipliers():... return [lambda x, i=i : i * x for i in range(5)]...>>> for multiplier in create_multipliers():... print multiplier(2)...02468
没错！我们利用了匿名函数lambda的默认参数来生成结果序列。有人觉得这种用法很简洁，有人会说它很巧妙，还有人会觉得晦涩难懂。如果你是Python开发人员，那么深刻理解上述语法对你而言非常重要。
常见错误7：模块之间出现循环依赖
假设你有两个文件，分别是a.py和b.py，两者相互导入，如下所示：
a.py模块中的代码：
import bdef f():return b.xprint f()
b.py模块中的代码：
import ax = 1def g():print a.f()
首先，我们尝试导入a.py：
>>> import a1
运行结果正确！这似乎有点出人意料，因为我们在这里进行循环导入，应该会报错呀！
答案是，在Python中如果仅存在一个循环导入，程序不会报错。如果一个模块已经被导入，Python会自动识别而不会再次导入。但是如果每个模块试图访问其他模块不同位置的函数或变量时，那么Error又双叒叕出现了。
回到上面的示例中，当导入a.py模块时，程序可以正常导入b.py模块，因为此时b.py模块未访问a.py中定义任何的变量或函数。b.py模块仅引用了a.py模中的a.f()函数。调用的a.f()函数隶属于g()函数，而a.py或b.py模块中并没有调用g()函数。所以程序没有报错。
但是，如果我们在未导入a.py模块之前先导入b.py模块，结果会怎样？
>>> import bTraceback (most recent call last):File "
报错了！问题在于，在导入b.py的过程中，它试图导入a.py模块，而a.py模块会调用f()函数，f()函数又试图访问b.x变量。但此时，还未对变量b.x进行定义，所以出现了AttributeError异常。
稍微修改下b.py，即在g()函数内部导入a.py就可以解决上述问题。
修改后的b.py：
x = 1def g():
import a # This will be evaluated only when g() is calledprint a.f()
现在我们再导入b.py模块，就不会报错啦！
>>> import b>>> b.g()1 # Printed a first time since module 'a' calls 'print f()' at the end1 # Printed a second time, this one is our call to 'g'
常见错误8：文件命名与Python标准库模块的名称冲突
Python的优势之一就是其集成了丰富的标准库。正因为如此，稍不留神就会在为自己的文件命名时与Python自带标准库模块重名。例如，如果你的代码中有一个名为email.py的模块，恰好就和Python标准库中email.py模块重名了。）
上述问题比较复杂。举个例子，在导入模块A的时候，假如该模块A试图导入Python标准库中的模块B，但你已经定义了一个同名模块B，模块A会错误导入你自定义的模块B，而不是Python标准库中的模块B。这种错误很糟糕，因为程序员很难察觉到是因为命名冲突而导致的。
因此，Python程序员要注意避免与Python标准库模块的命名冲突。毕竟，修改自己模块的名称比修改标准库的名称要容易的多！当然你也可以写一份Python改善建议书（Python Enhancement Proposal，PEP）提议修改标准库的名称。
常见错误9：不熟悉Python2和Python3之间的差异
先来看看foo.py文件中的代码：
import sysdef bar(i):if i == 1: raise KeyError(1) if i == 2: raise ValueError(2)def bad(): e = None try: bar(int(sys.argv[1])) except KeyError as e: print('key error') except ValueError as e: print('value error') print(e)bad()
在Python 2中，上述代码运行正常
$ python foo.py 1key error1$ python foo.py 2value error2
但是在Python 3中运行时：
$ python3 foo.py 1key errorTraceback (most recent call last):File "foo.py", line 19, in
什么情况？原来，在Python 3中，在except代码块作用域外无法访问异常对象。（原因是，Python 3会将内存堆栈中的循环引用进行保留，直到垃圾回收...
在Python 2.7即将停止支持时，我们为你准备了一份3.x迁移指南 企业视频课程
机器之心编译
目前，Python 科学栈中的所有主要项目都同时支持 Python 3.x 和 Python 2.7，不过，这种情况很快即将结束。去年 11 月，Numpy 团队的一份声明引发了数据科学社区的关注：这一科学计算库即将放弃对于 Python 2.7 的支持，全面转向 Python 3。Numpy 并不是唯一宣称即将放弃 Python 旧版本支持的工具，pandas 与 Jupyter notebook 等很多产品也在即将放弃支持的名单之中。对于数据科学开发者而言，如何将已有项目从 Python 2 转向 Python 3 成为了正在面临的重大问题。来自莫斯科大学的 Alex Rogozhnikov 博士为我们整理了一份代码迁移指南。
Python 3 功能简介
Python 是机器学习和其他科学领域中的主流语言，我们通常需要使用它处理大量的数据。Python 兼容多种深度学习框架，且具备很多优秀的工具来执行数据预处理和可视化。
但是，Python 2 和 Python 3 长期共存于 Python 生态系统中，很多数据科学家仍然使用 Python 2。2019 年底，Numpy 等很多科学计算工具都将停止支持 Python 2，而 2018 年后 Numpy 的所有新功能版本将只支持 Python 3。
为了使 Python 2 向 Python 3 的转换更加轻松，我收集了一些 Python 3 的功能，希望对大家有用。
使用 pathlib 更好地处理路径
pathlib 是 Python 3 的默认模块，帮助避免使用大量的 os.path.joins：
from pathlib importPath
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
Python 2 总是试图使用字符串级联（准确，但不好），现在有了 pathlib，代码安全、准确、可读性强。
此外，pathlib.Path 具备大量方法，这样 Python 新用户就不用每个方法都去搜索了：
p.exists()
p.is_dir()
p.parts()
p.with_name('sibling.png')# only change the name, but keep the folder
p.with_suffix('.jpg')# only change the extension, but keep the folder and the name
p.chmod(mode)
p.rmdir()
pathlib 会节约大量时间，详见：
文档：https://docs.python.org/3/library/pathlib.html；
参考信息：https://pymotw/3/pathlib/。
类型提示（Type hinting）成为语言的一部分
PyCharm 中的类型提示示例：
Python 不只是适合脚本的语言，现在的数据流程还包括大量步骤，每一步都包括不同的框架（有时也包括不同的逻辑）。
类型提示被引入 Python，以帮助处理越来越复杂的项目，使机器可以更好地进行代码验证。而之前需要不同的模块使用自定义方式在文档字符串中指定类型（注意：PyCharm 可以将旧的文档字符串转换成新的类型提示）。
下列代码是一个简单示例，可以处理不同类型的数据（这就是我们喜欢 Python 数据栈之处）。
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 提供细粒度类型，但是或许我们很快就可以拥有这样的提示工具了，这将是 DS 的伟大功能。
类型提示 → 运行时的类型检查
默认情况下，函数注释不会影响代码的运行，不过它也只能帮你指出代码的意图。
但是，你可以在运行时中使用 enforce 等工具强制进行类型检查，这可以帮助你调试代码（很多情况下类型提示不起作用）。
@enforce.runtime_validation
def foo(text: str)->None:
print(text)
foo('Hi')# ok
foo(5)# fails
@enforce.runtime_validation
def any2(x:List[bool])->bool:
return any(x)
any ([False,False,True,False])# True
any2([False,False,True,False])# True
any (['False'])# True
any2(['False'])# fails
any ([False,None,"",0])# False
any2([False,None,"",0])# fails
函数注释的其他用处
如前所述，注释不会影响代码执行，而且会提供一些元信息，你可以随意使用。
例如，计量单位是科学界的一个普遍难题，astropy 包提供一个简单的装饰器（Decorator）来控制输入量的计量单位，并将输出转换成所需单位。
# Python 3
from 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 正则化的线性回归：
# l2-regularized linear regression: || AX - b ||^2 + alpha * ||x||^2 ->min
# Python 2
X = np.linalg.inv(np.dot(A.T, A)+ alpha * np.eye(A.shape[1])).dot(A.T.dot(b))
# Python 3
X = np.linalg.inv(A.T @ A + alpha * np.eye(A.shape[1]))@(A.T @ b)
下面 Python 3 带有 @ 作为矩阵乘法的符号更具有可读性，且更容易在深度学习框架中转译：因为一些如 X @ W + b[None, :] 的代码在 numpy、cupy、pytorch 和 tensorflow 等不同库下都表示单层感知机。
使用 ** 作为通配符
递归文件夹的通配符在 Python2 中并不是很方便，因此才存在定制的 glob2 模块来克服这个问题。递归 flag 在 Python 3.6 中得到了支持。
import glob
# Python 2
found_images = \
glob.glob('/path*.jpg') \
+ glob.glob('/path*.jpg') \
+ glob.glob('/path***.jpg')
# Python 3
found_images = glob.glob('/path*.jpg', recursive=True)
python3 中更好的选择是使用 pathlib：
# Python 3
found_images = pathlib.Path('/path/').glob('**/*.jpg')
Print 在 Python3 中是函数
Python 3 中使用 Print 需要加上麻烦的圆括弧，但它还是有一些优点。
使用文件描述符的简单句法：
print>>sys.stderr,"critical error"# Python 2
print("critical error", file=sys.stderr)# Python 3
在不使用 str.join 下输出 tab-aligned 表格：
# Python 3
print(*array, sep='\t')
print(batch, epoch, loss, accuracy, time, sep='\t')
修改与重新定义 print 函数的输出：
# Python 3
_print =print# store the original print function
defprint(*args,**kargs):
pass# do something useful, e.g. store output to some file
在 Jupyter 中，非常好的一点是记录每一个输出到独立的文档，并在出现错误的时候追踪出现问题的文档，所以我们现在可以重写 print 函数了。
在下面的代码中，我们可以使用上下文管理器暂时重写 print 函数的行为：
@contextlib.contextmanager
def 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= _print
with replace_print():
上面并不是一个推荐的方法，因为它会引起系统的不稳定。
print 函数可以加入列表解析和其它语言构建结构。
# Python 3
result = process(x)if is_valid(x)elseprint('invalid item: ', x)
f-strings 可作为简单和可靠的格式化
默认的格式化系统提供了一些灵活性，且在数据实验中不是必须的。但这样的代码对于任何修改要么太冗长，要么就会变得很零碎。而代表性的数据科学需要以固定的格式迭代地输出一些日志信息，通常需要使用的代码如下：
# Python 2
print('{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)
))
样本输出：
12012/300 accuracy:0.8180±0.4649 time:56.60
f-strings 即格式化字符串在 Python 3.6 中被引入：
# 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 = f"INSERT INTO STATION VALUES (13, '{city}', '{state}', {latitude}, {longitude})"
「true pision」和「integer pision」之间的明显区别
对于数据科学来说这种改变带来了便利（但我相信对于系统编程来说不是）。
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
注意，该运算可以应用到内建类型和由数据包（例如，numpy 或 pandas）提供的自定义类型。
严格排序
# All these comparisons are illegal in Python 3
3<'3'
2 (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 isnotNone: pass if a:# WRONG check for None pass 自然语言处理的 Unicode s ='您好' print(len(s)) print(s[:2]) 输出： Python 2: 6\n Python 3: 2\n 您好. x = u'со' x +='co'# ok x +='со'# fail Python 2 在此失败了，而 Python 3 可以如期工作（因为我在字符串中使用了俄文字母）。 在 Python 3 中 strs 是 Unicode 字符串，对非英语文本的 NLP 处理更加方便。 还有其它有趣的方面，例如： 'a'< type < u'a'# Python 2: True 'a'< u'a'# Python 2: False from collections importCounter 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（在 3.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} 它同样适用于**kwargs（在 Python 3.6+版本中）：它们的顺序就像参数中显示的那样。当设计数据流程时，顺序至关重要，以前，我们必须以这样繁琐的方式来编写： 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()) ) 注意到了吗？名称的唯一性也会被自动检查。 迭代地拆封 # handy when amount of additional stored info may vary between experiments, but the same code can be used in all cases model_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 引擎为数组提供更好的压缩 # Python 2 import cPickle as pickle import numpy print len(pickle.dumps(numpy.random.normal(size=[1000,1000]))) # result: 23691675 # Python 3 import pickle import numpy len(pickle.dumps(numpy.random.normal(size=[1000,1000]))) # result: 8000162 节省 3 倍空间，而且速度更快。实际上，类似的压缩（不过与速度无关）可以通过 protocol=2 参数来实现，但是用户...
Python程序员最常犯的10个错误，你中招了吗？ 互联网视频课程
大数据文摘作品
编译：什锦甜、Gao Ning、小鱼
Python简介
Python是一种具有动态语义的、面向对象的解释型高级编程语言。因其内置了高级数据结构，并支持动态类型和动态绑定，使用Python进行快速应用程序开发十分便利。同时作为一门脚本语言，它兼容部分现有的组件和服务。Python还支持模块和各种库的扩展，有助于实现模块化编程和提高代码复用率。
关于本文
刚接触这门语言的新手可能会对Python简洁灵活的语法有些不适应，或是低估了Python强大的性能。鉴于此，本文列出了Python开发人员常犯的10个小错误，资深程序猿也难免会中招哦。
本文供Python高级开发人员参考，Python小白可以参考下面这篇文章：
http://onlamp/pub/a/python/2004/02/05/learn_python.html
常见错误1：滥用表达式作为函数参数的默认值
Python允许开发者指定函数参数的默认值，这也是Python的一大特色，但当默认值可变时，可能会给开发者带来一些困扰。例如下面定义的函数：
>>> def foo(bar=[]): # bar is optional and defaults to [] if not specified... bar.append("baz") # but this line could be problematic, as we'll see...... return bar
看出bug了吗？那就是在每次调用函数前没有对可变参数进行赋值，而认为该参数就是默认值。比如上面的代码，有人可能期望在反复调用foo()时返回'baz'，以为每次调用foo()时，bar的值都为[]，即一个空列表。
但是，让我们来看看代码运行结果：
>>> foo()["baz"]>>> foo()["baz", "baz"]>>> foo()["baz", "baz", "baz"]
嗯？为什么每次调用foo()后会不断把"baz"添加到已有的列表，而不是新建一个新列表呢？答案就是，函数参数的默认值仅在定义函数时执行一次。因此，仅在第一次定义foo()时，bar初始化为默认值（即空列表），此后，每次调用foo()函数时，参数bar都是第一次初始化时生成的列表。
常见的解决方案：
>>> def foo(bar=None):... if bar is None: # or if not bar:... bar = []... bar.append("baz")... return bar...>>> foo()["baz"]>>> foo()["baz"]>>>foo()["baz"]
常见错误2：错误地使用类变量
代码示例：
>>> class A(object):... x = 1...>>> class B(A):... pass...>>> class C(A):... pass...>>> print A.x, B.x, C.x1 1 1
运行结果没问题。
>>> B.x = 2>>> print A.x, B.x, C.x1 2 1
结果也正确。
>>> A.x = 3>>> print A.x, B.x, C.x3 2 3
什么鬼？我们只改变了A.x.，为什么C.x 也变了？
在Python中，类变量是以字典形式进行内部处理，遵循方法解析顺序（Method Resolution Order ，MRO）。因此，在上述代码中，因为在类C中没有找到属性x，它就会从父类中查找x的值（尽管Python支持多重继承，但上述代码只存在一个父类A）。换句话说，C没有独立于类A的属于自己的x。因此，C.x实际上指的是A.x。除非处理得当，否则就会导致Python出现错误。
如果想更深入了解Python的类特性，请戳：
https://toptal/python/python-class-attributes-an-overly-thorough-guide
常见错误3：错误指定异常代码块的参数
假设你有如下代码：
>>> try:... l = ["a", "b"]... int(l[2])... except ValueError, IndexError: # To catch both exceptions, right?... pass...Traceback (most recent call last):File "
这里的问题是except语句不接受以这种方式指定的异常列表。在Python2.x中，except Exception语句中变量e可用来把异常信息绑定到第二个可选参数上，以便进一步查看异常的情况。因此，在上述代码中，except语句并没有捕捉到IndexError异常；而是将出现的异常绑定到了参数IndexError中。
想在一个except语句同时捕捉到多个异常的正确方式是，将第一个参数指定为元组，并将要捕捉的异常类型都写入该元组中。为了方便起见，可以使用as关键字，Python 2 和Python 3都支持这种语法格式：
>>> try:... l = ["a", "b"]... int(l[2])... except (ValueError, IndexError) as e: ... pass...>>>
常见错误4：错误理解Python中变量的作用域
Python变量作用域遵循LEGB规则，LEGB是Local，Enclosing，Global，Builtin的缩写，分别代表本地作用域、封闭作用域、全局作用域和内置作用域，这个规则看起来一目了然。事实上，Python的这种工作方式较为独特，会导致一些编程错误，例如：
>>> x = 10>>> def foo():... x += 1... print x...>>> foo()Traceback (most recent call last):File "
问题出在哪？
上面的错误是因为在作用域内对变量赋值时，Python自动将该变量视为该作用域的本地变量，并对外部定义的同名变量进行了屏蔽。因此，原本正确的代码，在某个函数内部添加了一个赋值语句后，却意外收到了UnboundLocalError的报错信息。
关于UnboundLocalError更多内容请戳：
https://docs.python.org/2/faq/programming.html#why-am-i-getting-an-unboundlocalerror-when-the-variable-has-a-value
在使用列表时，Python程序员更容易掉入此类陷阱，例如：
>>> lst = [1, 2, 3]>>> def foo1():... lst.append(5) # This works ok......>>> foo1()>>> lst[1, 2, 3, 5]>>> lst = [1, 2, 3]>>> def foo2():... lst += [5] # ... but this bombs!...>>> foo2()Traceback (most recent call last):File "
奇怪，为什么foo1正常运行，而foo2崩溃了呢？
原因和上一个案例中出现的问题相似，但这里的错误更加细微。函数foo1没有对变量lst进行赋值操作，而函数foo2有赋值操作。
首先， lst += [5]是lst = lst + [5]的缩写形式，在函数foo2中试图对变量lst进行赋值操作（Python将变量lst默认为本地作用域的变量）。但是，lst += [5]语句是对lst变量自身进行的赋值操作（此时变量lst的作用域是函数foo2），但是在函数foo2中还未声明该变量，所以就报错啦！
常见错误5:在遍历列表时修改列表
下面代码中的错误很明显：
>>> odd = lambda x : bool(x % 2)>>> numbers = [n for n in range(10)]>>> for i in range(len(numbers)):... if odd(numbers[i]):... del numbers[i] # BAD: Deleting item from a list while iterating over it...Traceback (most recent call last):File "
有经验的程序员都知道，在Python中遍历列表或数组时不应该删除该列表（数组）中的元素。虽然上面代码的错误很明显，但是在编写复杂代码时，资深程序员也难免会犯此类错误。
幸好Python集成了大量经典的编程范式，如果运用得当，可以大大简化代码并提高编程效率。简单的代码会降低出现上述bug的几率。列表解析式（list comprehensions）就是利器之一，它将完美避开上述bug，解决方案如下：
>>> odd = lambda x : bool(x % 2)>>> numbers = [n for n in range(10)]>>> numbers[:] = [n for n in numbers if not odd(n)] # ahh, the beauty of it all>>> numbers[0, 2, 4, 6, 8]
更多有关列表解析式的详细内容，请戳：https://docs.python.org/2/tutorial/datastructures.html#tut-listcomps
常见错误6：不理解Python闭包中的变量绑定
代码示例：
>>> def create_multipliers():... return [lambda x : i * x for i in range(5)]>>> for multiplier in create_multipliers():... print multiplier(2)...
你以为运行结果会是：
02468
但实际输出结果是：8
8888
惊不惊喜！
这种情况是由于Python延迟绑定（late binding）机制造成的，也就是说只有在内部函数被调用时才会搜索闭包中变量的值。所以在上述代码中，每次调用create_multipliers()函数中的return函数时，会在附近作用域中查询变量i的值。（此时，return中循环已结束，所以i值为4）。
常见解决方案：
>>> def create_multipliers():... return [lambda x, i=i : i * x for i in range(5)]...>>> for multiplier in create_multipliers():... print multiplier(2)...02468
没错！我们利用了匿名函数lambda的默认参数来生成结果序列。有人觉得这种用法很简洁，有人会说它很巧妙，还有人会觉得晦涩难懂。如果你是Python开发人员，那么深刻理解上述语法对你而言非常重要。
常见错误7：模块之间出现循环依赖
假设你有两个文件，分别是a.py和b.py，两者相互导入，如下所示：
a.py模块中的代码：
import bdef f():return b.xprint f()
b.py模块中的代码：
import ax = 1def g():print a.f()
首先，我们尝试导入a.py：
>>> import a1
运行结果正确！这似乎有点出人意料，因为我们在这里进行循环导入，应该会报错呀！
答案是，在Python中如果仅存在一个循环导入，程序不会报错。如果一个模块已经被导入，Python会自动识别而不会再次导入。但是如果每个模块试图访问其他模块不同位置的函数或变量时，那么Error又双叒叕出现了。
回到上面的示例中，当导入a.py模块时，程序可以正常导入b.py模块，因为此时b.py模块未访问a.py中定义任何的变量或函数。b.py模块仅引用了a.py模中的a.f()函数。调用的a.f()函数隶属于g()函数，而a.py或b.py模块中并没有调用g()函数。所以程序没有报错。
但是，如果我们在未导入a.py模块之前先导入b.py模块，结果会怎样？
>>> import bTraceback (most recent call last):File "
报错了！问题在于，在导入b.py的过程中，它试图导入a.py模块，而a.py模块会调用f()函数，f()函数又试图访问b.x变量。但此时，还未对变量b.x进行定义，所以出现了AttributeError异常。
稍微修改下b.py，即在g()函数内部导入a.py就可以解决上述问题。
修改后的b.py：
x = 1def g():
import a # This will be evaluated only when g() is calledprint a.f()
现在我们再导入b.py模块，就不会报错啦！
>>> import b>>> b.g()1 # Printed a first time since module 'a' calls 'print f()' at the end1 # Printed a second time, this one is our call to 'g'
常见错误8：文件命名与Python标准库模块的名称冲突
Python的优势之一就是其集成了丰富的标准库。正因为如此，稍不留神就会在为自己的文件命名时与Python自带标准库模块重名。例如，如果你的代码中有一个名为email.py的模块，恰好就和Python标准库中email.py模块重名了。）
上述问题比较复杂。举个例子，在导入模块A的时候，假如该模块A试图导入Python标准库中的模块B，但你已经定义了一个同名模块B，模块A会错误导入你自定义的模块B，而不是Python标准库中的模块B。这种错误很糟糕，因为程序员很难察觉到是因为命名冲突而导致的。
因此，Python程序员要注意避免与Python标准库模块的命名冲突。毕竟，修改自己模块的名称比修改标准库的名称要容易的多！当然你也可以写一份Python改善建议书（Python Enhancement Proposal，PEP）提议修改标准库的名称。
常见错误9：不熟悉Python2和Python3之间的差异
先来看看foo.py文件中的代码：
import sysdef bar(i):if i == 1: raise KeyError(1) if i == 2: raise ValueError(2)def bad(): e = None try: bar(int(sys.argv[1])) except KeyError as e: print('key error') except ValueError as e: print('value error') print(e)bad()
在Python 2中，上述代码运行正常
$ python foo.py 1key error1$ python foo.py 2value error2
但是在Python 3中运行时：
$ python3 foo.py 1key errorTraceback (most recent call last):File "foo.py", line 19, in
什么情况？原来，在Python 3中，在except代码块作用域外无法访问异常对象。（原因是，Python 3会将内存堆栈中的循环引用进行保留，直到垃圾回收...
