字符串, 列表, 元祖, 集合, 字典的相关操作和函数, 深浅copy

# 1、字符串的相关操作：
# (1) 字符串的拼接：
s1 = "我是字符串1号"
s2 = "我是字符串2号"
s3 = s1 + s2
print(s3) # 我是字符串1号我是字符串2号

# (2) 字符串的重复：
s1 = "早餐要吃好"
s2 = s1 * 3
print(s2) #　早餐要吃好早餐要吃好早餐要吃好

# (3) 字符串的跨行拼接： \
s1 = "你在哪儿我在这儿"
print(s1) # 你在哪儿我在这儿

# (4) 字符串的索引：可使用正序，也可使用倒序
s1 = "我是字符串"
print(s1[0]) # 我
print(s1[-1]) # 串

# (5) 字符串的切片:顾头不顾尾
s1 = "天空中飞鸟划过的痕迹,是你来过我世界的踪影"
print(s1[:5]) # 天空中飞鸟  从第0个字符截取到第四个字符
print(s1[7:]) # 的痕迹,是你来过我世界的踪影  从第七个字符截取到末尾
print(s1[3:6]) # 飞鸟划  从第三个字符截取到第五个字符
print(s1[::2]) # 天中鸟过痕,你过世的影  从左到右隔一个字符截取一个
print(s1[0:5:3]) #　天飞　从第0个字符到第四个字符，隔两个字符截取一个
print(s1[::-2]) # 影的世过你,痕过鸟中天  从右到左,隔一个字符截取一个
print(s1[-9:-3:3]) # 你我  从倒数第九个字符到倒数第四个字符,隔两个取一个
print(s1[:]) # 天空中飞鸟划过的痕迹,是你来过我世界的踪影  截取整个字符
print(s1[::]) # 天空中飞鸟划过的痕迹,是你来过我世界的踪影  截取整个字符
print(s1[::-1]) # 影踪的界世我过来你是,迹痕的过划鸟飞中空天  让整个字符倒序显示

# 字符串的相关函数:
# (1) 首字母大写:capitalize
s1 = "how old are you"
print(s1.capitalize()) # How old are you

# (2) 每个单词的首字母大写:title
print(s1.title()) # How Old Are You

# (3) 将所有字母都变成大写:upper
print(s1.upper()) # HOW OLD ARE YOU

# (4) 将所有字母都变成小写:lower
print("How Old Are You".lower()) # how old are you

# (5) 大小写互换:swapcase
print("How Old Are You".swapcase()) # hOW oLD aRE yOU

# (6) 计算字符串的长度:len()
print(len(s1)) # 15

# (7) 统计字符串中某个元素的次数:count
print(s1.count("o")) # 3
print(s1.count("o",0,6)) # 2  表示从开始到第六个字符,o出现了几次

# (8) 查找某个字符第一次出现的索引位置:find,找不到返回-1
print(s1.find("a")) # 8
print(s1.find("a",0,8)) # -1 find指定位置查找的时候顾头不顾尾,找不到就返回-1

# (9)  查找某个字符第一次出现的索引位置,index,找不到报错
print(s1.index("a")) # 8
# print(s1.index("a",0,8)) # 顾头不顾尾,直接报错

# (10) 判断是否以某个字符开头,返回bool值,startswith
print(s1.startswith("h")) # True

# (11) 判断是否以某个字符结尾,返回bool值,endswith
print(s1.endswith("u")) # True

# (12) 判断是否是大写字母:返回bool值,isupper
print("HOW ARE YOU".isupper()) # True

# (13) 判断是否是小写字母,返回bool值,islower
print(s1.islower()) # True

# (13) 判断字符串是否是以数字组成:返回bool值,isdemical
print("2897".isdecimal()) # True

# 重点记忆
# (1) 按照某个字符将字符串分割成列表:split(默认按照空格分割)
res1 = "蓝天-白云-轻风-雨水"
print(res1.split("-")) # [‘蓝天‘, ‘白云‘, ‘轻风‘, ‘雨水‘]
print(res1.split("-",2)) # [‘蓝天‘, ‘白云‘, ‘轻风-雨水‘]  从左到右分割两次
print(res1.rsplit("-",2)) # [‘蓝天-白云‘, ‘轻风‘, ‘雨水‘]  rsplit从右向左分割两次

