列表、字典、集合、元组的操作及函数备忘查询

一、列表的操作

1、列表的基本操作

①查看

list1 = ['奔驰','宝马','奥迪','玛莎拉蒂','凯迪拉克','路虎']
#查看
print(list1[1])
#多级列表查看
list2 = ['普通车',['凯迪拉克','奔驰']]
print(list2[1][1])
>>>
宝马
奔驰

②修改列表值

list3 = ['奔驰','宝马','奥迪','玛莎拉蒂','凯迪拉克','路虎']
#修改单个值
list3[1] = '大众'
print(list3)
#使用切片修改单个值需要用可迭代数据类型进行赋值
#修改多个值
list3[0:2] = "林肯",'红旗'   #虽然没加括号，但这是个元组
#list3[0:2] = ('林肯','红旗')  #元组
#list3[0:2] = ['林肯','红旗']  #列表
print(list3)
>>>
['大众', '宝马', '奥迪', '玛莎拉蒂', '凯迪拉克', '路虎']
['林肯', '红旗', '奥迪', '玛莎拉蒂', '凯迪拉克', '路虎']

③删除列表里的值

list5 =  ['奔驰','宝马','奥迪','玛莎拉蒂','凯迪拉克','路虎']
del list5[0:3]
print(list5)
>>>
['玛莎拉蒂', '凯迪拉克', '路虎']

④增加列表里的值，需要开始索引需要与结束索引一致，在指定索引之前增加内容，因为是切片操作，所以赋值必须是可迭代的

list6 =  ['奔驰','宝马','奥迪','玛莎拉蒂','凯迪拉克','路虎']
# list6[1:1] = "大宝马",  #写法1
# list6[1:1] = ("大宝马",)  #写法2
list6[1:1] = ["大宝马"]   #写法3
print(list6)
>>>
['奔驰', '大宝马', '宝马', '奥迪', '玛莎拉蒂', '凯迪拉克', '路虎']

③列表乘法运算、加法运算

list1 = ['呵呵','哈哈','哦哦']
list2 = ['李白','李清照','辛弃疾']
print(list1*2)
print(list1+list2)
>>>
['呵呵','哈哈','哦哦','呵呵','哈哈','哦哦']
['呵呵','哈哈','哦哦','李白','李清照','辛弃疾']

④列表具有穿透性

列表，如果局部变量未真实创建，则是全局变量，可以进行修改

list1 = [1,2,3,4]
def func():
    list1[0] = 3
    return list1
func()
print(list1)
>>>
[3, 2, 3, 4]

⑤列表常用函数

列表常用函数 max()最大值 min() 最小值 len()获取容器的长度

list2 = [5,6,7,8]
print(max(list2))
>>>
8

获取长度

print(len(list2))
>>>
2

2、列表的遍历

#for...in遍历
list_4 = [5,6,7,8]
for i in list_4:
	print(i,end="")
>>>
5678
#while遍历
i = 0
while i < len(list4):
    print(list4[i],end = "")
    i+=1
>>>
5678

3、列表推导式

基本推导式

list3 = [i for i in range(5)]
print(list3)
>>>
[0,1,2,3,4]

带有判断条件的推导式（过滤，筛选数据）

list5 = [i for i in range(5) if i%2 == 0]
print(list5)
>>>
[0,2,4]

判断条件在前 if…else…（了解）

list6 = [i if i%2==0 else-i for i in range(5)]
print(list6)
>>>
[0, -1, 2, -3, 4]

多循环列表推导式

list_7 = [i+j for i in range(5) for j in range(4)]
print(list_7)
>>>
[0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7]

#九九乘法表的表示
list_99 = ["{}*{}={}".format(i,j,i*j) for i in range(1,10) for j in range(1,i+1)]
print(list_99)

带有判断条件的多循环推导式

list1 = ['唐僧','猪八戒','沙僧']
list2 = ['贾宝玉','林黛玉','薛宝钗']
res = [i+j for i in list1 for j in list2 if len(i)==2 and len(j)==3]
print(res)
>>>
['唐僧贾宝玉', '唐僧林黛玉', '唐僧薛宝钗', '沙僧贾宝玉', '沙僧林黛玉', '沙僧薛宝钗']

判断条件在前if…else…的多循环推导式

