python3
import sys
print(sys.maxsize)执行结果，如图1所示。
图1 求int最大值
与不同的是，给变量赋值时不需要预先声明变量类型。八进制数字、十六进制数字都是属于int(Long)类型的。
长整数，超过sys.maxsize的整数还是int类型。想赋值多大都行，只要内存足够大就可以。在Windows中打开cmd.exe，执行命令：
python
import sys
sys.maxsize
type(999999999999999999999999999999)执行结果如图2所示。
图2 Python long int
(2)float类型
浮点型实数，基本和C语言的浮点型一致，也就是数学中带小数点的数，不包括无限小数，不区分精度。只要是带小数点的数都可以看作浮点型数据。
(3)complex类型
复数，在中是需要自定义的一个数据类型。在中把它单独列出来作为基本数据类型。复数包含一个有序对，表示为a + bj，其中，a是实部，b是复数的虚部。
用一个简单的程序showNumType.py来显示的数字类型。使用Putty连接到，执行命令：
mkdir -pv code/crawler
cd !$
vi showNumType.py
vi showNumType.py的代码如下：
1 #!/usr/bin/env python3
2 #-*- coding: utf-8 -*-
3 __author__ = 'hstking hst_king@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("##########显示整型#############")
14 print("十进制的整型")
15 print("%-20d,%-20d,%-20d" %(-10000,0,10000))
16 print("二进制的整型")
17 print("%-20s,%-20s,%-20s" %(bin(-10000),bin(0),bin(10000)))
18 print("八进制的整型")
19 print("%-20s,%-20s,%-20s" %(oct(-10000),oct(0),oct(10000)))
20 print("十六进制的整型")
21 print("%-20s,%-20s,%-20s" %(hex(-10000),hex(0),hex(10000)))
22
23 def showLong(self):
24 print("##########显示长整型#############")
25 print("十进制的整型")
26 print("%-20Ld,%-20Ld,%-20Ld" %(-10000000000000000000,0,10000000000000000000))
27 print("八进制的整型")
28 print("%-20s,%-20s,%-20s" %(oct(-10000000000000000000),oct(0),
oct(10000000000000000000)))
29 print("十六进制的整型")
30 print("%-20s,%-20s,%-20s" %(hex(-10000000000000000000),hex(0),hex(10000000000000000000)))
31
32 def showFloat(self):
33 print("##########显示浮点型#############")
34 print("%-20.10f,%-20.10f,%-20.10f" %(-100.001,0,100.001))
35
36 def showComplex(self):
37 print("##########显示复数型#############")
38 print("变量赋值复数 var = 3 + 4j")
39 var = 3 + 4j
40 print("var的实部是：%dtvar的虚部是：%d" %(var.real,var.imag))
41
42
43 if __name__ == '__main__':
44 showNum = ShowNumType在Putty下执行命令：
python3 showNumType.py
得到的结果如图3所示。
图3 运行showNumType.py
showNumType.py是下以风格编写的示范程序，展示如何标准输出各种基本数字类型。
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中的oldstr替换为newstr，count为替换次数。
S.strip([chars])：把S左右两端chars中有的字符全部去掉，一般用于去除空格。
S.lstrip([chars])：把S左端chars中所有的字符全部去掉。
S.rstrip([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是否是首字母大写的。
编写一个showStrOperation.py来实验一下。这次在Windows下以IDLE为IDE来编写程序。showStrOperation.py代码如下：
打开Windows的命令行工具(cmd.exe)，执行命令：
python showStrOperation.py
得到的结果如图4所示。
图4 运行showStrOperation.py
与showNumType.py不同，showStrOperation.py是在下以的风格编写的。实际上这两个程序并没有什么区别，使用哪种风格视个人习惯而定。
字符串也可以看成一个不可修改的字符列表，所以大部分用来操作列表的方法(不涉及修改列表元素的)同样可以用来操作字符串。
3、列表
列表是最常用的变量类型。列表是一个可变序列，序列中的每个元素都分配一个数字，即它的位置，或者叫索引。第一个索引是0，第二个索引是1，以此类推。列表中的元素可以是数字、字符串、列表、元组、字典……使用中括号[ ]来解析列表，将一个变量赋值为空列表，很简单，执行命令var = []就可以了。
列表的基本操作很简单，一般是创建列表、插入数据、追加数据、访问数据、删除数据。下面实验一下。
创建列表，直接赋值即可。访问列表，只需要列表名和列表中元素的下标即可。创建一个字符的列表，执行命令：
L1=['a','b','c','d','e']
L1[0]
L1[1]
L1[2]
L1[3]
L1[4]
L1[5]执行的结果如图5所示。
图5 创建列表
如图5所示，如果访问超出范围，Python 3则会抛出一个异常IndexError。如果只是创建一个纯字符的列表，无须逐个输入字符，执行命令L1 = list('abcde')即可。
插入、追加、删除列表数据也很简单，执行命令：
L1.insert(0,0)
L1.insert(-1,100)
L1.append('python')
L1.pop(3)
L1.pop执行结果如图6所示。
图6 插入、追加、删除数据
对列表最常用的操作是列表分片。分片可以简单地理解为将一个列表分成几块。它的操作方法是list[index1:index2[:step]]。先创建一个较长的数字列表做这个分片示例，执行命令：
L2=[]
for i in xrange(0,101):
L2.append(i)
L2这样就创建了一个包含0～100共101个数字的列表，如图7所示。
图7 创建数字列表
列表切片其实和访问列表元素很相似。例如，要访问列表L2的第10个元素，直接用L2[10]就可以了。如果要访问列表L2的第10到20个元素呢？很简单，L2[10:21]就可以了。至于list[index1:index2[:step]]中的step是步长。实验一下就清楚了，执行命令：
L2[0:21]
L2[21:41]
L2[81:101]
L2[0:21:1]
L2[0:21:2]
L2[0:21:3]
L2[0:21:4]
L2[0:21:5]执行结果如图8所示。
图8 列表分片
写个简单的程序showList.py验证一下。打开Putty连接到Linux，执行命令：
cd code/crawler
vi showList.py
showList.py的代码如下：
1 #!/usr/bin/env python3
2 #-*- coding: utf-8 -*-
3 __author__ = 'hstking hst_king@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 range(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("插入数据")
33 print("L1列表中第3个位置插入数字100，执行命令：L1.insert(3,100)")
34 self.L1.insert(3,100)
35 print("L1 = "),
36 print(self.L1)
37 print("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("追加数据")
45 print("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("L2列表尾追加一个元组('a','b','c')，执行命令L2.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("删除数据")
57 print("删除L1的最后一个元素，执行命令L1.pop")
58 self.L1.pop
59 print("L1 = "),
60 print(self.L1)
61 print("删除L1的第1个元素，执行命令L1.pop(0)")
62 self.L1.pop(0)
63 print("L1 = "),
64 print(self.L1)
65 print("删除L2的第4个元素，执行命令L2.pop(3)")
66 self.L2.pop(3)
67 print("L2 = "),
68 print(self.L2)
69 print('n')
70
71 def subList(self):
72 print("列表分片")
73 print("取列表L1的第3到最后一个元素组成的新列表，执行命令L1[2:]")
74 print(self.L1[2:])
75 print("取列表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按Esc键，进入命令模式后输入:wq保存showList.py。showList.py显示了Python列表的基本功能——列表的创建、插入、追加、分片等。执行命令：
python3 showList.py
得到的结果如图9所示。
图9 运行showList.py
列表还有很多其他的函数和操作方法，如有兴趣可以参考官方文档和Google。列表和元组非常相似，掌握了列表，就基本掌握了元组。列表是Python中必不可少的一种数据类型。
4、元组
的元组与列表非常相似，不同之处在于元组的元素是不可修改的，是一个不可变序列(意思是赋值后就无法再修改了。同列表一样，可以用序列号来访问，有点类似C语言中的常量)。列表使用[]声明，元组使用声明。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。创建一个空元组，执行命令var = 。因为元组中元素是不可修改的，所以列表中的操作方法insert、append、pop等操作对于元组都没有。又因为元组与列表的高度相似性，列表的切片对元组是完全适用的(切片并不改变原始数据)，所以只需要记住一个原则，列表中修改元素值的操作元组都不可用，列表中不修改元素值的操作元组基本上都可以用。
元组和列表是可以互相转换的。使用tuple(list)可以将一个列表转换成元组，反过来使用list(tuple)也可以将一个元组转换成列表。
编写一个showTuple来实验一下。打开Putty连接到Linux，执行命令：
cd code/crawler
vi showTuple.py
showTuple.py的代码如下：
1 #!/usr/bin/env python3
2 #-*- coding: utf-8 -*-
3 __author__ = 'hstking hst_king@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("创建元组：")
14 print("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("T1 = "),
17 print(self.T1)
18 print('n')
19
20 def subTuple(self,Tuple):
21 print("元组分片：")
22 print("取元组T1的第4个到最后一个元组组成的新元组，执行命令T1[3:]")
23 print(self.T1[3:])
24 print("取元组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("元组转换成列表：")
30 print("显示元组")
31 print("T1 = "),
32 print(self.T1)
33 print("执行命令 L2 = list(T1)")
34 L2 = list(self.T1)
35 print("显示列表")
36 print("L2 = "),
37 print(L2)
38 print("列表追加一个元素100后，转换成元组。执行命令L2.append(100)tuple(L2)")
39 L2.append(100)
40 print("显示新元组")
41 print(tuple(L2))
42
43
44 if __name__ == '__main__':
45 st = ShowTuple按Esc键，进入命令模式后输入:wq，保存showTuple.py。showTuple.py显示了Python元组的创建、分片和转换。执行命令：
python3 showTuple.py
得到的结果如图10所示。
图10 运行showTuple.py
因为元组和列表高度相似，绝大部分场合都可以用列表来替代元组。
元组和列表的不同仅在于一个可修改，一个不可修改。其他方面几乎没有什么区别。由于元组不可修改的特性，一般在函数中需要返回多个返回值时，可以将这些返回值放入一个元组中返回。
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.keys：返回一个包含字典所有key的列表。
dict.values：返回一个包含字典所有value的列表。
dict.items：返回一个包含所有(键，值)元组的列表。
dict.clear：删除字典中所有的元素。
dict.get(key)：返回字典中key所对应的值。
编写一个showDict来实验一下。打开Putty连接到Linux，执行命令：
cd code/crawler
vi showDict.py
showDict.py的代码如下：
得到的结果如图11所示。
图11 运行showDict.py
Python3的基本变量类型就是这些。其他的类型几乎都是由这些基本类型组合而来(Python还有特殊的数据类型None和boolean)。
字典的键和键值可以是任何类型。在没有什么特殊要求的情况下，尽可能地使用字符串作为键。如果把键设置得太复杂了，就失去字典的意义了。