# (2) 按某个字符将列表拼接成字符串 join (也适用于其他容器类型)
list1 = [‘蓝天‘, ‘白云‘, ‘轻风‘, ‘雨水‘]
print("*".join(list1)) # 蓝天*白云*轻风*雨水

# (3) 填充字符串,原字符串居中:center(默认填充空格)
str = "中国"
print(str.center(10)) #     中国
print(str.center(10,"*")) # ****中国****

# (4) 默认去掉左右两边的空格: strip
str = "  空格   "
print(str.strip()) # 空格
str = "&*&空格&&"
print(str.strip("&")) # *&空格  只去掉左右两边的&

# (5) 替换字符:replace
str = "我是个字符1号和字符2号"
print(str.replace("是","不是")) # 我不是个字符1号和字符2号
print(str.replace("字符","列表")) # 我是个列表1号和列表2号
print(str.replace("字符","列表",1)) # 我是个列表1号和字符2号  可以选择替换的次数
print("  空格  ".replace(" ","")) # 空格  可以消掉字符中的所有空格

# 列表的相关操作:
# (1) 列表的拼接  (同元祖)
list1 = ["我是"]
list2 = ["列表"]
list3 = list1+list2
print(list3) # [‘我是‘, ‘列表‘]

# (2) 列表的重复:  (同元祖)
list4 = list3*2
print(list4) # [‘我是‘, ‘列表‘, ‘我是‘, ‘列表‘]

# (3) 列表的切片,顾头不顾尾  (同元祖)
list5 = ["天空","大地","云朵","徐风","小鱼","青草"]
print(list5[:3]) # [‘天空‘, ‘大地‘, ‘云朵‘] 从第0个元素截取到第二个
print(list5[3:6]) #[‘徐风‘, ‘小鱼‘, ‘青草‘]　从第三个元素截取到第五个
print(list5[::-1]) # [‘青草‘, ‘小鱼‘, ‘徐风‘, ‘云朵‘, ‘大地‘, ‘天空‘]  反转列表
print(list5[-6:-3:2]) # [‘天空‘, ‘云朵‘] 从倒数第六个到倒数第四个,隔一个截取一个
print(list5[::]) # [‘天空‘, ‘大地‘, ‘云朵‘, ‘徐风‘, ‘小鱼‘, ‘青草‘]  截取所有列表

# (4) 列表的获取:根据索引获取(同元祖)
list1 = ["米饭","面条","大饼"]
print(list1[0]) # 米饭
print(list1[-1]) # 大饼

# (5) 列表的修改:可根据索引或者切片修改
list2 = ["米饭","面条","大饼","武昌鱼","酸菜鱼","鱼头汤","排骨藕汤"]
list2[:3] = ["我喜欢吃"]
print(list2) # [‘我喜欢吃‘, ‘武昌鱼‘, ‘酸菜鱼‘, ‘鱼头汤‘, ‘排骨藕汤‘]   没有步长的情况下

list3 = [‘我喜欢吃‘, ‘武昌鱼‘, ‘酸菜鱼‘, ‘鱼头汤‘, ‘排骨藕汤‘,"番茄鸡蛋","洋葱炒肉"]
list3[::2] = ["我不喜欢吃","肥肉","苦瓜","猪蹄"]
print(list3) # [‘我不喜欢吃‘, ‘武昌鱼‘, ‘肥肉‘, ‘鱼头汤‘, ‘苦瓜‘, ‘番茄鸡蛋‘, ‘猪蹄‘]  有步长的情况下,替换的元素要一样多

# (6) 列表的删除
list4 = [‘我不喜欢吃‘, ‘武昌鱼‘, ‘肥肉‘, ‘鱼头汤‘, ‘苦瓜‘, ‘番茄鸡蛋‘, ‘猪蹄‘]
del list4[1]
print(list4) # [‘我不喜欢吃‘, ‘肥肉‘, ‘鱼头汤‘, ‘苦瓜‘, ‘番茄鸡蛋‘, ‘猪蹄‘]  单个删除

del list4[1:3]
print(list4) # [‘我不喜欢吃‘, ‘苦瓜‘, ‘番茄鸡蛋‘, ‘猪蹄‘]  通过切片批量删除

# 列表的相关函数
# (1)列表的增: append insert extend
list1 = ["青菜","西葫芦","藕","胡萝卜","芹菜"]
list1.append("猪肉")
print(list1) # [‘青菜‘, ‘西葫芦‘, ‘藕‘, ‘胡萝卜‘, ‘芹菜‘, ‘猪肉‘]
# append 不用指定索引,从列表的最后添加

