7.5 Python中的构造类型变量

所谓“构造类型”，就是将不同基本类型的数据组合在一起构成的新数据类型，类似于C语言中的结构体等类型。Python中的构造类型主要包括：

· 序列[包括字符串（String）、列表（List）和元组（Tuple）]。

· 映射[字典（Dictionary）]。

· 集合（Set）。

7.5.1 字符串

字符串是由一个或多个字符组成的序列，它是Python中使用极为普遍的数据类型之一。Python不支持单字符类型，单字符在Python中也被视为字符串。

1．字符串变量的定义

定义字符串变量的语法如下（通过举例加以说明）：

>>> v1=’我要学好Python'
>>> v2="我能学好Python"
>>> v3='''
我要学好Python
我能学好Python
'''
>>> print(v1)
我要学好Python
>>> print(v2)
我能学好Python
>>> print(v3)

我要学好Python
我能学好Python

>>>

在上述程序中，分别用3种不同的方式定义了3个字符串变量：v1、v2、v3。其中，v3是多行字符串变量。

除此之外，字符串变量还可以通过相互赋值加以定义，举例如下：

>>> v4=v2
>>> print(v4)
我能学好Python
>>>

上述程序通过将v2的值赋给v4，从而定义了字符串变量v4。

归纳起来，在Python中，通常采用以上4种方式定义字符串变量。

2．字符串的特点

字符串中的元素是不可变的，这是字符串最大的特点。

例如，以下程序欲将字符串的第二个字符由b改为B。

>>> ss="abcdef"
>>> ss[1]='B'
Traceback (most recent call last):
  File "<pyshell#65>", line 1, in <module>
    ss[1]='B'
TypeError: 'str' object does not support item assignment
>>>

程序中定义了一个字符串变量ss，希望修改下标为1的元素，将它由b改为B。但在程序运行后抛出异常，异常类型是：str对象不支持修改。

3．字符串的使用

可以使用方括号[]访问字符串中的子字符串。方括号内的数字表示下标，下标从0开始。

举例如下：

>>> msg='Amazing Python! '
>>> print(msg)
Amazing Python!
>>> print(msg[0:])
Amazing Python!
>>> print(msg[:4])
Amaz
>>> print(msg[1:5])
mazi
>>>

由此可见，字符串元素的下标是从0开始的。

截取子字符串的方法是：

字符串变量[起始下标：结束下标]

其中，起始下标默认为0，可省略；结束下标表示要截取字符串的最后一个字符加1，也就是说，截取的子字符串不包括结束下标对应的元素。Python将这个过程称为“切片（Slice）”。

下标可为负数，它表示从字符串的尾部逆向访问字符串，最后一个元素的下标对应为-1。依次类推，倒数第二个元素的下标为-2。与正向截取子字符串相同的是，逆向截取的子字符串也不包括结束下标对应的元素。

举例说明如下：

>>> msg='This is a test string! '
>>> print(msg[:-1])
This is a test string
>>> print(msg[:-0])

>>> print(msg[-1:])
!
>>> print(msg[0:-3])
This is a test stri
>>>

由以上程序可知，不允许直接对字符串中的元素进行修改。那么，在何种情况下可以修改字符串中的元素呢？可对已存在的字符串进行修改，但它必须被赋给另一个变量。也就是说，要改变一个字符串中的元素，必须新建一个字符串变量。

以下这样做是不被允许的：

>>> msg='Hello, world! '
>>> msg[6]="W"
Traceback (most recent call last):
  File "<pyshell#48>", line 1, in <module>
    msg[6]="W"
TypeError: 'str' object does not support item assignment
>>>

但是，可将修改后的字符串赋给另一个字符串变量。

>>> msg1='Hello, world! '
>>> msg2=msg1[:6]
>>> msg1='Hello, world! '
>>> msg2=msg1[:6]+'Python! '
>>> print(msg2)
Hello, Python!
>>>

归纳起来，字符串中下标的用法有以下几种形式。

· string[0:-1])：从头到尾。

· string[2:])：从下标2开始到尾。

· string[2:6])：从下标2到下标（6-1）。

4．字符串的重复输出

字符串可被重复输出，其方法如下：

字符串*n

其中，n代表重复输出的次数，它必须是一个整数。

例如：

print(string*2)  #输出两次
print("*"*10)   #输出10个*

7.5.2 列表

列表是一种不同数据类型元素的有序集合。与元组和字符串不同的是，列表中的元素是可变的，也就是可以随时添加或删除其中的元素。

列表通过方括号“[]”加以表示。

1．列表变量的定义

1）定义列表变量的一般方法

列表变量的定义方法如下：

列表变量 = [元素1，元素2，元素3, …]

其中，每个元素的类型可以各不相同，但它们被依次存储，也就是说，其下标是固定的，起始下标为0。

