数据类型

列表-list

列表的概念

• 类型名称：list
• 定界符：[ ]
• 可变行：可变
• 有序性：有序
• 对元素类型与值的要求：无
• 元素可否重复：可以
• 元素查找速度：非常慢
• 增删元素速度：尾部快，其它位置慢

列表是包含若干元素的有序连续内存空间，当列表增加或删除元素时，列表对象自动进行内存的扩展或收缩，从而保证相邻元素之间没有缝隙。列表的这个内存自动管理功能可以大幅减少程序员的工作，但插入和删除非尾部元素时涉及列表中大量元素的移动，严重影响效率。

另外在非尾部位置插入和删除元素时，会改变该位置后面的元素在列表中的索引，这对于某些操作可能会导致意外的错误结果，因此除非确实有必要，否则应尽量从列表尾部进行元素的追加与删除操作。

在Python中，同一个列表中元素的数据类型可以各不相同，可以同时包含整数、实数、字符串等基本类型的元素，也可以包含列表、元组、字典、集合、函数以及其他任意对象。

列表的创建

​ 在Python中，使用“=”直接将一个列表赋值给变量，即可创建列表对象。

>>> list1=[1,'a',4]            #直接赋值，将元素用逗号隔开，并且用中括号括起来

​ 也可以使用list()函数把元组、range对象、字符串、字典、集合或其他可迭代对象转化为列表。需要注意的是，把字典转换为列表时，默认是将字典的键转换为列表，而不是把字典的元素转换为列表，如果想把字典的元素转换为列表，需要使用字典对象的items()方法明确说明，当然也可以使用values()来明确说明要把字典的值转换为列表。

>>> list((1,2,3))
[1, 2, 3]
>>> list(range(3))
[0, 1, 2]
>>> list('nihao!')
['n', 'i', 'h', 'a', 'o', '!']
>>> list({1,2,3})
[1, 2, 3]
>>> list({'a':1,'b':2,'c':3})
['a', 'b', 'c']
>>> list({'a':1,'b':2,'c':3}.items())
[('a', 1), ('b', 2), ('c', 3)]

访问

索引

单个元素方法

>>> t=['a', 'b', 'c', 'd', 'e']
>>> t[1]
'b'
>>> t[-3]
'c'

列表的截取

列表的截取又称作列表的切片，它需要使用两个索引下标来确定切片的起始位置和结束位置。列表的截 取格式为：变量[头下标：尾下标：步长]，其中步长为可选参数，如果没有步长参数，则代表步长为1;如 果切片是从头开始或者是到最后结束，头下标和尾下标也可以没有，示例如下。

>>> t = ['a', 'b', 'c', 'd', 'e']
>>> t[:3]
['a', 'b', 'c']
>>> t[3:]
['d', 'e']
>>> t[-3:]
['c', 'd', 'e']

注意

1. 步长是选取间隔，正负整数均可，默认步长为1，正为从左往右，负为从右往左；
2. 开始位置下标/结束位置下标，正负整数均可，值为负代表从左往右倒数几个元素；
开始位置下标：默认第一个元素，步长为负数时，默认最后一个元素
结束位置下标：默认最后一个元素，步长为负数时，默认第一个元素
3. 不包含结束位置下标对应的数据
4. 切片始终以开始位置下标为开始，结束位置下标结束，确保切片[开始位置下标: 结束位置下标]区间有
值，否则为空表

示例

list1 = [1,2,3,4,5,6,7,8,9,10]
print(list1[2:8:3]) #[3, 6]
print(list1[2:8])  #[3, 4, 5, 6, 7, 8]
print(list1[2:])   #[3, 4, 5, 6, 7, 8, 9, 10]
print(list1[:])   #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list1[:-6:-1])#[10, 9, 8, 7, 6]

添加

append()

作用：将元素添加到列表的末尾。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.append(1)
>>> List
['a', 'b', 'c', 'd', 'e', 1]

insert()

作用：将元素插入指定的位置。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.insert(2,"Python")
>>> List
['a', 'b', 'Python', 'c', 'd', 'e']

更新

• 更新单个值

  >>>List = ['a','b','c','d','e']
  >>>List[2] = 'aa'
  >>>List
  ['a','b','aa','d','e']
  

• 利用列表切片技术，列表的值也可以同时更新多个，如下例所示。

  >>> List =  ['a','b','c','d','e']
  >>> List [1:4] = [1,2,3]
  >>> List
  ['a', 1, 2, 3, 'e']
  

删除

当一个列表不再使用时，可以使用del命令将其删除，这一点适用于所有类型的Python对象。本质上del命令并不删除变量对应的值，只是删除变量，并解除变量和值的绑定。 垃圾回收机制：Python内部每个值配备一个计数器，每当有新的变量引用该值是，其计数器加1，当该变量被删除或不再引用该值时，其计数器减1。当某个值的计数器变为0时，则由垃圾回收器负责清理和删除。

删除列表中的值有多种方法，主要的有以下4种方法。

del()

作用：删除列表中的指定下标的值，如果没有指定下标，则是删除整个变量。

>>> List =  ['a','b','c','d','e']
>>> del List[1]   # del(List[1]) 为另外一种写法
>>> List
['a', 'c', 'd', 'e']

pop()

作用：删除指定下标的元素，并返回被删除元素的内容，如果没有指定下标，则默认删除最后一个元素。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.pop(1)
'b'
>>> List
['a', 'c', 'd', 'e']
>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.pop()
'e'
>>> List
['a', 'b', 'c', 'd']

remove()

作用：移除列表里面第一次出现的指定值的元素。我们有时候需要删除某一个元素，但是不知道它在列表的什么位置，这时候使用remove()最合适。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.remove('c')
>>> List
['a', 'b', 'd', 'e']

clear()

作用：清除列表所有的元素，但是不删除列表，只是列表为空。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.clear()
>>> List
[]    #列表List依然存在，但是为空列表

排序

sort()