list1.insert(-1,"牛肉")
print(list1) # [‘青菜‘, ‘西葫芦‘, ‘藕‘, ‘胡萝卜‘, ‘芹菜‘, ‘牛肉‘, ‘猪肉‘]
# insert 需要指定索引,从指定索引的前面添加 若未指定索引则报错

list1.extend(["米饭","面条"])
print(list1) # [‘青菜‘, ‘西葫芦‘, ‘藕‘, ‘胡萝卜‘, ‘芹菜‘, ‘牛肉‘, ‘猪肉‘, ‘米饭‘, ‘面条‘]
# extend 迭代追加所有元素
list1.extend(("青椒","红椒"))
print(list1) # [‘青菜‘, ‘西葫芦‘, ‘藕‘, ‘胡萝卜‘, ‘芹菜‘, ‘牛肉‘, ‘猪肉‘, ‘米饭‘, ‘面条‘, ‘青椒‘, ‘红椒‘]
list1.extend({"葱","姜","蒜"})
print(list1) # [‘青菜‘, ‘西葫芦‘, ‘藕‘, ‘胡萝卜‘, ‘芹菜‘, ‘牛肉‘, ‘猪肉‘, ‘米饭‘, ‘面条‘, ‘青椒‘, ‘红椒‘, ‘姜‘, ‘葱‘, ‘蒜‘]

# (2)列表的删:pop remove clear
list1 = [‘青菜‘, ‘西葫芦‘, ‘藕‘, ‘胡萝卜‘, ‘芹菜‘, ‘牛肉‘, ‘猪肉‘, ‘米饭‘, ‘面条‘, ‘青椒‘, ‘红椒‘, ‘姜‘, ‘葱‘, ‘蒜‘]
list1 .pop()
print(list1) # [‘青菜‘, ‘西葫芦‘, ‘藕‘, ‘胡萝卜‘, ‘芹菜‘, ‘牛肉‘, ‘猪肉‘, ‘米饭‘, ‘面条‘, ‘青椒‘, ‘红椒‘, ‘姜‘, ‘葱‘]
list1.pop(0)
print(list1) # [‘西葫芦‘, ‘藕‘, ‘胡萝卜‘, ‘芹菜‘, ‘牛肉‘, ‘猪肉‘, ‘米饭‘, ‘面条‘, ‘青椒‘, ‘红椒‘, ‘姜‘, ‘葱‘]
# .pop() 根据索引删除,如不指定索引则默认删除最后一个元素

list1.remove("胡萝卜")
print(list1) # [‘西葫芦‘, ‘藕‘, ‘芹菜‘, ‘牛肉‘, ‘猪肉‘, ‘米饭‘, ‘面条‘, ‘青椒‘, ‘红椒‘, ‘姜‘, ‘葱‘]
# .remove根据值来删除,如果列表中值相同,则默认删除第一个值

list1.clear()
print(list1) # []
# .clear()删除整个列表的元素,返回空列表

# (3)获取某个值在列表中的索引:
list1 = ["幼儿园","小学","初中","高中","大学"]
print(list1.index("初中")) # 2
# print(list1.index("初中",0,2)) # 报错 根据切片查找顾头不顾尾,找不到就报错

# (4)计算某个元素出现的次数
print(list1.count("大学")) # 1

# (5)对列表进行排序
list1 = [7892,337,922,728,76]
list1.sort()
print(list1) # [76, 337, 728, 922, 7892]  默认按照从小到大的顺序排列
list1.sort(reverse=True)
print(list1) # [7892, 922, 728, 337, 76] 设定reverse为True,可以让列表从大到小排列

# 英文字母的排序是按照ASCII码进行排列的,中文也有排列顺序,但是无规律可循

# (6)列表的反转:
list1 = ["小鱼","中鱼","大鱼"]
list1.reverse()
print(list1) # [‘大鱼‘, ‘中鱼‘, ‘小鱼‘]

# 元祖的相关函数只有两个:count index
# (1) 计算某个字符出现的次数
tuple1 = ("硬盘","内存","鼠标","硬盘","内存")
print(tuple1.count("硬盘")) # 2

# (2) 查找某个字符出现的索引
print(tuple1.index("鼠标")) # 2
print(tuple1.index("鼠标",0,2)) # 报错

