2.1 Python变量类型
Python的标准数据类型只有5个，分别是数字、字符串、列表、元祖、字典。看起来比C语言的数据类型少了很多，但该有的功能一个不少。即使C语言的代表作链表和二叉树，Python同样能应付自如。
2.1.1 数字
Python支持4种不同的数值类型：
1. int类型
有符号整数，就是C语言中所指的整型，也就是数学中的整数。它的大小与安装的解释器的位数有关。如果赋值超出了这个范围，则自动转换成了Long长整型。查看当前系统下的Int最大值，使用Putty登录Linux，执行命令：
python
import sys
print sys.maxint
执行结果，如图2-1所示。
图2-1 求int最大值
与C语言不同的是，Python给变量赋值时不需要预先声明变量类型。也就是说，在给变量赋值时小于9223372036854775807的数字会被默认为int类型。超过了，则自动变成Long类型。
另外，八进制数字、十六进制数字都是属于int（Long）类型的。
2. Long类型
长整数，超过int类型的整数默认转换Long，一般来说int足够用了。Long类型没有限制大小，想赋值多大都行，只要内存足够大就可以了。在Windows中打开cmd.exe，执行命令：
python
type(999999999999999999999999999999)
执行结果如图2-2所示。
图2-2 Python long int
3. Float类型
浮点型实数，基本和C语言的浮点型一致，也就是数学中带小数点的数，不包括无限小数，不区分精度。只要是带小数点的数都可以看作浮点型数据。
4. Complex类型
复数，在C语言中是需要自定义的一个数据类型。在Python中把它单独列出作为基本数据类型。复数包含一个有序对，表示为a + bj，其中，a是实部，b是复数的虚部。
【示例2-1】用一个简单的程序showNumType.py来显示Python的数字类型。使用Putty连接到Linux，执行命令：
mkdir -pv code/crawler
cd ! $
vi showNumType.py
showNumType.py代码如下：
1 #! /usr/bin/env python
2 #-＊- coding: utf-8-＊-
3 __author__ = 'hstking hstking@hotmail.com'
4
5 class ShowNumType(object):
6 def __init__(self):
7 self.showInt()
8 self.showLong()
9 self.showFloat()
10 self.showComplex()
11
12 def showInt(self):
13 print(u"##########显示整型#############")
14 print(u"十进制的整型")
15 print("%-20d, %-20d, %-20d" %(-10000,0,10000))
16 print(u"二进制的整型")
17 print("%-20s, %-20s, %-20s" %(bin(-10000), bin(0), bin(10000)))
18 print(u"八进制的整型")
19 print("%-20s, %-20s, %-20s" %(oct(-10000), oct(0), oct(10000)))
20 print(u"十六进制的整型")
21 print("%-20s, %-20s, %-20s" %(hex(-10000), hex(0), hex(10000)))
22
23 def showLong(self):
24 print(u"##########显示长整型#############")
25 print(u"十进制的整型")
26 print("%-20Ld, %-20Ld, %-20Ld" %(-
10000000000000000000,0,10000000000000000000))
27 print(u"八进制的整型")
28 print("%-20s, %-20s, %-20s" %(oct(-
10000000000000000000), oct(0), oct(10000000000000000000)))
29 print(u"十六进制的整型")
30 print("%-20s, %-20s, %-20s" %(hex(-
10000000000000000000), hex(0), hex(10000000000000000000)))
31
32 def showFloat(self):
33 print(u"##########显示浮点型#############")
34 print("%-20.10f, %-20.10f, %-20.10f" %(-100.001,0,100.001))
35
36 def showComplex(self):
37 print(u"##########显示复数型#############")
38 print(u"变量赋值复数var = 3 + 4j")
39 var = 3 + 4j
40 print(u"var的实部是：%d\tvar的虚部是：%d" %(var.real, var.imag))
41
42
43 if __name__ == '__main__':
44 showNum = ShowNumType()
在Putty下执行命令：
python showNumType.py
得到结果如图2-3所示。
图2-3 run showNumType.py
showNumType.py是Linux下以C++风格写的程序，展示如何标准输出各种基本数字类型。
2.1.2 字符串
在Python中，字符串是被定义为在引号（或双引号）之间的一组连续的字符。这个字符可以是键盘上的所有可见字符，也可以是不可见的如“回车符”“制表符”等等。
字符串的操作方法很多，这里只选出最典型的几种。
（1）字符串大小写转换
● S.lower() ：字母大写转换成小写。
● S.upper() ：字母小写转换成大写。
● S.swapcase()：字母大写转换小写，小写转换成大写。
● S.title()：将首字母大写。
（2）字符串搜索、替换
● S.find(substr, [start, [end]])：返回S中出现substr的第一个字母的标号，如果S中没有substr则返回-1, start和end作用就相当于在S[start:end]中搜索。
● S.count(substr, [start, [end]]) ：计算substr在S中出现的次数。
● S.replace(oldstr, newstr, [count])：把S中的oldstar替换为newstr, count为替换次数。
● S.strip([chars])：把S左右两端chars中有的字符全部去掉，一般用于去除空格。
● S.lstrip([chars])：把S左端chars中所有的字符全部去掉。
● S.strip([chars])：把S左端chars中所有的字符全部去掉。
（3）字符串分割、组合
● S.split([sep, [maxsplit]])：以sep为分隔符，把S分成一个list。maxsplit表示分割的次数，默认的分割符为空白字符。
● S.join(seq)：把seq代表的序列— 字符串序列，用S连接起来。
（4）字符串编码、解码
● S.decode([encoding])：将以encoding编码的S解码成unicode编码。
● S.encode([encoding])：将以unicode编码的S编码成encoding, encoding可以是gb2312、gbk、big5……
（5）字符串测试
● S.isalpha():S是否全是字母，至少有一个字符。
● S.isdigit() :S是否全是数字，至少有一个字符。
● S.isspace():S是否全是空白字符，至少有一个字符。
● S.islower():S中的字母是否全是小写。
● S.isupper():S中的字母是否全是大写。
● S.istitle():S是否是首字母大写的。
【示例2-2】编写一个showStrOperation.py来实验一下。这次在Windows下以IDLE为IDE来编写程序。showStrOperation.py代码如下：
#! /usr/bin/env python
#-＊- coding: GBK -＊-
''’因为Windows默认的中文字符编码是GBK，所以…'''
__author__ = 'hstking hstking@hotmail.com'
def strCase():
"字符串大小写转换"
print "演示字符串大小写转换"
print "演示字符串S赋值为：' ThIs is a PYTHON '"
S = ' ThIs is a PYTHON '
print "大写转换成小写：\tS.lower() \t= %s"%(S.lower())
print "小写转换成大写：\tS.upper() \t= %s"%(S.upper())
print "大小写转换：\t\tS.swapcase() \t= %s"%(S.swapcase())
print "首字母大写：\t\tS.title() \t= %s"%(S.title())
print '\n'
def strFind():
"字符串搜索、替换"
print "演示字符串搜索、替换等"
print "演示字符串S赋值为：' ThIs is a PYTHON '"
S = ' ThIs is a PYTHON '
print "字符串搜索：\t\tS.find('is') \t= %s"%(S.find('is'))
print "字符串统计：\t\tS.count('s') \t= %s"%(S.count('s'))
print "字符串替换：\t\tS.replace('Is', 'is') = %s"%(S.replace('Is', 'is'))
print "去左右空格：\t\tS.strip() \t=#%s#"%(S.strip())
print "去左边空格：\t\tS.lstrip() \t=#%s#"%(S.lstrip())
print "去右边空格：\t\tS.rstrip() \t=#%s#"%(S.rstrip())
print '\n'
def strSplit():
"字符串分割、组合"
print "演示字符串分割、组合"
print "演示字符串S赋值为：' ThIs is a PYTHON '"
S = ' ThIs is a PYTHON '
print "字符串分割：\t\tS.split() \t= %s"%(S.split())
print "字符串组合1: '#'.join(['this', 'is', 'a', 'python']) \t=
%s"%('#'.join(['this', 'is', 'a', 'python']))
print "字符串组合2: '$'.join(['this', 'is', 'a', 'python']) \t=
%s"%('$'.join(['this', 'is', 'a', 'python']))
print "字符串组合3: ' '.join(['this', 'is', 'a', 'python']) \t= %s"%('
'.join(['this', 'is', 'a', 'python']))
print '\n'
def strCode():
"字符串编码、解码"
print "演示字符串编码、解码"
print "演示字符串S赋值为：’编码解码测试’"
S = ’编码解码测试’
print "GBK编码的S \t = %s"%(S)
print "GBK编码的S转换unicode编码"
print "S.decode('GBK')= %s"%(S.decode("GBK"))
print "GBK编码的S转换成utf8"
print "S.decode('GBK').encode('utf8') =
%s"%(S.decode("GBK").encode("utf8"))
print "注意：不管是编码还是解码针对的都是unicode字符编码，\n所以要编码或者解码前
必须先将源字符串转换成unicode编码格式"
print '\n'
def strTest():
"字符串测试"
print "演示字符串测试"
print "演示字符串S赋值为：'abcd'"
S1 = 'abcd'
print "测试S.isalpha() = %s"%(S1.isalpha())
print "测试S.isdigit() = %s"%(S1.isdigit())
print "测试S.isspace() = %s"%(S1.isspace())
print "测试S.islower() = %s"%(S1.islower())
print "测试S.isupper() = %s"%(S1.isupper())
print "测试S.istitle() = %s"%(S1.istitle())
if __name__ == '__main__':
strCase()
strFind()
strSplit()
strCode()
strTest()
打开Windows的命令行工具（cmd.exe），执行命令：
python showStrOperation.py
得到结果如图2-4所示。
图2-4 run showStrOperation.py
与showNumType.py不同，showStrOperation.py是在Windows下以C语言的风格编写的。实际上这两个程序并没有什么区别，写哪种风格看个人习惯。唯一的区别就是Windows默认的是GBK编码，所以showStrOperation.py声明的是#-*- coding:GBK -*-；而Linux默认的是utf8编码，所以showNumType.py声明的是#-*- coding:utf8-*-。
提示
字符串也可以看成一个不可修改的字符列表。所以，大部分用来操作列表的方法（不涉及修改列表元素的）同样可以用来操作字符串。
2.1.3 列表
列表是Python最常用的变量类型。列表是一个可变序列，序列中的每个元素都分配一个数字即它的位置，或者叫索引。第一个索引是0，第二个索引是1，依此类推。列表中的元素可以是数字、字符串、列表、元组、字典……Python使用中括号 [ ] 来解析列表，给一个变量赋值为空列表。很简单，执行命令var = []就可以了。
列表的基本操作很简单，常用的操作一般是创建列表、插入数据、追加数据、访问数据、删除数据。下面实验一下：
创建列表，直接赋值即可。访问列表只需要列表名和列表中元素的下标即可。创建一个字符的列表，执行命令：
L1 = ['a', 'b', 'c', 'd', 'e']
L1[0]
L1[1]
L1[4]
L1[5]
执行结构如图2-5所示。
图2-5 创建列表
如图2-5所示，如果访问超出范围，Python则会抛出一个异常IndexError。如果只是创建一个纯字符的列表，无须一个个地输入字符，有个更简单的方法，执行命令L1 =list(‘abcde')即可。
插入、追加、删除列表数据也很简单。执行命令：
L1.insert(0,0)
L1.insert(-1,100)
L1.append('python')
L1.pop(3)
L1.pop()
执行结果如图2-6所示。
图2-6 插入、追加、删除数据
对列表最常用的操作是列表分片。分片可以简单地理解为将一个列表分成几块。它的操作方法是list[index1:index2[:step]]。先创建一个较长的数字列表做这个分片示例，执行命令：
L2 = []
for i in xrange(0,101):
L2.append(i)
L2
这样就创建了一个包含了从0～100，共101个数字的列表，如图2-7所示。
图2-7 创建数字列表
列表切片其实和访问列表元素很相似。例如，要访问列表L2的第10个元素，那么就应该是L2[10]就可以了。如果要访问列表L2的第10到20个元素呢？很简单，L2[10:21]就可以了。至于list[index1:index2[:step]]中的step是步长。实验一下就清楚了，执行命令：
L2[0:21]
L2[21:41]
L2[81:100]
L2[0:21:1]
L2[0:21:2]
L2[0:21:3]
L2[0:21:4]
L2[0:21:5]
执行结果如图2-8所示。
图2-8 列表分片
【示例2-3】写个简单的程序showList.py验证一下。打开Putty连接到Linux，执行命令：
cd code/crawler
vi showList.py
showList.py的代码如下：
1 #! /usr/bin/env python
2 #-＊- coding: utf-8-＊-
3 __author__ = 'hstking hstking@hotmail.com'
4
5 class ShowList(object):
6 def __init__(self):
7 self.L1 = []
8 self.L2 = []
9
10 self.createList() #创建列表
11 self.insertData() #插入数据
12 self.appendData() #追加数据
13 self.deleteData() #删除数据
14 self.subList() #列表分片
15
16 def createList(self):
17 print("创建列表：")
18 print("L1 = list('abcdefg')")
19 self.L1 = list('abcdefg')
20 print("L2 = []")
21 print("for i in xrange(0,10):")
22 print("\tL2.append(i)")
23 for i in xrange(0,10):
24 self.L2.append(i)
25 print("L1 = "),
26 print(self.L1)
27 print("L2 = "),
28 print(self.L2)
29 print('\n')
30
31 def insertData(self):
32 print(u"插入数据")
33 print(u"L1列表中第3个位置插入数字100，执行命令：L1.insert(3,100)")
34 self.L1.insert(3,100)
35 print("L1 = "),
36 print(self.L1)
37 print(u"L2列表中第10个位置插入字符串’python'，执行命令：
L2.insert(10, 'python')")
38 self.L2.insert(10, 'python')
39 print("L2 = "),
40 print(self.L2)
41 print('\n')
42
43 def appendData(self):
44 print(u"追加数据")
45 print(u"L1列表尾追加一个列表[1,2,3]，执行命令L1.append([1,2,3]")
46 self.L1.append([1,2,3])
47 print("L1 = "),
48 print(self.L1)
49 print(u"L2列表尾追加一个元组('a', 'b', 'c')，执行命令
L1.append(('a', 'b', 'c')")
50 self.L2.append(('a', 'b', 'c'))
51 print("L2 = "),
52 print(self.L2)
53 print('\n')
54
55 def deleteData(self):
56 print(u"删除数据")
57 print(u"删除L1的最后一个元素，执行命令L1.pop()")
58 self.L1.pop()
59 print("L1 = "),
60 print(self.L1)
61 print(u"删除L1的第1个元素，执行命令L1.pop(0)")
62 self.L1.pop(0)
63 print("L1 = "),
64 print(self.L1)
65 print(u"删除L2的第4个元素，执行命令L1.pop(3)")
66 self.L2.pop(3)
67 print("L2 = "),
68 print(self.L2)
69 print('\n')
70
71 def subList(self):
72 print(u"列表分片")
73 print(u"取列表L1的第3到最后一个元素组成的新列表，执行命令L1[2:]")
74 print(self.L1[2:])
75 print(u"取列表L2的第2个到倒数第2个元素组成的新列表，步长为2，执行命>
令L2[1:-1:2]")
76 print(self.L2[1:-1:2])
77 print('\n')
78
79
80 if __name__ == '__main__':
81 print("演示列表操作：\n")
82 sl = ShowList()
输入：wq，保存showList.py。showList.py显示了Python列表的基本功能——列表的创建、插入、追加、分片等。执行命令：
python showList.py
得到的结果如图2-9所示。
图2-9 run showList.py
列表还有很多其他的函数和操作方法，如有兴趣可参考官方文档和google。列表和元组非常相似，掌握了列表，就基本掌握了元组。列表，是Python编程中必不可少的一部分。
2.1.4 元组
Python的元组与列表非常相似，不同之处在于元组的元素是不可修改，它是一个不可变序列。列表使用[]来声明，元组使用()声明。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。创建一个空元组，执行命令var = ()。因为元组中元素是不可修改的，所以列表中的操作方法insert、append、pop等操作对于元组这些都没有。又因为元组与列表的高度相似性，列表的切片对元组是完全适用的（切片并不改变原始数据），所以只需要记住一个原则，列表中修改元素值的操作元组都不可用，列表中不修改元素值的操作元组基本上都可以用。
元组和列表是可以互相转换的。使用tuple(list)可以将一个列表转换成元组，反过来使用list(tuple)也可以将一个元组转换成列表。
【示例2-4】编写一个showTuple来实验一下。打开Putty连接到Linux，执行命令：
cd code/crawler
vi showTuple.py
showTuple.py的代码如下：
1 #! /usr/bin/env python
2 #-＊- coding: utf-8-＊-
3 __author__ = 'hstking hstking@hotmail.com'
4
5 class ShowTuple(object):
6 def __init__(self):
7 self.T1 = ()
8 self.createTuple() #创建元组
9 self.subTuple(self.T1) #元组分片
10 self.tuple2List(self.T1) #元组、列表转换
11
12 def createTuple(self):
13 print(u"创建元组：")
14 print(u"T1 = (1,2,3,4,5,6,7,8,9,10)")
15 self.T1 = (1,2,3,4,5,6,7,8,9,10)
16 print(u"T1 = "),
17 print(self.T1)
18 print('\n')
19
20 def subTuple(self, Tuple):
21 print(u"元组分片：")
22 print(u"取元组T1的第4个到最后一个元组组成的新元组，执行命令T1[3:]")
23 print(self.T1[3:])
24 print(u"取元组T1的第2个到倒数第2个元素组成的新元组，步长为2，执行命令
T1[1:-1:2]")
25 print(self.T1[1:-1:2])
26 print('\n')
27
28 def tuple2List(self, Tuple):
29 print(u"元组转换成列表：")
30 print(u"显示元组")
31 print(u"T1 = "),
32 print(self.T1)
33 print(u"执行命令L2 = list(T1)")
34 L2 = list(self.T1)
35 print(u"显示列表")
36 print(u"L2 = "),
37 print(L2)
38 print(u"列表追加一个元素100后，转换成元组。执行命令L2.append(100)
tuple(L2)")
39 L2.append(100)
40 print(u"显示新元组")
41 print(tuple(L2))
42
43
44 if __name__ == '__main__':
45 st = ShowTuple()
输入：wq，保存showTuple.py。showTuple.py显示了Python元组的创建、分片和转换。执行命令：
python showTuple.py
得到的结果如图2-10所示。
图2-10 run showTuple.py
因为元组和列表高度相似，绝大部分场合都可以用列表来替代元组。
提示
元组和列表不同仅在于一个可修改，一个不可修改。其他方面几乎没什么区别。由于元组不可修改的特性，一般在函数中需要返回多个返回值时，可以将这些返回值放入一个元组中返回。
2.1.5 字典
从某种意义上来说，字典和列表也很相似。字典使用的是{}，列表使用的是[]，元素分隔符都是逗号。所不同的是列表的索引只是从0开始的有序整数，不可重复；而字典的索引实际上在字典里应该叫键。虽然字典中的键和列表中的索引一样是不可重复的，但键是无序的，也就是说字典中的元素是没有顺序而言的。字典中的元素任意排列都不影响字典的使用。
字典的键可以是数字、字符串、列表、元组……几乎什么都可以，一般用字符串来做键，键与键值用冒号分割。在列表中是通过索引来访问元素，而在字典中是通过键来访问键值。因为字典按“键”寻值而不同于列表的按“索”寻值，所以字典的操作方法与列表稍有区别。
首先创建一个字典实验一下，执行命令：
ironMan = {'name':'tony stark', 'age':47, 'sex':'male'}
这样就建立了一个简单的IronMan字典。因为字典的键值是无序的，所以插入一个数据无须insert之类的方法。直接定义即可，执行命令：
ironMan['college'] = 'NYU'
ironMan['Nation'] = 'America'
如需添加资料，只需要继续这样添加即可。如果发现资料有误，修改字典，同样也是直接定义，执行命令：
ironMan['college'] = 'MIT'
如果要删除某个元素，可以使用del命令。del命令可以理解为取消分配给变量的内存空间。执行命令：
del ironman['Nation']
del命令不只是可以删除字典的元素，类似字典元素、用户定义的变量都可以用del来删除。它可以删除数字变量、字符串变量、列表、元组、字典等等。
字典还有一些独特的操作。以下是字典中最常用的操作：
● dict.items()：返回一个包含所有(键，值)元组的列表。
● dict.values()：返回一个包含字典所有value的列表。
● dcit.keys()：返回一个包含字典所有key的列表。
● dict.clear()：删除字典中所有的元素。
● dict.get(key)：返回字典中key所对应的值。
【示例2-5】编写一个showDict来实验一下。打开Putty连接到Linux，执行命令：
cd code/crawler
vi showDict.py
showDict.py的代码如下：
1 #! /usr/bin/env python
2 #-＊- coding: utf-8-＊-
3 __author__ = 'hstking hstking@hotmail.com'
4
5 class ShowDict(object):
6 ''’该类用于展示字典的使用方法 '''
7 def __init__(self):
8 self.spiderMan = self.createDict() #创建字典
9 self.insertDict(self.spiderMan) #插入元素
10 self.modifyDict(self.spiderMan) #修改元素
11 self.operationDict(self.spiderMan) #字典操作
12 self.deleteDict(self.spiderMan) #删除元素
13
14 def createDict(self):
15 print(u"创建字典：")
16 print(u"执行命令spiderMan = {'name':'Peter
Parker', 'sex':'male', 'Nation':'Americ', 'college':'MIT'}")
17 spiderMan = {'name':'Peter
Parker', 'sex':'male', 'Nation':'Americ', 'college':'MIT'}
18 self.showDict(spiderMan)
19 return spiderMan
20
21 def showDict(self, spiderMan):
22 print(u"显示字典")
23 print(u"spiderMan = "),
24 print(spiderMan)
25 print('\n')
26
27 def insertDict(self, spiderMan):
28 print(u"字典中添加键age，值为31")
29 print(u"执行命令spiderMan['age'] = 31")
30 spiderMan['age'] = 31
31 self.showDict(spiderMan)
32
33 def modifyDict(self, spiderMan):
34 print(u"字典修改键’college’的值为’Empire State University'")
35 print(u"执行命令spiderMan['college'] = 'Empire State University'")
36 spiderMan['college'] = 'Empire State University'
37 self.showDict(spiderMan)
38
39 def operationDict(self, spiderMan):
40 print(u"字典的其他操作方法")
41 print(u"###########################")
42 print(u"显示字典所有的键，keyList = spiderMan.keys()")
43 keyList = spiderMan.keys()
44 print(u"keyList = "),
45 print(keyList)
46 print('\n')
47 print(u"显示字典所有键的值，valueList = spiderMan.values()")
48 valueList = spiderMan.values()
49 print(u"valueList = "),
50 print(valueList)
51 print('\n')
52 print(u"显示字典所有键和值的元组，itemList = spiderMan.items()")
53 itemList = spiderMan.items()
54 print(u"itemList = "),
55 print(itemList)
56 print('\n')
57 print(u"取字典中键为college的值，college =
spiderman.get('college')")
58 college = spiderMan.get('college')
59 print(u"college = %s" %college)
60 print('\n')
61
62 def deleteDict(self, spiderMan):
63 print(u"删除字典中键为Nation的值")
64 print(u"执行命令del(spiderMan['Nation'])")
65 del(self.spiderMan['Nation'])
66 self.showDict(spiderMan)
67 print(u"清空字典中所有的值")
68 print(u"执行命令spiderMan.clear()")
69 self.spiderMan.clear()
70 self.showDict(spiderMan)
71 print(u"删除字典")
72 print(u"执行命令del(spiderMan)")
73 del(spiderMan)
74 print(u"显示spiderMan")
75 try:
76 self.showDict(spiderMan)
77 except NameError:
78 print(u"spiderMan未被定义")
79
80
81 if __name__ == '__main__':
82 sd = ShowDict()
输入：wq，保存showDict.py。showDict.py显示了Python字典的基本功能。执行命令：
python showDict.py
得到的结果如图2-11所示。
图2-11 run showDict.py
Python的基本变量类型就是这些。其他的类型几乎都是由这些基本类型组合而来（Python的数据类型还有None和boolean）。
提示
字典的键和键值可以是任何类型。在没有什么特殊要求的情况下尽可能地使用字符串作为键。如果把键设置得太复杂了，那也就失去字典的意义了。