Python语言程序设计（北京理工大学）第六周_Python Programming week06
1. 关于Python组合数据类型，以下描述错误的是：
A. 序列类型是二维元素向量，元素之间存在先后关系，通过序号访问
B. 组合数据类型可以分为3类：序列类型、集合类型和映射类型
C. 组合数据类型能够将多个相同类型或不同类型的数据组织起来，通过单一的表示使数据操作更有序、更容易
D. Python的字符串、元组和列表类型都属于序列类型
序列类型总体上可以看成一维向量，如果其元素都是序列，则可被当作二维向量。
2. 关于Python的元组类型，以下选项错误的是：
A. 元组一旦创建就不能被修改
B. 元组采用逗号和圆括号（可选）来表示
C. 一个元组可以作为另一个元组的元素，可以采用多级索引获取信息
D. 元组中元素必须是相同类型
序列类型（元组、列表）中元素都可以是不同类型。
3. 关于大括号{}，以下描述正确的是：
A. 直接使用{}将生成一个集合类型
B. 直接使用{}将生成一个元组类型
C. 直接使用{}将生成一个字典类型
D. 直接使用{}将生成一个列表类型
集合类型和字典类型最外侧都用{}表示，不同在于，集合类型元素是普通元素，字典类型元素是键值对。
字典在程序设计中非常常用，因此，直接采用{}默认生成一个空字典。
4. 哪个选项是下面代码的输出结果？
d= {'a': 1, 'b': 2, 'b': '3'}
print(d['b'])A. 1
B. 2
C. {'b':2}
D. 3
创建字典时，如果相同键对应不同值，字典采用最后（最新）一个"键值对"。
5. S和T是两个集合，哪个选项对S^T的描述是正确的？
A. S和T的补运算，包括集合S和T中的非相同元素
B. S和T的交运算，包括同时在集合S和T中的元素
C. S和T的差运算，包括在集合S但不在T中的元素
D. S和T的并运算，包括在集合S和T中的所有元素
集合"交并差补"四种运算分别对应的运算符是：& | - ^
6. 以下不是Python序列类型的是：
A. 数组类型
B. 元组类型
C. 字符串类型
D. 列表类型
Python内置数据类型中没有数组类型。
7. 序列s，哪个选项对s.index(x)的描述是正确的？
A. 返回序列s中序号为x的元素
B. 返回序列s中x的长度
C. 返回序列s中元素x所有出现位置的序号
D. 返回序列s中元素x第一次出现的序号
注意：s.index(x)返回第一次出现x的序号，并不返回全部序号。
8. 列表ls，哪个选项对ls.append(x)的描述是正确的？
A. 替换列表ls最后一个元素为x
B. 向ls中增加元素，如果x是一个列表，则可以同时增加多个元素
C. 只能向列表ls最后增加一个元素x
D. 向列表ls最前面增加一个元素x
ls.append(x)，如果x是一个列表，则该列表作为一个元素增加的ls中。
9. 给定字典d，哪个选项对d.values()的描述是正确的？
A. 返回一个元组类型，包括字典d中所有值
B. 返回一个列表类型，包括字典d中所有值
C. 返回一种dict_values类型，包括字典d中所有值
D. 返回一个集合类型，包括字典d中所有值
运行如下代码：（其中d是一个预定义的字典）
>>> d = {"a":1, "b":2}
>>> d
{'a': 1, 'b': 2}
>>> type(d.values())
输出结果是：
d.values()返回的是dict_values类型，这个类型通常与for..in组合使用。
10. 给定字典d，哪个选项对x in d的描述是正确的？
A. x是一个二元元组，判断x是否是字典d中的键值对
B. 判断x是否是字典d中的值
C. 判断x是否是字典d中的键
D. 判断x是否是在字典d中以键或值方式存在
键是值的序号，也是字典中值的索引方式。
因此，x in d 中的x被当作d中的序号进行判断。
>>> A = {"python", 123, ("python", 123)}
>>> print(A)
{'python', 123, ('python', 123)}
>>> B = set("pypy123")
>>> print(B)
{'y', '3', '2', 'p', '1'}
>>> C = {"python", 123, "python", 123}
>>> print(C)
{'python', 123}>>> A = {"p", "y", 123}
>>> B = set("pypy123")
>>> print(A)
{123, 'y', 'p'}
>>> print(B)
{'y', '3', '2', 'p', '1'}
>>> A-B
{123}
>>> B-A
{'2', '3', '1'}
>>> A&B
{'y', 'p'}
>>> A|B
{'y', '3', '2', 'p', '1', 123}
>>> A^B
{'2', '1', 123, '3'}>>> A = {"p", "y", 123}
>>> print(A)
{123, 'y', 'p'}
>>> for item in A:
print(item, end="")
123yp
>>> print(A)
{123, 'y', 'p'}
>>> try:
while True:
print(A.pop(), end="")
except:
pass
123yp
>>> print(A)
set()>>> "p" in {"p", "y", 123}
True
>>> {"p", "y"} >= {"p", "y", 123}
False
>>> {"p", "y"} < {"p", "y", 123}
True
>>> {"p", "y", 123} < {"p", "y", 123}
False
>>> {"p", "y", 123} <= {"p", "y", 123}
True# set的应用：数据去重
>>> ls = ["p", "p", "y", "y", 123]
>>> s = set(ls)
>>> print(s)
{123, 'y', 'p'}
>>> lt = list(s)
>>> print(lt)
[123, 'y', 'p']>>> ls = ["python", 123, ".io"]
>>> ls[::-1]
['.io', 123, 'python']
>>> s = "python123.io"
>>> s[::-1]
'oi.321nohtyp'>>> ls = ["python", 123, ".io"]
>>> len(ls)
3
>>> s = "python123.io"
>>> max(s)
'y'>>> def func():
return 1,2
>>> func()
(1, 2)
>>> creature = "cat", "dog", "tiger", "human"
>>> creature
('cat', 'dog', 'tiger', 'human')
>>> color = (0x001100, "blue", creature)
>>> color
(4352, 'blue', ('cat', 'dog', 'tiger', 'human'))
>>> creature[::-1]
('human', 'tiger', 'dog', 'cat')
>>> color[-1][2]
'tiger'>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls
['cat', 'dog', 'tiger', 1024]
>>> lt = ls
>>> lt
['cat', 'dog', 'tiger', 1024]>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls
['cat', 'dog', 'tiger', 1024]
>>> ls[1:2] = [1,2,3,4]
>>> ls
['cat', 1, 2, 3, 4, 'tiger', 1024]
>>> del ls[::3]
>>> ls
[1, 2, 4, 'tiger']
>>> ls*2
[1, 2, 4, 'tiger', 1, 2, 4, 'tiger']>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls
['cat', 'dog', 'tiger', 1024]
>>> ls.append(1234)
>>> ls
['cat', 'dog', 'tiger', 1024, 1234]
>>> ls.insert(3, "human")
>>> ls
['cat', 'dog', 'tiger', 'human', 1024, 1234]
>>> ls.reverse()
>>> ls
[1234, 1024, 'human', 'tiger', 'dog', 'cat']# 定义空列表lt
>>> lt = list()
>>> lt
[]
>>> lt2 = []
>>> lt2
[]
# 向lt新增5个元素
>>> lt.append(1); lt.append(2); lt.append(3); lt.append(4); lt.append(5);
>>> lt
[1, 2, 3, 4, 5]
>>> lt2 += [1,2,3,4,5]
>>> lt2
[1, 2, 3, 4, 5]
# 修改lt中第二个元素
>>> lt[2] = "3"
>>> lt
[1, 2, '3', 4, 5]
# 向lt中第2个位置增加一个元素
>>> lt.insert(2, 3)
>>> lt
[1, 2, 3, '3', 4, 5]
# 从lt中第1个位置删除一个元素
>>> del lt[1]
>>> lt
[1, 3, '3', 4, 5]
# 删除lt中第1-3位置元素
>>> del lt[1:4]
>>> lt
[1, 5]
# 判断lt中是否包含数字0
>>> 0 in lt
False
# 向lt新增数字0
>>> lt.append(0)
>>> lt
[1, 5, 0]
# 返回数字0所在lt中的索引
>>> lt.index(0)
2
# lt的长度
>>> len(lt)
3
# lt中最大元素
>>> max(lt)
5
# 清空lt
>>> lt.clear()
>>> lt
[]>>> d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> d
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
>>> d["中国"]
'北京'
>>>
>>> de = {} # 建立空字典能用{}
>>> de
{}
>>> type(de)
>>> set = set() # 建立空集合不能用{}
>>> type(set)
>>> "中国" in d
True
>>>
>>> d.keys()
dict_keys(['中国', '美国', '法国'])
>>> d.values()
dict_values(['北京', '华盛顿', '巴黎']) >>> d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> d
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
>>> d.get("中国", "伊斯兰堡")
'北京'
>>> d
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
>>> d.get("巴基斯坦", "伊斯兰堡")
'伊斯兰堡'
>>> d
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
>>> d.popitem()
('法国', '巴黎')
>>> d
{'中国': '北京', '美国': '华盛顿'}# 定义空字典d
>>> d = {}
# 向d新增2个键值对元素
>>> d["key1"] = "value1"; d["key2"] = "value2"
>>> d
{'key1': 'value1', 'key2': 'value2'}
# 修改第2个元素
>>> d["key2"] = "value2_tmp"
>>> d
{'key1': 'value1', 'key2': 'value2_tmp'}
# 判断字符"c"是否是d的键
>>> "c" in d
False
# 计算d的长度
>>> len(d)
2
# 清空d
>>> d.clear()
>>> d
{}>>> import jieba
>>> jieba.lcut("中国是一个伟大的国家")
Building prefix dict from the default dictionary ...
Dumping model to file cache C:\Users\MoMo\AppData\Local\Temp\jieba.cache
Loading model cost 0.940 seconds.
Prefix dict has been built succesfully.
['中国', '是', '一个', '伟大', '的', '国家']