2.1 Python变量类型_Python网络爬虫实战（第2版）-QQ阅读男生都市网

书名：Python网络爬虫实战（第2版）
作者名：胡松涛
本章字数：4485字
更新时间：2021-03-23 23:03:55

2.1　Python变量类型

Python的标准数据类型只有5个，分别是数字、字符串、列表、元祖、字典。看起来比C语言的数据类型少了很多，但该有的功能一个不少。即使C语言的代表作链表和二叉树，Python同样能应付自如。

2.1.1　数字

Python支持以下3种不同的数值类型。

1. int类型

有符号整数，就是C语言中所指的整型，也就是数学中的整数。Python 3的int与Python 2的int略有不同。Python 2中有个sys.maxint限制了int类型的最大值，超过这个数值的将自动转换为Python 2的long类型。Python 3中没有sys.maxint，但有一个相似的sys.maxsize，这个数并没有限制Python 3中int类型数的极限。理论上来说Python 3的int类型是无限大的。查看当前系统下的sys.maxsize，使用Putty登录Linux，执行命令：

     python3
     import sys
     print(sys.maxsize)

执行结果，如图2-1所示。

图2-1　求int最大值

与C语言不同的是，Python给变量赋值时不需要预先声明变量类型。八进制数字、十六进制数字都是属于int（Long）类型的。

长整数，超过sys.maxsize的整数还是int类型。想赋值多大都行，只要内存足够大就可以。在Windows中打开cmd.exe，执行命令：

     Python
     import sys
     sys.maxsize
     type(999999999999999999999999999999)

执行结果如图2-2所示。

图2-2　Python long int

2. float类型

浮点型实数，基本和C语言的浮点型一致，也就是数学中带小数点的数，不包括无限小数，不区分精度。只要是带小数点的数都可以看作浮点型数据。

3. 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 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的实部是：%d\tvar的虚部是：%d" %(var.real,var.imag))
     41
     42
     43 if __name__ == '__main__':
     44     showNum = ShowNumType()

在Putty下执行命令：

     python3 showNumType.py

得到的结果如图2-3所示。

图2-3　运行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中的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是否是首字母大写的。

【示例2-2】编写一个showStrOperation.py来实验一下。这次在Windows下以IDLE为IDE来编写程序。showStrOperation.py代码如下：

打开Windows的命令行工具（cmd.exe），执行命令：

     python showStrOperation.py

得到的结果如图2-4所示。

图2-4　运行showStrOperation.py

与showNumType.py不同，showStrOperation.py是在Windows下以C语言的风格编写的。实际上这两个程序并没有什么区别，使用哪种风格视个人习惯而定。

提示

字符串也可以看成一个不可修改的字符列表，所以大部分用来操作列表的方法（不涉及修改列表元素的）同样可以用来操作字符串。

2.1.3　列表

列表是Python最常用的变量类型。列表是一个可变序列，序列中的每个元素都分配一个数字，即它的位置，或者叫索引。第一个索引是0，第二个索引是1，以此类推。列表中的元素可以是数字、字符串、列表、元组、字典……Python使用中括号[ ]来解析列表，将一个变量赋值为空列表，很简单，执行命令var = []就可以了。

列表的基本操作很简单，一般是创建列表、插入数据、追加数据、访问数据、删除数据。下面实验一下。

创建列表，直接赋值即可。访问列表，只需要列表名和列表中元素的下标即可。创建一个字符的列表，执行命令：

     L1 = ['a','b','c','d','e']
     L1[0]
     L1[1]
     L1[2]
     L1[4]
     L1[5]

执行的结果如图2-5所示。

图2-5　创建列表

如图2-5所示，如果访问超出范围，Python 3则会抛出一个异常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:101]
     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 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

得到的结果如图2-9所示。

图2-9　运行showList.py

列表还有很多其他的函数和操作方法，如有兴趣可以参考官方文档和Google。列表和元组非常相似，掌握了列表，就基本掌握了元组。列表是Python编程中必不可少的一种数据类型。

2.1.4　元组

Python的元组与列表非常相似，不同之处在于元组的元素是不可修改的，是一个不可变序列（意思是赋值后就无法再修改了。同列表一样，可以用序列号来访问，有点类似C语言中的常量）。列表使用[]声明，元组使用()声明。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。创建一个空元组，执行命令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 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

得到的结果如图2-10所示。

图2-10　运行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.keys()：返回一个包含字典所有key的列表。
dict.values()：返回一个包含字典所有value的列表。
dict.items()：返回一个包含所有（键，值）元组的列表。
dict.clear()：删除字典中所有的元素。
dict.get(key)：返回字典中key所对应的值。

【示例2-5】编写一个showDict来实验一下。打开Putty连接到Linux，执行命令：

     cd code/crawler
     vi showDict.py

showDict.py的代码如下：

得到的结果如图2-11所示。

图2-11　运行showDict.py

Python 3的基本变量类型就是这些。其他的类型几乎都是由这些基本类型组合而来（Python还有特殊的数据类型None和boolean）。

提示

字典的键和键值可以是任何类型。在没有什么特殊要求的情况下，尽可能地使用字符串作为键。如果把键设置得太复杂了，就失去字典的意义了。