list_8 = ['唐僧','猪八戒','沙僧']
list_9 = ['贾宝玉','林黛玉','薛宝钗']
res = [i+j if len(i)==2 and len(j)==3 else '值' for i in list_8 for j in list_9 ]
print(res)
>>>
['唐僧贾宝玉', '唐僧林黛玉', '唐僧薛宝钗', '值', '值', '值', '沙僧贾宝玉', '沙僧林黛玉', '沙僧薛宝钗']

前后都有条件

q = [x+y if x%3==2 or y%3==0 else None for x in range(1,10) for y in range(10) if y%3==1]
print(q)
>>>
[None, None, None, 3, 6, 9, None, None, None, None, None, None, 6, 9, 12, None, None, None, None, None, None, 9, 12, 15, None, None, None]

4、列表专用函数方法

#append(值)	向列表最后添加数据
list1 = ['上海','深圳','杭州']
list1.append('北京')
print(list1)
>>>
['上海','深圳','杭州','北京']
-----------------------------------------------------------------------------------------
list2=[]
for i in range(5):
	list2.append(i)
print(list2)
>>>
[0,1,2,3,4]

#insert(索引，值)	在列表的指定索引之前添加数据
list3 = ['扬州','南通','无锡']
list3.insert(1,'苏州')
print(list3)
>>>
['扬州', '苏州', '南通', '无锡']

#pop(索引)	删除列表指定索引位置的数据/慕课解释：将索引位置的值取出并删除该元素，a = list5.pop(3)
list4 = ["上海","深圳","杭州","加利福尼亚","威尼斯"]
list4.pop(3)
print(list4)
>>>
['上海', '深圳', '杭州', '威尼斯']

#remove(值)	在列表中删除第一个出现的指定数据，即若有重复数据，后面的不会被删
list5 = ["上海","深圳","杭州","加利福尼亚","威尼斯"]
list5.remove("深圳")
print(list5)
>>>
['上海', '杭州', '加利福尼亚', '威尼斯']

#clear()	清空列表
list6 = ["上海","深圳","杭州","加利福尼亚","威尼斯"]
list6.clear()
print(list6)
>>>
[]

#copy()	复制列表，是一种浅拷贝
list7 = ["上海","深圳","杭州","加利福尼亚","威尼斯"]
list8 = list7.copy()
print(list8)
for city in list7:
    list8.remove(city)
print(list8)
>>>
['上海', '深圳', '杭州', '加利福尼亚', '威尼斯']
[]

#第一种浅拷贝方式	切片拷贝
list1 = ["上海","深圳","杭州","加利福尼亚","威尼斯"]
list2 = list1[:]
list1[0] = "魔都"
print(list1,list2)  #list1变了，list2不变
>>>
['魔都', '深圳', '杭州', '加利福尼亚', '威尼斯'] ['上海', '深圳', '杭州', '加利福尼亚', '威尼斯']

#第二种浅拷贝方式	调用对象方法 .copy()
list1 = ["上海","深圳","杭州","加利福尼亚","威尼斯"]
list2 = list1.copy()
list1[2] = "天堂"
print(list1)
print(list2)
>>>
['上海', '深圳', '天堂', '加利福尼亚', '威尼斯']
['上海', '深圳', '杭州', '加利福尼亚', '威尼斯']

#第三种浅拷贝	调用库
import copy
list1 = ['扬州','盐城','南通','无锡']
list2 = copy.copy(list1)
list1[0] = "烟花三月"
print(list1,list2)
>>>
['烟花三月', '盐城', '南通', '无锡'] ['扬州', '盐城', '南通', '无锡']

#深拷贝-调用库	用于多级嵌套容器类型
import copy
list1 = ['扬州','盐城',['南通','通州'],'无锡']
list2 = copy.deepcopy(list1) #list2完全独立
list1[2][1] = "崇川"
print(list1,list2) #list2不变
>>>
['扬州', '盐城', ['南通', '崇川'], '无锡'] ['扬州', '盐城', ['南通', '通州'], '无锡']

