python中true

刚开始学习一门编程语言，除了了解运行环境与语言类型之外，最基本还是从该语言的基本数据类型开始学起。

Python六大常用数据类型：

int 整数 float 浮点数 str 字符串 list 列表 tuple 元组 dict 字典

讲解这些先说一下python中的变量与变量名。

变量其实本质上是一个具有特殊格式的内存，变量名则是指向这个内存的别名。python中的变量不需要声明，所有的变量必须赋值了才能使用。赋值的步骤：

a = 100

第一步：准备好值100第二部：准备好变量名a第三部：将值与名字进行关联

一、整数python将其他一些静态语言中的int、long，也就是整型和长整型合并为了一个。python中的int是边长的，也就是说可以存储无限大的整数，但是这是不现实的，因为没有这么多的内存够分配。整型不仅支持十进制，还支持二进制、八进制、十六进制。可以通过下面的方式来互相转换：

print(bin(20)) #转换二进制print(oct(20)) #转换八进制print(hex(20)) #转换十六进制

二、浮点型浮点数也就是小数，如22.1,44.2，也可以使用科学计数法,比如：1.22e8。python支持对整数和浮点数直接进行四则混合运算。整数运算结果仍然是整数，浮点数运算结果仍然是浮点数,但整数和浮点数混合运算的结果就变成浮点数了。

a = 1b = 1.1print(type(a+b)) #

三、字符串字符串在任何编程语言中都是最常用的数据类型。字符串的创建很简单，也是上面所说的三步，但是要加上单引号或者双引号。

a = "hello python"

也可以使用 “”" 创建多行字符串：

a = """ hello python"""

字符串可以通过下面方式进行截取或者连接：

print (str[0:4]) 输出第一个到倒数第四个的所有字符 print (str[0]) 输出单字符 第1个字符print (str[3:]) 输出从第四个开始之后的所有字符print (str * 2) 输出字符串两次print (str + "bbbb") 连接字符串

字符串常用函数：str.strip() 消除字符串s左右两边的空白字符（包括’\t’，’\n’,’\r’,’’）len(str) 获取字符串长度str.upper() 转换为大写str.lower() 转换为小写str.title() 每个单词首字母大写str.capitalize() 首字母大写字符串翻转：

a = 'abcde'print(a[::-1])

字符串分割：

a = 'hello,python'print(a.split(',')) #['hello', 'python'] 返回一个列表

相对应的还有一个将列表元素连接成字符串:

a = ['hello', 'python']str = '-'print(str.join(a)) # hello-python

四、列表列表的写法是一个方括号内的值用逗号分隔。比如上面的[‘hello’, ‘python’]。列表的数据项不需要具有相同的类型，列表中的每个元素都分配一个数字索引，第一个索引是0，第二个索引是1，依此类推。访问列表中的值可以通过下面的方式：

list1 = [1, 2, 3, 4, 5, 6]print(list1[2])

同样可以通过索引截取

print ("list1[2:5]: ", list1[2:5])

列表常用操作:list1.append(‘7’) 追加一个元素在末尾，每次只能添加一个len(list1) 返回列表元素个数max(list1) 返回列表元素最大值min(list1) 返回列表元素最小值list1.count(obj) 统计某个元素在列表中出现的次数list1.index(obj) 从列表中找出某个值第一个匹配项的索引位置list1.reverse() 反向列表中元素list1.clear() 清空列表list1.extend(seq) 在列表末尾一次性追加另一个序列中的多个值,也就是扩充了列表 append与extend的区别：

A = ['a', 'b', 'c']A.append(['d', 'e'])print(A) # ['a', 'b', 'c', ['d', 'e']]B = ['a', 'b', 'c']B.extend(['d', 'e'])print(B) # ['a', 'b', 'c', 'd', 'e']

extend方法只能接收list类型，它是把这个列表中的每个元素添加到原list中。append可以接收任意类型，追加到原list的末尾。

五、元组元组的创建也很简单，和list类似，只是把’[]‘换成了’()’。

tup1 = ('hello', 'python')

元组中只有一个元素的时候要注意：

tup2 = (10)tup3 = ('a')print(type(tup2)) #print(type(tup3)) #

因为这样会被解释器当做运算符，所以正确的方法是在第一个元素后面添加逗号。

tup4 = ('a',)print(type(tup4)) #