作用：对原列表进行排序，不返回新列表。如果指定参数，则使用指定的比较函数进行排序。

>>> List = ['e', 'b', 'a','d', 'c', 'f']
>>> List.sort()
>>> List
['a', 'b', 'c', 'd', 'e', 'f']

>>> List2 = ['e', 'b', 'a','d', 'c', 'f']
>>> List2.sort(reverse=True)
>>> List2
['f', 'e', 'd', 'c', 'b', 'a']

sorted()

作用：对可迭代的对象进行排序操作，会生成新的列表。

>>> List = [122,23,1,9,-34,546,12.3]
>>> NewList = sorted(List,reverse=True)
>>> List
[122, 23, 1, 9, -34, 546, 12.3]
>>> NewList
[546, 122, 23, 12.3, 9, 1, -34]

reverse()

作用：用于反向排列列表中的元素，并不进行排序，而是将列表里的元素进行顺序上的前后颠倒；另外，reverse()和sort()一样：都是在原列表中进行操作，所以没有返回值，但是会改变原列表的值，如下例所示。 

>>> List = [122,23,1, 9,-34,546,12.3]
>>> List.reverse()
>>> List
[12.3, 546, -34, 9, 1, 23, 122]

查找元素

index()

作用：查找元素在列表中的位置，返回值为该元素在列表中的下标。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.index("c")
2
>>> List2 = ['a', 'b', 'c', 'd', 'e', 'a', 'b']
>>> List2.index("a")
0
>>> List2.index("a",2,6)
5

count()

作用：统计某个元素在列表中出现的次数，返回值为该元素的个数。

>>> List = ['a', 'b', 'c', 'd', 'e', 'a', 'b']
>>> List.count('a')
2

通用方法

• len()—取列表的长度

>>>T = [1,2,3,4,5]
>>>len(T)
5

• in—检查元素是否包含在列表中

>>>T = [1,2,3,(10,9,8)]
>>>print(8 in T)
False

• max()—找出列表中的最大元素

>>>T = [21,2,3,4,5,8,0]
>>>print (max(T))
21

• min()—找出列表中的最小元素

>>>T = [21,2,3,4,5,8,0]
>>>print(min(T))
0

• sum()—列表求和运算

>>>T = [21,2,3,4,5,8,0]
>>>print(sum(T))
43

• 列表的加法运算

>>>T = [21,2,3,4,5,8,0]
>>>t = ['a', 'b', 'c']
>>>print (T+t)
[21,2,3,4,5,8,0,'a','b','c']

• 列表的乘法运算

>>>T = ['a', 'b', 'c', 'd']
>>>print(T*2)
['a', 'b','c','d','a','b','c','d']

map()函数的使用

map()是 Python 的内置函数，会根据提供的函数对指定的序列做映射。

第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列。

把函数依次作用在列表中的每一个元素上，得到一个新的列表并返回。注意，map()函数不改变原列表，而是返回一个新列表，如下例所示。

def square (x):
    return x**2
l=list(map(square,[1,2,3,4,5]))
print(l)

运行结果∶

[1, 4, 9, 16, 25]

通过使用lambda 匿名函数的方法使用map()函数，如下例所示。

l=list(map(lambda x,y:x+y,[1,3,5,7,9],[2,4,6,8,10]))
print(l)

运算结果∶

[3, 7, 11, 15, 19]

通过 lambda 函数使返回值是一个元组，如下例所示。

l=list(map(lambda x,y:(x**y,x+y),[2,4,6],[3,2,1]))
print(l)

运算结果∶

[(8, 5), (16, 6), (6, 7)]

map()函数还可以实现类型转换。

例1 将元组转换为列表

l=list(map(int,(1,2,3)))
print (1)

运算结果∶

[1,2,3]

例2 将字符串转换为列表

l=list(map(int,'1234'))
print(l)

运算结果∶

[1,2,3,4]

例3 提取字典中的键，并将结果放在一个列表中

l=list(map(int,{1:2,2:3,3:4}))
print(l)

运算结果∶

[1,2,3]

zip()函数的使用

• 描述

  zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

  我们可以使用 list() 转换来输出列表。

  如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

• 语法

  zip([iterable, ...])
  

  参数说明：iterabl -- 一个或多个迭代器，如列表;

• 返回值

​ 返回一个zip对象，可以使用 list() 转换来输出列表。

• 实例

  以下实例展示了 zip 的使用方法：

  >>> a = [1,2,3]
  >>> b = [4,5,6]
  >>> c = [4,5,6,7,8]
  >>> zipped = zip(a,b)     # 返回一个对象
  >>> zipped
  <zip object at 0x103abc288>
  >>> list(zipped)  # list() 转换为列表
  [(1, 4), (2, 5), (3, 6)]
  >>> list(zip(a,c))              # 元素个数与最短的列表一致
  [(1, 4), (2, 5), (3, 6)]
  
  >>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
  >>> list(a1)
  [1, 2, 3]
  >>> list(a2)
  [4, 5, 6]
  

列表推导式

列表推导式也称为列表解析式，可以使用非常简洁的方式对列表或其他可迭代对象的元素进行遍历、过滤或再次计算，快速生成满足特定需求的新列表，代码简洁，具有很强的可读性，是推荐使用的一种技术。

列表推导式在逻辑上等价于一个循环语句，只是形式上更加简洁。

例：

lis=[i*i for i in range(3)]
lis
[0, 1, 4]

等价于：

>>> for i in range(3):
    lis.append(i*i)    
>>> lis
[0, 1, 4]

本例也可以利用Python函数式编程的特点,使用map()实现同样的功能。

  >>> lis=list(map(lambda i:i*i,range(3)))
  >>> lis
  [0, 1, 4]

模拟考题

考题1 单选题

求1-100之内能被4整除，但是不能被5整除的所有数，正确的列表推导式是？（ ）

A. print([for x in range(0, 100) if x % 4 == 0 and x % 5 != 0])

