字典，集合

元组的创建

(1)使用"="将一个元组赋值给变量

tuple_a = ('a', 'b', 'mpilgrim', 'z', 'example')
print(tuple_a)
tuple_b = (3,)  # 包含一个元素的元组，最后必须多写一个逗号
print(tuple_b)

(2)使用 tuple 函数将其他序列转换为元组

print(tuple('abcdefg'))  # 把字符串转换为元组
list_a = [-1, -4, 6, 7.5, -2.3, 9, -11]
print(tuple(list_a))  # 把列表转换为元组

(3)创建空元组

tuple_c = ()  # 空元组

元组的使用

(1)访问元组元素

tuple_d = (1, 2, 3, 4, 5)
tuple_d[3]  # 下标从0开始顺序访问

(2)元组的切片

tuple_e = (11, 22, 33, 44, 55)
print(tuple_e[::])  # 返回包含所有元素的元组
print(tuple_e[::-1])  # 逆序输出所有的元素
print(tuple_e[1::])  # 从下标为1的元素开始遍历
print(tuple_e[1:-1])  # 从下标为1的元素开始遍历至倒数第二个元素
print(tuple_e[::2])  # 偶数位置，隔一个取一个
print(tuple_e[1::2])  # 奇数位置,隔一个取一个

元组的删除

tuple_f = (66, 22, 33, 44, 55, "buk")
del tuple_f
tuple_f  # 使用del关键字删除后，整个元组将不再存在

字典的创建和删除

(1)使用"="将一个字典赋值给一个变量

dict_a = {'server': 'db.diveintopython3.org', 'database': 'mysql'}
print(dict_a)
dict_b = {}  # 空字典

(2)使用 dict 利用已有数据创建字典

keys = ['a', 'b', 'c', 'd']
values = [1, 2, 3, 4]
dict_c = dict(zip(keys, values))
dict_c
dict_d = dict()  # 空字典

(3)使用 dict 根据给定的键和值创建字典

dict_e = dict(name='Tom', age=23)
dict_e

(4)以给定内容为键，创建值为空的字典

dict_f = dict.fromkeys(['name', 'age', 'sex'])
dict_f

(5)使用 del 删除字典

dict_g = dict(year=2022, month='March')
dict_g

字典的使用

(1)以键作为下标可以读取字典元素，若键不存在则抛出异常

dict_g = {'name': 'Tom', 'sex': 'male', 'age': 37}
dict_g['name']

(2)使用字典对象的 get()方法获取指定键对应的值

dict_h = {'name': 'Petty', 'sex': 'male', 'age': 17}
print(dict_h.get('sex'))

集合的创建

(1)使用{}或者 set()函数创建集合

set_a = {10, 3, 5, 1, 2, 1, 2, 3, 1, 1, 1, 1}
set_b = set()  # 创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典

(2)使用 set()将其他类型数据转换为集合

set_c = set([0, 1, 2, 3, 0, 1, 2, 3, 7, 8])  # 将列表转换为集合并且自动去重
print(set_c)
set_d = set(range(0, 21))
print(set_d)
set_e = set('hello python')  # 将字符串序列转换成集合
print(set_e)
set_f = set({'a': 1, 'b': 2, 'c': 3})  # 使用set()将字典转换为集合时，只会包含字典中的键
print(set_f)

集合的使用

(1)使用in和not in来检查集合中的元素

set_g={'a','b','c',1,2,3}
print('e' in set_g)
print(0 not in set_g)

(2)使用len()获取集合中元素的数量

set_h={'a','b','c','e','f','g'}
print(len(set_h))

(3)使用add()向集合中添加元素

set_i={'a','b','c','e','f','g',0,1,2}
set_i.add(3)
print(set_i)
set_i.add(0) #如果元素已存在，则不进行任何操作
print(set_i)

(3)update()将一个集合中的元素添加到当前集合中

set_j={1,2,3}
set_k={"hello",'world'}
set_j.update(set_k)
print(set_j)
set_l={1,2,3,4,5}
set_l.update({100:'aa',200:'bb',300:'cc'})  #传递一个字典作为参数时只使用键值
print(set_l)

(4)pop()随机删除集合中的一个元素

set_m={4, 2, 3, 100, 40, 'o', 'a', 'h'}
set_m=set_m.pop()
print(set_m)

(5)remove(x)删除集合中指定的元素

set_n={4, 21, 39, 130, 40, 'j', 'b', 'h'}
set_n.remove(21)
print(set_n)

(6)clear()清空集合

set_o = {90, 21, 40, 'a', 'e', 'c', }
set_o.clear()
print(set_o)

列表、元组、字典等序列的解包操作

(1)列表和元组的解包可以方便对多个变量同时赋值

x,y,z=(10,20,30)    #元组的解包
print(y)
[a,b,c,d] = [11,22,33,44]    #列表的解包
print(a)
print(a,c,d)

(2)字典的解包

dict_i={'name':'jack','age':18,'job':'programmer','sex':'男'}
a,b,c,d=dict_i
print(b)    #序列解包用于字典时，默认是对“键”进行操作
print(a,c)
a,b,c,d=dict_i.items()  #如果需要对键值对操作,需要使用items()
print(d)
print(a,c)
a,b,c,d=dict_i.values() #如果需要对值进行操作,需要使用values()
print(c)
print(a,d)

(3)其他常用解包