# 字典相关函数
# (1)字典的增:
dict1 = {"幼儿园":"幼儿"}
dict1["小学"] = "小学生"
dict1["初中"] = "初中生"
dict1["高中"] = "高中生"
print(dict1)
# {‘幼儿园‘: ‘幼儿‘, ‘小学‘: ‘小学生‘, ‘初中‘: ‘初中生‘, ‘高中‘: ‘高中生‘}

# 使用一组键和None来创建字典  fromkeys()   可以用列表或者元祖包起来
dict2 = {}.fromkeys(["一元","五十元","一百元"],None)
print(dict2)  # {‘一元‘: None, ‘五十元‘: None, ‘一百元‘: None}

# 注意点
dict3 = {}.fromkeys(["一元","五十元","一百元"],["小","中","大"])
print(dict3) # {‘一元‘: [‘小‘, ‘中‘, ‘大‘], ‘五十元‘: [‘小‘, ‘中‘, ‘大‘], ‘一百元‘: [‘小‘, ‘中‘, ‘大‘]}
dict3["一百元"].append("有十张")
print(dict3)
# {‘一元‘: [‘小‘, ‘中‘, ‘大‘, ‘有十张‘], ‘五十元‘: [‘小‘, ‘中‘, ‘大‘, ‘有十张‘], ‘一百元‘: [‘小‘, ‘中‘, ‘大‘, ‘有十张‘]}
# 每个元素都增加了"有十张"
# 改进:使用如上方式
dict4 = {}
dict4["一元"] = ["小"]
dict4["五十元"] = ["中"]
dict4["一百元"] = ["大"]
dict4["一百元"].append("有十张")
print(dict4)
# {‘一元‘: [‘小‘], ‘五十元‘: [‘中‘], ‘一百元‘: [‘大‘, ‘有十张‘]}

# (2)字典的删除:pop  popitem  clear
dict5 = {‘幼儿园‘: ‘幼儿‘, ‘小学‘: ‘小学生‘, ‘初中‘: ‘初中生‘, ‘高中‘: ‘高中生‘}
res= dict5.pop("高中")
print(res) # 高中生 返回对应的值
print(dict5) # {‘幼儿园‘: ‘幼儿‘, ‘小学‘: ‘小学生‘, ‘初中‘: ‘初中生‘}
# pop方法可以设置默认值来预防程序报错
res= dict5.pop("高中","没有")
print(res) # 没有 若返回的是没有,则该字典中没有这个键

print(dict5) # {‘幼儿园‘: ‘幼儿‘, ‘小学‘: ‘小学生‘, ‘初中‘: ‘初中生‘}
dict5.popitem()
print(dict5) # {‘幼儿园‘: ‘幼儿‘, ‘小学‘: ‘小学生‘}
# popitem 不需要传值,默认删除最后一个键值对

dict5.clear()
print(dict5) # {} 全部清除,返回空字典

# (3) 字典的改:update 有该键就修改,没有的话就增加,批量更新
dict6 = {‘幼儿园‘: ‘幼儿‘, ‘小学‘: ‘小学生‘, ‘初中‘: ‘初中生‘, ‘高中‘: ‘高中生‘}
dict7 ={‘幼儿园‘: ‘幼儿‘,"高中":"青年人","大学":"大学生"}
dict6.update(dict7)
print(dict6) # {‘幼儿园‘: ‘幼儿‘, ‘小学‘: ‘小学生‘, ‘初中‘: ‘初中生‘, ‘高中‘: ‘青年人‘, ‘大学‘: ‘大学生‘}
dict6.update(高中="成年人") # 修改单个值
print(dict6) # {‘幼儿园‘: ‘幼儿‘, ‘小学‘: ‘小学生‘, ‘初中‘: ‘初中生‘, ‘高中‘: ‘成年人‘, ‘大学‘: ‘大学生‘}

# (4) 字典的查:get
dict8 ={‘幼儿园‘: ‘幼儿‘,"高中":"青年人","大学":"大学生"}
print(dict8["幼儿园"]) # 幼儿
# dict8["小学"]  # 如果查找的键没有的话,程序直接报错
res= dict8.get("小学")
print(res) # None  get方法找不到字典的键的话返回None

#get方法也能设置默认值
res1= dict8.get("硕士","没有这个值")
print(res1) # 没有这个值