B. print([for x in range(1, 101) if x % 4 == 0 and x % 5 != 0])

C. print([x for x in range(0, 100) if x % 5 == 0 and x % 4 != 0])

D. print([x for x in range(1, 101) if x % 4 == 0 and x % 5 != 0])

答案：D

解析：列表推导式的应用

考题2 单选题

小明将社会主义核心价值观存放在一个列表lis当中，lis=["富强","民主","文明","和谐","自由","平等","公正","法治","爱国","敬业","诚信","友善"]。请问以下哪一个选项能够正确显示出“爱国”这个词组？（ ）

A. lis[9]

B. lis[-5]

C. lis[2:10][-2]

D. lis[:-2][-3]

答案：C

解析：本题主要考察学生对列表中索引及切片的理解和认识。在Python中列表的索引值从0开始。因此A选项是错误的。在Python中列表的索引值可以为负值，从列表右侧开始为-1。因此B选项错误。对列表切片操作后可以组成新的列表，其索引值同样从0或-1开始。因此C选项正确。

考题3 单选题

已知一个列表lis = [5, 8, 'x', ['yy', 202, ['k3', ['aa', 2, '5']], 78], 'ca', 'sdv']。下列选项不能把列表lis中’aa’字符串变为大写‘AA’字符串的是？（ ）

A. lis[3][2][1][:1] = ['AA']

B. lis[3][2][1][0] = lis[3][2][1][0].upper()

C. lis[-3][-2][-1][0] = "AA"

D. lis[-3][-2][-1][0].upper()

答案：D

解析：本题重点考察列表的嵌套及列表中大小写转换函数的应用。在D选项中，没有进行赋值操作，故不能将列表中’aa’字符串变为大写‘AA’字符串。

考题4 单选题

以下哪个选项不能生成列表['data1', 'data3', 'data5', 'data7', 'data9'] ？（ ）

A.

list1 = []
for i in range(1,10,2):
    list1.append("data{}".format(i))
print(list1)

B.

list2 = [ "data{}".format(i)for i in range(1,10,2)]
print(list2)

C.

list3= []
for i in range(10):
    if i %2 == 1:
        list3.append("data{}".format(i))
print(list3)

D.

list4 = [ "data{}".format(i) for i in range(0,10) if i % 2 == 0]
print(list4)

答案：D

解析：

list4 = [ "data{}".format(i) for i in range(0,10) if i % 2 == 1]

或者

list4 = [ "data{}".format(i) for i in range(1,10) if i % 2 == 1]

考题5 单选题

下列语句正确的输出是？（ ）

lis= [4 * c for c in "draw"]
print(tuple(lis))

A. ('4d', '4r', '4a', '4w')

B. ('dddd', 'rrrr', 'aaaa', 'wwww')

C. ('draw', 'draw', 'draw', 'draw')

D. (4d, 4r, 4a, 4w)

答案：B

解析：列表推导式会遍历后面的可迭代对象,然后按照for前的表达式进行运算生成列表，最终转换为元组

考题6 单选题

已知一个字符串s="iloveyou"。通过操作该字符串构造一个新的列表li=['i', 'oveyou']。以下哪个选项不能构造新列表li？（　）

A. li = s.split("l",0)

B. li = s.split("l",1)

C. li = s.split("l",2)

D. li = s.split("l",3)

答案：A

解析：本题主要考察split()函数的用法。拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（list）。 其语法规则为：str.split(str="",num=string.count(str)) str:表示为分隔符，默认为空格，但是不能为空('')。若字符串中没有分隔符，则把整个字符串作为列表的一个元素 num:表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量

考题7 判断题

一个完整的切片表达式包含两个“:”，用于分隔三个参数（start_index、end_index、step），当只有一个“:”时，默认第三个参数step=0。（ ）

答案：错误

解析：当只有一个“:”时，默认第三个参数step=1

元组-tuple

元组的概念

• 类型名称：tuple
• 定界符：()
• 可变性：不可变
• 有序性：有序
• 对元素类型与值的要求：无
• 元素可否重复：可以
• 元素查找速度：较慢
• 增删元素速度：不可以

元组是轻量级的列表，在形式上元组的所有元素放在一对圆括号中，元素之间使用逗号分隔，如果元组中只有一个元素，则必须在最后增加一个逗号。

>>> t=(1,2,3)    #正常方式
>>> t2=1,2,3    #可省略小括号
>>> t=()        #空元组
>>> t=(1,)        #一个元素的元组

元组属于不可变序列，其元素的值是不可改变的。元组中元素可包含可变序列。例：

>>> t=([1,2],3)
>>> t[0][0]=4
>>> t
([4, 2], 3)
>>> t[0].append(6)
>>> t
([4, 2, 6], 3)

但是，不支持原位改变。例如上例中：

>>> t
([4, 2, 6], 3)
>>> t[0]=t[0]+[9]
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    t[0]=t[0]+[9]
TypeError: 'tuple' object does not support item assignment
>>>

元组的相关方法

元组的以下运算和方法和列表相同。

1. len(): 获取元组的长度。

2. in：检查元素是否包含在元组中。

3. max()：求最大元素。

4. min()：求最小元素。

5. sum()：求和运算。

6. +：元组的加法运算。元组虽然是不可变序列，但是依然可以进行加法运算。元组的加法是将两个元组结合在一起，形成一个新的元组，并不改变原元组的值。

7. *：元组的乘法运算。元组也可以进行乘法运算，和列表的乘法运算一 样，也是将元组的元素重复相应的次数。

8. index()

9. count()

10. sorted()：由于元组是不可变序列，所以无法使用sort()进行排序，但是可以使用 sorted()进行排序，会生成一个列表，而不是元组。

11. map和zip函数

生成器推导式

生成器推导式的用法与列表推导式相似，使用圆括号作为定界符。

与列表推导式最大的不同是生成器推导式的结果是一个生成器对象。生成器对象类似于迭代器对象。具有惰性求值的特点，比列表推导式更高效，空间占用少。