#这种情况如果浅拷贝的话，list2的二级里的数据会跟着变
list1 = ['扬州','盐城',['南通','通州'],'无锡']
list2 = copy.copy(list1) #list2完全独立
list1[0] = '瘦西湖'
list1[2][1] = "崇川"
print(list1,list2) #结果是list2的外层数据虽然不会被改动，但内层数据跟着改动了，因为内层只是个引用
>>>
['瘦西湖', '盐城', ['南通', '崇川'], '无锡'] ['扬州', '盐城', ['南通', '崇川'], '无锡']

#count()计算列表中指定数据出现的次数
list_99 = [1,2,1,1]
print(list_99.count(1))
>>>
3

#extend()将两个列表合并为1个，括号里的合并到括号外的
list_88 = ['英语','法语']
list_89 = ['德语','日语']
list_89.extend(list_88)
print(list_89)
>>>
['德语', '日语', '英语', '法语']

#reverse()	列表反转
list1 = [1,2,3,4]
list1.reverse()
print(list1)

#sort()	列表排序 可选：reverse=True key=func()  与高阶函数sorted(iterable,reverse,key)一样
list2 = [1,3,5,-2,8]
list2.sort(key=lambda x:x**2,reverse=True)
print(list2)
>>>
[8, 5, 3, -2, 1]

#index()   获取某个值在列表中的索引
list_45 = ["哥哥",'姐姐','弟弟']
print(list_45.index('姐姐'))
>>>
1

二、元组的操作

1、关于元组的定义

空元组

变量 = () 或者 变量= tuple()

tuple1 = ()
thple2 = ()
print(tuple1,tuple2)

()  ()

单个元素的元组

tuple3 = (1,)
print(tuple3)

(1,)

元组的定义,可以不加括号

tuple1 = 1,3,4
print(tuple1,type(tuple1))

(1, 3, 4) <class 'tuple'>

元组的增删改查只能查

tuple2 = ['北京','上海','深圳']

上海
['北京', '上海']
['北京', '深圳']

2、元组推导式

元组推导式的结果不是元组，而是生成器(生成器需要操作才会得到结果)
语法同列表推导式一样

res = (i+1 for i in range(10) if i%2==0)
print(res)

<generator object <genexpr> at 0x0047BAB0>

结果这是个生成器对象，生成器是一种特殊的迭代器

也可以转换为其他数据类型
print(list(res))
#检测这是个迭代器
from collections.abc import Iterator
result = isinstance(res,Iterator)
print(result)

[1, 3, 5, 7, 9]
True

可以自定义，按照某种算法推算下一个数据,只需往内存里存一个生成器,节省空间

语法:

• 里面是推导式,外面是()的是生成器

• 含有yield关键字的函数是生成器函数，它可以返回一个迭代器，换句话说，生成器是一个返回迭代器的函数。

  #手动写一个生成器（生成器函数）
  # 带有yield关键字的函数
  def func():
      print(1)
      yield "第一次"
      print(2)
      yield "第二次"
  res = func()
  print(res)
  print(next(res))
  print(next(res))

<generator object func at 0x0047BDF0>
1
第一次
2
第二次

yield 有点像 return
共同点在于:执行到这句话会把值返回出去
不同点在于:再次执行生成器时会从上一次yield执行的位置继续向下走,它会记住上一次离开时的状态.
每次返回,都会记住当前代码执行的位置,再次调用的时候会从上次位置继续向下执行

#index()获取指定值的索引
tuple2 = ['北京','上海','扬州','扬州']
print(tuple2.index('扬州'))

#count()获取指定的值在元组中出现的次数
print(tuple2.count('扬州'))

2
2

三、集合的操作

1、创建一个空集合

set1 = set()
print(set1)
>>>
set()

集合里只能放不可变类型：数字、字符串、元组、冰冻集合

集合没有增删改查的操作

set2 = {"绝地求生","王者荣耀","英雄联盟","刺激战场"}
print(set2)
#成员检测
res = "王者荣耀" in set2
print(res)
>>>
{'英雄联盟', '王者荣耀', '刺激战场', '绝地求生'}
True

集合的遍历只能用for…in操作

for game in set2:
    print(game)
>>>
英雄联盟
王者荣耀
刺激战场
绝地求生

2、集合推导式

#普通推导
res1 = {i for i in range(5)}
print(res1)
>>>
{0, 1, 2, 3, 4}

#带判断条件的推导
res2 = {i for i in range(5) if i%2==0}
print(res2)
>>>
{0, 2, 4}

