Python冷知识、技巧
10 分钟速成 Python3
https://mp.weixin.qq.com/s/vwz7jyGrmTTTkYuzeLB9eQ
https://learnxinyminutes.com/docs/zh-cn/python3-cn/
90%的人说Python程序慢，5大神招让你的代码像赛车一样跑起来
https://mp.weixin.qq.com/s/XZcqzwodPjvjltPRNRTpVQ
几点要注意的
https://mp.weixin.qq.com/s/04fnb0XV9nIsDsDDEDjsnw
25条 Python 技巧
https://mp.weixin.qq.com/s/cJXmZuf6pQYt71hJgGyB8w
https://mp.weixin.qq.com/s/W0QZ94_7m-kwQyZf2GVZUw
总结一些改善Python程序的建议
https://www.jianshu.com/p/9d07e0994eac
Python这些函数简直是屌爆了
https://mp.weixin.qq.com/s/G0erckY6RYKfIOMOeupyCQ
while 1比while True更快？
https://mp.weixin.qq.com/s/aTn629fYjRfVkf9pag944g
史上最全的 Python 3 类型转换指南
https://shockerli.net/post/python3-data-type-convert/
3道趣味Python题，非常适合菜鸟练手
https://mp.weixin.qq.com/s/4CqvmH0l-OD3A7C76INjZQ
Python中字符串拼接的N种方法
https://mp.weixin.qq.com/s/9qtjtYVvC28djEuYawRDzw
Python下调用Linux的Shell命令
https://blog.csdn.net/longerzone/article/details/17889969
菜鸟学Python入门教程大盘点
https://mp.weixin.qq.com/s/4O7YlRSfrb0FAI-MS3WkfA
爬虫、面试文章整理
https://mp.weixin.qq.com/s/rGseqlsiXIV2c2srr9izog
python之装饰器
http://hexo.mykernel.cn/python-function-3.html
10张Gif动图让你弄懂递归等概念
https://mp.weixin.qq.com/s/wFqfO-BFeL61Alzz8V_W3g
Python 语法速览与实战清单
https://segmentfault.com/a/1190000012129654
https://mp.weixin.qq.com/s/MzZldFmMRZRpj-hclkZMSA
你真的懂 Unicode 和 UTF-8 是什么关系吗？
https://mp.weixin.qq.com/s/yF8w5X55TGHnF62v6-Ysvw
17个实用的小技巧
交换变量
有时候，当我们要交换两个变量的值时，一种常规的方法是创建一个临时变量，然后用它来进行交换。比如：
# 输入
a = 5
b = 10
#创建临时变量
temp = a
a = b
b = temp
print(a)
print(b)
但在Python中，其实我们有一种更简洁的写法：
将list中的所有元素转为单个字符串
列表和字符串是Python中最常见的数据类型，它们会遇到互相转换的需要。那么，我们该怎么把list中的所有元素转为字符串呢？
查找list中出现次数最多的元素
给定一个包含多个元素的list，让你查找其中出现次数最多的元素，你会怎么做？在下图中，我们介绍了两种方法，其中第一种是利用max()函数的key参数，第二种则是使用Counter。
判断两个字符串是否是anagram
所谓anagram，就是两个词所用的字母及其个数都是一样的，但是它们字母的位置不一样，比如abc，bac，acb。在Python中，Counter可以解决这个问题，
字符串倒转
字符串倒转，就是把1234转成4321。下面我们介绍了三种方法：
方法一：最简单的切片法，a[::-1]就相当于a[尾:头:-1]。
方法二：用Python自带reversed()函数，它可被用于list倒转。
方法三：第三种是通过倒转数据类型和切片倒转整数。
list倒转
和字符串倒转类似，切片法也可以被用于list倒转，如下面的第一种方法。第二种方法调用的是上面提到的reversed()函数。
二维矩阵转置
如果要转置矩阵，可以直接使用使用zip()函数。除此之外，没有比import numpy更简单的方法了。
链式比较
如果想输出数组中介于4-7之间的元素，java是这么写的：if( b > 4 && b < 7){ }，但Python更人性化。包括最后一句1 == b < 20，这和C、java也很不一样。
链式调用
在python中实现链式调用只需在函数返回对象自己就行了。
复制list
如果是刚学习Python的C用户，你可能会想写b = a，但这是错的。在Python中，变量指向的是某个对象的标签。也就是说，按照这种的写法，b和a指向的是内存中的同一个列表，对b操作，就相当于对a操作。所以正确的写法有以下几种：
方法一：b=a[:]。
方法二：b=list(a)。
方法三：使用Python 3的copy()函数，直接复制list，类似a[:]。
方法四：使用copy.deepcopy()。
判断一个key是否在字典中
如果目标key不在字典中，以下代码会返回None或default。
字典排序
按value排序字典
Python的内置字典数据类型是无序的，而key可以被用来获取对应的value。有时我们需要根据value对字典中的item进行排序输出。方法如下所示：
方法一：用sorted函数排序，其中key参数是lamda表达式。
方法二：用operator.itemgetter而不是lamda表达式进行排序。
方法三：如果只需得到排序后的key，可用.get。
字典有序迭代
使用OrderedDict类
使用代码如下：
from collections import defaultdict, OrderedDict
grade_test = OrderedDict()
grade_test['小明'] = 90
grade_test['小王'] = 80
grade_test['小张'] = 70
for key, item in grade_test.items():
print("key:{0}, item:{1}".format(key, item))
# 输出
key:小明, item:90
key:小王, item:80
key:小张, item:70
实现了让字典按照自己的添加顺序输出功能。
for ... else语法
用逗号分隔list
下面分别是字符串list、数字list和混合list的逗号分隔方式。
合并字典
方法一：Python 3.5可以存在重复键值，print({**d## **d2})。
方法二：在内存中创建两个列表，再创建第三个列表，拷贝完成后，创建新的dict，删除掉前三个列表。
方法三：d1.update()。
list中的最小和最大索引
从list中删除重复项
方法一：把list转成set，去除重复项，再转回list。
方法二：调用collections里的OrderedDict，和set差不多。
参考：https://mp.weixin.qq.com/s/BHEL7QcplUYcsG7r_5strQ
原文：hackernoon.com/python-tricks-101-2836251922e0
省略号也是对象
... 这是省略号，在Python中，一切皆对象。它也不例外。
在 Python 中，它叫做 Ellipsis 。
在 Python 3 中你可以直接写…来得到这玩意。
>>> ...
Ellipsis
>>> type(...)
<class 'ellipsis'>
而在 2 中没有…这个语法，只能直接写Ellipsis来获取。
>>> Ellipsis
Ellipsis
>>> type(Ellipsis)
<type 'ellipsis'>
>>>
它转为布尔值时为真
>>> bool(...)
True
最后，这东西是一个单例。
>>> id(...)
4362672336
>>> id(...)
4362672336
这东西有啥用呢？据说它是Numpy的语法糖，不玩 Numpy 的人，可以说是没啥用的。
在网上只看到这个 用 ... 代替 pass ，稍微有点用，但又不是必须使用的。
try:
1/0
except ZeroDivisionError:
...
类的首字母不一定是大写
在正常情况下，我们所编写的所见到的代码，好像都默许了类名首字母大写，而实例用小写的这一准则。但这并不是强制性的，即使你反过来的也没有关系。
但有一些内置的类，首字母都是小写，而实例都是大写。
比如 bool 是类名，而 True，False 是其实例；
比如 ellipsis 是类名，Ellipsis是实例；
还有 int，string，float，list，tuple，dict 等一系列数据类型都是类名，它们都是小写
增量赋值的性能更好
诸如 += 和 *= 这些运算符，叫做 增量赋值运算符。
这里使用用 += 举例，以下两种写法，在效果上是等价的。
# 第一种
a = 1 ; a += 1
# 第二种
a = 1; a = a + 1
+= 其背后使用的魔法方法是 iadd，如果没有实现这个方法则会退而求其次，使用 add 。
这两种写法有什么区别呢？
用列表举例 a += b，使用 add 的话就像是使用了a.extend(b),如果使用 add 的话，则是 a = a+b,前者是直接在原列表上进行扩展，而后者是先从原列表中取出值，在一个新的列表中进行扩展，然后再将新的列表对象返回给变量，显然后者的消耗要大些。
所以在能使用增量赋值的时候尽量使用它。
and和or的取值顺序
and 和 or 是我们再熟悉不过的两个逻辑运算符。而我们通常只用它来做判断，很少用它来取值。
如果一个or表达式中所有值都为真，Python会选择第一个值，而and表达式则会选择第二个。
>>>(2 or 3) * (5 and 7)
14 # 2*7
如何修改解释器提示符
这个当做今天的一个小彩蛋吧。应该算是比较冷门的，估计知道的人很少了吧。
正常情况下，我们在 终端下 执行Python 命令是这样的。
>>> for i in range(2):
... print (i)
...
0
1
你是否想过 >>> 和 ...这两个提示符也是可以修改的呢？
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>>
>>> sys.ps2 = '---------------- '
>>> sys.ps1 = 'Python编程时光>>>'
Python编程时光>>>for i in range(2):
---------------- print (i)
----------------
0
1
默认参数最好不为可变对象
函数的参数分三种
- 可变参数
- 默认参数
- 关键字参数
这三者的具体区别，和使用方法在 廖雪峰的教程 里会详细的解释。这里就不搬运了。
今天要说的是，传递默认参数时，新手很容易踩雷的一个坑。
先来看一个示例
def func(item, item_list=[]):
item_list.append(item)
print(item_list)
func('iphone')
func('xiaomi', item_list=['oppo','vivo'])
func('huawei')
在这里，你可以暂停一下，思考一下会输出什么？
思考过后，你的答案是否和下面的一致呢
['iphone']
['oppo', 'vivo', 'xiaomi']
['iphone', 'huawei']
如果是，那你可以跳过这部分内容，如果不是，请接着往下看，这里来分析一下。
Python 中的 def 语句在每次执行的时候都初始化一个函数对象，这个函数对象就是我们要调用的函数，可以把它当成一个一般的对象，只不过这个对象拥有一个可执行的方法和部分属性。
对于参数中提供了初始值的参数，由于 Python 中的函数参数传递的是对象，也可以认为是传地址，在第一次初始化 def 的时候，会先生成这个可变对象的内存地址，然后将这个默认参数 item_list 会与这个内存地址绑定。
在后面的函数调用中，如果调用方指定了新的默认值，就会将原来的默认值覆盖。如果调用方没有指定新的默认值，那就会使用原来的默认值。
访问类中的私有方法
大家都知道，类中可供直接调用的方法，只有公有方法（protected类型的方法也可以，但是不建议）。也就是说，类的私有方法是无法直接调用的。
这里先看一下例子
class Kls():
def public(self):
print('Hello public world!')
def __private(self):
print('Hello private world!')
def call_private(self):
self.__private()
ins = Kls()
# 调用公有方法，没问题
ins.public()
# 直接调用私有方法，不行
ins.__private()
# 但你可以通过内部公有方法，进行代理
ins.call_private()
既然都是方法，那我们真的没有方法可以直接调用吗？
当然有啦，只是建议你千万不要这样弄，这里只是普及，让你了解一下。
# 调用私有方法，以下两种等价
ins._Kls__private()
ins.call_private()
时有时无的切片异常
这是个简单例子
my_list = [1, 2, 3, 4, 5]
print(my_list[5])
执行一下，和我们预期的一样，会抛出索引异常。
Traceback (most recent call last):
File "F:/Python Script/test.py", line 2, in <module>
print(my_list[5])
IndexError: list index out of range
但是今天要说的肯定不是这个，而是一个你可能会不知道的冷知识。
来看看，如下这种写法就不会报索引异常，执行my_list[5:]，会返回一个新list：[]。
my_list = [1, 2, 3]
print(my_list[5:])
哪些情况下不需要续行符
在写代码时，为了代码的可读性，代码的排版是尤为重要的。
为了实现高可读性的代码，我们常常使用到的就是续行符 \。
>>> a = 'talk is cheap,'\
... 'show me the code.'
>>>
>>> print(a)
talk is cheap,show me the code.
那有哪些情况下，是不需要写续行符的呢？
经过总结，在这些符号中间的代码换行可以省略掉续行符：[],(),{}
>>> my_list=[1,2,3,
... 4,5,6]
>>> my_tuple=(1,2,3,
... 4,5,6)
>>> my_dict={"name": "MING",
... "gender": "male"}
另外还有，在多行文本注释中 ''' ，续行符也是可以不写的。
>>> text = '''talk is cheap,
... show me the code'''
上面只举了一些简单的例子。
但你要学会举一反三。一样的，在以下这些场景也同样适用
- 类，和函数的定义。
- 列表推导式，字典推导式，集合推导式，生成器表达式。
Py2 也可以使用 print()
我相信应该有不少人，思维定式，觉得只有 Py3 才可以使用 print()，而 Py2 只能使用print ''。
今天，小明要为 Py2 正名一次。
在Python 2.6之前，只支持
print "hello"
在Python 2.6和2.7中，可以支持如下三种
print "hello"
print("hello")
print ("hello")
在Python3.x中，可以支持如下两种
print("hello")
print ("hello")
for死循环
for 循环可以说是 基础得不能再基础的知识点了。但是如果让你用 for 写一个死循环，你会写吗？（问题来自群友 陈**）
这是个开放性的问题，在往下看之前，建议你先尝试自己思考，你会如何解答。
好了，如果你还没有思路，那就来看一下 一个海外 MIT 群友的回答:
for i in iter(int, 1):pass
是不是懵逼了。iter 还有这种用法？这为啥是个死循环？
这真的是个冷知识，关于这个知识点，你如果看中文网站，可能找不到相关资料。
还好你可以通过 IDE 看py源码里的注释内容，介绍了很详细的使用方法。
原来iter有两种使用方法，通常我们的认知是第一种，将一个列表转化为一个迭代器。
而第二种方法，他接收一个 callable对象，和一个sentinel 参数。第一个对象会一直运行，直到它返回 sentinel 值才结束。
那int 呢，这又是一个知识点，int 是一个内建方法。通过看注释，可以看出它是有默认值0的。你可以在终端上输入 int() 看看是不是返回0。
由于int() 永远返回0，永远返回不了1，所以这个 for 循环会没有终点。一直运行下去。
奇怪的字符串
示例一
# Python2.7
>>> a = "Hello_Python"
>>> id(a)
32045616
>>> id("Hello" + "_" + "Python")
32045616
# Python3.7
>>> a = "Hello_Python"
>>> id(a)
38764272
>>> id("Hello" + "_" + "Python")
32045616
示例二
>>> a = "MING"
>>> b = "MING"
>>> a is b
True
# Python2.7
>>> a, b = "MING!", "MING!"
>>> a is b
True
# Python3.7
>>> a, b = "MING!", "MING!"
>>> a is b
False
示例三
# Python2.7
>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
True
>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
False
# Python3.7
>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
True
>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
True
两次return
我们都知道，try…finally… 语句的用法，不管 try 里面是正常执行还是报异常，最终都能保证finally能够执行。
同时，我们又知道，一个函数里只要遇到 return 函数就会立马结束。
基于以上这两点，我们来看看这个例子，到底运行过程是怎么样的？
>>> def func():
... try:
... return 'try'
... finally:
... return 'finally'
...
>>> func()
'finally'
惊奇的发现，在try里的return居然不起作用。
原因是，在try…finally…语句中，try中的return会被直接忽视，因为要保证finally能够执行。
小整数池
先看例子。
>>> a = -6
>>> b = -6
>>> a is b
False
>>> a = 256
>>> b = 256
>>> a is b
True
>>> a = 257
>>> b = 257
>>> a is b
False
>>> a = 257; b = 257
>>> a is b
True
为避免整数频繁申请和销毁内存空间，Python 定义了一个小整数池 [-5, 256] 这些整数对象是提前建立好的，不会被垃圾回收。
以上代码请在 终端Python环境下测试，如果你是在IDE中测试，并不是这样的效果。
那最后一个示例，为啥又是True？
因为当你在同一行里，同时给两个变量赋同一值时，解释器知道这个对象已经生成，那么它就会引用到同一个对象。如果分成两成的话，解释器并不知道这个对象已经存在了，就会重新申请内存存放这个对象。
intern机制
字符串类型作为 Python 中最常用的数据类型之一，Python解释器为了提高字符串使用的效率和使用性能，做了很多优化。
例如：Python 解释器中使用了 intern（字符串驻留）的技术来提高字符串效率。
什么是 intern 机制？就是同样的字符串对象仅仅会保存一份，放在一个字符串储蓄池中，是共用的，当然，肯定不能改变，这也决定了字符串必须是不可变对象。
>>> s1="hello"
>>> s2="hello"
>>> s1 is s2
True
# 如果有空格，默认不启用intern机制
>>> s1="hell o"
>>> s2="hell o"
>>> s1 is s2
False
# 如果一个字符串长度超过20个字符，不启动intern机制
>>> s1 = "a" * 20
>>> s2 = "a" * 20
>>> s1 is s2
True
>>> s1 = "a" * 21
>>> s2 = "a" * 21
>>> s1 is s2
False
>>> s1 = "ab" * 10
>>> s2 = "ab" * 10
>>> s1 is s2
True
>>> s1 = "ab" * 11
>>> s2 = "ab" * 11
>>> s1 is s2
False
参考：https://mp.weixin.qq.com/s/mNNn7un9npw0cgzOyJhT2Q
交互式“_”操作符
对于 _ ，我想很多人都非常熟悉。
给变量取名好艰难，用 _；
懒得长长的变量名，用 _；
无用的垃圾变量，用 _；
以上，我们都很熟悉了，今天要介绍的是他在交互式中使用。
>>> 3 + 4
7
>>> _
7
>>> name='ming'
>>> name
'ming'
>>> _
'ming'
它可以返回上一次的运行结果。
但是，如果是print函数打印出来的就不行了。
>>> 3 + 4
7
>>> _
7
>>> print("ming")
ming
>>> _
7
我自己写了个例子，验证了下，用__repr__输出的内容可以被获取到的。
首先，在我们的目录下，写一个文件 ming.py。内容如下
# ming.py
class mytest():
def __str__(self):
return "hello"
def __repr__(self):
return "world"
然后在这个目录下进入交互式环境。
>>> import ming
>>> mt=ming.mytest()
>>> mt
world
>>> print(mt)
hello
>>> _
world
知道这两个魔法方法的人，一看就明白了。
优雅的反转字符串/列表
反转序列并不难，但是如何做到最优雅呢？
先来看看，正常是如何反转的。
最简单的方法是使用列表自带的reverse()方法。
>>> ml = [1,2,3,4,5]
>>> ml.reverse()
>>> ml
[5, 4, 3, 2, 1]
但如果你要处理的是字符串，reverse就无能为力了。你可以尝试将其转化成list，再reverse，然后再转化成str。转来转去，也太麻烦了吧？需要这么多行代码（后面三行是不能合并成一行的），一点都Pythonic。
mstr1 = 'abc'
ml1 = list(mstr1)
ml1.reverse()
mstr2 = str(ml1)
对于字符串还有一种稍微复杂一点的，是自定义递归函数来实现。
def my_reverse(str):
if str == "":
return str
else:
return my_reverse(str[1:]) + str[0]
在这里，介绍一种最优雅的反转方式，使用切片，不管你是字符串，还是列表，简直通杀。
>>> mstr = 'abc'
>>> ml = [1,2,3]
>>> mstr[::-1]
'cba'
>>> ml[::-1]
[3, 2, 1]
改变递归次限制
上面才提到递归，大家都知道使用递归是有风险的，递归深度过深容易导致堆栈的溢出。如果你这字符串太长啦，使用递归方式反转，就会出现问题。
那到底，默认递归次数限制是多少呢？
可以使用sys这个库来查看
>>> import sys
>>> sys.getrecursionlimit()
1000
可以查，当然也可以自定义修改次数，退出即失效。不过友情提醒，这玩意还是不要轻易去碰，万一导致系统崩溃了小明可不背锅。
>>> sys.setrecursionlimit(2000)
>>> sys.getrecursionlimit()
2000
一行代码实现FTP服务器
搭建FTP，或者是搭建网络文件系统，这些方法都能够实现Linux的目录共享。但是FTP和网络文件系统的功能都过于强大，因此它们都有一些不够方便的地方。比如你想快速共享Linux系统的某个目录给整个项目团队，还想在一分钟内做到，怎么办？很简单，使用Python中的SimpleHTTPServer。
SimpleHTTPServer是Python 2自带的一个模块，是Python的Web服务器。它在Python 3已经合并到http.server模块中。具体例子如下，如不指定端口，则默认是8000端口。
# python2
python -m SimpleHTTPServer 8888
# python3
python3 -m http.server 8888
直接在浏览器访问即可。
SimpleHTTPServer有一个特性，如果待共享的目录下有index.html，那么index.html文件会被视为默认主页；如果不存在index.html文件，那么就会显示整个目录列表。
让你晕头转向的 else 用法
if else 用法可以说最基础的语法表达式之一，但是今天不是讲这个的，一定要讲点不一样的。
if else 早已烂大街，但可能有很多人都不曾见过 for else 和 try else 的用法。为什么说它曾让我晕头转向，因为它不像 if else 那么直白，非黑即白，脑子经常要想一下才能才反应过来代码怎么走。反正我是这样的。
先来说说，for else
def check_item(source_list, target):
for item in source_list:
if item == target:
print("Exists!")
break
else:
print("Does not exist")
在往下看之前，你可以思考一下，什么情况下才会走 else。是循环被 break，还是没有break？
给几个例子，你体会一下。
check_item(["apple", "huawei", "oppo"], "oppo")
# Exists!
check_item(["apple", "huawei", "oppo"], "vivo")
# Does not exist
可以看出，没有被 break 的程序才会正常走else流程。
再来看看，try else 用法。
def test_try_else(attr1 = None):
try:
if attr1:
pass
else:
raise
except:
print("Exception occurred...")
else:
print("No Exception occurred...")
同样来几个例子。当不传参数时，就抛出异常。
test_try_else()
# Exception occurred...
test_try_else("ming")
# No Exception occurred...
可以看出，没有 try 里面的代码块没有抛出异常的，会正常走else。
总结一下，for else 和 try else 相同，只要代码正常走下去，不被 break，不抛出异常，就可以走else。
参考：https://mp.weixin.qq.com/s/mNNn7un9npw0cgzOyJhT2Q
dict函数,将键/值对序列，映射为字典
元组：a = [("name","zs"),("age",18)]
转成字典：b = {"name":"zs","age":18}
字典推导式
a = {"name":"zs", "city":"深圳", "age":"18"}
如何互换键和值？得出
b = {"zs":"name", "深圳":"city", "18":"age"}
字典推导式用法看场景，在爬虫里面获取cookies时候时也经常用到
集合推导式
列表推导式，字典推导式，集合推导式，都没毛病，都有的知识点，集合推导式跟列表推导式用法差不多。
字典排序
dic = { "zs":18, "ls":9, "sl":27}
分别排序：
根据数值大小排序：a = { "ls":9, "zs":18, "sl":27} x[1]
根据键字母排序：b = { "ls":9, "sl":27, "zs":18} x[0]
用类写装饰器
https://zhuanlan.zhihu.com/p/44667584
https://mp.weixin.qq.com/s/-ppy1Tp82ax7jcC0vasH0g
空字符串计数
求一个字符串里，某子字符（串）出现的次数。在Python中使用 count() 函数，就可以轻松实现。
比如下面几个常规例子
>>> "aabb".count("a")
2
>>> "aabb".count("b")
2
>>> "aabb".count("ab")
1
但是如果使用空字符串呢，你可能想不到会是这样的结果。
>>> "aabb".count("")
5
具体原因，我不敢妄下结论。
由此我还衍生出另一个想法，实验了下。不知道空字符串，是一种什么样的存在，难道字母与字母之间 “缝隙” 也算吗？
>>> "" in ""
True
>>> "" in "ab"
True
有兴趣的可以去看看CPython的源码实现。如果有结论，还请后台回复一下。不胜感激。
负负得正
从初中开始，我们就开始接触了负数 这个概念。知道了负负得正，这和武侠世界里的以毒功毒，有点神似。
Python 作为一门高级语言，它的编写符合人类的思维逻辑，这其中也包括负负得正这个思想。
>>> 5-3
2
>>> 5--3
8
>>> 5+-3
2
>>> 5++3
8
>>> 5---3
2
数值与字符串比较
在 Python2 中，数字可以与字符串直接比较。结果是数值永远比字符串小。
>>> 100000000 < ""
True
>>> 100000000 < "ming"
True
但在 Python3 中，却不行。
>>> 100000000 < ""
TypeError: '<' not supported between instances of 'int' and 'str'
循环中的局部变量泄露
在Python 2中x的值在一个循环执行之后被改变了。
# Python2
>>> x = 1
>>> [x for x in range(5)]
[0, 1, 2, 3, 4]
>>> x
4
不过在Python3 中这个问题已经得到解决了。
# Python3
>>> x = 1
>>> [x for x in range(5)]
[0, 1, 2, 3, 4]
>>> x
1
让字典可排序
字典不可排序的思想，似乎已经根深蒂固。
# Python2.7.10
>>> mydict = {str(i):i for i in range(5)}
>>> mydict
{'1': 1, '0': 0, '3': 3, '2': 2, '4': 4}
在 Python3 中字典已经是有序的。
# Python3.6.7
>>> mydict = {str(i):i for i in range(5)}
>>> mydict
{'0': 0, '1': 1, '2': 2, '3': 3, '4': 4}