元组同样可以使用下标索引来访问元组中的值：

tup5 = ('hello', 'python', 'hello', 'word')print(tup5[1]) #pythonprint(tup5[1:3]) #('python', 'hello')

注意：元组是不可以被修改的。

tup6 = ('hello', 'python', 'hello', 'word')tup6[2] = 'aaa'

上面会出现一个异常： TypeError: ‘tuple’ object does not support item assignment.但是元组中如果包含了一个列表，那么这个列表是可以被修改的。

tup7 = ('hello', 'python', 'hello', 'word', ['aa', 'bb', 'cc'])tup7[-1][1] = 'ddd'print(tup7) # ('hello', 'python', 'hello', 'word', ['aa', 'ddd', 'cc'])

元组运算符：len(tup) 计算元素个数tup1 + tup2 连接生成新元组tup * 4 元组复制num in tup 元素是否存在,返回True/False

六、字典python中的字典就是key，value的形式。使用大括号包含起来。字典中的成员的键是唯一的,如果出现多个同名的键，那么写在后面覆盖前面的值。形式如下：

dict1 = {'a' : 1, 'b' : 2}

字典的常用操作最基本的也就是增删改查:获取：直接通过键来获取。

dict['b'] # 2

dict.keys() 获取字典中所有的键dict.values() 获取字典中的所有的值增加：

dict1['c'] = 3 #{'a': 1, 'b': 2, 'c': 3} #如果键存在则更新对应的值

修改：直接给键进行再次赋值就可以修改键对应的值了。如果键不存在，则变成添加成员。还可以通过：

dict1.update({"a":"11"})dict1.setdefault("a", "222") # 已存在的键则修改无效dict1.setdefault("d","222") # 不存在的话则创建dict1.setdefault("e") # 没有设置值为None

删除：使用pop删除指定键对应的成员,同时返回该值

print(dict1) # {'a': '11', 'b': 2, 'c': 3, 'd': '222', 'e': None}print(dict1.pop("a")) # aprint(dict1) # {'b': 2, 'c': 3, 'd': '222', 'e': None}#在不设置默认值的情况下，使用pop删除不存在的键，会报错。print(dict1.pop("f")) # 报错 KeyError: 'f'

如果设置了默认值， print(dict1.pop(“f”, None))，则不会报错，返回这个默认值。判断是否删除成功可以通过下面方式来判断：

if dict1.pop("f", None) == None: print('键不存在')else: print('删除成功')

以上则是python中最基本的数据类型以及用法，当然还有其他的数据类型，作者暂时只列举了这些。

更过python文章，关注作者哦！干货多多！！

自学了很久的Python，水平一直不上不下，很恼火。所以现在打算整理一下自己大脑中关于Python的内存。

if __name__=='__main__':print(file_size(100,False))print(file_size(100))

这段代码是我在pycharm中敲出来的，刚开始并不明白它的意思是什么。后来问了度娘之后，明白了其中的奥秘。

看到if语句，有点编程基础的人都应该知道这是一个判断语句，当if后面的值未true时，后面的代码块才会被执行。反之则不会。

__name__代表当前文件的名字，__main__代表的是当前被执行的文件的名字。

下面看一个简单的例子，来做一下说明。

直接新建一个test.py文件，输入如下代码：

print ('I'm the first.')

if __name__=='__main__':

print ('I'm the second.')

直接执行test.py文件的结果如下：

可以看到两个print语句均被执行。

下面在同一个文件夹中新建import_test.py文件

只在文件中输入：import test

然后执行import_test.py文件，执行结果如下：

可以看到第二个print语句并咩有被执行。所以我们可以判断此时 __name__=='__main__':结果为false。那是因为在import_test.py文件中的__name__==import_test(没有包含后缀名)，而__main__==import_test.py(包含后缀名),所以在import之后，if语句之后的print方法没有被执行。

如果看文字觉得太绕的话，我们可以在test.py文件中将__name__的值打印出来，大家看一下：

运行结果显示 __name__==__main__，所以在test.py文件中if语句后的print语句页被执行了。

同样，再执行import_test.py文件，可以看到输出结果如下：

此时__name__==test，if __name__=='__main__':结果为false所以在执行import_test.py文件时，if语句之后的print函数并咩有被执行。

一、集合（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 科学栈中的所有主要项目都同时支持 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 参数来实现，但是用户�...