举例说明列表变量的定义：

#ListDemo.py
listDemo=["aa",1, "bb",2]
print(listDemo)
print(listDemo[0])           #输出下标为0的元素
print(listDemo[2:])           #输出从下标2开始到尾的元素
print(listDemo[1:3])          #输出从下标2到下标（n-1）的元素
print(listDemo*2)           #输出两次
listDemo[0]="替换的"
print(listDemo)             #修改后的

运行上述程序后，结果如下：

['aa', 1, 'bb', 2]
aa
['bb', 2]
[1, 'bb']
['aa', 1, 'bb', 2, 'aa', 1, 'bb', 2]
[’替换的’, 1, 'bb', 2]
>>>

2）通过list()定义列表变量

可以通过内置函数list()将字符串定义为列表变量。

举例如下：

>>> mylist=list('hello')
>>> mylist
['h', 'e', 'l', 'l', 'o']
>>>

2．列表的使用

与字符串相同，列表也可通过下标法进行访问。当正向访问时，下标从0开始，也可从尾部逆向访问，最后一个列表元素的下标为-1。对列表进行操作时一定要避免越界。所谓“越界”，是指超出下标范围。

举例如下：

>>> mylist=list('hello')
>>> mylist
['h', 'e', 'l', 'l', 'o']
>>> mylist[-1]
'o'
>>> mylist[1:3]
['e', 'l']
>>>

在截取列表元素时，可使用以下形式：

列表[m:n]

但一定要注意，在截取的元素中，只包括从下标m开始至下标（n-1）的部分，不包括下标n对应的元素。此特性适用于字符串、列表和元组3种序列型数据。

1）添加新元素

使用append()方法可把新元素追加到列表的尾部；而使用insert()方法则可将新元素添加到特定的位置。

2）删除元素

删除元素可采用pop()方法。执行L.pop()命令可删除列表L中的最后一个元素。如果要删除特定位置的元素，则可以采用pop(2)的形式，其中参数2表示的是位置，即下标。

3）替换

列表中的元素可被方便地替换，替换操作可直接使用下标法。例如：

>>> mm[3]=mm[3]+1

该语句通过下标法将列表中下标为3的元素在原值的基础上增加1。

4）遍历打印

通过for语句可实现对列表的遍历访问。举例如下：

>>> L = ['a', 'b', 'c']
>>> for i in L:
    print(i)
a
b
c

3．列表的特点

列表中的元素是可变的，这是列表有别于元组的最大特点。举例如下：

>>> mylist=list('hello')
>>> mylist
['h', 'e', 'l', 'l', 'o']
>>> mylist[-1]
'o'
>>> mylist[1:3]
['e', 'l']
>>> mylist[0]='H'
>>> mylist
['H', 'e', 'l', 'l', 'o']
>>>

7.5.3 元组

1．什么是元组

元组是另一种有序列表，可将元组理解成一种不可变的列表。

元组和列表非常类似，但是，元组一旦被初始化，就不能被修改。那么，不可变的元组有何意义？元组的意义在于，因为元组是不可变的，所以在某些场合使用元组可以提高代码的安全性。因此，笔者建议，凡能用元组代替的变量应尽可能地使用元组，而不要使用列表。

2．如何定义元组变量

元组通过括号“()”加以表示。

1）元组变量的定义

定义元组变量的语法如下：

元组变量 = (元素1，元素2，元素3, …)

其中，每个元素的类型可以各不相同。

举例如下：

# TupleDemo.py
tupleDemo=("aa",1, "bb",2)
print(tupleDemo)
print(tupleDemo[0])          #输出下标为0的元素
print(tupleDemo[2:])         #输出从下标2开始到尾的元素
print(tupleDemo[1:3])         #输出从下标1到下标（3-1）的元素
print(tupleDemo*2)          #输出两次

在上述程序中，第一条语句为tupleDemo=("aa",1, "bb",2)，它定义了一个名为tupleDemo的元组变量，共有4个元素，它们各自有不同的类型，分别是字符串、整数、字符串、整数。

运行上述程序后，输出结果如下：

('aa', 1, 'bb', 2)
aa
('bb', 2)
(1, 'bb')
('aa', 1, 'bb', 2, 'aa', 1, 'bb', 2)
>>>

通过将程序与输出结果对照分析，不难理解元组定义与使用的一般方法。

2）空元组的定义

空元组的定义如下：

tupleDemo=()              #空元组

3）定义只有一个元素的元组

定义只有一个元素的元组：

tupleDemo=(a, )             #一个元素

必须在元素之后加上“, ”，否则，定义的不是元组，而是一个普通变量。

举例如下：

>>> tupledemo=(1, )
>>> print(tupledemo)
(1, )
>>> tupledemo=(1)
>>> print(tupledemo)
1
>>>