#多循环的集合推导
res3 = {i+j for i in range(5) for j in range(5)}
print(res3)
>>>
{0, 1, 2, 3, 4, 5, 6, 7, 8}

#带判断条件的多循环推导
res4 = {i+j for i in range(4) for j in range(4) if i%2==0 and j%2==0}
print(res4)
>>>
{0, 2, 4}
#不仅是range(),还可以是其他容器类型
list1 = ['山丘','大太阳','小溪水']
res5 = {thing for thing in list1 if len(thing)==3}
print(res5)
>>>
{ '大太阳', '小溪水'}

3、集合的函数（方法）

• add() 向集合中添加一个元素/数据（集合专用）
  格式：集合.add(数据)
  返回值：None
  注意：操作直接修改原有集合。

set3 = {"绝地求生","王者荣耀","英雄联盟","刺激战场"}
set3.add('中路')
print(set3)
>>>
{'绝地求生', '英雄联盟', '刺激战场', '王者荣耀', '中路'}

• pop() 随机删除集合中的一个元素/数据
  格式：集合.pop()
  返回值：随机删除的数据
  注意：操作直接修改原有集合。

set3.pop()
print(set3)
>>>
{'绝地求生', '英雄联盟', '中路', '王者荣耀'}  #结果是随机的，每执行一次会变换结果

• remove() 删除指定的数据,数据不存在会报错
  格式：集合.remove(数据)
  返回值:None
  注意：操作直接修改原有集合。

set3 = {"绝地求生","王者荣耀","英雄联盟","刺激战场",'中路'}
set3.remove('中路')
print(set3)
>>>
{'英雄联盟', '刺激战场', '王者荣耀', '绝地求生'}

• discard() 删除指定的数据，数据不存在不进行操作
  格式：集合.discard(数据)
  返回值：None
  注意：操作直接修改原有集合。

set4 = {'卡丁车','笑傲江湖','刀塔'}
set4.discard('传奇')
print(set4)
>>>
{'刀塔', '笑傲江湖', '卡丁车'}

• clear() 清空集合
  格式：集合.clear()
  返回值:None
  注意：操作直接修改原有集合。

set5 = {1,2,3,4}
set5.clear()
print(set5)
>>>
set()

• copy() 复制集合
  格式：集合.copy()
  返回值:None
  注意：复制的集合和原集合内容一样，但是不是一个集合

set6 = {7,8,9}
set7 = set6.copy()
print(set7)
>>>
{8, 9, 7}

4、集合的运算

#集合运算符：
& 交集 | 并集 -差集 ^ 对称差集

# &交集
set1 = {1,2,3,4}
set2 = {2,3}
print(set1&set2)
>>>
{2,3}

# |并集
set3 = {1,2,5}
set4 = {3,4}
print(set3 | set4)
>>>
{1,2,3,4,5}

# -差集
set5 = {1,2,3,4,5}
set6 = {2,3}
print(set5-set6)
print(set5-(set5&set6))
>>>
{1, 4, 5}
{1, 4, 5}

# ^对称差集
set7 = {1,2,3,4,5}
set8 = {4,5,6,7,8}
print(set7^set8)
print((set7|set8) -(set7&set8))
>>>
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}

5、集合的运算函数

#差集    集合1.difference(集合2)
set5 = {1,2,3,4,5}
set6 = {2,3}
print(set5.difference(set6))
>>>
{1,4,5}

#更新差集  集合1.difference_update(集合2)
set5 = {1,2,3,4,5}
set6 = {2,3}
set5.difference_update(set6)
print(set5)
>>>
{1,4,5}
#注意：所谓更新差集，就是计算差集之后将结果重新赋值给第一个集合

#交集 	集合1.intersection(集合2)
set1 = {1,2,3,4}
set2 = {2,3}
print(set1.intersection(set2))
>>>
{2,3}

#更新交集
set1 = {1,2,3,4}
set2 = {2,3}
set1.intersection_update(set2)
print(set1)
>>>
{2,3}

#并集		集合1.union(集合2)
set3 = {1,2,5}
set4 = {3,4}
print(set3.union(set4))
>>>
{1,2,3,4,5}

