【python学习】字典、集合和序列

一、字典

字典可以理解为一种映射，类似C++中STL模板里的map。

比如整形数组建立了一种从数字到数字的映射，字符串数组建立了一种从数字到字符串的映射。
而字典则可建立更广泛的映射。比如可以建立字符串到数字的映射、元祖到字符串的映射。

映射中有一对关键概念，即：键（key）与值（value），其中键用来索引，值就是存储的对象。例如，字符串数组的键是数字，值就是字符串。这一对键值以二元组（key，value）的形式构成了字典的基本元素。在python里，需要注意的是，键只能是数字、字符串或元祖等不可变类型，不能取列表这一类的可变类型。而值则可取任意类型。

字典用花括号{}表示，键值之间用冒号:隔开。如：

>>> dic = {
     "name":"Tom", 'age':12,'love':'girl'}
>>> type(dic)
<class 'dict'>

练习题

1、字典基本操作
字典内容如下：

dic= {
      
'python': 95,
'java': 99,
'c': 100
}

用程序解答下面的题目:

• 字典的长度是多少

• 请修改java’这个key对应的value值为98

• 删除c这个key

• 增加一个key-value对、 key值为php，value是90

• 获取所有的key值，存储在列表里

• 获取所有的value值，存储在列表里

• 判断javascript是否在字典中

• 获得字典里所有value的和

• 获取字典里最大的value

• 获取字典里最小的value

• 字典dic1 = {‘php’: 97}、 将dic1的数据更新到dic中

分析：主要考察列表的基本操作，代码如下：

>>> dic
{
     'python': 95, 'java': 99, 'c': 100}	#初始字典

>>> len(dic)	#查询字典的长度
3

>>> dic['java'] = 98	#修改'java'这个key对应的value值为98
>>> dic
{
     'python': 95, 'java': 98, 'c': 100}

>>> del dic['c']	#删除c这个key
>>> dic
{
     'python': 95, 'java': 98}

>>> dic['php'] = 90	#增加一个key-value对、 key值为php，value是90
>>> dic
{
     'python': 95, 'java': 98, 'php': 90}	

>>> lst = list(dic.keys())	#获取所有的key值，存储在列表里
>>> lst
['python', 'java', 'php']

>>> lst = list(dic.values())	#获取所有的value值，存储在列表里
>>> lst
[95, 98, 90]

>>> 'javascript' in dic	#判断javascript是否在字典中
False

>>> sum(dic.values())	#获得字典里所有value的和
283

>>> max(dic.values())	#获取字典里最大的value
98

>>> min(dic.values())	#获取字典里最小的value
90

>>> dic1 = {
     'php': 97}	#将dic1的数据更新到dic中
>>> dic.update(dic1)
>>> dic
{
     'python': 95, 'java': 98, 'php': 97}

2、字典中的value

有一个字典，保存的是学生各个编程语言的成绩、内容如下

data = {
       'python':{
      '上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{
      '月考':'90', '期中考试': '94', '期末考试': '98'}]
        }

各门课程的考试成绩存储方式并不相同，有的用字典，有的用列表，但是分数都是字符串类型，
请实现函数transfer_ score(score_dict)，将分数修改成int类型

思路：使用递归思想，根据传入函数数据类型的不同，分类讨论。

• 递归边界为传入数据的类型为字符串，此时尝试修改字符串为int类型并返回该值。
• 注意字符串有可能不是数字，因此需要用异常处理进行特判，防止程序异常退出。
• 当传入数据的类型为字典或列表时，遍历其各个元素，对它们递归的调用此函数。并将返回值赋值给各元素。

def transfer_score(data):
    if type(data) == str: #递归边界
        try:
            data = int(data)
        except ValueError: #特判字符串不是数字的情形
            pass
    elif type(data) == dict:
        for i in data: #字典的遍历方法
            data[i] = transfer_score(data[i]) #注意这里要用赋值语句修改，否则传入的字典里的值无法得到修改
    elif type(data) == list:
        for i in range(len(data)): #列表的遍历方法
            data[i] = transfer_score(data[i])
    return data #将处理好的data返回

data = {
      'python':{
     '上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{
     '月考':'90', '期中考试': '94', '期末考试': '98'}]
        }

print(data)
transfer_score(data)
print('\n' + '*' * 30 + '修改后' + '*' * 30 + '\n')
print(data)

执行结果如下：

output：
{
     'python': {
     '上学期': '90', '下学期': '95'}, 'c++': ['95', '96', '97'], 'java': [{
     '月考': '90', '期中考试': '94', '期末考试': '98'}]}

