字典，集合

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

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

tuple_c = ()  # 空元组

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

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关键字删除后，整个元组将不再存在

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

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

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

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

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

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

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

set_a = {10, 3, 5, 1, 2, 1, 2, 3, 1, 1, 1, 1}
set_b = set()  # 创建一个空集合必须用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)

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

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

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)

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)

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

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

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

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

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)

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))

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()获取生成器对象中的元素

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

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)}

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

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

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

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

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

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

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

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

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

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

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

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)