#更新并集 	集合1.update(集合2)
set3 = {1,2,5}
set4 = {3,4}
set3.update(set4)
print(set3)
>>>
{1,2,3,4,5}

#检测是不是超集	集合1.issuperset(集合2)
set7 = {1,2,3,4,5}
set8 = {1,2,3}
res = set7.issuperset(set8)
print(res)
>>>
True

#检测是不是子集	集合1.issubset(集合2)
res1 = set8.issubset(set7)
print(res1)
>>>
True

#检测是否不相交，即是否没有交集	集合1.isdisjoint(集合2)
set9 = {1,2,3,4,5}
set10 = {7,8,9}
res3 = set10.isdisjoint(set9)
print(res3)
>>>
True

#对称差集	集合1.symmetric_difference(集合2)
set7 = {1,2,3,4,5}
set8 = {4,5,6,7,8}
print(set7.symmetric_difference(set8))
>>>
{1,2,3,6,7,8}

#更新对称差集 集合1.symmetric_difference(集合2)
set7.symmetric_difference_update(set8)
print(set7)
>>>
{1,2,3,6,7,8}

6、冰冻集合

一旦创建就不可以进行修改的集合。一种数据类型

#创建一个空的冰冻集合 #数据类型为frozenset
set1 = frozenset()
print(set1,type(set1))
>>>
frozenset() <class 'frozenset'>

#将列表转化为冰冻集合
frozen_1 = frozenset([1,2,3,4,5,6])
print(frozen_1)
>>>
frozenset({1, 2, 3, 4, 5, 6})

#difference()差集
frozen_2 = frozenset({5,6,7,8,9})
res = frozen_1.difference(frozen_2)
print(res)
>>>
frozenset({1, 2, 3, 4})

四、字典的操作

字典的键必须是不可以改变的类型。 常用的就是字符串，整型，浮点型，用于区分字典中值的标识。

python3.6以后，python的字典数据的修改与输出的顺序则有序，在内存中的存储依然无序。

1、字典的定义

​ 1.方法1：
​ 变量 = {键:值,键:值,键:值,键:值…}
​ 2.方法2:
​ 变量 = dict(形参 = 值,形参=值…)
​ 3.方法3：数据类型转换
​ 变量 = dict(符合条件的嵌套容器) #容器必须是列表或者元组
​ 4.方法4：
​ 变量 = dict(zip(键的容器,值的容器))#容器必须是列表或者元组

#定义字典
dict1 = {1:'周一',2:'周二',3:'周三'}
#传形参法
dict2 = dict(day = "周一",thing = "睡觉")
print(dict1,dict2)
>>>
{1: '周一', 2: '周二', 3: '周三'} {'day': '周一', 'thing': '睡觉'}

#数据类型转换为字典    二级列表、元组、集合
dict3 = dict([[1,2],[3,4],[5,6]])
dict4 = dict(([1,2],[3,4],[5,6]))
dict5 = dict({(1,2),(3,4),(7,8)})
print(dict3,dict4,dict5)
>>>
{1: 2, 3: 4, 5: 6} {1: 2, 3: 4, 5: 6} {1: 2, 3: 4, 7: 8}

#变量 = dict(zip(键的容器，值的容器))
dict6 = dict(zip(['你好','打招呼'],['nihao','dazhaohu']))
print(dict6)
>>>
{'你好':'nihao','打招呼':'dazhaohu'}

2、字典的增删改查

#访问字典中的值（查）
dict7 = {'周一':'monday','周二':'tuesday'}
print(dict7['周一'])
>>>
monday

#增加值(增)
dict7['周三'] = 'wednesday'
print(dict7)
>>>
{'周一': 'monday', '周二': 'tuesday', '周三': 'wednesday'}

#增加值的时候，如果键存在则进行修改（改）
dict7['周一'] = 'mondaya'
print(dict7)
>>>
{'周一': 'mondaya', '周二': 'tuesday', '周三': 'wednesday'}

#总结：键存在则修改，键不存在则添加

#删除字典中的值（删）
dict8 = {'周一':'monday','周二':'tuesday','周三':'wednesday','周四':'thursday'}
del dict8['周三']
print(dict8)
{'周一': 'monday', '周二': 'tuesday', '周四': 'thursday'}

成员检测 in not in 检测的是键

3、字典的遍历