******************************修改后******************************

{
     'python': {
     '上学期': 90, '下学期': 95}, 'c++': [95, 96, 97], 'java': [{
     '月考': 90, '期中考试': 94, '期末考试': 98}]}

二、集合

集合也是一种存储数据的容器，它的特点是没有索引，且各元素不能重复。这和数学中的概念相类似，在此不做赘述。

集合也用花括号{}表示，但没有键值的概念了。如：

>>> s = {
     1, 2, 2, 3, 5}
>>> s
{
     1, 2, 3, 5}	#注意集合元素不能重复，这里自动去掉了重复元素
>>> type(s)
<class 'set'>

练习题

1.怎么表示只包含一个数字1的元组。

思路：使用圆括号表示元祖

>>> tu = (1,)
>>> tu
(1,)
>>> type(tu)
<class 'tuple'>

2.创建一个空集合，增加{‘x",‘y’,z’}三个元素。

>>> s = set()
>>> s.add('x')
>>> s.add('y')
>>> s.add('z')
>>> s
{
     'x', 'z', 'y'}
>>> type(s)
<class 'set'>

3.列表[‘A’, ‘B’, ‘A’, ‘B’]去重。

思路：利用set去重

>>> lst = list(set(['A', 'B', 'A', 'B']))
>>> lst
['B', 'A']

4.求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素(差集指的是两个集合交集外的部分)。

思路：此即求两个集合的异或结果。对于集合A与B，A ^ B = (A - B) ∪ (B - A）

>>> s1 = {
     6, 7, 8}
>>> s2 = {
     7, 8, 9}
>>> s = s1 ^ s2
>>> s
{
     9, 6}

5.求{‘A’, ‘B’, ‘C’}中元素在{‘B’, 'C, ‘D’}中出现的次数。

res = 0
s1 = {
     'A', 'B', 'C'}
s2 = {
     'B', 'C', 'D'}
for i in s1:
    if i in s2:
        res += 1
print(res)

output: 2

三、序列

字符串、列表、元祖都可以算作序列，因为他们都能用整数索引。

练习题

1.怎么找出序列中的最大、小值?

使用max()，min()函数，用法如下：

代码一（数字型序列）

>>> lst = [2, 3, 4, 5, 1, -6]
>>> min(lst)
-6
>>> max(lst)
5
>>> type(min(lst))	#返回类型为int（）
<class 'int'>

>>> lst.append(-9.63)	#继续添加一个浮点数
>>> lst
[2, 3, 4, 5, 1, -6, -9.63]
>>> type(min(lst))	#可见返回类型会随具体情况而定，且int和float可以混用
<class 'float'>
>>> type(max(lst))
<class 'int'>

代码二（字符串型序列）

>>> lst = ['fef', '55', 'haha']
>>> lst
['fef', '55', 'haha']
>>> min(lst)
'55'
>>> max(lst)
'haha'
>>> type(min(lst))
<class 'str'>

代码三（单个字符串，可理解为字符序列）

<class 'str'>

>>> max('abcdABCD')
'd'
>>> type(max('abcdABCD'))
<class 'str'>

2.sort() 和sorted()区别

对于序列 lst 来说，lst.sort()是一个操作，会使原序列 lst 直接排好序，且无返回值。而sorted是一个函数，其返回值是排好序的序列，但原序列 lst 保持不变。用法为sorted(lst)

>>> print(sorted(lst))
['55', 'fef', 'haha']
>>> print(lst.sort())
None

3.怎么快速求1到100所有整数相加之和?

思路：直接用sum()函数求和，其中传入函数的序列用range()函数生成。

>>> sum(range(1, 101))
5050

4.求列表[2,3,4,5]中每个元素的立方根。

lst = [2,3,4,5]
for i in lst:
    if i != lst[-1]:
        print('%.2f' % (i ** (1 / 3)), end = ' ')
    else:
        print('%.2f' % i ** (1 / 3))

output：
1.26 1.44 1.59 1.71

5.将[‘x’,‘y’,‘z’] 和[1,2,3]转成[(‘x’,1), (‘y’,2), (‘z’,3)]的形式。

思路：使用zip()函数将两组序列分别合并成二元组的形式。

>>> a = ['x','y','z']
>>> b = [1,2,3]
>>> a, b
(['x', 'y', 'z'], [1, 2, 3])
>>> list( zip(a, b) )	#zip的返回值需要用list函数转化为列表
[('x', 1), ('y', 2), ('z', 3)]