3．元组的特点

元组中的元素是不可变的。

如何真正理解元组的这个特性呢？举例说明如下：

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
t[0]='b'
print(t)

在上述程序中，第一条语句定义了一个元组变量t，其中第三个元素为列表。第四条语句试图将元组的第一个元素由’a’改为’b'。

运行上述程序后，得到的结果如下：

Traceback (most recent call last):
  File "C:/Users/Administrator/Desktop/hhfgh.py", line 4, in <module>
    t[0]='b'
TypeError: 'tuple' object does not support item assignment
>>>

由此可见，第四条语句出错了。

如果将第四条语句删除，改为如下程序：

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
print(t)

运行上述程序，一切正常并得到如下结果：

('a', 'b', ['X', 'Y'])
>>>

上述举例说明，元组中的元素是不可变的，但是，由于第三个元素是列表，而列表是可变的，所以第二、三条语句是正常的。注意，千万不能将此理解成元组中的元素是可变的。

举例如下：

t = ('a', 'b', ['A', 'B'])
t[2]=3
print(t)

上述程序中的第二条语句试图将第三个元素由列表改为整型，运行上述程序，程序出错了。

Traceback (most recent call last):
  File "C:/Users/Administrator/Desktop/hhfgh.py", line 2, in <module>
    t[2]=3
TypeError: 'tuple' object does not support item assignment
>>>

出错的原因是：'tuple' object does not support item assignment。将它翻译成中文就是“元组不支持修改”。

4．元组的使用

直接使用下标索引。

举例如下：

>>> t=(6,7,8)
>>> t[1]
7
>>>

在元组中，虽然元素不可被修改，但是可通过运算符“+”对两个元组进行连接组合。举例如下：

>>> t1=(6,7,8)
>>> t2=(-1,0,1)
>>> t3=t1+t2
>>> t3
(6, 7, 8, -1, 0, 1)
>>> t3=t2+t1
>>> t3

(-1, 0, 1, 6, 7, 8)
>>>

实际上，“+”运算的作用远不止这一个。请看：

>>> aa=(1,2,3)
>>> bb=(4,5,6)
>>> cc=aa+bb
>>> cc
(1, 2, 3, 4, 5, 6)
>>> aa="123"
>>> bb="456"
>>> cc=aa+bb
>>> cc
'123456'
>>> aa=[1,2,3]
>>> bb=[4,5,6]
>>> cc=aa+bb
>>> cc
[1, 2, 3, 4, 5, 6]
>>>

除此之外，在上面的举例中，曾涉及元组的重复输出，重复输出的方法与字符串重复输出的方法非常相似。事实上，列表也可以重复输出。举例如下：

>>> mytuple=("1",2, "abc")
>>>print(mytuple*2) #重复输出元组两次
('1', 2, 'abc', '1', 2, 'abc')
>>> mylist=[1,2,3]
>>>print(mylist*2)  #重复输出列表两次
[1, 2, 3, 1, 2, 3]
>>>

7.5.4 集合

1．什么是集合

集合是一系列无序的、不重复的元素的组合体，集合中的每个元素可为不同的类型。因此，集合可被看成数学意义上的无序、无重复元素的集合。

2．集合变量的定义

集合通过“{}”加以表示。

常用以下3种方法定义集合变量。

第一种——直接定义。

>>> setdemo={1, "ab",7.8}
>>> print("第一种方法定义的集合：", setdemo)
第一种方法定义的集合： {1, 'ab',7.8}
>>>

第二种——通过列表和set()函数定义集合变量。

>>> vlist=[12,78,56,12,66,78]
>>> vset=set(vlist)
>>> vset
{56, 66, 12, 78}
>>>

在上述程序中，首先定义一个列表变量，然后通过内置函数set()将列表转换为集合。由于集合类型具有不重复和无序的特性，所以，从举例中可见，列表中的重复元素被删除，元素的顺序关系被忽略。

第三种——通过add()方法对已定义的空集合进行添加。

>>> sdemo=set()
>>> sdemo.add(23)
>>> sdemo.add(12)
>>> sdemo.add("abc")
>>> sdemo
{'abc', 12, 23}
>>> sdemo.add(23)
>>> sdemo
{'abc', 12, 23}
>>>

在上述程序中，首先通过set()函数定义一个空集合对象，然后通过对象的内置方法add()进行元素添加，在添加过程中如果出现相同的元素则被忽略。例如，两次添加23，但是第二次添加被忽略。

3．集合的使用

1）两个集合的运算

两个集合可进行交集、并集、差集等运算。

举例如下：

setDemo1={"a",23}
setDemo2={"a", "b"}
print("集合B ", setDemo2)
print("AB的差集 ", setDemo1-setDemo2)
print("AB的并集 ", setDemo1|setDemo2)
print("AB的交集 ", setDemo1&setDemo2)
print("AB的不同时存在的 ", setDemo1^setDemo2)