使用生成器对象的元素时，可以将其转换为列表或元组，也可以使用生成器对象的__next__()方法或next()函数进行遍历。或者直接使用for循环来遍历其中的元素。只能从左往后正方向访问其中的元素。没有任何方法可以再次访问已访问过的元素，也不支持使用下标访问其中的元素。

>>> t=((i+2)**2 for i in range(3))#创建生成器对象
>>> t
<generator object <genexpr> at 0x000001CADAFA08C8>
>>> tuple(t)
(4, 9, 16)
>>> list(t)#遍历结束，无元素
[]

使用__next__()方法或next()函数进行遍历

>>> t=((i+2)**2 for i in range(3))
>>> t.__next__()
4
>>> t.__next__()
9
>>> next(t)
16

使用for循环来遍历

>>> t=((i+2)**2 for i in range(3))
>>> for i in t:
    print(i,end=" ")

4 9 16

关键字yield

Python中有一个非常有用的语法叫做生成器，用到的关键字就是yield。yield的作用是把一个函数变成生成器(generator)，起到一个延迟的作用。

如下示例，输出斐波那契數列前 N 个数：

def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max: 
        yield b      # 使用 yield
        # print b 
        a, b = b, a + b 
        n = n + 1

for n in fab(5): 
    print n

输入结果如下：

1 
1 
2 
3 
5

简单地讲，yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator，调用 fab(5) 不会执行 fab 函数，而是返回一个 iterable 对象！在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。

也可以手动调用 fab(5) 的 __next()__ 方法（因为 fab(5) 是一个 generator 对象，该对象具有 next() 方法），这样我们就可以更清楚地看到 fab 的执行流程：

>>> f = fab(5) 
>>> f.__next__()
1
>>> f.__next__()
1
>>> f.__next__()
2
>>> f.__next__()
3
>>> f.__next__()
5
>>> f.__next__()
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    f.__next__()
StopIteration

当函数执行结束时，generator 自动抛出 StopIteration 异常，表示迭代完成。在 for 循环里，无需处理 StopIteration 异常，循环会正常结束。

模拟考题

考题1 单选题

计算1-100之间的完全平方数，正确的生成器推导式是？（ ）

A. square = (x**2 for x in range(10))

B. square = (x**2 for x in range(11))

C. square = (x**2 for x in range(1,11))

D. square = [x**2 for x in range(1,10)]

答案：C

解析：生成器推导式的应用

考题2 单选题

下面哪个语句正确定义了元组类型数据tuple1？（ ）

A. tuple1=["张三","李四","王五"]

B. tuple1=("张三";"李四";"王五")

C. tuple1=(张三,李四,王五)

D. tuple1=("张三",)

答案：D

解析：元组定义符号为“()”,多个元素之间用英文“,”分割，当只有一个元素时，要加“,”。

考题3 单选题

关于各类推导式的运用的表述中，错误的是？（ ）

A. yield作为Python的关键字之一，在生成器函数中用来返回值。

B. 使用生成器对象的元素时，不可以将其根据需要转化为列表或者元组。

C. 与列表推导式不同的是，生成器推导式的结果是一个生成器对象，而不是列表，也不是元组。

D. 从形式上看，生成器推导式与列表推导式非常接近，只是生成器推导式使用圆括号而不是列表推导式所使用的方括号。

答案：B

解析：使用生成器对象的元素时，可以根据需要将其根据需要转化为列表或者元组

考题4 单选题

Python中yield是一个类似return 的关键字，迭代一次遇到yield时就返回yield后面(右边)的值。下一次迭代时，从上一次迭代遇到的yield后面的代码(下一行)开始执行。下列程序的输出结果是？（ ）

def fun():
    a,b = 1,1
    while True:
        yield a
        a,b = b,a+b
c = fun()
for i in range(6):
    print(c.__next__(),end = ' ')

A. 1 1 2 3 5 8

B. 1 1 2 2 3 3

C. 8 5 3 2 1 1

D. 1 2 3 4 5 6

答案：A

解析：运用序列解包，该程序的功能是输出斐波那契数列前6项

考题5 单选题

计算三位完全平方数（100-999范围内），正确的生成器推导式是？（　）

A. square = (x**2 for x in range(10,32))

B. square = (x**2 for x in range(32))

C. square = (x**2 for x in range(10,31))

D. square = [x**2 for x in range(31)]

答案：A

解析：生成器推导式的语法格式如下：

(表达式 for 迭代变量 in 可迭代对象 [if 条件表达式])

考题6 判断题

元组是一种有序的序列结构，元素可重复，数据类型可不相同，元素可以修改。（ ）

答案：错误

解析：元组的元素是不能修改的

考题7 判断题

使用生成器对象的元素时，不可以将其根据需要转化为列表或者元组。（　）

答案：错误

解析：使用生成器对象的元素时，可以将其根据需要转化为列表或者元组。

字符串-str

字符串的概念：

在Python中，字符串属于不可变有序序列。使用单引号、双引号、三个单引号或三个双引号作为定界符，并且不同的定界符之间可以互相嵌套。

除了支持序列通用操作(双向索引、比较大小、计算长度、元素访问、切片、成员测试等)以外，字符串类型还支持一些特有的用法，例如字符串格式化、查找、替换等，但由于字符串属于不可变序列，不能直接对字符串对象进行元素增加、修改与删除等操作，切片操作也只能访问其中的元素，而无法修改字符串中的字符。

Python支持短字符串驻留机制，不支持长字符串驻留机制。对于短字符串将其赋值给多个不同的对象时，内存中只有一个副本，多个对象共享该副本。然而这一点并不适用于长字符串。

>>> a='1234'
>>> b='1234'
>>> id(a)==id(b)
True

>>> a='1234'*5000
>>> b='1234'*5000
>>> id(a)==id(b)
False

