目录
1、元组类型的概念和总结1.1、元组类型的概念1.2、元组类型的总结2、元组的内置方法2.1、元组优先掌握的操作2.2、元组需要掌握的操作3、字典类型的概念和总结3.1、字典类型的概念3.2、字典类型的总结4、字典的内置方法4.1、字典优先掌握的操作4.2、字典需要掌握的操作5、集合类型的概念和总结5.1、集合类型的概念5.2、集合类型的总结6、集合的内置方法6.1、集合优先掌握的操作6.2、集合需要掌握的操作1、元组类型的概念和总结
1.1、元组类型的概念
1、用途：按照位置存放多个值，索引对应值2、定义方式：在()内用逗号分隔开多个任意类型的元素t = (11, 11.11, 'aaa', [222, 333]) # t = tuple(...)print(t[-1][0]) # 222l[0] = 1111 # 报错，因为元组是不可变的l[-1][1] = 1111 # 元组中列表是可变类型，可以修改列表的子元素print(l, type(l)) # (11, 11.11, 'aaa', [222, 1111]) <class 'tuple'>3、数据类型转换print(tuple('hello')) # ('h','e','l','l','o')，必须是可迭代对象才能转换t = (111,) # 元组中只有一个值的时候，一定要加上逗号，否则()中的值类型时什么，变量类型就是什么print(type(t)) # <class 'tuple'>
1.2、元组类型的总结
# ===========该类型总结===========存多个值有序不可变
2、元组的内置方法
2.1、元组优先掌握的操作
1、按索引取值(正向取+反向取)：只能取# 示例1：t = (11, 11.11, 'aaa', [222, 333])print(t[-1]) # [222, 333]print(t[-1][0]) # 2222、切片(顾头不顾尾，步长)# 示例2：t = (11, 11.11, 'aaa', [222, 333])print(t[:2]) # (11, 11.11)print(t[:]) # (11, 11.11, 'aaa', [222, 333])，相当于复制print(t[::-1]) # ([222, 333], 'aaa', 11.11, 11)，元组反转3、长度 len()# 示例3：t = (11, 11.11, 'aaa', [222, 333])print(len(t)) # 44、成员运算 in和 not in# 示例4：t = (11, 11.11, 'aaa', [222, 333])print(11 in t) # Trueprint(222 in t) # False5、循环# 示例5：t = (11, 11.11, 'aaa', [222, 333])for item in t:print(item)
2.2、元组需要掌握的操作
1、t.index# 示例1：t = (11, 11.11, 'aaa', [222, 333])print(t.index('aaa')) # 2print(t.index(222)) # 报错，元素不存在则报错2、t.count# 示例2：t=(11, 222, '333', 222, [222,333])print(t.count(222)) # 2，找到则返回元素个数print(t.count(333)) # 0，找不到则返回0
3、字典类型的概念和总结
3.1、字典类型的概念
1、用途：按照key:value的形式存放多个值，key对应值2、定义方式：在{}内用逗号分隔开多个key:value的元素，其中value可以是任意数据类型，而key必须是不可变类型，通常是字符串类型，且key不能重复d = {1:1111, (1,2,3):2222} # d = dict(...)print(d[(1,2,3)]) # 2222d[1] = 3333 # 改了key[1]对应的值变成3333d['k1'] = 4444 # key['k1']不存在，则添加对应的key:value键值对print(d) # {1: 3333, (1, 2, 3): 2222, 'k1': 4444}针对存在的key则改值，不存在的key则加值# key不能重复，以重复的最后一个key值为准d={"k1":111,"k2":222,"k3":333,"k1":444,"k1":5555}print(d) # {'k1': 5555, 'k2': 222, 'k3': 333}3、数据类型转换，快速初始化一个字典res = dict([("k1", 1111), ("k2", 2222), ("k3", 3333)])print(res) # {'k1': 1111, 'k2': 2222, 'k3': 3333}res = dict(x=111, y=222, z=333)print(res) # {'x': 111, 'y': 222, 'z': 333}res = {}.fromkeys(["name", "age", "gender"], None) # 把第一个参数遍历出来，依次与第二个参数匹配成一个key:value组合，第二个参数的内存地址不变print(res) # {'name': None, 'age': None, 'gender': None}
3.2、字典类型的总结
# ===========该类型总结===========存多个值无序可变
4、字典的内置方法
4.1、字典优先掌握的操作
1、按key存取值：可存可取# 示例1：d={"k1":111,"k2":222,"k3":333}print(d['k2']) # 222d['k1'] = 100 # 改了key[1]对应的值变成100d['k4'] = 444 # key['k4']不存在，则添加对应的key:value键值对print(d) # {"k1":100,"k2":222,"k3":333,"k4":444}针对存在的key则改值，不存在的key则加值# key不能重复，以重复的最后一个key值为准d={"k1":111,"k2":222,"k3":333,"k1":444,"k1":5555}print(d) # {'k1': 5555, 'k2': 222, 'k3': 333}2、长度len# 示例2：d={"k1":111,"k2":222,"k3":333}print(len(d)) # 33、成员运算 in和 not in，针对key来判断的# 示例3：d={"k1":111,"k2":222,"k3":333}print("k1" in d) # True4、删除# 示例4：d={"k1":111,"k2":222,"k3":333}方式一：del d["k1"]print(d) # {"k2":222,"k3":333}方式二：res=d.pop("k2")print(res) # 222，返回删除的key对应的valueprint(d) # {'k3': 333}5、键keys()，值values()，键值对items()# 示例5：d={"k1":111,"k2":222,"k3":333}print(d.keys()) # dict_keys(['k1', 'k2', 'k3'])print(d.values()) # dict_values([111, 222, 333])print(d.items()) # dict_items([('k1', 111), ('k2', 222), ('k3', 333)])# 在python2中返回的是列表形式，在python3中返回的是个类似老母鸡形式6、get# 示例6：d={"k1":111,"k2":222,"k3":333}print(d.get('k3')) # 333，如果key存在，则返回对应的value值print(d.get('k4')) # None，如果key不存在，则返回None7、循环# 示例7：d={"k1":111,"k2":222,"k3":333}for k in d.keys():print(k)for k in d:print(k, d[k])for v in d.values():print(v)for k, v in d.items(): # k,v=('k1', 111)print(k, v)
4.2、字典需要掌握的操作
1、d.copy# 示例1：d1={"k1":111,"k2":222,"k3":333}d2=d1.copy()print(d2)2、d.update# 示例2：d={"k1":111,"k2":222,"k3":333}d.update({"k3":444,"k5":5555}) # 如果key存在，则更新对应value值；若key不存在，则新增key:value键值对print(d) # {'k1': 111, 'k2': 222, 'k3': 444, 'k5': 5555}3、d.popitem# 示例3：d={"k1":111,"k2":222,"k3":333}res = d.popitem() # 随机删除一个key:value键值对，有返回值，以元组的形式返回删除的键值对print(d) # {"k1":111,"k3":333}4、d.setdefault# 示例4：d={"k1":111,"k2":222,"k3":333}if "k1" not in d:d["k1"] = 66666666666666res = d.setdefault("k1", 666666666666) # setdefault就是相当于上面这个if判断功能，key存在则不动，key不存在则添加对应的key:value键值对print(d) # {"k1":111,"k2":222,"k3":333}print(res) # 1111，setdefault有返回值，返回key对应的value5、d.clear# 示例5：d={"k1":111,"k2":222,"k3":333}d.clear()print(d) # {}，清空字典
5、集合类型的概念和总结
5.1、集合类型的概念
1、用途：（1）去重（局限性太大，建议手写代码去重）（2）关系运算2、定义方式：在{}内用逗号分隔开多个不可变类型集合特点：1、元素必须是不可变类型2、集合内元素无序3、集合内元素唯一s = {111,111,111,111,111,"aaa",3.3,(111,222)} # s=set(...)print(s)3、数据类型转换基于集合的特点，只能转换符合特点的数据成集合res1 = set('hello')print(res1) # {'l', 'e', 'h', 'o'}res2 = set([111,222,333,111,[1,2,3]])print(res2) # 报错，不符合集合的特点4、集合的去重（只针对符合集合特点的数据类型可以去重，且无序）nums = [111, "aaa", 111, 111, 222, 3333, 444] # 不能有可变类型元素s = set(nums) nums = list(s)print(nums) # [3333, 'aaa', 111, 444, 222]，顺序都变了5、手写代码去重：l1 = [{'name': 'egon', 'age': 18, 'sex': 'male'},{'name': 'alex', 'age': 73, 'sex': 'male'},{'name': 'tom', 'age': 20, 'sex': 'female'},{'name': 'egon', 'age': 18, 'sex': 'male'},{'name': 'egon', 'age': 18, 'sex': 'male'},]res = []for item in l1:if item not in res:res.append(item)print(res)
5.2、集合类型的总结
# ================该类型总结================存多个值无序可变
6、集合的内置方法
6.1、集合优先掌握的操作
1、长度 len()# 示例1：s={11,222,333}print(len(s)) # 32、成员运算 in和 not in# 示例2：s={11,222,333}print(11 in s) # True3、关系运算：交集& 并集| 差集- 对称差集^ 等集== 父集>= 子集<=# 示例3：pythons = ['alex','egon','yuanhao','wupeiqi','gangdan','biubiu']linuxs = ['wupeiqi','oldboy','gangdan']3.1) 交集 &：共同部分print(pythons & linuxs) # {'gangdan', 'wupeiqi'}或者print(pythons.intersection(linuxs))3.2) 并集 |：合并去重print(pythons | linuxs) # {'egon', 'oldboy', 'alex', 'biubiu', 'gangdan', 'yuanhao', 'wupeiqi'}或者print(pythons.union(linuxs))3.3) 差集 -：-前的集合不同于 -后的集合的部分print(pythons - linuxs) # {'alex', 'yuanhao', 'egon', 'biubiu'}或者print(pythons.difference(linuxs))---------------------------------------------------------------------print(linuxs - pythons) # {'oldboy'}或者print(linuxs.difference(pythons))3.4) 对称差集 ^：两个集合不同的部分，也就是两个集合相互差集的并集print(pythons ^ linuxs) # {'alex', 'yuanhao', 'oldboy', 'biubiu', 'egon'}或者print(pythons.symmetric_difference(linuxs))3.5) 等集 ==：判断两个集合是否完全相等# 示例4：s1 = {1, 2, 3}s2 = {3, 2, 1}print(s1 == s2) # True或者print(s1.issubset(s2) and s1.issuperset(s2))3.6) 父集 >=：判断 >=前面的集合是否是 >=后面的集合的父集合，也就是完全包含关系# 示例5：s1 = {1, 2, 3, 4, 5}s2 = {3, 2, 1}print(s1 >= s2) # True或者print(s1.issuperset(s2))3.7) 子集 <=：判断 <=前面的集合是否是 <=后面的集合的子集合，也就是完全被包含关系# 示例6：s1 = {1, 2, 3, 4, 5}s2 = {3, 2, 1}print(s2 <= s1) # True或者print(s2.issubset(s1))
6.2、集合需要掌握的操作
1、s.update，用另一个集合去更新目标集合，已存在的元素则去重，不存在的元素则添加# 案例1：s = {"aaa", 22, 3, "bbb"}s.update({3, 4, 5})print(s) # {3, 'bbb', 4, 22, 5, 'aaa'}2、s.pop，随机删除一个元素，返回被删除的元素值# 案例2：s = {"aaa", 22, 3, "bbb"}res = s.pop()print(s) # {'aaa', 22, 'bbb'}print(res) # 33、s.remove，删除指定元素，如果元素存在则删除并返回None；若元素不存在则报错# 案例3：s = {"aaa", 22, 3, "bbb"}res=s.remove("bbb")print(s) # {3, 22, 'aaa'}print(res) # None4、s.discard，和remove差不多，删除指定元素，存在则删除并返回None，不存在不会报错也返回None，# 案例4：s = {"aaa", 22, 3, "bbb"}res = s.discard("cccccccccc")print(s) # {'bbb', 3, 22, 'aaa'}print(res) # None5、s.add，添加元素，如果元素已存在则不添加，不存在则添加# 案例5：s = {"aaa", 22, 3, "bbb"}s.add("ccc")print(s) # {'aaa', 3, 22, 'ccc', 'bbb'}6、s.isdisjoint，判断两个集合内有没有相同的元素，有则为False，没有则为True# 案例6：s1 = {1, 2, 3}s2 = {4, 5, 6, 3}print(s1.isdisjoint(s2)) # False
