将 列表======>字符串
将 list 转化为 str
e.g
s="可口可乐"
s1=s.join("非常可乐") # 将s 放置到 非常可乐 中间
print(s1)========> 非 可口可乐 常 可口可乐 可 可口可乐 乐
s="tx".join("ab")
print(s)=====>atxb
s="_".join([ "alex","wusir","taibai" , "slary" ])
print(s)=====>alex_wusir_taibai_slary
lst=["我不是药神","西游记","天龙八部","后来"]
lst.clear()====>[] #将lst清空
for el in lst: # 在执行for循环的时候 内部有一个变量 index=0
index=index+1
因此,,,当删除完第" 0 "项的时候, 第" 1 "项会自动移动到"0"的位
置, 但是 index=index+1===>1了,所以,会继续删除现在在"1"项
的" 天龙八部 " ,原来在"2"的后来就跑到了"1",index=2,所以循环执行完毕,最后剩下 西游记 , 后来
lst.remove(el)=======>"西游记","后来" # 没有清空
list 在循环列表的时候不能删,,,,,,,,因为会改变 索引位置
在循环列表时删除 :
e.g 删除姓周的人
lst=["周杰伦","周润发","周星驰","麻花藤","周树人"]
lst1=[] # 创建一个空的列表 ,放置要删除的项
for el in lst: #遍历原来的列表
if el.startswith("周"): # 找到以 周 字开头的元素
lst1.append(el) # 将以周字开头的元素 添加到新列表中
for el in lst1: # 遍历新的列表 ,
lst.remove(el) ## 删除新列表在 原来列表中的元素 # 删除原来列表中姓周的元素
print(lst)=========> ["麻花藤"]
字典在循环时,也不允许增加和删除
dict.fromkeys() 是用dict 类 执行的.
dict.fromkeys() 不会对原来的字典产生影响, 因为 它会产生一个新的字典
e.g
dic={}
dic.fromkeys("王健林","王思聪")
print(dic)====>{} # 对原来的字典不产生变化
a=dic.fromkeys() #将其定义
print(a)====>{ "王": "思聪" , "健": "思聪" , "林": "思聪" } # 新的字典
e.g
a=dict.fromkeys("麻花藤","ab")
print(a)=====>{"麻": "ab", "花":"ab","藤":"ab"}
a=dict.fromkeys([ "jj" , "jay" ] , "bd")
print(a)======>{"jj": bd , " jay ": "bd" }
类型转换
像转换成啥,就用啥括起来
元组 ====> 列表 list( tuple )
列表 ====> 元组 tuple( list )
列表 ====>字符串 str.join( list )
字符串====> 列表 str.split()
set 集合 集合是基本的数据类型
s=set() 空集合 # 为了和字典区分
元素: 不重复的 , 无序的 可hash的 ( 不可变的 ) ( int , str, tuple ,bool )
set 就是 dict 字典类型的数据 ,但是不保存 value 只保存 key , 因此也用 { " " , " " , " " } 表示
set 元素是可hash的, 但是set本身是 不可hash 的, 因此set 本身是可以变得
e.g
s= {"王者刃", "英雄" , 123, true ,"英雄" , 123}
print(s) ======> {" 英雄 ", 123 ," 王者刃 " , true}
s={ 123 , [ 1,2,3 ] }
print(s) ====> 报错 =====> list 是不可hash的
set 集合 可帮助 去重复
# 给list去重复
lst = [45, 5, "哈哈", 45, '哈哈', 50]
lst = list(set(lst)) # 把list转换成set, 然后再转换回list
print(lst)====> [45, 5, "哈哈", 50]
set集合增删改查
1. 增加
s = {"刘嘉玲", '关之琳', "王祖贤"}
s.add("郑裕玲")
print(s) =====>{"刘嘉玲", '关之琳', "王祖贤","郑裕玲"}
s.add("郑裕玲") # 重复的内容不不会被添加到set集合中
print(s) =======>{"刘嘉玲", '关之琳', "王祖贤","郑裕玲"}
s = {"刘嘉玲", '关之琳', "王祖贤"}
s.update("麻花藤") # 迭代更新
print(s) =====> {'花' , '关之琳', '藤', '刘嘉玲', '王祖贤 ' , '麻'}
s.update(["张曼⽟玉", "李李若彤","李李若彤"]) # 将列表内容 迭代加入
print(s) ======> {'李若彤', '藤', '张曼玉', '刘嘉玲', '关之琳', '花', '王祖贤', '麻'}
2. 删除
s = {"刘嘉玲", '关之琳', "王祖贤","张曼玉", "李若彤"}
item = s.pop() # 随机弹出⼀一个. 随机删除一个
print(s) =====> {'刘嘉玲', '李若彤', '张曼玉', '关之琳'}
print(item)=====> 王祖贤
s = {"刘嘉玲", '关之琳', "王祖贤","张曼玉", "李若彤"}
s.remove("关之琳") # 直接删除元素
# s.remove("⻢马⻁虎疼") # 不不存在这个元素. 会报错
print(s) =====> {'刘嘉玲', '张曼⽟玉', '李李若彤', '王祖贤'}
s.clear() # 清空set集合.需要注意的是set集合如果是空的.
打印出来是set() 因为要和 dict区分的. print(s) #
=======> set()
3. 修改 set集合中的数据没有索引. 也没有办法去定位⼀一个元素. 所以没有办法进⾏行行直接修改.
先 删除 要修改的元素
再 添加 要改后的结果========> 修改
e.g
s = {"刘嘉玲", '关之琳', "王祖贤","张曼玉", "李若彤"}
# 把刘嘉玲改成赵本山
s.remove("刘嘉玲")
s.add("赵本⼭山")
print(s)========> {'赵本山', '张曼玉', '王祖贤', '李若彤', '关之琳'}
4. 查询
# set是⼀一个可迭代对象.
所以可以进⾏行行for循环
for el in s:
print(el)
5. 常⽤用操作
s1 = {"刘能", "赵四", "皮长山"}
s2 = {"刘科长", "冯乡长", "皮长山"}
# 交集 # 两个集合中的共有元素
print(s1 & s2) =======> {'皮长山'}
print(s1.intersection(s2)) # {'皮长山'}
# 并集
print(s1 | s2) ======> # { '刘科长', '冯乡长', '赵四', '皮长山', '刘能'}
print(s1.union(s2)) =====> # {'刘科长', '冯乡长', '赵四', '皮长山', '刘能'}
# 差集
print(s1 - s2) =====> # {'赵四', '刘能'} 得到第⼀一个中单独存在的
print(s1.difference(s2)) ======> # {'赵四', '刘能'} 得到第⼀一个中单独存在的
# 反交集
print(s1 ^ s2) ====> # 两个集合中单独存在的数据 {'冯乡长', '刘能', '刘科长', '赵四'}
print(s1.symmetric_difference(s2)) ====> 两个集合中单独存在的数据 # {'冯乡长', '刘能', '刘科长', '赵四'}
s1 = {"刘能", "赵四"}
s2 = {"刘能", "赵四", "⽪皮⻓长⼭山"}
# 子集
print(s1 < s2) # set1是set2的⼦子集吗? 判断s1 是否是 s2 的子集 ====> True
print(s1.issubset(s2))====> True
# 超集
print(s1 > s2) # set1是set2的超集吗? False
print(s1.issuperset(s2))=====> False
set集合本⾝身是可以发⽣生改变的. 是不可hash的.
我们可以使⽤用frozenset来保存数据. frozenset是不可变的. 也就是⼀一个可哈希的数据类型
e.g
s = frozenset([1,2,6,6,8,7,9,7]) # 列表是不可hash的, 只有变成 可hash 才会放入其中
print(s)=====> frozenset([6,2,1,8,9,7])
ss={"a", s}
print(ss) ====>{ "a", frozenset([6,2,1,8,9,7]) }
三. 深浅拷贝
lst1 = ["⾦金金⽑毛狮王", "紫衫⻰龙王", "⽩白眉鹰王", "⻘青翼蝠王"]
lst2 = lst1 # 进行赋值操作 ,实际上是引用内存地址的赋值, 内存中此时 只有一个 列表
两个变量 指向的是一个列表
print(lst1) =====> ["⾦金金⽑毛狮王", "紫衫⻰龙王", "⽩白眉鹰王", "⻘青翼蝠王"]
print(lst2) ====> ["⾦金金⽑毛狮王", "紫衫⻰龙王", "⽩白眉鹰王", "⻘青翼蝠王"]
lst1.append("杨逍") # 由于两个变量指向的是同一个 列表, 因此 一个改变 两个都会改变
print(lst1) =====> ['⾦金金⽑毛狮王', '紫衫⻰龙王', '⽩白眉鹰王', '⻘青翼蝠王', '杨逍']
print(lst2) ====> ['⾦金金⽑毛狮王', '紫衫⻰龙王', '⽩白眉鹰王', '⻘青翼蝠王', '杨逍']
e.g
lst1=["赵本山","刘能","小沈阳"]
lst2=lst1
lst2.append("赵四")
print(lst1)=====> ['赵本山', '刘能', '小沈阳', '赵四']
print(lst2)=====> ['赵本山', '刘能', '小沈阳', '赵四']
print(id(lst1))=====>48849584
print(id(lst2))======> 48849584
浅拷贝
浅拷贝. 只会拷贝第一层. 第二层的内容不会拷贝. 所以被称为浅拷贝
拷贝后.内存地址会发生变化, 因此是两个不同的对象
e.g
lst3=["赵本山","刘能","小沈阳"]
lst4=lst3.copy() 将原来的列表3,copy了一个, 内存地址变了, 变量指向的是两个对象, 不是一个,,
因此,改变一个,另一个不变
lst4.append("谢大脚")
print(lst3) ======> ['赵本山', '刘能', '小沈阳']
print(lst4) =====> ['赵本山', '刘能', '小沈阳', '谢大脚']
print(id(lst3)) ====>59794096
print(id(lst4)) ====>59794056
深拷贝
e.g
lst1 = ["何炅", "杜海海涛","周渝⺠民", ["麻花藤", "⻢马芸", "周笔畅"]]
lst2 = lst1.copy() # 将lst1 copy 出来一个, 表面 的列表是两个,,但是两个列表 包含的内部的列表,她两指向的是 同
一个内部列表,,,,因此内部的列表改变的话,外边两个整体指的是 同一个内部表 因此,内部改
变两个都会变
lst1[3].append("无敌是多磨寂寞")
print(lst1) ======> ['何炅', '杜海海涛', '周渝⺠民', ['麻花藤', '⻢马芸', '周笔畅', '无敌是多磨寂寞']]
print(lst2) =====> ['何炅', '杜海海涛', '周渝⺠民', ['麻花藤', '⻢马芸', '周笔畅', '无敌是多磨寂寞']]
print(id(lst1[3]) ====> 50029232
printid(lst2[3])) ====> 50029232
深拷贝
e.g
import copy
lst1 = ["何炅", "杜海海涛","周渝⺠民", ["麻花藤", "⻢马芸", "周笔畅"]]
lst2 = copy.deepcopy(lst1) # 把lst1 扔进去进行 深度拷贝 ,
将里边嵌套的所有东西,,都拷一份,就成为两个对象了, 两个 内存地址
lst1[3].append("⽆无敌是多磨寂寞")
print(lst1) ===> ['何炅', '杜海海涛', '周渝⺠民', ['麻花藤', '⻢马芸', '周笔畅', '⽆无敌是多磨寂寞']]
print(lst2) =====.>['何炅', '杜海海涛', '周渝⺠民', ['麻花藤', '⻢马芸', '周笔畅']]
print(id(lst1[3])) =====> 4447221448
print(id(lst2[3])) ====> 4447233800