Python3.x和Python2.x的区别

心已赠人 2021-12-17 14:59 409阅读 0赞

**http://www.techug.com/the-difference-of-python2-and-python3\#print**

**===================================================================**

**这个星期开始学习Python了，因为看的书都是基于Python2.x，而且我安装的是Python3.1，所以书上写的地方好多都不适用于Python3.1，特意在Google上search了一下3.x和2.x的区别。特此在自己的空间中记录一下，以备以后查找方便，也可以分享给想学习Python的friends.**

**1.性能**  
Py3.0运行 pystone benchmark的速度比Py2.5慢30%。Guido认为Py3.0有极大的优化空间，在字符串和整形操作上可  
以取得很好的优化结果。  
Py3.1性能比Py2.5慢15%，还有很大的提升空间。  
**2.编码**  
Py3.X源码文件默认使用utf-8编码，这就使得以下代码是合法的：  
>>> 中国 = 'china'  
>>>print(中国)  
china  
**3. 语法**  
1）去除了<>，全部改用!=  
2）去除\`\`，全部改用repr()  
3）关键词加入as 和with，还有True,False,None  
4）整型除法返回浮点数，要得到整型结果，请使用//  
5）加入nonlocal语句。使用noclocal x可以直接指派外围（非全局）变量  
6）去除print语句，加入print()函数实现相同的功能。同样的还有 exec语句，已经改为exec()函数  
例如：  
2.X: print "The answer is", 2\*2  
3.X: print("The answer is", 2\*2)  
2.X: print x, \# 使用逗号结尾禁止换行  
3.X: print(x, end=" ") \# 使用空格代替换行  
2.X: print \# 输出新行  
3.X: print() \# 输出新行  
2.X: print >>sys.stderr, "fatal error"  
3.X: print("fatal error", file=sys.stderr)  
2.X: print (x, y) \# 输出repr((x, y))  
3.X: print((x, y)) \# 不同于print(x, y)!  
7）改变了顺序操作符的行为，例如x<y，当x和y类型不匹配时抛出TypeError而不是返回随即的 bool值   
8）输入函数改变了，删除了raw\_input，用input代替：  
2.X:guess = int(raw\_input('Enter an integer : ')) \# 读取键盘输入的方法  
3.X:guess = int(input('Enter an integer : '))

9）去除元组参数解包。不能def(a, (b, c)):pass这样定义函数了  
10）新式的8进制字变量，相应地修改了oct()函数。  
2.X的方式如下：  
>>> 0666  
438  
>>> oct(438)  
'0666'  
3.X这样：  
>>> 0666  
SyntaxError: invalid token (<pyshell\#63>, line 1)  
>>> 0o666  
438  
>>> oct(438)  
'0o666'  
11）增加了 2进制字面量和bin()函数  
>>> bin(438)  
'0b110110110'  
>>> \_438 = '0b110110110'  
>>> \_438  
'0b110110110'  
12）扩展的可迭代解包。在Py3.X 里，a, b, \*rest = seq和 \*rest, a = seq都是合法的，只要求两点：rest是list  
对象和seq是可迭代的。  
13）新的super()，可以不再给super()传参数，  
>>> class C(object):  
def \_\_init\_\_(self, a):  
print('C', a)  
>>> class D(C):  
def \_\_init(self, a):  
super().\_\_init\_\_(a) \# 无参数调用super()  
>>> D(8)  
C 8  
<\_\_main\_\_.D object at 0x00D7ED90>  
14）新的metaclass语法：  
class Foo(\*bases, \*\*kwds):  
pass  
15）支持class decorator。用法与函数decorator一样：  
>>> def foo(cls\_a):  
def print\_func(self):  
print('Hello, world!')  
cls\_a.print = print\_func  
return cls\_a  
>>> @foo  
class C(object):  
pass  
>>> C().print()  
Hello, world!  
class decorator可以用来玩玩狸猫换太子的大把戏。更多请参阅PEP 3129  
**4. 字符串和字节串**  
1）现在字符串只有str一种类型，但它跟2.x版本的unicode几乎一样。

2）关于字节串，请参阅“数据类型”的第2条目  
**5.数据类型**  
1）Py3.X去除了long类型，现在只有一种整型——int，但它的行为就像2.X版本的long  
2）新增了bytes类型，对应于2.X版本的八位串，定义一个bytes字面量的方法如下：  
>>> b = b'china'  
>>> type(b)  
<type 'bytes'>  
str对象和bytes对象可以使用.encode() (str -> bytes) or .decode() (bytes -> str)方法相互转化。  
>>> s = b.decode()  
>>> s  
'china'  
>>> b1 = s.encode()  
>>> b1  
b'china'  
3）dict的.keys()、.items 和.values()方法返回迭代器，而之前的iterkeys()等函数都被废弃。同时去掉的还有  
dict.has\_key()，用 in替代它吧  
**6.面向对象**  
1）引入抽象基类（Abstraact Base Classes，ABCs）。  
2）容器类和迭代器类被ABCs化，所以cellections模块里的类型比Py2.5多了很多。  
>>> import collections  
>>> print('\\n'.join(dir(collections)))  
Callable  
Container  
Hashable  
ItemsView  
Iterable  
Iterator  
KeysView  
Mapping  
MappingView  
MutableMapping  
MutableSequence  
MutableSet  
NamedTuple  
Sequence  
Set  
Sized  
ValuesView  
\_\_all\_\_  
\_\_builtins\_\_  
\_\_doc\_\_  
\_\_file\_\_  
\_\_name\_\_  
\_abcoll  
\_itemgetter  
\_sys  
defaultdict  
deque  
另外，数值类型也被ABCs化。关于这两点，请参阅 PEP 3119和PEP 3141。  
3）迭代器的next()方法改名为\_\_next\_\_()，并增加内置函数next()，用以调用迭代器的\_\_next\_\_()方法  
4）增加了@abstractmethod和 @abstractproperty两个 decorator，编写抽象方法（属性）更加方便。  
**7.异常**  
1）所以异常都从 BaseException继承，并删除了StardardError  
2）去除了异常类的序列行为和.message属性  
3）用 raise Exception(args)代替 raise Exception, args语法  
4）捕获异常的语法改变，引入了as关键字来标识异常实例，在Py2.5中：  
>>> try:  
... raise NotImplementedError('Error')  
... except NotImplementedError, error:

... print error.message  
...  
Error  
在Py3.0中：  
>>> try:  
raise NotImplementedError('Error')  
except NotImplementedError as error: \#注意这个 as  
print(str(error))  
Error  
5）异常链，因为\_\_context\_\_在3.0a1版本中没有实现  
**8.模块变动**  
1）移除了cPickle模块，可以使用pickle模块代替。最终我们将会有一个透明高效的模块。  
2）移除了imageop模块  
3）移除了 audiodev, Bastion, bsddb185, exceptions, linuxaudiodev, md5, MimeWriter, mimify, popen2,   
rexec, sets, sha, stringold, strop, sunaudiodev, timing和xmllib模块  
4）移除了bsddb模块(单独发布，可以从[http://www.jcea.es/programacion/pybsddb.htm][http_www.jcea.es_programacion_pybsddb.htm]获取)  
5）移除了new模块  
6）os.tmpnam()和os.tmpfile()函数被移动到tmpfile模块下  
7）tokenize模块现在使用bytes工作。主要的入口点不再是generate\_tokens，而是 tokenize.tokenize()  
**9.其它**  
1）xrange() 改名为range()，要想使用range()获得一个list，必须显式调用：  
>>> list(range(10))  
\[0, 1, 2, 3, 4, 5, 6, 7, 8, 9\]  
2）bytes对象不能hash，也不支持 b.lower()、b.strip()和b.split()方法，但对于后两者可以使用 b.strip(b’   
\\n\\t\\r \\f’)和b.split(b’ ‘)来达到相同目的  
3）zip()、map()和filter()都返回迭代器。而apply()、 callable()、coerce()、 execfile()、reduce()和reload  
()函数都被去除了

现在可以使用hasattr()来替换 callable(). hasattr()的语法如：hasattr(string, '\_\_name\_\_')

4）string.letters和相关的.lowercase和.uppercase被去除，请改用string.ascii\_letters 等  
5）如果x < y的不能比较，抛出TypeError异常。2.x版本是返回伪随机布尔值的  
6）\_\_getslice\_\_系列成员被废弃。a\[i:j\]根据上下文转换为a.\_\_getitem\_\_(slice(I, j))或 \_\_setitem\_\_和  
\_\_delitem\_\_调用  
7）file类被废弃，在Py2.5中：  
>>> file  
<type 'file'>  
在Py3.X中：  
>>> file  
Traceback (most recent call last):  
File "<pyshell\#120>", line 1, in <module>  
file  
NameError: name 'file' is not defined

=====================

**Python2.4+ 与 Python3.0+ 主要变化或新增内容**  
  
**Python2** **Python3**  
print是内置命令 print变为函数  
print >> f,x,y print(x,y,file=f)  
print x, print(x,end='')  
reload(M) imp.reload(M)  
apply(f, ps, ks) f(\*ps, \*\*ks)  
x <> y x != y  
long int  
1234L 1234  
d.has\_key(k) k in d 或 d.get(k) != None (has\_key已死, in永生!!)  
raw\_input() input()  
input() eval(input())  
xrange(a,b) range(a,b)  
file() open()  
x.next() x.\_\_next\_\_() 且由next()方法调用  
x.\_\_getslice\_\_() x.\_\_getitem\_\_()  
x.\_\_setsilce\_\_() x.\_\_setitem\_\_()  
\_\_cmp\_\_() 删除了\_\_cmp\_\_(),改用\_\_lt\_\_(),\_\_gt\_\_(),\_\_eq\_\_()等  
reduce() functools.reduce()  
exefile(filename) exec(open(filename).read())  
0567 0o567 (八进制)  
新增nonlocal关键字  
str用于Unicode文本,bytes用于二进制文本  
新的迭代器方法range,map,zip等  
新增集合解析与字典解析  
u'unicodestr' 'unicodestr'  
raise E,V raise E(V)  
except E , x: except E as x:  
file.xreadlines for line in file: (or X = iter(file))  
d.keys(),d.items(),etc list(d.keys()),list(d.items()),list(etc)  
map(),zip(),etc list(map()),list(zip()),list(etc)  
x=d.keys(); x.sort() sorted(d)  
x.\_\_nonzero\_\_() x.\_\_bool\_\_()  
x.\_\_hex\_\_,x.\_\_bin\_\_ x.\_\_index\_\_  
types.ListType list  
\_\_metaclass\_\_ = M class C(metaclass = M):  
\_\_builtin\_\_ builtins  
sys.exc\_type,etc sys.exc\_info()\[0\],sys.exc\_info()\[1\],...  
function.func\_code function.\_\_code\_\_  
增加Keyword-One参数  
增加Ellipse对象  
简化了super()方法语法  
用过-t,-tt控制缩进 混用空格与制表符视为错误  
from M import \*可以 只能出现在文件的顶层  
出现在任何位置.  
class MyException: class MyException(Exception):  
thread,Queue模块 改名\_thread,queue  
cPickle,SocketServer模块 改名\_pickle,socketserver  
ConfigSparser模块 改名configsparser  
Tkinter模块 改名tkinter  
其他模块整合到了如http模块,urllib, urllib2模块等  
os.popen subprocess.Popen  
基于字符串的异常 基于类的异常  
新增类的property机制(类特性)  
未绑定方法 都是函数  
混合类型可比较排序 非数字混合类型比较发生错误  
/是传统除法 取消了传统除法, /变为真除法  
无函数注解 有函数注解 def f(a:100, b:str)->int 使用通过f.\_\_annotation\_\_  
新增环境管理器with/as  
Python3.1支持多个环境管理器项 with A() as a, B() as b  
扩展的序列解包 a, \*b = seq  
统一所有类为新式类  
增强\_\_slot\_\_类属性  
if X: 优先X.\_\_len\_\_() 优先X.\_\_bool\_\_()  
type(I)区分类和类型 不再区分(不再区分新式类与经典类,同时扩展了元类)  
静态方法需要self参数 静态方法根据声明直接使用  
无异常链 有异常链 raise exception from other\_exception

=================================================================

http://chenqx.github.io/2014/11/10/Key-differences-between-Python-2-7-x-and-Python-3-x/

因这学期负责Python课程的助教，刚开始上机试验的几节课，有很多同学用 Python3.4 的编译器编译 Python 2.7 的程序而导致不通过。Python 2.7.x 和 Python 3.x 版本并非完全兼容。  
　　许多 Python 初学者想知道他们应该从 Python 的哪个版本开始学习。对于这个问题我的答案是 “你学习你喜欢的教程的版本，然后检查他们之间的不同。” 但如果你并未了解过两个版本之间的差异，个人推荐使用 Python 2.7.x 版本，毕竟大部分教材等资料还是用Python 2.7.x来写的。  
　　但是如果你开始一个新项目，并且有选择权？我想说的是目前没有对错，只要你计划使用的库 Python 2.7.x 和 Python 3.x 双方都支持的话。尽管如此，当在编写它们中的任何一个的代码，或者是你计划移植你的项目的时候，是非常值得看看这两个主要流行的 Python 版本之间的差别的，以便避免常见的陷阱。  
　　本文翻译自：[《Key differences between Python 2.7.x and Python 3.x》][Key differences between Python 2.7.x and Python 3.x]

## **`__future__`模块** ##

Python 3.x 介绍的 一些Python 2 不兼容的关键字和特性可以通过在 Python 2 的内置`__future__` 模块导入。如果你计划让你的代码支持 Python 3.x，建议你使用`__future__` 模块导入。例如，如果我想要 在Python 2 中表现 Python 3.x 中的整除，我们可以通过如下导入

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>from __future__ <span>import division</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

更多的`__future__` 模块可被导入的特性被列在下表中：

<table style="font:16px/28.8px 'Helvetica Neue', Helvetica, 'Microsoft YaHei', 'WenQuanYi Micro Hei', Arial, sans-serif;border:0px;color:#413f3f;text-transform:none;text-indent:0px;letter-spacing:normal;word-spacing:0px;vertical-align:middle;border-collapse:collapse;border-spacing:0px;"> 
 <thead> 
  <tr> 
   <th><strong>feature</strong></th> 
   <th><strong>optional in</strong></th> 
   <th><strong>mandatory in</strong></th> 
   <th><strong>effect</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>nested_scopes</td> 
   <td>2.1.0b1</td> 
   <td>2.2</td> 
   <td><a href="http://legacy.python.org/dev/peps/pep-0227/" rel="nofollow">PEP 227</a>: Statically Nested Scopes</td> 
  </tr> 
  <tr> 
   <td>generators</td> 
   <td>2.2.0a1</td> 
   <td>2.3</td> 
   <td><a href="http://legacy.python.org/dev/peps/pep-0255/" rel="nofollow">PEP 255</a>: Simple Generators</td> 
  </tr> 
  <tr> 
   <td>division</td> 
   <td>2.2.0a2</td> 
   <td>3.0</td> 
   <td><a href="http://legacy.python.org/dev/peps/pep-0238/" rel="nofollow">PEP 238</a>: Changing the Division Operator</td> 
  </tr> 
  <tr> 
   <td>absolute_import</td> 
   <td>2.5.0a1</td> 
   <td>3.0</td> 
   <td><a href="http://legacy.python.org/dev/peps/pep-0328/" rel="nofollow">PEP 328</a>: Imports: Multi-Line and Absolute/Relative</td> 
  </tr> 
  <tr> 
   <td>with_statement</td> 
   <td>2.5.0a1</td> 
   <td>2.6</td> 
   <td><a href="http://www.python.org/dev/peps/pep-0343" rel="nofollow">PEP 343</a>: The “with” Statement</td> 
  </tr> 
  <tr> 
   <td>print_function</td> 
   <td>2.5.0a2</td> 
   <td>3.0</td> 
   <td><a href="http://legacy.python.org/dev/peps/pep-3105/" rel="nofollow">PEP 3105</a>: Make print a function</td> 
  </tr> 
  <tr> 
   <td>unicode_literals</td> 
   <td>2.5.0a2</td> 
   <td>3.0</td> 
   <td><a href="http://legacy.python.org/dev/peps/pep-3112/" rel="nofollow">PEP 3112</a>: Bytes literals in Python 3000</td> 
  </tr> 
 </tbody> 
</table>

(Source:[https://docs.python.org/2/library/future.html][https_docs.python.org_2_library_future.html])

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>from platform <span>import python_version</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

## **`print`函数** ##

很琐碎，而`print` 语法的变化可能是最广为人知的了，但是仍值得一提的是： Python 2 的 print 声明已经被`print()` 函数取代了，这意味着我们必须包装我们想打印在小括号中的对象。  
Python 2 不具有额外的小括号问题。但对比一下，如果我们按照 Python 2 的方式不使用小括号调用`print` 函数，Python 3 将抛出一个语法异常（`SyntaxError`）。

***Python 2***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div> 
     <span>print <span>'Hello, World!'</span></span> 
    </div> 
    <div>
      print( 
     <span>'Hello, World!')</span> 
    </div> 
    <div> 
     <span>print <span>"text", ; <span>print <span>'print more text on the same line'</span></span></span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.6  
Hello, World!  
Hello, World!  
text print more text on the same line

***Python 3***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div>
      print( 
     <span>'Hello, World!')</span> 
    </div> 
    <div>
      print( 
     <span>"some text,", end=<span>"") </span></span> 
    </div> 
    <div>
      print( 
     <span>' print more text on the same line')</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1  
Hello, World!  
some text, print more text on the same line

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Hello, World!'</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
File ““, line 1  
　　print ‘Hello, World!’  
　　　　　　　　　　^  
SyntaxError: invalid syntax

**Note:**  
　　以上通过 Python 2 使用`Printing "Hello, World"` 是非常正常的，尽管如此，如果你有多个对象在小括号中，我们将创建一个元组，因为`print`在 Python 2 中是一个声明，而不是一个函数调用。

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div>
      print( 
     <span>'a', <span>'b')</span></span> 
    </div> 
    <div> 
     <span>print <span>'a', <span>'b'</span></span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.7  
(‘a’, ‘b’)  
a b

## **整除** ##

如果你正在移植代码，这个变化是特别危险的。或者你在 Python 2 上执行 Python 3 的代码。因为这个整除的变化表现在它会被忽视（即它不会抛出语法异常）。  
　　因此，我还是倾向于使用一个`float(3)/2` 或`3/2.0` 代替在我的 Python 3 脚本保存在 Python 2 中的`3/2` 的一些麻烦（并且反而过来也一样，我建议在你的 Python 2 脚本中使用`from __future__ import division`）  
　　  
***Python 2***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div> 
     <span>print <span>'3 / 2 =', <span>3 / <span>2</span></span></span></span> 
    </div> 
    <div> 
     <span>print <span>'3 // 2 =', <span>3 // <span>2</span></span></span></span> 
    </div> 
    <div> 
     <span>print <span>'3 / 2.0 =', <span>3 / <span>2.0</span></span></span></span> 
    </div> 
    <div> 
     <span>print <span>'3 // 2.0 =', <span>3 // <span>2.0</span></span></span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.6  
3 / 2 = 1  
3 // 2 = 1  
3 / 2.0 = 1.5  
3 // 2.0 = 1.0

***Python 3***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div>
      print( 
     <span>'3 / 2 =', <span>3 / <span>2)</span></span></span> 
    </div> 
    <div>
      print( 
     <span>'3 // 2 =', <span>3 // <span>2)</span></span></span> 
    </div> 
    <div>
      print( 
     <span>'3 / 2.0 =', <span>3 / <span>2.0)</span></span></span> 
    </div> 
    <div>
      print( 
     <span>'3 // 2.0 =', <span>3 // <span>2.0)</span></span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1  
3 / 2 = 1.5  
3 // 2 = 1  
3 / 2.0 = 1.5  
3 // 2.0 = 1.0

## **`Unicode`** ##

Python 2 有 ASCII str() 类型，`unicode()` 是单独的，不是`byte` 类型。  
　　现在， 在 Python 3，我们最终有了`Unicode (utf-8)` 字符串，以及一个字节类：`byte` 和`bytearrays`。

***Python 2***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.6

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>print type(unicode(<span>'this is like a python3 str type'))</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
< type ‘unicode’ >

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>print type(<span>b'byte type does not exist')</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
< type ‘str’ >

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'they are really' + <span>b' the same'</span></span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
they are really the same

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>print type(bytearray(<span>b'bytearray oddly does exist though'))</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
< type ‘bytearray’ >

***Python 3***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div>
      print( 
     <span>'strings are now utf-8 \u03BCnico\u0394é!')</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1  
strings are now utf-8 μnicoΔé!

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version(), end=<span>"")</span></span> 
    </div> 
    <div>
      print( 
     <span>' has', type(<span>b' bytes for storing data'))</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1 has < class ‘bytes’ >

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'and Python', python_version(), end=<span>"")</span></span> 
    </div> 
    <div>
      print( 
     <span>' also has', type(bytearray(<span>b'bytearrays')))</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
and Python 3.4.1 also has < class ‘bytearray’>

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>'note that we cannot add a string' + <span>b'bytes for data'</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
\-—————————————————————————————————————  
TypeError Traceback (most recent call last)  
< ipython-input-13-d3e8942ccf81> in < module>()  
——> 1 ‘note that we cannot add a string’ + b’bytes for data’

TypeError: Can’t convert ‘bytes’ object to str implicitly

## **`xrange`模块** ##

在 Python 2 中`xrange()` 创建迭代对象的用法是非常流行的。比如：`for` 循环或者是列表/集合/字典推导式。  
　　这个表现十分像生成器（比如。“惰性求值”）。但是这个`xrange-iterable` 是无穷的，意味着你可以无限遍历。  
　　由于它的惰性求值，如果你不得仅仅不遍历它一次，`xrange()` 函数 比`range()` 更快（比如`for` 循环）。尽管如此，对比迭代一次，不建议你重复迭代多次，因为生成器每次都从头开始。  
　　在 Python 3 中，`range()` 是像`xrange()` 那样实现以至于一个专门的`xrange()` 函数都不再存在（在 Python 3 中`xrange()` 会抛出命名异常）。

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> </td> 
   <td> 
    <div> 
     <span>import timeit</span> 
    </div> 
    <div>
      n = 
     <span>10000</span> 
    </div> 
    <div> 
     <span><span>def <span>test_range<span>(n):</span></span></span></span> 
    </div> 
    <div> 
     <span>return <span>for i <span>in range(n):</span></span></span> 
    </div> 
    <div> 
     <span>pass</span> 
    </div> 
    <div> 
     <span><span>def <span>test_xrange<span>(n):</span></span></span></span> 
    </div> 
    <div> 
     <span>for i <span>in xrange(n):</span></span> 
    </div> 
    <div> 
     <span>pass</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

***Python 2***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div> 
     <span>print <span>'\ntiming range()'</span></span> 
    </div> 
    <div>
      %timeit test_range(n) 
    </div> 
    <div> 
     <span>print <span>'\n\ntiming xrange()'</span></span> 
    </div> 
    <div>
      %timeit test_xrange(n) 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.6

timing range()  
1000 loops, best of 3: 433 µs per loop

timing xrange()  
1000 loops, best of 3: 350 µs per loop

***Python 3***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div>
      print( 
     <span>'\ntiming range()')</span> 
    </div> 
    <div>
      %timeit test_range(n) 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1

timing range()  
1000 loops, best of 3: 520 µs per loop

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div>
      print(xrange( 
     <span>10))</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
\-—————————————————————————————————————  
NameError Traceback (most recent call last)

in ()  
——> 1 print(xrange(10))

NameError: name ‘xrange’ is not defined

## **Python3中的`range`对象的`__contains__`方法** ##

另外一件值得一提的事情就是在 Python 3 中`range` 有一个新的`__contains__` 方法（感谢 Yuchen Ying 指出了这个），`__contains__` 方法可以加速 “查找” 在 Python 3.x 中显著的整数和布尔类型。

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> 
    <div>
      10 
    </div> </td> 
   <td> 
    <div>
      x = 
     <span>10000000</span> 
    </div> 
    <div> 
     <span><span>def <span>val_in_range<span>(x, val):</span></span></span></span> 
    </div> 
    <div> 
     <span>return val <span>in range(x)</span></span> 
    </div> 
    <div> 
     <span><span>def <span>val_in_xrange<span>(x, val):</span></span></span></span> 
    </div> 
    <div> 
     <span>return val <span>in xrange(x)</span></span> 
    </div> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div> 
     <span>assert(val_in_range(x, x/<span>2) == <span>True)</span></span></span> 
    </div> 
    <div> 
     <span>assert(val_in_range(x, x//<span>2) == <span>True)</span></span></span> 
    </div> 
    <div>
      %timeit val_in_range(x, x/ 
     <span>2)</span> 
    </div> 
    <div>
      %timeit val_in_range(x, x// 
     <span>2)</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1  
1 loops, best of 3: 742 ms per loop  
1000000 loops, best of 3: 1.19 µs per loop  
　　  
　　基于以上的 timeit 的结果，当它使一个整数类型，而不是浮点类型的时候，你可以看到执行查找的速度是 60000 倍快。尽管如此，因为 Python 2.x 的`range` 或者是`xrange` 没有一个`__contains__` 方法，这个整数类型或者是浮点类型的查询速度不会相差太大。

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> 
    <div>
      6 
    </div> 
    <div>
      7 
    </div> 
    <div>
      8 
    </div> 
    <div>
      9 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div> 
     <span>assert(val_in_xrange(x, x/<span>2.0) == <span>True)</span></span></span> 
    </div> 
    <div> 
     <span>assert(val_in_xrange(x, x/<span>2) == <span>True)</span></span></span> 
    </div> 
    <div> 
     <span>assert(val_in_range(x, x/<span>2) == <span>True)</span></span></span> 
    </div> 
    <div> 
     <span>assert(val_in_range(x, x//<span>2) == <span>True)</span></span></span> 
    </div> 
    <div>
      %timeit val_in_xrange(x, x/ 
     <span>2.0)</span> 
    </div> 
    <div>
      %timeit val_in_xrange(x, x/ 
     <span>2)</span> 
    </div> 
    <div>
      %timeit val_in_range(x, x/ 
     <span>2.0)</span> 
    </div> 
    <div>
      %timeit val_in_range(x, x/ 
     <span>2)</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.7  
1 loops, best of 3: 285 ms per loop  
1 loops, best of 3: 179 ms per loop  
1 loops, best of 3: 658 ms per loop  
1 loops, best of 3: 556 ms per loop  
　　  
　　下面说下`__contain__`方法并没有加入到 Python 2.x 中的证据：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div>
      range.__contains__ 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1

< slot wrapper ‘**contains**‘ of ‘range’ objects >

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div>
      range.__contains__ 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.7

\-—————————————————————————————————————  
AttributeError Traceback (most recent call last)  
< ipython-input-7-05327350dafb> in < module>()  
1 print ‘Python’, python*version()  
——> 2 range.\`\_contains*\`

AttributeError: ‘builtin*functionor\_method’ object has no attribute \`’\_\_contains*‘\`

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div>
      xrange.__contains__ 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.7

\-—————————————————————————————————————  
AttributeError Traceback (most recent call last)  
< ipython-input-8-7d1a71bfee8e> in < module>()  
1 print ‘Python’, python*version()  
——> 2 xrange.\`\_contains*\`

AttributeError: type object ‘xrange’ has no attribute`'__contains__'`

**注意在 Python 2 和 Python 3 中速度的不同**  
　　有些人指出了 Python 3 的`range()` 和 Python 2 的`xrange()` 之间的速度不同。因为他们是用相同的方法实现的，因此期望相同的速度。尽管如此，这事实在于 Python 3 倾向于比 Python 2 运行的慢一点。

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> </td> 
   <td> 
    <div> 
     <span><span>def <span>test_while<span>():</span></span></span></span> 
    </div> 
    <div>
      i = 
     <span>0</span> 
    </div> 
    <div> 
     <span>while i &lt; <span>20000:</span></span> 
    </div> 
    <div>
      i += 
     <span>1</span> 
    </div> 
    <div> 
     <span>return</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

***Python 3***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div>
      %timeit test_while() 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1  
100 loops, best of 3: 2.68 ms per loop

***Python 2***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div>
      %timeit test_while() 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.6  
1000 loops, best of 3: 1.72 ms per loop

## **Raising exceptions** ##

Python 2 接受新旧两种语法标记，在 Python 3 中如果我不用小括号把异常参数括起来就会阻塞（并且反过来引发一个语法异常）。

***Python 2***

*run result:*  
Python 2.7.6

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>raise IOError, <span>"file error"</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*

\-—————————————————————————————————————  
IOError Traceback (most recent call last)  
< ipython-input-8-25f049caebb0> in < module>()  
——> 1 raise IOError, “file error”

IOError: file error

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>raise IOError(<span>"file error")</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
\-—————————————————————————————————————  
IOError Traceback (most recent call last)  
< ipython-input-9-6f1c43f525b2> in < module>()  
——> 1 raise IOError(“file error”)

IOError: file error

***Python 3***

*run result:*  
Python 3.4.1

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div> 
     <span>raise IOError, <span>"file error"</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*

File ““, line 1  
raise IOError, “file error”  
　　　　　　^  
SyntaxError: invalid syntax  
　　  
　　在 Python 3 中，可以这样抛出异常：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div> 
     <span>raise IOError(<span>"file error")</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1

\-—————————————————————————————————————  
OSError Traceback (most recent call last)  
< ipython-input-11-c350544d15da> in < module>()  
1 print(‘Python’, python\_version())  
——> 2 raise IOError(“file error”)

OSError: file error

## **Handling exceptions** ##

在 Python 3 中处理异常也轻微的改变了，在 Python 3 中我们现在使用`as` 作为关键词。

***Python 2***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div> 
     <span>try:</span> 
    </div> 
    <div>
      let_us_cause_a_NameError 
    </div> 
    <div> 
     <span>except NameError, err:</span> 
    </div> 
    <div> 
     <span>print err, <span>'--&gt; our error message'</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.6  
name ‘let\_us\_cause\_a\_NameError’ is not defined —> our error message

***Python 3***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div> 
     <span>try:</span> 
    </div> 
    <div>
      let_us_cause_a_NameError 
    </div> 
    <div> 
     <span>except NameError <span>as err:</span></span> 
    </div> 
    <div>
      print(err, 
     <span>'--&gt; our error message')</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*

Python 3.4.1  
name ‘let\_us\_cause\_a\_NameError’ is not defined —> our error message

## **`next()`函数 and`.next()`方法** ##

因为`next() (.next())` 是一个如此普通的使用函数（方法），这里有另外一个语法改变（或者是实现上改变了），值得一提的是：在 Python 2.7.5 中函数和方法你都可以使用，`next()` 函数在 Python 3 中一直保留着（调用`.next()` 抛出属性异常）。

***Python 2***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div>
      my_generator = (letter 
     <span>for letter <span>in <span>'abcdefg')</span></span></span> 
    </div> 
    <div>
      next(my_generator) 
    </div> 
    <div>
      my_generator.next() 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.6

‘b

***Python 3***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div>
      my_generator = (letter 
     <span>for letter <span>in <span>'abcdefg')</span></span></span> 
    </div> 
    <div>
      next(my_generator) 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1

‘a’

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> </td> 
   <td> 
    <div>
      my_generator.next() 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
\-—————————————————————————————————————  
AttributeError Traceback (most recent call last)  
< ipython-input-14-125f388bb61b> in < module>()  
——> 1 my\_generator.next()

AttributeError: ‘generator’ object has no attribute ‘next’

## **`For`循环变量和全局命名空间泄漏** ##

好消息：在 Python 3.x 中`for` 循环变量不会再导致命名空间泄漏。  
　　在 Python 3.x 中做了一个改变，在 What’s New In Python 3.0 中有如下描述：  
　　“列表推导不再支持`[... for var in item1, item2, ...]` 这样的语法。使用`[... for var in (item1, item2, ...)]` 代替。也需要提醒的是列表推导有不同的语义： 他们关闭了在`list()` 构造器中的生成器表达式的语法糖, 并且特别是循环控制变量不再泄漏进周围的作用范围域.”

***Python 2***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div>
      i = 
     <span>1</span> 
    </div> 
    <div> 
     <span>print <span>'before: i =', i</span></span> 
    </div> 
    <div> 
     <span>print <span>'comprehension: ', [i <span>for i <span>in range(<span>5)]</span></span></span></span></span> 
    </div> 
    <div> 
     <span>print <span>'after: i =', i</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.6  
before: i = 1  
comprehension: \[0, 1, 2, 3, 4\]  
after: i = 4

***Python 3***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> 
    <div>
      5 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div>
      i = 
     <span>1</span> 
    </div> 
    <div>
      print( 
     <span>'before: i =', i)</span> 
    </div> 
    <div>
      print( 
     <span>'comprehension:', [i <span>for i <span>in range(<span>5)])</span></span></span></span> 
    </div> 
    <div>
      print( 
     <span>'after: i =', i)</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1  
before: i = 1  
comprehension: \[0, 1, 2, 3, 4\]  
after: i = 1

## **比较不可排序类型** ##

在 Python 3 中的另外一个变化就是当对不可排序类型做比较的时候，会抛出一个类型错误。

***Python 2***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version()</span></span> 
    </div> 
    <div> 
     <span>print <span>"[1, 2] &gt; 'foo' = ", [<span>1, <span>2] &gt; <span>'foo'</span></span></span></span></span> 
    </div> 
    <div> 
     <span>print <span>"(1, 2) &gt; 'foo' = ", (<span>1, <span>2) &gt; <span>'foo'</span></span></span></span></span> 
    </div> 
    <div> 
     <span>print <span>"[1, 2] &gt; (1, 2) = ", [<span>1, <span>2] &gt; (<span>1, <span>2)</span></span></span></span></span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.6  
\[1, 2\] > ‘foo’ = False  
(1, 2) > ‘foo’ = True  
\[1, 2\] > (1, 2) = False

***Python 3***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div>
      print( 
     <span>"[1, 2] &gt; 'foo' = ", [<span>1, <span>2] &gt; <span>'foo')</span></span></span></span> 
    </div> 
    <div>
      print( 
     <span>"(1, 2) &gt; 'foo' = ", (<span>1, <span>2) &gt; <span>'foo')</span></span></span></span> 
    </div> 
    <div>
      print( 
     <span>"[1, 2] &gt; (1, 2) = ", [<span>1, <span>2] &gt; (<span>1, <span>2))</span></span></span></span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1

\-—————————————————————————————————————  
TypeError Traceback (most recent call last)  
< ipython-input-16-a9031729f4a0> in < module>()  
1 print(‘Python’, python\_version())  
——> 2 print(“\[1, 2\] > ‘foo’ = “, \[1, 2\] > ‘foo’)  
3 print(“(1, 2) > ‘foo’ = “, (1, 2) > ‘foo’)  
4 print(“\[1, 2\] > (1, 2) = “, \[1, 2\] > (1, 2))

TypeError: unorderable types: list() > str()

## **通过`input()`解析用户的输入** ##

幸运的是，在 Python 3 中已经解决了把用户的输入存储为一个`str` 对象的问题。为了避免在 Python 2 中的读取非字符串类型的危险行为，我们不得不使用`raw_input()` 代替。

***Python 2***  
Python 2.7.6  
\[GCC 4.0.1 (Apple Inc. build 5493)\] on darwin  
Type “help”, “copyright”, “credits” or “license” for more information.

>>> my_input = input('enter a number: ')
     enter a number: 123 >>> type(my_input) <type 'int'> >>> my_input = raw_input('enter a number: ') enter a number: 123 >>> type(my_input) <type 'str'>

***Python 3***  
Python 3.4.1  
\[GCC 4.2.1 (Apple Inc. build 5577)\] on darwin  
Type “help”, “copyright”, “credits” or “license” for more information.

>>> my_input = input('enter a number: ')
     enter a number: 123 >>> type(my_input) <class 'str'>

## **返回可迭代对象，而不是列表** ##

如果在 xrange 章节看到的，现在在 Python 3 中一些方法和函数返回迭代对象 — 代替 Python 2 中的列表  
　　因为我们通常那些遍历只有一次，我认为这个改变对节约内存很有意义。尽管如此，它也是可能的，相对于生成器 —- 如需要遍历多次。它是不那么高效的。  
　　而对于那些情况下，我们真正需要的是列表对象，我们可以通过`list()` 函数简单的把迭代对象转换成一个列表。

***Python 2***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> </td> 
   <td> 
    <div> 
     <span>print <span>'Python', python_version() </span></span> 
    </div> 
    <div> 
     <span>print range(<span>3) </span></span> 
    </div> 
    <div> 
     <span>print type(range(<span>3))</span></span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 2.7.6  
\[0, 1, 2\]  
< type ‘list’>

***Python 3***

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      1 
    </div> 
    <div>
      2 
    </div> 
    <div>
      3 
    </div> 
    <div>
      4 
    </div> </td> 
   <td> 
    <div>
      print( 
     <span>'Python', python_version())</span> 
    </div> 
    <div>
      print(range( 
     <span>3))</span> 
    </div> 
    <div>
      print(type(range( 
     <span>3)))</span> 
    </div> 
    <div>
      print(list(range( 
     <span>3)))</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*run result:*  
Python 3.4.1  
range(0, 3)  
< class ‘range’>  
\[0, 1, 2\]  
　　  
　　在 Python 3 中一些经常使用到的不再返回列表的函数和方法：

*  `zip()`
 *  `map()`
 *  `filter()`
 *  dictionary’s`.keys()` method
 *  dictionary’s`.values()` method
 *  dictionary’s`.items()` method

## **更多的关于 Python 2 和 Python 3 的文章** ##

下面是我建议后续的关于 Python 2 和 Python 3 的一些好文章。

**移植到 Python 3**

*  [Should I use Python 2 or Python 3 for my development activity?][Should I use Python 2 or Python 3 for my development activity]
 *  [What’s New In Python 3.0][What_s New In Python 3.0]
 *  [Porting to Python 3][]
 *  [Porting Python 2 Code to Python 3][]
 *  [How keep Python 3 moving forward][]

**Python 3 的拥护者和反对者**

*  [10 awesome features of Python that you can’t use because you refuse to upgrade to Python 3][10 awesome features of Python that you can_t use because you refuse to upgrade to Python 3]
 *  [Everything you did not want to know about Unicode in Python 3][]
 *  [Python 3 is killing Python][]
 *  [Python 3 can revive Python][]
 *  [Python 3 is fine][]

转载于:https://www.cnblogs.com/kungfupanda/p/5548303.html

[http_www.jcea.es_programacion_pybsddb.htm]: http://www.jcea.es/programacion/pybsddb.htm
[Key differences between Python 2.7.x and Python 3.x]: http://nbviewer.ipython.org/github/rasbt/python_reference/blob/master/tutorials/key_differences_between_python_2_and_3.ipynb?create=1
[https_docs.python.org_2_library_future.html]: https://docs.python.org/2/library/future.html
[Should I use Python 2 or Python 3 for my development activity]: https://wiki.python.org/moin/Python2orPython3
[What_s New In Python 3.0]: https://docs.python.org/3.0/whatsnew/3.0.html
[Porting to Python 3]: http://python3porting.com/differences.html
[Porting Python 2 Code to Python 3]: https://docs.python.org/3/howto/pyporting.html
[How keep Python 3 moving forward]: http://nothingbutsnark.svbtle.com/my-view-on-the-current-state-of-python-3
[10 awesome features of Python that you can_t use because you refuse to upgrade to Python 3]: http://asmeurer.github.io/python3-presentation/slides.html#1
[Everything you did not want to know about Unicode in Python 3]: http://lucumr.pocoo.org/2014/5/12/everything-about-unicode/
[Python 3 is killing Python]: https://medium.com/@deliciousrobots/5d2ad703365dverything-about-unicode/
[Python 3 can revive Python]: https://medium.com/@opinionbreaker/python-3-can-revive-python-2a7af4788b10
[Python 3 is fine]: http://sealedabstract.com/rants/python-3-is-fine/