Python3.x完全支持中文字符，默认使用UTF-8编码格式，无论是一个数字、英文字母，还是一个汉字，都按一个字符处理。在Python3.x中甚至可以使用中文作为变量名、函数名等标识符，但不建议这样做。

字符串的以下运算和方法和列表相同：

字符串的访问、字符串的截取、len()、in、max()、min()、字符串的加法（连接）、字符串的乘法（重复输出）、sorted()、index()、count()

字符串的转义符

​ 转义字符是指在字符串中某些特定的符号前加一个斜杠，之后该字符将被解释为另一种含义，不再表示本来的字符。常用的转义符如下：

• \n 换行符；
• \r 回车；
• \t 水平制表符；
• \v 垂直制表符；
• \\ 一个斜杠；
• \’ 单引号；
• \” 双引号；
• \ooo 3位八进制对应的字符；
• \xhh 2位十六进制对应的字符；
• \uhhhh 4位十六进制对应的Unicode字符

>>> print('\101') #3位八进制对应的字符
A
>>> print('\102')
B
>>> print('\x41') #2位十六进制对应的字符
A
>>> print('\x48')
H
>>> print('\u4eba\u751f\u82e6\u77ed') #4位十六进制对应的Unicode字符
人生苦短

格式化输出

Python支持格式化字符串的输出，格式化输出有两种方式，一种是％, 一 种是 format。

%格式化输出

• %s：格式化输出字符串

• %d：格式化输出整数

• %f：格式化输出浮点数（%.2f保留两位小数）

• %c：单个字符

• %b：二进制整数

• %o：八进制整数

• %x：十六进制整数

>>> a=123
>>> s='%o'%a
>>> s
'173'
>>> s='%x'%a
>>> s
'7b'
>>> s='%s'%a
>>> s
'123'

>>> print("我的名字是%s，今年%d，体重%.2f斤。" % ('小明', 12,65.25) )
我的名字是小明，今年12，体重65.25斤。

format格式化输出

第一种：不设置指定位置，按默认顺序，如下例所示。

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'

第二种：使用format后面的元组索引位置格式，如下例所示。

>>> print('1乘以{0}等于{0}, 2乘以{1}等于{2}。'.format(3,4,8))
1乘以3等于3, 2乘以4等于8。

第三种：使用命名方式，给每个需要格式化的位置命名，然后在format中 进行变量赋值，如下例所示。

>>> print ('我叫{name}，我会的编程语言有{program1}'.format(name='张三',program1='Python'))
我叫张三，我会的编程语言有Python

str()函数

str()函数可以将任意类型转换为字符串

>>> str([1,2,3])
'[1, 2, 3]'
>>> str((1,2,3))
'(1, 2, 3)'

字符串的常用函数

replace()

>>> mystr = "hello world and Tmbc and Python"
>>> print(mystr.replace('and', 'he'))
hello world he Tmbc he Python

split()

作用：字符串分割，将一个完整的字符串使用分割符分割成字符串列表。

>>> Fruits="苹果,香蕉,橘子,葡萄"
>>> Fruits1=Fruits.split(",")
>>> Fruits1
['苹果', '香蕉', '橘子', '葡萄']

join()

作用：和split()的功能刚好相反，将列表结合为字符串。

>>> Fruits=['苹果', '香蕉', '橘子', '葡萄']
>>> Fruitsl = ",".join (Fruits)
>>> Fruitsl
'苹果,香蕉,橘子,葡萄'

find()、rfind()

find()和rfind()方法分别用来查找一个字符串在另一个字符串指定范围中首次和最后一次出现的位置，如果不存在，则返回-1。

>>> s='nihao！wohao'
>>> s.find('hao')
2
>>> s.rfind('hao')
8
>>> s.find('ta')
-1

lower()、upper()、capitalize()、title()

他们分别对字符串进行转换，新生成的字符串不对原字符串做任何修改。

• lower()用来将字符串转化为小写字母

>>> s1="Python"
>>> s1.lower()
'python'
>>> s1
'Python'

• upper()用来将字符串转化为大写字母

>>> s2="python"
>>> s2.upper()
'PYTHON'
>>> s2
'python'

• capitalize()将字符串首字母变为大写

>>> s3 = "this is string Example From Python!!!"
>>> s3.capitalize()
'This is string example from python!!!'
>>> s3
'this is string Example From Python!!!'

• title()将每个单词的首字母变为大写

>>> s4 = "this is string example from python!!!"
>>> s4.title()
'This Is String Example From Python!!!'
>>> s4
'this is string example from python!!!'

strip()、rstrip()、lstrip()

它们分别用来删除两端、右端、左端连续的空白字符或指定字符。

>>> s='   abc   '
>>> s1=s.strip()
>>> s1
'abc'
>>> s.rstrip()
'   abc'
>>> s.lstrip()
'abc   '

模拟考题

考题1 单选题

已知字符串：s="语文,数学,英语"，执行print(s.split(","))语句后结果是？（ ）

A. ['语文', '数学', '英语']

B. [语文, 数学, 英语]

C. ['语文, 数学, 英语']

D. ['语文 数学 英语']

答案：A

解析：s.split(",")是对字符串变量以“,”进行分割，返回类型为列表类型数据。

考题2 单选题

能输出下面字符串的是？（ ）

what's this?
it's an "apple"

A. print("what\'s this?\nit\'s an \"apple\"")

B. print("what's this? it's an \"apple\"")

C. print('what's this?\nit's an "apple"')

D. print("what\'s this?\nit\'s an "apple\"")

答案：A

解析：输出有换行，可以用“\n”转义，输出有单引号和双引号，可用\'和\"转义。

考题3 单选题

下面语句不能输出"我是小星，今年5岁。"的是？（ ）

A. print("我是{}，今年{}岁。".format("小星",5))

B. print("我是{name}，今年{age}岁。".format(age=5,name="小星"))

C. print("我是%s，今年%s岁。"%(5,"小星"))

