转载请注明预见才能遇见的博客：http://my.csdn.net/
原文地址：https://blog.csdn.net/pcaxb/article/details/90748443
人工智能系列-Python系列（四）列表、元组、字典、集合
目录
1.append、extend原来值最后追加、扩展原列表，参数：可迭代对象
7、 pop删除某个值(1.指定索引；2. 默认最后一个)，并获取删除的值
8. remove、pop、del、clear 删除列表中的指定值，左边优先
5 get根据Key获取值，key不存在时，可以指定默认值（None）,通过[]获取就会报错
7.判断2个集合有没有交集，判断一个集合是不是另外一个集合的子集，判断一个集合是不是另外一个集合的父集
一、列表 6个 基础知识总结
# 列表，有序；元素可以被修改
# 列表中可以嵌套任何类型 和 JavaScript中的数组一样
# for . in . 可以被for循坏,可迭代# li = [1, 2, 3, 4, [5, 6]]
# print(len(li)) # 51.索引、切片取值
# print(li[0]) # 1
# print(li[0:2]) # [1, 2]
# for item in li:
# print(item)2.通过索引修改、删除 del
# li[0] = 0
# print(li) # [0, 2, 3, 4]
# del li[0]
# print(li) # [2, 3, 4]3.通过切片修改、删除
# li[0:2] = [5, 6]
# print(li) # [5, 6, 3, 4]
# del li[0:2]
# print(li) # [3, 4]4.in操作
# m = 3 in li
# print(m) # True
# m1 = 5 in li
# print(m1) # False5.操作 多维操作
# li = [1, 12, 9, "age", ["name", ["19", 10], "哈哈"], "alex", True]
# print(li[4][1][0]) # 196. 字符串转换列表 、 列表转换成字符串
# print(list("fhahfhafh")) # ['f', 'h', 'a', 'h', 'f', 'h', 'a', 'f', 'h']
# 既有数字又有字符串，需要自己写for循环一个一个处理
# li = [11, 22, 33, "123", "alex"]
# print(str(li)) # [11, 22, 33, '123', 'alex']
# print(11 + "") # 报错 JavaScript 可以这样把数字转换成字符串
# s = ""
# for m in li:
# s += str(m)
# print(s) # 112233123alex
# s1 = ""
# s1 = "".join(li)
# print(s1) # 报错
# 列表中的元素只有字符串， 直接使用字符串join方法
# print(str(["12", "34"])) # ['12', '34']
# li = ["44", "22", "11", "123", "alex"]
# m = "".join(li)
# print(m) # 442211123alex二、列表 10个函数总结
1.append、extend原来值最后追加、扩展原列表，参数：可迭代对象
# a = [1, 2]
# a.append(3)
# print(a) # [1, 2, 3]
# a.append(["111"])
# print(a) # [1, 2, 3, ['111']]
#
# # 相当于for循环，然后append
# a.extend(["111"])
# print(a) # [1, 2, 3, ['111'], '111']
# a.extend("不得了")
# print(a) # [1, 2, 3, ['111'], '111', '不', '得', '了']
2 clear 清空列表
# a.clear()
# print(a) # []3 count 拷贝，浅拷贝
# b = a.count()
# print(b) # [1, 2]4、count计算元素出现的次数
# a = [1, 2, 2]
# print(a.count(2)) # 25、index根据值获取当前值索引位置（左边优先）
# li = [11, 22, 33, 22, 44]
# v = li.index(22) # 1
# print(v)6、 insert 在指定索引位置插入元素
# li = [11, 22, 33, 22, 44]
# li.insert(0, 99)
# print(li) # [99, 11, 22, 33, 22, 44]7、 pop删除某个值(1.指定索引；2. 默认最后一个)，并获取删除的值
# li = [11, 22, 33, 22, 44]
# v = li.pop()
# print(li) # [11, 22, 33, 22]
# print(v) # 44
# li = [11, 22, 33, 22, 44]
# v = li.pop(1)
# print(li) # [11, 33, 22, 44]
# print(v) # 228. remove、pop、del、clear 删除列表中的指定值，左边优先
# PS: pop remove del li[0] del li[7:9] clear
# li = [11, 22, 33, 22, 44]
# li.remove(22)
# print(li) # [11, 33, 22, 44]9 reverse 将当前列表进行翻转
# li = [11, 22, 33, 22, 44]
# li.reverse()
# print(li) # [44, 22, 33, 22, 11]10 sort 列表的排序
# li = [11, 44, 22, 33, 22]
# li.sort() # 正着排序
# print(li) # [11, 22, 22, 33, 44]
# li.sort(reverse=True) # 反着排序
# print(li) # [44, 33, 22, 22, 11]三、元组 tuple
# 列表的二次加工
# tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
# 一般写元组的时候，推荐在最后加入 ,
# 元组，元素不可被修改，不能被增加或者删除
1.count、index获取指定元素在元组中出现的次数
# tu = (11, 22, 33, 44)
# print(tu.count(33)) # 1
# 2.获取指定元素在元组中的位置
# print(tu.index(22)) # 12.索引
# print(tu[2]) # 333.切片
# print(tu[2:8]) # (33, 44)4.可以被for循环，可迭代对象
# for item in tu:
# print(item)5.转换
# s = "asdfasdf0"
# li = ["asdf", "asdfasdf", 123]
# tu = ("asdf", "asdf")
# # str--list
# print(list(s)) # ['a', 's', 'd', 'f', 'a', 's', 'd', 'f', '0']
# # str--tuple
# print(tuple(s)) # ('a', 's', 'd', 'f', 'a', 's', 'd', 'f', '0')
#
# # list--str
# print(str(li)) # ['asdf', 'asdfasdf', 123]
# # 扩展 for 或者如有只有字符串可以使用join
# # tuple--str
# print(str(tu)) # ('asdf', 'asdf')
# print("_".join(tu)) # asdf_asdf
# print("_".join(("1", "2", "3",))) # 1_2_3 只能是字符串
#
# # list--tuple
# print(tuple(li)) # ('asdf', 'asdfasdf', 123)
# # tuple --list
# print(list(tu)) # ['asdf', 'asdf']6.list中追加元组extend
# print(li) # ['asdf', 'asdfasdf', 123]
# li.extend(tu)
# print(li) # ['asdf', 'asdfasdf', 123, 'asdf', 'asdf']7.元组的一级元素不可修改/删除/增加
# tu = (111, "alex", (11, 22), [(33, 44)], True, 33, 44,)
# # 元组，有序。
# print(tu[3]) # [(33, 44)]
# print(tu[3][0]) # (33, 44)
# tu[3][0] = "12" # 可以修改
# print(tu) # (111, 'alex', (11, 22), ['12'], True, 33, 44)
# tu[3][0][0] = "11" 错误元组不能修改四、字典 dict
# 字典 dict 键值对
# 键 列表、字典不能作为字典的key
# 值 是任何类型
# 字典无序
# dc = {"name": "cc", "age": 22}
# 布尔值可以作为字典的key，但是1.和True如果重复就会覆盖
# print({1: "11", False: "11"}) # {1: '11', False: '11'}
# print({0: "11"}) # {0: '11'}
# print({True: "11"}) # {True: '11'}
# print({False: "11"}) # {False: '11'}
# info = {
# "k1": 18,
# 2: True,
# "k3": [
# 11,
# [],
# (),
# 22,
# 33,
# {
# 'kk1': 'vv1',
# 'kk2': 'vv2',
# 'kk3': (11, 22),
# }
# ],
# "k4": (11, 22, 33, 44)
# }
1、找指定元素
# print(info["k1"]) # 18
# print(info["k3"][5]["kk3"][0]) # 11
# # print(info.k1) 错误2.字典 del删除
# del info["k4"]
# print(info) # {'k1': 18, 2: True, 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]}
3.for循环
# for item in info:
# print(item) # k1 2 k3 k4 打印出所有的键
# print(info[item]) # 键对应的值
# k v 随便定义成什么，第一个是key，第二个是value
# for k, v in info.items():
# print(k, v) # 可以打印出键值
# for m, n in info.items():
# print(m, n) # 可以打印出键值
# for item in info.keys():
# print(item) # 打印出所有的键
#
#
# for item in info.values():
# print(item) # 打印出所有的值4 formkeys根据序列，创建字典，并指定统一的值
# v = dict.fromkeys([1, 2, 3], "PP")
# print(v) # {1: 'PP', 2: 'PP', 3: 'PP'}5 get根据Key获取值，key不存在时，可以指定默认值（None）,通过[]获取就会报错
# print(v[1]) # PP
# # print(v["k1"]) # 获取不到报错
# print(v.get("k1")) # None
# print(v.get("k1"), 111) # None 1116 pop、popitem删除并获取值
# dic = {
# "k1": 'v1',
# "k2": 'v2'
# }
# m = dic.pop('k1')
# print(m) # v1 返回删除的值
# n = dic.pop('k5', 2)
# print(n) # 如果不设置默认值，没有对应key的时候，就会报错
#
# k, v = dic.popitem() # 删除返回key和value
# print(dic, k, v)7 setdefault设置值，
# 已存在，不设置，获取当前key对应的值
# 不存在，设置，获取当前key对应的值dic = {
"k1": 'v1',
"k2": 'v2'
}
# m = dic.setdefault("k1", 11)
# print(dic, m) # {'k1': 'v1', 'k2': 'v2'} v1
# m1 = dic.setdefault("k3", 11)
# print(dic, m1) # {'k1': 'v1', 'k2': 'v2', 'k3': 11} 11
8.update更新
print(dic) # {'k1': 'v1', 'k2': 'v2'}
dic.update({"k1": "v11", "k2": "v22"})
print(dic) # {'k1': 'v11', 'k2': 'v22'}5、集合
# 1.）不同元素组成
# 2.）无序，可变
# 3.）集合中元素必须是不可变类型
# 使用集合去重
v = set("liming")
print(v) # {'n', 'g', 'l', 'i', 'm'}
m = set([1, 2, 3, 4])
print(m) # {1, 2, 3, 4}扩展
# 1.可变不可变：
# 1.）可变：列表、字典
# 2.）不可变：字符串、数字、元组
# 2.访问顺序
# 1）直接访问：数字
# 2）顺序访问：字符串、列表、元组
# 3）映射：字典
# 3.存放元素个数
# 1）容器类型：列表、元组、字典
# 2）原子：数字、字符串name = "lim"
print(id(name))
name = "123"
print(id(name))1.添加
m.add("m")
print(m) # {1, 2, 3, 4, 'm'}2.清除
# m.clear()
# print(m) # set()3.复制
m1 = m.copy()
print(m1) # {1, 2, 3, 4, 'm'}4.随机删 随机删除一个元素
m1.pop()
print(m1) # {2, 3, 4, 'm'}5.指定删除
m1.remove(4) # 删除元素不存在会报错
print(m1) # {2, 3, 'm'}
m1.discard('aa') # 删除元素不存在不会报错
print(m1) # {2, 3, 'm'}
m1.discard('m')
print(m1) # {2, 3}6.交集 并集 差集 交叉补集
a1 = {1, 24, 4}
a2 = {"aa", 2, 4}
# 1）交集：相同的部分
print(a1.intersection(a2)) # {4}
print(a1 & a2) # {4}
# 2）并集：相加,重复元素保留一个
print(a1.union(a2)) # {1, 2, 4, 'aa', 24}
print(a1 | a2) # {1, 2, 4, 'aa', 24}
# 3）差集：相减
print(a1.difference(a2)) # {24, 1}
print(a2.difference(a1)) # {'aa', 2}
print(a2 - a1) # {'aa', 2}
#
print(a1 - a2, a1, a2) # {24, 1} {24, 1, 4} {2, 4, 'aa'}
# a1和a2去求差集，difference_update就是把a1和a2得到的差集给a1
print(a1.difference_update(a2), a1, a2) # None {24, 1} {2, 'aa', 4}
# 4）交叉补集:相加，重复元素全部删除
print(a1.symmetric_difference(a2)) # {1, 2, 'aa', 24}7.判断2个集合有没有交集，判断一个集合是不是另外一个集合的子集，判断一个集合是不是另外一个集合的父集
# 1）isdisjoint判断2个集合有没有交集，没有交集就是True，有交集就是False
s1 = {1, 2}
s2 = {2, 3, 5}
s3 = {6, 7}
s4 = {1, 2, 3}
print(s1.isdisjoint(s2)) # False
print(s1.isdisjoint(s3)) # True
# 2）issubset判断一个集合是不是另外一个集合的子集， 是子集就是True，不是子集就是False
print(s1.issubset(s4)) # True
print(s4.issubset(s1)) # False
# 3) issuperset判断一个集合是不是另外一个集合的父集， 是父集就是True，不是父集就是False
print(s1.issuperset(s4)) # False
print(s4.issuperset(s1)) # True8.update 更新多个值
# print(s1.union(s4), s1, s4) # {1, 2, 3} {1, 2} {1, 2, 3}
print(s1.update(s4), s1, s4) # None {1, 2, 3} {1, 2, 3}
# 和并集不同，update没有返回，然后更新s19.定义不可变集合
c1 = frozenset([1, 2, 4])
print(c1) # frozenset({1, 2, 4})
# c1.pop() # 报错10.列表去重
names = ['12', '34', '56', '12']
print(names) # ['12', '34', '56', '12']
names1 = list(set(names))
print(names1) # ['12', '34', '56']人工智能系列-Python系列（四）列表、元组、字典、集合
扫一扫
8666
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