运行上述程序后，得到的结果如下：

集合B  {'b', 'a'}
AB的差集  {23}
AB的并集  {'b', 'a',23}
AB的交集  {'a'}
AB的不同时存在的  {'b',23}
>>>

2）添加、删除集合中的元素

对集合对象可进行添加元素、删除元素、随机删除元素并获得该元素等操作。

· 添加的方法：add()内置方法。

· 删除的方法：discard()、remove()、pop()等内置方法。要注意三者的区别。

· 删除集合中所有元素的方法：clear()内置方法。

4．集合的特点

集合中的元素是无序的、不可重复的，即不允许在集合对象中出现两个及以上的相同元素。举例如下：

>>> set1={11,15,17,18}
>>> set2={11, "a",67.8, "bc"}
>>> set3={11,12,12,17}
>>> set3
{17, 11, 12}
>>>

上述程序表明，在定义集合变量set3时使用了两个相同的元素，虽然这在语法上被允许，但是从实际结果来看，两个相同的元素（重复）是不被接受的。

7.5.5 字典

1．什么是字典

字典是一个存放无序的键/值（key/value）映射类型数据的容器。

字典的键可为数字、字符串或元组，键必须是唯一的。在Python中，数字、字符串和元组均为不可变类型，而列表、集合是可变类型，所以列表和集合不能作为字典的键。键必须为不可变类型，而值则可为任意类型。

2．字典变量的定义

字典通过“{}”加以定义。这一点与集合是一样的，但要注意两者的区别。

定义字典变量的方法如下：

字典变量 = {键1：值1，键2：值2，键3：值3, …}

举例如下：

>>> ddemo={"name":"shenhongwei", "sex":'M', "year":52}
>>> ddemo
{'name': 'shenhongwei', 'sex': 'M', 'year': 52}
>>>

在上述举例中，定义了一个字典变量ddemo，它有3个键值对。

还有一种方法可定义字典变量：首先创建空字典对象，然后逐一添加键值对，从而定义字典变量。

举例如下：

>>> ddemo1={}
>>> ddemo1["a"]=12
>>> ddemo1["b"]=13
>>> ddemo1["c"]=14
>>> ddemo1
{'a': 12, 'b': 13, 'c': 14}
>>>

在上述程序中，首先创建空字典变量ddemo1，然后分3次逐一添加键值对，从而定义字典变量ddemo1。注意，添加时必须以键为关键字。

3．字典的使用

字典是通过键（key）作为索引来访问和操作值（value）的。特别要引起注意的是，字典一旦被定义，它的键不能被修改，而值可以被修改。

修改值的具体方法如下：

字典[key]

举例1：

ddemo={"name":"shenhongwei", "sex":'M', "year":52}
print(ddemo)
print(ddemo["name"])

上述程序被运行后，得到的结果如下：

{'name': 'shenhongwei', 'sex': 'M', 'year': 52}
shenhongwei

首先输出整个字典，然后通过键索引方式索引键“name”，从而输出其对应的值“shenhongwei”。

举例2：
>>> ddemo1={'a': 13, 'b': 13, 'c': 14}
>>> ddemo1["c"]=15
>>> ddemo1
{'a': 13, 'b': 13, 'c': 15}
>>>

通过键“c”将它对应的值由14改为15。

举例3：

>>> ddemo1={'a': 13, 'b': 13, 'c': 14}
>>> x=ddemo1.pop("c")
>>> print(ddemo1)
{'a': 13, 'b': 13}
>>> print(x)
14
>>>

上述程序移除键“c”，返回其对应的值并赋给变量x, x的值为14。此处使用了内置方法pop()，从中可了解该方法的具体用法。

举例4：

>>> ddemo1={'a': 13, 'b': 13, 'c': 14}
>>> print(ddemo1.keys())
dict_keys(['a', 'b', 'c'])
>>> print(ddemo1.values())
dict_values([13, 13, 14])
>>>

上述程序首先定义一个字典变量ddemo1，然后通过方法keys()和values()得到它的全部键和值。这两个方法的返回值均为列表形式。

举例5：

>>> ddemo1={'a': 13, 'b': 13, 'c': 14}
>>> for i in ddemo1.keys():
    print(i)

a
b
c
>>>

4．字典的特点

（1）字典的第一个特点是查找速度快，而且查找的速度与元素的个数无关；而列表的查找速度是随着元素的增加而逐渐下降的。

（2）字典的第二个特点是存储的键值对是无序的。

（3）字典的第三个特点是键的数据类型必须是不可变的类型，所以列表和集合不能作为字典的键。

（4）字典的第四个特点是占用的内存空间大。