D. print("我是%s，今年%d岁。"%("小星",5))

答案：C

解析：格式化输出，如果不用变量格式化输出时，需要格式化字符与数据一一对应。

考题4 单选题

已知字符串：s="python学习手册.txt"，下面语句不能输出"python学习手册"的是？（ ）

A. print(s[0:s.find(".txt")])

B. print(s[0:-4])

C. print(s.replace(".txt",""))

D. print(s.split("."))

答案：D

解析：s.split(".")返回的是列表数据类型。

考题5 单选题

回文指正读和反读都相同的字符序列，如“abba”、“abccba”、12321、123321是“回文”，“abcde”和“ababab”则不是“回文”。 在数学中具备这样特征的数就叫做回文数。假设字符变量a中存放的是一个三位数，下列语句不能取出字符变量a中的回文数的是？（ ）

A. a[2]+a[1]+a[0]

B. a[::-1]

C. a[-1]+a[-2]+a[-3]

D. a[-1:0:-1]

答案：D

解析：字符串的索引、切片操作的运用

考题6 单选题

Python中 print('十六进制{0:x}'.format(100)) 正确的输出结果是？（　）

A. 十六进制0:x64

B. 十六进制64

C. 十六进制0x100

D. 十六进制100

答案：B

解析：字符串的format()函数，x:输出整数的小写十六进制形式，十进制100的十六进制为64，正确的输出结果为"十六进制64"

考题7 判断题

在Python中设定字符串 str="Happy new year"， 则str.rfind('y')返回值为4。（　）

答案：错误

解析：str="Happy new year"， str.rfind('y')返回值为10。

考题8 判断题

Python中可以通过 .replace() 删除字符串开头和结尾的空格。（　）

答案：错误

解析：Python中可以通过.replace(old,new[,max])把字符串中的old字符串换成new字符串, 如果指定第三个参数max，则替换不超过 max 次

字典-dict

字典的概念

• 类型名称：dict
• 定界符：{}
• 可变性：可变
• 有序性：无序
• 对元素类型与值的要求：键值对
• 元素可否重复：键不可重复，值可重复
• 元素查找速度：非常快

• 增删元素速度：快

  字典是包含若干“键：值”元素的无序可变序列，字典中的每个元素包含用冒号分隔开的键和值两部分，表示一种映射或对应关系。定义字典时，每个元素的键和值之间用冒号分隔，不同元素之间用逗号分隔，所有的元素放在一对大括号中。

字典中元素的键可以是Python中任意不可变数据，例如整数、实数、复数、字符串、元组等类型，但不能使用列表、集合、字典或其他可变类型作为字典的键。

另外，字典的键不允许重复。值是可以重复的

字典的创建

字典的特性和声明方式入下图：

• 空字典

>>> d={}
>>> d
{}
>>> type(d)
<class 'dict'>

• 有数据字典

>>> e={'name':'Tom','age':20,"salary":3900}
>>> e
{'name': 'Tom', 'age': 20, 'salary': 3900}

• dict(key=value)方式声明字典

>>> book=dict(title='Python',author='Tom',price=59)
>>> book
{'title': 'Python', 'author': 'Tom', 'price': 59}

• dict([(key,value),(key,value),......])方式声明字典

>>> lst=[('name','Jerry'),('age',20)]
>>> emp=dict(lst)
>>> emp
{'name': 'Jerry', 'age': 20}
>>> type(emp)
<class 'dict'>

• dict.fromkeys([key1,key2,......])方式声明字典

>>> keys=['name','age','job']
>>> emp3=dict.fromkeys(keys)
>>> emp3
{'job': None, 'name': None, 'age': None}

字典的元素访问

常用方法如下：

判断键是否在字典中

使用in可以检测键是否在字典中，如果在则返回True，否则返回False；

但是这里要注意：in只检查键，并不检查值

>>> book={'title':'Python入门精典','author':'兰溪三中','price':59,'publisher':{'title':'浙江教育出版社','address':'杭州'}}
>>> book
{'author': '兰溪三中', 'title': 'Python入门精典', 'price': 59, 'publisher': {'address': '杭州', 'title': '浙江教育出版社'}}
>>> 'name' in emp
True
>>> 'Name' in emp
False
>>> 'price' in book
True

访问字典里的值

由于字典没有索引，所以我们不能使用索引的方法来访问字典。要访问字典里的值，有两种常用方法。

第一种：使用字典名加键进行访问，这种方法有点像是把键当作字典的“索引”来访问，格式为“字典名[键名]”，如下例所示。

>>> book = {'author': '兰溪三中', 'title': 'Python入门精典', 'price': 59, 'publisher': {'address': '杭州', 'title': '浙江教育出版社'}}
>>> print(book)
{'author': '兰溪三中', 'title': 'Python入门精典', 'price': 59, 'publisher': {'address': '杭州', 'title': '浙江教育出版社'}}
>>> book[0]
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    book[0]
KeyError: 0
>>> book['title']
'Python入门精典'
>>> book['price']
59
>>> book['publisher']['address']
'杭州'
>>> book['publisher']['title']
'浙江教育出版社'

注意：如果键不存在，则报KeyError错误

第二种：使用字典中的get()函数进行访问，格式为“字典名.get(键名)”， 如下例所示。

• 语法

字典序列.get(key, 默认值)

注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。

• 快速体验

>>> book['Title']
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    book['Title']
KeyError: 'Title'
>>> book.get('title')
'Python入门精典'
>>> book.get('Title')

>>> book.get('Title','未找到')
'未找到'

遍历字典对象

遍历字典对象，则是遍历对应的key，例如：

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1:
    print(key)

输出：

name
age
gender

遍历字典的key

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
    print(key)

输出：

name
age
gender

遍历字典的value

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
    print(value)

输出：

Tom
20
男

遍历字典的元素

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
    print(item)

输出：

('name', 'Tom')
('age', 20)
('gender', '男')

