人工智能系列-Python系列(四)列表、元组、字典、集合

转载请注明预见才能遇见的博客:http://my.csdn.net/

原文地址:https://blog.csdn.net/pcaxb/article/details/90748443

人工智能系列-Python系列(四)列表、元组、字典、集合

目录

人工智能系列-Python系列(四)列表、元组、字典、集合

一、列表 6个 基础知识总结

1.索引、切片取值

2.通过索引修改、删除 del

3.通过切片修改、删除

4.in操作

5.操作 多维操作

6. 字符串转换列表 、 列表转换成字符串

二、列表 10个函数总结

1.append、extend原来值最后追加、扩展原列表,参数:可迭代对象

2 clear 清空列表

3 count 拷贝,浅拷贝

4、count计算元素出现的次数

5、index根据值获取当前值索引位置(左边优先)

6、 insert 在指定索引位置插入元素

7、 pop删除某个值(1.指定索引;2. 默认最后一个),并获取删除的值

8. remove、pop、del、clear 删除列表中的指定值,左边优先

9 reverse 将当前列表进行翻转

10 sort 列表的排序

三、元组 tuple

1.count、index获取指定元素在元组中出现的次数

 2.索引

3.切片

4.可以被for循环,可迭代对象

5.转换

6.list中追加元组extend

 7.元组的一级元素不可修改/删除/增加

四、字典 dict

1、找指定元素

2.字典 del删除

3.for循环

4 formkeys根据序列,创建字典,并指定统一的值

5 get根据Key获取值,key不存在时,可以指定默认值(None),通过[]获取就会报错

 6 pop、popitem删除并获取值

7 setdefault设置值,

8.update更新

5、集合

扩展

1.添加

2.清除

3.复制

 4.随机删 随机删除一个元素

5.指定删除

6.交集 并集 差集 交叉补集

7.判断2个集合有没有交集,判断一个集合是不是另外一个集合的子集,判断一个集合是不是另外一个集合的父集

8.update 更新多个值

9.定义不可变集合

10.列表去重


一、列表 6个 基础知识总结

# 列表,有序;元素可以被修改
# 列表中可以嵌套任何类型  和 JavaScript中的数组一样
# for . in . 可以被for循坏,可迭代
# li = [1, 2, 3, 4, [5, 6]]
# print(len(li))  # 5

1.索引、切片取值

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

5.操作 多维操作

# li = [1, 12, 9, "age", ["name", ["19", 10], "哈哈"], "alex", True]
# print(li[4][1][0])  # 19

6. 字符串转换列表 、 列表转换成字符串

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

5、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)  # 22

8. 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))  # 1

 2.索引

# print(tu[2])  # 33

3.切片

# 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 111

 6 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))  # True

8.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没有返回,然后更新s1

9.定义不可变集合

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系列(四)列表、元组、字典、集合

博客地址:https://blog.csdn.net/pcaxb/article/details/90748443

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值