# (5) 其他用法:
# 字典的键可以组成一个可迭代对象
dict9 ={‘幼儿园‘: ‘幼儿‘,"高中":"青年人","大学":"大学生"}
res = dict9.keys()
print(res,type(res)) # dict_keys([‘幼儿园‘, ‘高中‘, ‘大学‘]) <class ‘dict_keys‘>

res2 = dict9.values()
print(res2) # dict_values([‘幼儿‘, ‘青年人‘, ‘大学生‘])

res3 = dict9.items()
print(res3) # dict_items([(‘幼儿园‘, ‘幼儿‘), (‘高中‘, ‘青年人‘), (‘大学‘, ‘大学生‘)])
for k,v in res3:
    print(k,v)
# 幼儿园 幼儿
# 高中 青年人
# 大学 大学生

# 集合相关的函数
# (1)集合的增: add  update
set1 = {"天空","大地"}
set1.add("空气")
print(set1)
# add方法一次加一个元素

list1 = ["云朵","闪电","氧气"]
set1.update(list1)
print(set1) # {‘闪电‘, ‘天空‘, ‘氧气‘, ‘大地‘, ‘云朵‘, ‘空气‘}
str = "字符串"
set1.update(str)
print(set1) # {‘闪电‘, ‘字‘, ‘大地‘, ‘云朵‘, ‘空气‘, ‘符‘, ‘串‘, ‘氧气‘, ‘天空‘}
# update方法,一次可以加一堆,加的对象是可迭代的

# (2) 集合的删: pop discard remove clear
set2 = {‘闪电‘, ‘天空‘, ‘氧气‘, ‘大地‘, ‘云朵‘, ‘空气‘}
set2.pop()
print(set2) # {‘空气‘, ‘闪电‘, ‘氧气‘, ‘大地‘, ‘天空‘}
# pop 随机删除一个值

set2.discard("氧气")
print(set2) # {‘云朵‘, ‘空气‘, ‘大地‘, ‘闪电‘}
set2.discard("小草")
print(set2) # {‘天空‘, ‘空气‘, ‘大地‘, ‘闪电‘}
# discard 删除指定的值,如果这个值不在集合中,也不会报错

set2.remove("大地")
print(set2) # {‘空气‘, ‘云朵‘, ‘天空‘}
# set2.remove("小草")
# print(set2)  # 报错
# remove方法删除指定的值,不存在则报错

set2.clear()
print(set2) # set()
# clear 方法清除整个集合

# (3) 冰冻集合:frozenset 可将容器类型强转成冰冻集合,冰冻集合只能做交叉并补的运算,不能做其他的修改
set3 = frozenset()
print(set3,type(set3)) # frozenset() <class ‘frozenset‘>

list2 = ["冰冻","集合"]
set4 = frozenset(list2)
print(set4,type(set4)) # frozenset({‘冰冻‘, ‘集合‘}) <class ‘frozenset‘>

for i in set4:
    print(i) # 冰冻集合可以遍历

# 深浅copy
# (1) 浅copy: 只拷贝一级层所有的元素,其他层级延续以前的数据
# 方式一:
lst = [1,2,3]
lst2 = lst.copy()
lst.append(5)
print(lst)  # [1, 2, 3, 5]
print(lst2) # [1, 2, 3]

lst2[0] = 2
print(lst2) # [2, 2, 3]
print( id(lst[0])) # 1554153584
print( id(lst2[0])) # 1554153616

# 方式二:
import copy
lst = [1,2,3]
lst2 = copy.copy(lst)
lst.append(10)
print(lst) # [1, 2, 3, 10]
print(lst2) # [1, 2, 3]

# (2) 深copy: 所有层级的元素都拷贝一份,形成独立的副本
lst = [1,2,3,[4,5,6]]
lst2 = copy.deepcopy(lst)
lst[-1].append(888)
print(lst) # [1, 2, 3, [4, 5, 6, 888]]
print(lst2) # [1, 2, 3, [4, 5, 6]]
print(id(lst[-1])  ,  id(lst2[-1]))
# 2345125212744 2345126694728

dic = {"a":1,"b":[1,2,3]}
dic2 = copy.deepcopy(dic)
dic["b"].append(4)
print(dic) # {‘a‘: 1, ‘b‘: [1, 2, 3, 4]}
print(dic2) # {‘a‘: 1, ‘b‘: [1, 2, 3]}

# 浅拷贝比深拷贝速度更快