页面导航：
英文教程的下载地址：
本篇文章是根据英文教程《Python Tutorial》来写的学习笔记。该英文教程的下载地址如下：
百度盘地址：
http://pan.baidu.com/s/1c0eXSQG
DropBox地址：
点此进入DropBox链接
Google Drive：
点此进入Google Drive链接
这是学习笔记，不是翻译，因此，有些内容，作者会略过。以下记录主要是根据英文教程的第四章来写的。(文章中的部分链接，可能需要通过代理访问!)
变量的基本概念：
变量其实就是用来存储数据的内存空间，可以在变量中存储各种类型的数据，比如：整数，浮点数(小数)，字符串等。
在Python中，设置变量时，并不需要去明确的声明它所存储的数据类型。当我们给某个变量赋值时，解释器会在内部自动将其设定为对应的类型，例如，下面的例子：
counter = 100 # An integer assignment
miles = 1000.0 # A floating point
name = "John" # A string
print counter
print miles
print name
|
上面的等号(
=)就是赋值运算符，在赋值运算符的左侧是变量名，右侧则是要设置的数据，上面依次将100，1000.0及"John"三个数据设置到counter，miles及name变量中，我们可以将代码保存到testval.py文件里，在命令行下的运行结果如下：
此外，我们还可以在一条语句中，同时为多个变量赋予相同的值：
name = miles = counter = 100 # Multiple assignment
print counter
print miles
print name
|
运行结果如下：
上面是多个变量赋予相同的值的例子，其实，还可以在同一条语句中，为不同的变量赋予不同的值：
counter, miles, name = 100, 1000.0, "John" # Multiple assignment
print counter
print miles
print name
|
运行结果如下(上面会将右侧的三个值，依次赋值给左侧的三个变量)：
在Python中，有以下几种标准的数据类型：
-
Numbers (数字类型)
-
String (字符串类型)
-
List (列表类型)
-
Tuple (元组类型)
-
Dictionary (词典类型)
-
set与frozenset类型
下面就对这些数据类型，依次进行介绍。
数字类型：
Python支持以下四种不同的数字类型：
-
int (signed integers) 有符号的整数类型
-
long 长整数类型
-
float 浮点数
-
complex 复数
int与long都是整数类型，它们的区别在于：int有一个明确的最大值与最小值，而long则没有明确的范围限制，long的范围仅受限于程序可以访问的内存空间的大小，当int类型的变量的值超出范围时，会自动切换到long类型。此外，在python 3.x的版本中，只存在long长整数类型，而不存在int这种受限的整数类型了。
我们可以通过 sys.maxint 或者 sys.maxsize 来查看int类型的最大值：
import sys
print sys.maxsize
print sys.maxint
|
可以将上面的代码保存到testval.py文件中，运行结果如下：
在python 3.x的版本中，sys.maxint已经被移除了。当然，在3.x的版本中，还可以使用sys.maxsize来查看。在32位系统里，int的最大值是2^31-1(即2的31次方减1)，在64位系统中，最大值则是2^63-1(即2的63次方减1)。
我们可以使用long来进行大整数运算：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> test = 51924361L
>>> print type(test)
<type 'long'>
>>> test2 = test * 65535
>>> print type(test2)
<type 'long'>
>>> print test2
3402862998135
>>> quit()
[email protected]:~/Pytest/ch4$
|
通过在数字后面加上
L字符，就表示该数字是long长整数类型(如上面的51924361
L)，可以用type函数来检测变量的类型，例如，上面的type(test)函数所返回的字符串信息
<type 'long'>就说明test变量存储的是long类型的整数，test * 65535得到的结果远超出int类型可以表示的范围，因此，test2就会自动以long类型来保存结果。
float浮点数也是有范围的，其范围与C语言里的double(双精度浮点数)的范围类似，在python里，可以通过
sys.float_info来查看其范围：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)
>>> quit()
[email protected]:~/Pytest/ch4$ |
在使用sys之前，需要先通过
import sys来导入该模块(模块的概念在以后的章节中会介绍)，上面输出显示的
max与
min分别为float浮点数的最大值与最小值。
有关float浮点数在计算机里的概念及原理，可以参考
汇编语言栏目中的"
汇编数据处理 (三) 浮点数"的文章。
在python里，要使用float的话，既可以使用常规的小数格式，也可以使用科学技术法的格式：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> test = 3.14
>>> print test
3.14
>>> test = 3.14e8
>>> print test
314000000.0
>>> test = 3.14E12
>>> print test
3.14e+12
>>> test = 3.14e+12
>>> print test
3.14e+12
>>> test = 3.14e-12
>>> print test
3.14e-12
>>> quit()
[email protected]:~/Pytest/ch4$
|
在Python中，还可以表示复数，有关复数的概念，可以参考
复数-维基百科 该链接对应的文章。
在维基百科中，给出了复数相关的加减乘除的法则，我们可以在Python里对这些运算法则进行测试：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a = (1+2j)
>>> b = (3+4j)
>>> print a+b
(4+6j)
>>> print a-b
(-2-2j)
>>> print a*b
(-5+10j)
>>> print a/b
(0.44+0.08j)
>>> quit()
[email protected]:~/Pytest/ch4$
|
不过，这里需要注意的是：在python里，是使用
j 来表示虚数单位的(电子工程领域一般也都是用
j)，而不是数学公式里的 i 。
字符串类型：
在上一章中，我们介绍过字符串的定义方法，即：可以通过单引号、双引号或三重引号来定义一个字符串。在将字符串设置到变量中后，还可以通过中括号来访问变量里的单个字符或者其中的子字符串，例如下面的例子：
#teststr.py
str = 'Hello-World!'
print str # Prints complete string
print str[0] # Prints first character of the string
print str[-1] # Prints last character of the string
print str[2:5] # Prints characters starting from 3rd to 5th
print str[2:] # Prints string starting from 3rd character
print str[:-2]
print str[:] # Prints complete string
print str * 2 # Prints string two times
print str + "TEST" # Prints concatenated string
|
上面代码里，通过中括号和索引值，可以访问字符串里的单个字符，索引值为0表示第一个字符，为1则表示第二个字符，以此类推。另外，索引值为-1表示最后一个字符，为-2则表示倒数第二个字符，以此类推。因此，上面的str[0]就可以访问到第一个'H'字符，str[-1]则访问的是最后一个'!'字符。
除了可以访问单个字符外，还可以通过冒号来访问其中的子字符串。冒号左侧的数值为子串的起始索引，右侧的数值为子串的结束索引(但最终提取的子串里不会包含结束索引在内)，所以，str[2:5]表示将索引值为2到索引值为4的子字符串给提取出来(但不包括索引值为5的字符)，如果冒号左侧的数值留空的话，则表示起始索引值为0，如果右侧的数值留空的话，则表示从起始索引到最后一个字符都提取出来，如果左右两侧全留空的话，那么就是将整个字符串提取出来。
还可以通过乘法运算符，将字符串以拷贝的形式进行扩展，例如上面的str * 2，得到的结果就会是"Hello-World!Hello-World!"，我们还可以使用加号来连接两个字符串，例如上面的str + "TEST"，得到的结果就会是"Hello-World!TEST"，我们将上面的代码保存到teststr.py文件里，运行结果如下：
[email protected]:~/Pytest/ch4$ python teststr.py
Hello-World!
H
!
llo
llo-World!
Hello-Worl
Hello-World!
Hello-World!Hello-World!
Hello-World!TEST
[email protected]:~/Pytest/ch4$
|
list列表类型：
在Python中，list(列表)的概念类似于C语言里的数组，只不过，列表里存储的元素可以是不同的数据类型，而且，列表的尺寸大小可以动态的改变。下面就是一个列表的例子：
#testlist.py
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print list # Prints complete list
print list[0] # Prints first element of the list
print list[1:3] # Prints elements starting from 2nd till 3rd
print list[2:] # Prints elements starting from 3rd element
print tinylist * 2 # Prints list two times
print list + tinylist # Prints concatenated lists
|
上面的代码是通过中括号来创建的列表，列表里的各个元素通过逗号来隔开。我们可以像访问字符串里的单个字符那样，来访问列表里的某个成员，还可以通过冒号来提取出其中的子列表。其访问方式与字符串的访问方式是一致的。此外，同样可以利用乘法运算符对列表进行拷贝扩展，以及通过加法运算符来连接两个列表。
我们将上面的代码保存到testlist.py文件里，运行结果如下：
[email protected]:~/Pytest/ch4$ python testlist.py
['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123, 'john']
[email protected]:~/Pytest/ch4$
|
tuple元组类型：
tuple元组类似于list列表，也是用于存储多个元素的集合，只不过tuple元组是只读的，它里面的成员是不能被修改的，元组的尺寸大小也不可以改变。创建元组需要使用小括号，如下所示：
#test_tuple.py
tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print tuple # Prints complete list
print tuple[0] # Prints first element of the list
print tuple[1:3] # Prints elements starting from 2nd till 3rd
print tuple[2:] # Prints elements starting from 3rd element
print tinytuple * 2 # Prints list two times
print tuple + tinytuple # Prints concatenated lists
|
可以看到，与之前testlist.py的例子相比，除了创建元组时，是用的小括号外，其他的代码都没什么不同，元组的成员访问方式，与列表的访问方式是一致的。上面代码的运行结果如下：
[email protected]:~/Pytest/ch4$ python test_tuple.py
('abcd', 786, 2.23, 'john', 70.2)
abcd
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.2, 123, 'john')
[email protected]:~/Pytest/ch4$
|
我们可以通过下面的例子，来看出tuple元组与list列表的区别：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> tuple = (123, 456)
>>> list = [123, 456]
>>> tuple[0] = 1000
Traceback (most recent call last):
File "<stdin>", line 1, in
TypeError: 'tuple' object does not support item assignment
>>> list[0] = 1000
>>> print list
[1000, 456]
>>> list.append(789)
>>> print list
[1000, 456, 789]
>>> tuple.append(789)
Traceback (most recent call last):
File "<stdin>", line 1, in
AttributeError: 'tuple' object has no attribute 'append'
>>> quit()
[email protected]:~/Pytest/ch4$
|
上面在python的交互式界面里，将tuple变量设置为了元组，将list变量设置为了列表，当
tuple[0] = 1000语句执行时，抛出了错误信息，说明元组里的成员是只读的，不可以被修改，而list[0] = 1000则可以执行，即列表里的成员是可以被修改的。
此外，list可以通过append方法，在列表后面添加新的成员，即列表的尺寸大小是可以动态改变的，而tuple元组则不存在类似的方法，即元组的尺寸大小是不可以被改变的。
元组的这种只读，不可变的性质，使得元组可以成为后面要介绍的dictionary(词典)里的key，还可以成为后面要介绍的set集合里的成员。
dictionary词典类型：
Python里的词典，类似于PHP语言中的数组，是包含key-value(名值对)的集合，可以通过大括号来创建词典，如下所示：
#test_dict.py
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print dict['one'] # Prints value for 'one' key
print dict[2] # Prints value for 2 key
print tinydict # Prints complete dictionary
print tinydict.keys() # Prints all the keys
print tinydict.values() # Prints all the values
|
上面代码的运行结果如下：
[email protected]:~/Pytest/ch4$ python test_dict.py
This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']
[email protected]:~/Pytest/ch4$
|
当大括号里面为空时，就表示创建一个空的词典，如果是非空的词典，则大括号里的每个key-value(名值对)需要用冒号来隔开，冒号左侧为key(名)，冒号右侧为value(值)，如上面的'name':'john' 。每个名值对之间需要通过逗号来隔开，在访问词典里的成员时，是通过key来访问的，例如上面的dict['one']，dict[2]，或者是tinydict['name']的形式，这里的'one'，2及'name'都是key 。
key-value(名值对)里的value可以是任意的数据类型，但是key对应的数据，则必须是hashable(可计算出哈希值)的数据类型，我们可以通过hash函数来测试哈希值：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> hash(123)
123
>>> hash('name')
15034981
>>> hash((3,4))
1699342716
>>> hash([3,4])
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
>>> dict = {(3,4):'john'}
>>> print dict[(3,4)]
john
>>> dict = {[3,4]:'john'}
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
>>> quit()
[email protected]:~/Pytest/ch4$
|
从上面的交互式输出结果中，可以看到，数字
123，字符串
'name'，以及元组
(3,4)都是可以计算出哈希值来的，但是
[3,4]这个list列表类型则不能计算出对应的哈希值来，在python里，通常只有不可变的数据类型，才可以计算出哈希值，像数字、字符串、元组等。如果是可变的数据类型，如列表类型等，则不能计算出对应的哈希值。
由于词典类型的数据，在python内部，保存的其实是key的哈希值，当需要访问词典里的某个key时，会先计算出该key的哈希值，然后再通过哈希值来找到对应的value ，接着才可以对找到的value进行读写操作。因此，如果某个数据不能计算出哈希值来的话，就不能将该数据作为key 。
如果在创建词典时，大括号中，两个key对应的哈希值是一样的话，那么前一个key的value会被后一个key的value给覆盖掉，如下所示：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> hash(123)
123
>>> hash(123.0)
123
>>> dict = {123:'hello',123.0:'end'}
>>> print dict
{123: 'end'}
>>> print dict.keys()
[123]
>>> print dict.values()
['end']
[email protected]:~/Pytest/ch4$
|
可以看到，123与123.0的哈希值都是123，因此，后面的123.0的值'end'会将之前123的值'hello'给覆盖掉，这样，dict词典里就只会存在一个哈希值为123的key-value(名值对)了，通过哈希值，词典就可以确保其包含的key-value(名值对)的唯一性，即不会有重复的key-value出现，也不会有相同哈希值的key出现。
set与frozenset类型：
大括号除了可以用来创建词典外，还可以用来创建set数据类型，set也是包含多个数据元素的集合，如下所示：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> set = {123, 'john'}
>>> print set
set([123, 'john'])
>>> quit()
[email protected]:~/Pytest/ch4$
|
从上面输出可以看到，当大括号里面包含的不是key-value(名值对)时，则创建的就会是set，set是通过哈希值来存储数据元素的，因此，它里面只能包含hashable(可计算出哈希值)的数据类型，如果是列表之类的不能计算哈希值的数据，则无法添加到set中，如下所示：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> set = {123, [3,4]}
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
>>> set = {123, (3,4)}
>>> print set
set([123, (3, 4)])
>>> quit()
[email protected]:~/Pytest/ch4$
|
上面的输出显示，由于
[3,4]是列表，不能计算其哈希值，因此，它不能作为set的数据元素，而
(3,4)是元组，可以计算出哈希值来，因此，(3,4)可以作为set的数据元素。
此外，由于set是使用哈希值来存储数据元素的，因此，它里面的数据元素都是唯一的，在set里不会有相同哈希值的数据存在，从而确保了set里所包含的数据的唯一性，如下所示：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> set = {123, 'john', 123, 123.0, 'john'}
>>> print set
set([123.0, 'john'])
>>> quit()
[email protected]:~/Pytest/ch4$
|
由于123，123.0具有相同的哈希值，因此，它们会被存储在同一个空间里，并且，在该空间中，后面的值会将前面的值给覆盖掉，因此，set里最后就只有一个123.0，同理，也只会保留一个'john' 。这样通过哈希值，就把重复的数据给剔除掉了。
由于set是利用哈希值来存储数据的，所以，set的数据元素都是无序的，不能像列表那样，通过索引来访问数据，只能通过以后要介绍的迭代方法，或者将set转换成list(列表)，才能访问到其中的指定的数据。
list(列表)与set是可以相互转换的，当我们需要将列表里的数据进行唯一性处理(即去掉重复的数据)时，就可以先将其转换为set，最后再将set转换为列表，如下所示：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> list = [345, 'name', 'hello', 'name', 345, 'zengl', 'zengl']
>>> print list
[345, 'name', 'hello', 'name', 345, 'zengl', 'zengl']
>>> set = __builtins__.set(list)
>>> print set
set([345, 'zengl', 'name', 'hello'])
>>> list = __builtins__.list(set)
>>> print list
[345, 'zengl', 'name', 'hello']
>>> print list[0]
345
>>> print list[1]
zengl
>>> quit()
[email protected]:~/Pytest/ch4$
|
上面先通过内建模块里的set函数，将list列表转为set类型，转换后，在set变量里，就不存在重复的数据了，最后就可以通过list函数，将set再转换为list(列表)类型，这样列表中的数据就是唯一的了，接着，就可以通过索引来访问这些列表数据了。由于在上面的python代码中，使用到了list与set作为变量名，因此为了防止与list和set函数名相冲突，就在set与list函数之前加了一个
__builtins__的内建模块名，如果python代码里没有与函数冲突的变量名的话，可以去掉__builtins__的模块名，如下所示：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> l = [345, 'name', 'hello', 'name', 345, 'zengl', 'zengl']
>>> print l
[345, 'name', 'hello', 'name', 345, 'zengl', 'zengl']
>>> s = set(l)
>>> print s
set([345, 'zengl', 'name', 'hello'])
>>> l = list(s)
>>> print l
[345, 'zengl', 'name', 'hello']
>>> print l[0]
345
>>> print l[1]
zengl
>>> quit()
[email protected]:~/Pytest/ch4$
|
除了set类型外，还有一个frozenset数据类型，frozenset与set的区别在于：frozenset是只读的，不可变的(可以计算出哈希值)，set则是可变的(可以通过add之类的方法来添加数据)，不能计算哈希值，如下所示：
[email protected]:~/Pytest/ch4$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> s = {123, 'john'}
>>> f = frozenset(s)
>>> hash(f)
1398992158
>>> hash(s)
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'set'
>>> quit()
[email protected]:~/Pytest/ch4$
|
上面通过frozenset函数就可以将set转换为frozenset类型，该类型的数据可以通过hash函数得出其哈希值，而set类型的数据则不能计算出其哈希值来。
数据类型转换：
Python中的各个数据类型之间是可以相互转换的，例如，上面提到的list(列表)与set，以及frozenset与set，它们之间都可以通过特定的函数来进行转换，至于其他的数据类型的转换，则可以参考下表中的函数(这些都是内建的模块函数)：
Function
函数 |
Description
描述 |
|
int(x [,base]) |
将参数x转换为int整数类型，如果指定了base参数(base用于指明x是10进制，8进制还是16进制数)，则x必须是一个字符串 |
|
long(x [,base]) |
将参数x转换为long类型的整数，如果指定了base参数，则x必须是一个字符串 |
|
float(x) |
将参数x转换为浮点数 |
|
complex(real [,imag]) |
创建一个以real为实部，imag为虚部的复数 |
|
str(x) |
将参数x转换为字符串 |
|
repr(x) |
将参数x转换为解释器可执行的字符串格式 |
|
eval(str) |
将str字符串当作表达式来进行计算，并将计算的结果返回 |
|
tuple(s) |
将参数s转换为tuple元组 |
|
list(s) |
将参数s转换为list列表类型 |
|
set(s) |
将参数s转换为set类型 |
|
dict(d) |
通过参数d来创建并返回一个词典 |
|
frozenset(s) |
将参数s转换为frozenset类型 |
|
chr(x) |
根据ASCII码，将整数x转换为一个字符 |
|
unichr(x) |
将整数x转换为一个unicode字符 |
|
ord(x) |
返回字符x所对应的ASCII码值 |
|
hex(x) |
将整数x转换为16进制格式的字符串 |
|
oct(x) |
将整数x转换为8进制格式的字符串 |
上表中的这些函数都好理解，这里只对个别函数进行介绍，从上表中可以看到，str(x)与repr(x)都是用于将参数转换为字符串的函数，它们的区别在于：str(x)函数转换出来的是human-readable(人类可读)的字符串，而repr(x)转换出来的是read by the interpreter即可被解释器解析的表达式格式的字符串，如果repr的参数x无法转换为一个有效的表达式格式的字符串的话，repr函数还会抛出语法错误。这两个函数的区别，可以参考下面的例子：
[email protected]:~$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> s = 'hello'
>>> print str(s)
hello
>>> print repr(s)
'hello'
>>> exec('print ' + repr(s))
hello
>>> exec('print ' + str(s))
Traceback (most recent call last):
File "", line 1, in
File "", line 1, in
NameError: name 'hello' is not defined
>>> quit()
[email protected]:~$
|
上面输出显示，str(s)返回的就是原字符串hello，而repr(s)返回的字符串里还会在hello两边加上单引号(有的python版本可能会加上双引号)，这样带引号的
'hello'就可以被解释器解析为字符串。
上面用到了exec函数，该函数的作用是将字符串当作python语句来执行，这样exec('print ' + repr(s))函数里的参数就会是：print
'hello'，这是一个有效的语句，因此，exec函数就可以正确执行该语句。而exec('print ' + str(s))函数里的参数则是：print hello，该语句里的hello因为没有被引号包含起来，因此hello会被当作变量标识符，而hello是一个无效的变量(之前没有语句对其进行过赋值之类的初始化操作)，所以，exec执行该语句时，就会抛出语法错误了。
在前面的函数表格里，有一个eval函数，该函数的作用是将字符串当作表达式来进行计算，并返回计算的结果，它与exec函数的区别在于：eval是一个函数，只能计算表达式，不能执行语句，而exec则是一个python关键字，它可以将字符串当作语句来执行，如下所示：
[email protected]:~$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> eval('1+2')
3
>>> eval('a = 1+2')
Traceback (most recent call last):
File "", line 1, in
File "", line 1
a = 1+2
^
SyntaxError: invalid syntax
>>> eval('print "hello"')
Traceback (most recent call last):
File "", line 1, in
File "", line 1
print "hello"
^
SyntaxError: invalid syntax
>>> exec('a = 1+2')
>>> exec('print "hello"')
hello
>>> exec 'a = 1+2'
>>> exec 'print a'
3
>>> quit()
[email protected]:~$
|
从上面的输出可以看到，eval只能计算'1+2'之类的表达式，它还会返回计算的结果，但是像'a = 1+2'之类的赋值语句，以及'print "hello"'之类的打印语句则无法执行，而exec则可以像解释器一样正确的执行这些赋值打印之类的python语句。另外，虽然exec可以执行语句，但是它的执行速度比eval函数要慢的多，因为它比eval要做更多的解析工作。
有关dict函数的用法，可以参考
https://docs.python.org/2/library/stdtypes.html?highlight=dict#dict 该链接，在该链接里，给出了dict函数创建词典的几种方式：
[email protected]:~$ python
Python 2.7.8 (default, Nov 26 2014, 11:28:30)
[GCC 4.5.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict([('two', 2), ('one', 1), ('three', 3)])
>>> d = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d
True
>>> print a
{'three': 3, 'two': 2, 'one': 1}
>>> print b
{'three': 3, 'two': 2, 'one': 1}
>>> print c
{'three': 3, 'two': 2, 'one': 1}
>>> print d
{'one': 1, 'three': 3, 'two': 2}
>>> quit()
[email protected]:~$
|
上面显示了创建词典的几种方式，可以通过大括号来创建，也可以通过dict函数来创建，使用dict函数创建时，参数可以使用列表加元组的方式，每个元组的第一项作为key，第二项则作为value。此外，由于词典的key是以哈希值的形式进行存储的，因此，词典里的key-value(名值对)都是无序的，在print显示时，哪个key-value排前面，哪个排后面都不影响结果(即上面a，b，c，d比较时都会是相等的)。
其他的函数则请参考python的官方手册。
限于篇幅，本章就到这里。
OK，休息，休息一下 o(∩_∩)o~~