遍历字典的键值对

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
    print(key,'=',value)

输出：

name = Tom
age = 20
gender = 男

修改和新增字典

修改已有的键的值

直接使用字典名加键的方式进行赋值即可，如下例所示。

>>> d = {"西瓜":9.6,"桃子":2,"苹果":4,"樱桃":12}
>>> d["樱桃"]=20
>>> print(d)
{'西瓜': 9.6, '桃子': 2, '苹果': 4, '樱桃': 20}
>>> d['梨']=8
>>> print(d)
{'西瓜': 9.6, '桃子': 2, '苹果': 4, '樱桃': 12, '梨': 8}

说明：如果字典中已有该键，则将该键的值修改为最新的值；如果字典中没有该键，则新增该键值对。

update()函数

写法：dict.update(dict2)

dict = {'Name': '张三', 'Age': 7}
dict2 = {'Sex': '男', 'Age': 79 }
dict.update(dict2)
print (dict)  #输出{'Name': '张三', 'Age': 79, 'Sex': '男'}

注意：字典dict2中key如果在dict1中存在则修改dict1这个key对应的值 ，如果key不存在则dict1新增此键值对。

删除字典

del() / del

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']  # del(dict1['gender'])为另外一种写法
print(dict1)    # 结果：{'name': 'Tom', 'age': 20}

说明：如果指定键则删除对应的键值对，不指定则删除整个字典

clear()

说明：用于删除字典内所有元素

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1)  # {}

pop()

说明：删除字典给定键 key 及对应的值，返回值为被删除的值。key 值必须给出。 否则，返回 default 值。

>>> dict = {'Name': '张三', 'Age': 7}
>>> pop_obj=dict.pop('Name')
>>> print(pop_obj)
张三
>>> dict
{'Age': 7}
>>> dict.pop('aaa','不存在')
'不存在'

popitem()

说明：返回并删除字典中的最后一对键和值。

>>> dict = {'Name': '张三', 'Age': 12, 'Class': '4年级'}
>>> pop_obj=dict.popitem()
>>> print(pop_obj)
('Class', '4年级')
>>> print(dict )
{'Name': '张三', 'Age': 12}

len()—取字典的长度

>>> dict = {'牛奶':'18元','鸡蛋':'30元','薯条':'23元'}
>>> print(len(dict))
3

copy()方法

Python 字典 copy() 函数返回一个字典的浅复制。

• copy()方法语法：

dict.copy()

返回一个字典的浅复制。

• 实例

以下实例展示了 copy()函数的使用方法：

dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

dict2 = dict1.copy()
print ("新复制的字典为 : ",dict2)

以上实例输出结果为：

新复制的字典为 :  {'Age': 7, 'Name': 'Runoob', 'Class': 'First'}

• 直接赋值和 copy 的区别

可以通过以下实例说明：

dict1 =  {'user':'runoob','num':[1,2,3]}

dict2 = dict1          # 浅拷贝: 引用对象
dict3 = dict1.copy()   # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，子对象是引用

# 修改 data 数据
dict1['user']='root'
dict1['num'].remove(1)

# 输出结果
print(dict1)
print(dict2)
print(dict3)

实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。

{'user': 'root', 'num': [2, 3]}
{'user': 'root', 'num': [2, 3]}
{'user': 'runoob', 'num': [2, 3]}

字典推导式

>>> {str(i):1 for i in range(1,4)}
{'1': 1, '2': 1, '3': 1}
>>> x=["A","B","C"]
>>> y=["a","b","c"]
>>> {i:j for i,j in zip(x,y)}
{'A': 'a', 'B': 'b', 'C': 'c'}

模拟考题

考题1 单选题

运行下列程序，输出结果正确的一项是？（ ）

ds = {'aa':2,'bb':4,'cc':9,'dd':6}
print(ds.popitem(), len(ds))

A. ('aa', 2) 4

B. ('dd', 6) 4

C. ('bb', 2) 3

D. ('dd', 6) 3

答案：D

解析：Python 字典 popitem() 方法表示，从字典中删除最后一个项目

考题2 单选题

下列books是一个字典，有一个for循环如下：

for  info1,info2 in books.items( ):
   print(info2)

上述info2可以得到什么？（　）

A. 键

B. 值

C. 键-值

D. 字典

答案：B

解析：字典键/值的简单应用，可以得到字典的值

考题3 单选题

下列代码运行后的结果是？（　）

dp={}
dp["2^10"]=1024
print(dp)

A. ['2^10': 1024]

B. {"2^10"}

C. 1024

D. {'2^10': 1024}

答案：D

解析：字典的创建、赋值、输出

考题4 判断题

当以指定“键”为下标给字典对象赋值时，若该“键”存在则表示修改该“键”对应的“值”，若不存在则抛出错误。（ ）

答案：错误

解析：若不存在则表示为字典对象添加一个新的“键-值对”

考题5 判断题

Python中字典(dict)的“值”可以是列表（list）、字典(dict)、集合（set）类型。（　）

答案：正确

解析：Python字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型

集合-set

集合的概念

• 类型名称：set
• 定界符：{}
• 可变性：可变
• 有序性：无序
• 对元素类型与值的要求：可哈希
• 元素可否重复：不可以
• 元素查找速度：非常快
• 增删元素速度：快

集合属于Python无序可变对象，使用一对大括号 { } 作为定界符，元素之间使用逗号分隔， 或者也可以使用 set() 函数创建集合。

同一个集合内的每个元素都是唯一的，元素之间不允许重复，如果有重复值，则只保留一个。

集合中只能包含数字、字符串、元组等不可变类型(可哈希)的数据，而不能包含列表、字典、集合等可变类型数据。可以使用set函数将列表、元组，字符串、range对象等其他可迭代对象转换为集合。如果原来的数据中存在重复元素，则在转化为集合时只留一个；如果原序列和迭代对象中有不可哈希的值，无法转换成集合，抛出异常。

集合的创建