x, y, z = range(3,6)              #可以对range对象进行序列解包
print(x,y,z)
x, y, z = iter([1, 2, 3])         #使用迭代器对象进行序列解包
print(x,y,z)
x, y, z = map(str, range(3))      #使用可迭代的map对象进行序列解包
print(x,y,z)
a, b = b, a                       #交换两个变量的值
x, y, z = sorted([99, 23, 890])   #sorted()函数返回排序后的列表
print(x,y,z)
a, b, c = 'ABC'                   #字符串也支持序列解包
x = [1, 2, 3, 4, 5, 6]
x[:3] = map(str, range(5))        #切片也支持序列解包
print(x)
keys= ['a', 'b', 'c', 'd']             
values = [1, 2, 3, 4]
for k, v in zip(keys, values):     #序列解包遍历多个序列
    print((k, v), end=' ')
x = ['a', 'b', 'c']                #使用序列解包遍历enumerate对象
for i, v in enumerate(x):
    print('The value on position {0} is {1}'.format(i,v))

生成器的使用

(1)使用生成器对象__next__()方法或内置函数next()进行遍历

g = ((i+2)**2 for i in range(10))  # 创建生成器对象
print(tuple(g))  # 将生成器对象转换为元组
print(list(g))  # 生成器对象已遍历结束，没有元素了

g = ((i+2)**2 for i in range(10))  # 重新创建生成器对象
print(g.__next__())  # 使用生成器对象的__next__()方法获取元素
print(g.__next__())  # 获取下一个元素
next(g)  # 使用函数next()获取生成器对象中的元素

(2)使用for循环直接迭代生成器对象中的元素

g = ((i+2)**2 for i in range(10))
for item in g:                #使用循环直接遍历生成器对象中的元素
    print(item, end=' ')

字典和集合推导式的使用

(1)字典推导式

s = {x:x.strip() for x in ('  he  ', 'she    ', '    I')}
print(s)
for k, v in s.items():
    print(k, ':', v)
    
x = ['A', 'B', 'C', 'D']
y = ['a', 'b', 'b', 'd']
{i:j for i,j in zip(x,y)}

(2)集合推导式

s = {x.strip() for x in ('  he  ', 'she    ', '    I','he')}
print(s) #生成的集合,其保存的元素是唯一的

配套实验指导书-实验 2

(1)编写程序，输入任意大的自然数，输出各位数之和。

num = input("请输入一个自然数")
print(sum(map(int, num)))

(2)编写程序输入两个集合 setA 和 setB,分别输出它们的交集、并集和差集 setA-setB。

setA = eval(input('请输入集合A'))
setB = eval(input('请输入集合B'))
print('交集：', setA & setB)
print('并集：', setA | setB)
print('差集setA-setB：', setA-setB)

(3) 编写程序，输入一个自然数，输出它的二进制、八进制、十六进制表示形式。

num = int(input('请输入一个自然数:'))
print("二进制:", bin(num))
print("八进制:", oct(num))
print("十六进制:", hex(num))

(4)编写程序，输入一个包含若干整数的列表，输出一个新列表，要求新列表中只包含原列表中的偶数。

list_1 = input('请输入一个包含若干整数的列表:')
list_1 = eval(list_1)
print(list_1(filter(lambda x: x % 2 == 0, list_1)))

(5)编写程序，输入两个分别包含若干整数的列表 lstA 和 lstB,输入一个字典，要求使用列表 lstA 中的元素作为键，列表 lstB 中的元素作为值，并且最终字典中的元素数量取决于 lstA 和 lstB 中元素最少的列表的数量。

lstA = eval(input("请输入包含若干整数的列表lstA:"))
lstB = eval(input("请输入包含若干整数的列表lstB:"))
result = dict(zip(lstA, lstB))
print(result)

(6)编写程序，输入一个包含若干整数的列表，输出新列表，要求新列表中的所有元素来自于输入的列表，并且降序排序。

lst = eval(input('请输入包含若干整数的列表lst:'))
print(sorted(lst, reverse=True))

(7)编写程序，输入一个包含若干整数的列表，输入列表中所有整数连乘的结果。

from functools import reduce
lst = eval(input("请输入包含若干整数的列表lst:"))
print(reduce(lambda x, y: x*y, lst))

(8)编写程序，输入两个包含 2 个整数的列表，分别表示城市中两个地点的坐标，输出两点之间的曼哈顿距离。

lstA = eval(input("请输入包含若干整数的列表lstA:"))
lstB = eval(input("请输入包含若干整数的列表lstB:"))
print(sum(map(lambda i, j: abs(i-j), lstA, lstB)))

(9)编写程序，输入包含若干集合的列表，输出这些集合的并集。要求使用 reduce()函数和 lambda 表达式完成。

from functools import reduce
lstSets = eval(input("请输入包含若干集合的的列表："))
print(reduce(lambda x, y: x | y, lstSets))

(10)编写程序，输入等比数列的首项、公比(不等于 1 且小于 36 的正整数)和一个自然数 n，输出这个等比数列前 n 项的和。关键步骤要求使用内置函数 int()。

a1 = int(input('请输入等比数列的首项：'))
q = int(input("请输入等比数列公比："))
n = int(input("请输入一个自然数:"))
result = a1*int('1'*n, q)
print(result)

(11)编写程序，输入一个字符串，输出其中出现次数最多的字符及其出现的次数。要求使用字典。

data = input('请输入一个字符串：')
d = dict()
for ch in data:
    d[ch] = d.get(ch, 0)+1
mostCommon = max(d.items(), key=lambda item: item[1])
print(mostCommon)