#常规遍历（获取的是字典的键）
dict9 = {'周一':'monday','周二':'tuesday','周三':'wednesday','周四':'thursday'}
for day in dict9:
    print(day,end="")
>>>
周一周二周三周四

#遍历字典的键
for day in dict9.keys():
    print(day,end="")
>>>
周一周二周三周四

#遍历字典的值
for day in dict9.values():
    print(day)
>>>
monday
tuesday
wednesday
thursday

#同时遍历键和值
for cday,eday in dict9.items():
    print(cday,eday)
>>>
周一 monday
周二 tuesday
周三 wednesday
周四 thursday

4、字典推导式

基本推导式
变量 ={变量1:变量2 for 变量1,变量2 in 字典.items()}

#普通推导式
#这里用字典当容器的话，需要写作dict.items
dict1 = {'周一':'monday','周二':'tuesday','周三':'wednesday','周四':'thursday'}
res1 = {cday:eday for cday,eday in dict1.items()}
print(res1)
>>>
{'周一': 'monday', '周二': 'tuesday', '周三': 'wednesday', '周四': 'thursday'}

#或者可结合字符串格式化来使用，保证：左右两边都有即可
res2 ={"周号:{}".format(cday):"英文表示：%s" % eday for cday,eday in dict1.items()}
print(res2)
>>>
{'周号:周一': '英文表示：monday', '周号:周二': '英文表示：tuesday', '周号:周三': '英文表示：wednesday', '周号:周四': '英文表示：thursday'}

#以下用list列表来循环出一个字典
list1 = ['周一','周二','周三','周四']
list2 = ['monday','tuesday','wednesday','thursday']
res3 = {cday:eday for cday in list1 for eday in list2}
print(res3)
>>>
{'周一': 'thursday', '周二': 'thursday', '周三': 'thursday', '周四': 'thursday'}
#结果是只能拥有相同值

#dict1.items()是个容器
dict1 = {'周一':'monday','周二':'tuesday','周三':'wednesday','周四':'thursday'}
res4 = dict1.items()
print(res4,type(res4))
for k,v in dict1.items():
    print(k,v)
>>>
dict_items([('周一', 'monday'), ('周二', 'tuesday'), ('周三', 'wednesday'), ('周四', 'thursday')]) <class 'dict_items'>
周一 monday
周二 tuesday
周三 wednesday
周四 thursday

#键值对互换
dict1 = {'周一':'monday','周二':'tuesday','周三':'wednesday','周四':'thursday'}
res5 = {cday:eday for eday,cday in dict1.items()}
print(res5)
>>>
{'monday': '周一', 'tuesday': '周二', 'wednesday': '周三', 'thursday': '周四'}

#多循环的字典推导式
dict2 = {'星期一':'1','星期二':'2','星期三':'3','星期四':'4'}
res6 = {cday+k:eday+v for cday,eday in dict1.items() for k,v in dict2.items()}
print(res6)
>>>
{'周一星期一': 'monday1', '周一星期二': 'monday2', '周一星期三': 'monday3', '周一星期四': 'monday4', '周二星期一': 'tuesday1', '周二星期二': 'tuesday2', '周二星期三': 'tuesday3', '周二星期四': 'tuesday4', '周三星期一': 'wednesday1', '周三星期二': 'wednesday2', '周三星期三': 'wednesday3', '周三星期四': 'wednesday4', '周四星期一': 'thursday1', '周四星期二': 'thursday2', '周四星期三': 'thursday3', '周四星期四': 'thursday4'}

#带有判断条件的多循环推导式
res7 = {'周号'+k:'数字'+v for k in dict1.keys() for v in dict2.values() if k == '周二'}
print(res7)
>>>
{'周号周二': '数字4'}

# python 的bug级存在：第二个循环只给出最后一次循环结果

5、字符串格式化对字典的操作

#字符串%(字典的键)s字符串  % 字典  注意：字典的键当做索引用，不加引号
str1 ="勇气是%(勇气)s唱的，鸡你太美是%(鸡你太美)s唱的" % {'勇气':'梁静茹','鸡你太美':'蔡徐坤'}
print(str1)
>>>
勇气是梁静茹唱的，鸡你太美是蔡徐坤唱的