创建格式：

parame = {value01,value02,...}
或者
set(value)

以下是一个简单实例：

set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

更多实例如下：

>>> s=set(range(3))                    #把range对象转集合。例：
>>> s
{0, 1, 2}

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

类似列表推导式，同样集合支持集合推导式(Set comprehension):

>>> {i.strip() for i in ('hello ','zhang  ','  san')}
{'hello', 'zhang', 'san'}

>>> {str(i) for i in range(3)}
{'1', '0', '2'}

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

访问集合元素

由于集合是无序的，因此不能像列表和元组那样通过索引来访问元素。但是，我们可以使用循环或者使用in关键字来判断元素是否存在于集合中。

thisset={"Google", "Runoob", "Taobao"}
# 使用循环访问集合元素
for fruit in thisset:
    print(fruit)

元素是否在集合中-in

语法格式如下：

x in s

判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False

添加元素-add

• 语法格式如下：

s.add( x )

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作，不会抛出异常。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

合并集合-update

update()合并另外一个集合中的元素到当前集合中，并自动去除重复元素，参数可以是列表，元组，字典等。

语法格式如下：

s.update( x )

x 可以有多个，用逗号分开。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

移除元素

remove()

remove()删除集合中的指定元素，如果指定元素不存在，则抛出异常

语法格式如下：

s.remove( x )

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'

discard()

discard方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

实例：

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

随机删除-pop()

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop()

实例：

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)

输出结果：

Runoob

多次执行测试结果都不一样。

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

清空集合-clear()

语法格式如下：

s.clear()

清空集合 s。

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

计算集合元素个数-len()

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3

集合交集-intersection()

intersection() 方法用于返回两个或更多集合中都包含的元素，即交集。

语法：

set.intersection(set1, set2 ... etc)

参数

• set1 -- 必需，要查找相同元素的集合
• set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开

返回值

​ 返回一个新的集合。

实例

返回一个新集合，该集合的元素既包含在集合 x 又包含在集合 y 中：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.intersection(y) 
print(z)

输出结果为：

{'apple'}

集合并集-union()

union() 方法返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。

语法：

set.union(set1, set2...)

参数

• set1 -- 必需，合并的目标集合
• set2 -- 可选，其他要合并的集合，可以多个，多个使用逗号 , 隔开。

返回值

返回一个新集合。

实例

合并两个集合，重复元素只会出现一次：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.union(y) 
print(z)

输出结果为：

{'cherry', 'runoob', 'google', 'banana', 'apple'}

集合差集-difference()

difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。

语法：

set.difference(set)

参数

• set -- 必需，用于计算差集的集合

返回值

返回一个新的集合。

实例

返回一个集合，元素包含在集合 x ，但不在集合 y ：

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y) 
print(z)

输出结果为：

{'cherry', 'banana'}

集合的其他方法

内置函数len()、max()、min()、sum()、sorted()、map()、filter()、enumerate()等也适合于集合。

支持数学意义上的交集、并集、差集等运算。

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

关系运算符>、>=、<、<=作用于集合时，表示集合之间的包含关系，而不是比较结合中元素的大小关系。

模拟考题

考题1 单选题

下列语句在运行时会出现错误的是？（ ）

A. s = {1,2,'three', 'four', (10, 11)}

B. s = {1,2,3,3,4}

C. s = {1,2,['three', 'four' ],(10, 11)}

D. s= set([1,2,3,4])

答案：C

解析：集合元素是不可变类型，所以可以使用数值、字符串、元组，而不能使用列表 字典当做元素值。

考题2 单选题

运行下面代码，程序输出正确的一项是？（ ）

s = {1,2,3,4,5}
s.update({s.add(9),3,7,2,s.remove(5)})
print(s)

A. {1,2,3,4,5,9}

B. {1,2,3,4,,7,9}

C. {1,9,3,7,,2}

D. {1,2,3,4,7,9,None}

答案：D

解析：本题主要考察集合中多个函数的组合应用:

• add()将元素9 添加到集合 s 中
• update()合并另外一个集合中的元素到当前集合中，并自动去除重复元素，参数可以是列表，元组，字典 等

考题3 单选题

通过下列哪个方法，可以实现两个集合交集的操作？（ ）

A. copy()

B. intersection()

C. union()

D. update()

答案：B

解析：集合的基本应用:

• copy()：复制集合
• intersection()：用于返回两个或更多集合中都包含的元素，即交集
• union() ：返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。
• update()合并另外一个集合中的元素到当前集合中，并自动去除重复元素，参数可以是列表，元组，字典 等

考题4 单选题

集合A是曾经到云南旅游的人，集合B是曾经到海南旅游的人，如果现在想要得到曾经到海南但是不曾到过云南旅游的人，可以使用那一种集合功能？（　）

A. A & B

B. A | B

C. A - B

D. B - A

答案：D

解析：集合的差集运算，返回一个新集合，包括在集合B中但不在集合A中的元素

考题5 单选题

请问以下Python代码输出的结果是？（ ）

a = {i**2 for i in (6,7,8) if i>3}
print(a)

A. (36,49,64)

B. {64, 49, 36}

C. {64,49}

D. {2,36,64}

答案：B

解析：集合推导式格式为：{expr for value in collection}或： {expr for value in collection if condition}

考题6 判断题

Python集合支持使用下标访问其中的元素。（ ）

答案：错误

解析：Python集合不支持使用下标访问其中的元素。

考题7 判断题

乐器社团活动，小明用Python进行信息汇总，为了便于操作，他使用了各个元素之间没有先后顺序的集合类型。（　）

答案：确

解析：Python中的集合元素是无序的

考题8 判断题

无法通过引用索引来访问集合中的元素，但是可以用for循环来遍历集合中的元素。（　）

答案：正确

解析：由于集合是无序的，因此不能像列表和元组那样通过索引来访问元素。但是，我们可以使用循环或者使用in关键字来判断元素是否存在于集合中。