#也可以使用format  同样字典的键当做索引用，不加引号
dictsing1 = {'歌名1':'勇气','歌名2':'鸡你太美'}
dictsing2 = {'歌手1':'梁静茹','歌手2':'蔡徐坤'}
str2 = "爱真的需要{0[歌名1]}，是{1[歌手1]}唱的，{0[歌名2]}是{1[歌手2]}唱的，很难听".format(dictsing1,dictsing2)
print(str2)
>>>
爱真的需要勇气，是梁静茹唱的，鸡你太美是蔡徐坤唱的，很难听

6、字典的函数（方法）

dict1 = {'歌名1':'勇气','歌名2':'鸡你太美'}
#清空字典 clear()
dict1.clear()
print(dict1)
>>>
{}

#复制字典 copy() #是深拷贝
dict2 = {'歌名1':'勇气','歌名2':'鸡你太美'}
res = dict2.copy()
print(res)
>>>
{'歌名1':'勇气','歌名2':'鸡你太美'}

# fromkeys()  使用指定的键容器制作一个字典，只是借了个壳子
res1 = dict2.fromkeys(['周一','周二'],'天天放假')
print(res1)
>>>
{'周一': '天天放假', '周二': '天天放假'}

# keys() 获取字典中的键组成新的容器，类型为dict_keys
res2 = dict2.keys()
print(res2,type(res2))
>>>
dict_keys(['歌名1', '歌名2']) <class 'dict_keys'>

# values() 获取字典中的值组成新的容器，类型为dict_values
res3 = dict2.values()
print(res3,type(res3))
>>>
dict_values(['勇气', '鸡你太美']) <class 'dict_values'>

# items() 获取字典的中的键和值组成嵌套容器,类型为dict_items
res4 = dict2.items()
print(res4)
>>>
dict_items([('歌名1', '勇气'), ('歌名2', '鸡你太美')])

# pop() 根据键删除指定的值
dict3 = {'星期一':'1','星期二':'2','星期三':'3','星期四':'4'}
res5 = dict3.pop('星期一')
print(res5)
print(dict3)
>>>
1
{'星期二': '2', '星期三': '3', '星期四': '4'}

#当删除的键不存在时，返回默认值 字典.pop(键,默认值)
res =dict3.pop('星期五','对不起，该键不存在')
print(res)
>>>
对不起，该键不存在

# popitem() 删除字典的显示的最后一个数据  #慕课：取出字典中显示的最后一个键值对，以元组方式储存
#坑，因为字典不能随便说它是有序的
dict4 = {'星期一':'1','星期二':'2','星期三':'3','星期四':'4'}
a = dict4.popitem()
print(dict4,a)
>>>
{'星期一': '1', '星期二': '2', '星期三': '3'}('星期四', '4')

# setdefault() 向字典中添加数据
dict5 = {'星期一':'1','星期二':'2','星期三':'3','星期四':'4'}
dict5.setdefault('星期五','5')
print(dict5)
>>>
{'星期一': '1', '星期二': '2', '星期三': '3', '星期四': '4', '星期五': '5'}

#键已存在不进行任何操作
dict5.setdefault('星期一','monday')
print(dict5)
>>>
{'星期一': '1', '星期二': '2', '星期三': '3', '星期四': '4', '星期五': '5'}

# update() 修改字典中的值，键不存在则会添加内容
#格式1
dict6 = {'周一':'monday','周二':'tuesday','周三':'wednesday'}
dict6.update(周一='星期一',周四='thursday')
print(dict6)
>>>
{'周一': '星期一', '周二': 'tuesday', '周三': 'wednesday', '周四': 'thursday'}

#格式2 字典.update({键:值,键:值,键:值...})
dict7 = {'周一':'monday','周二':'tuesday','周三':'wednesday'}
dict7.update({'周二':'Tuesday','周五':'Friday'})
print(dict7)
>>>
{'周一': 'monday', '周二': 'Tuesday', '周三': 'wednesday', '周五': 'Friday'}

# get()获取字典中的值  #可以设置<dfault>默认值
dict8 = {'周一': 'monday', '周二': 'Tuesday', '周五': 'Friday'}
res6 = dict8.get('周二') 
print(res6)
>>>
Tuesday

res7 = dict8.get('周六','找不到你要的值')
print(res7)
>>>
找不到你要的值