Python-元组&字典&集合及其内置方法

1、元组类型的概念和总结

1.1、元组类型的概念

1、用途：按照位置存放多个值，索引对应值
2、定义方式：在()内用逗号分隔开多个任意类型的元素
    t = (11, 11.11, 'aaa', [222, 333])  # t = tuple(...)
    print(t[-1][0])  # 222
    l[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])  # 222
    
2、切片(顾头不顾尾，步长)
	# 示例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))  # 4
    
4、成员运算 in和 not in
	# 示例4：
    t = (11, 11.11, 'aaa', [222, 333])
    print(11 in t)  # True
    print(222 in t)  # False
    
5、循环
	# 示例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'))  # 2
    print(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)])  # 2222
    d[1] = 3333  # 改了key[1]对应的值变成3333
    d['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'])  # 222
    d['k1'] = 100  # 改了key[1]对应的值变成100
    d['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))  # 3
    
3、成员运算 in和 not in，针对key来判断的
	# 示例3：
	d={"k1":111,"k2":222,"k3":333}
	print("k1" in d)  # True
    
4、删除
	# 示例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对应的value
    print(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不存在，则返回None
    
7、循环
	# 示例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"] = 66666666666666
    res = d.setdefault("k1", 666666666666)  # setdefault就是相当于上面这个if判断功能，key存在则不动，key不存在则添加对应的key:value键值对
    print(d)  # {"k1":111,"k2":222,"k3":333}
    print(res)  # 1111，setdefault有返回值，返回key对应的value
    
5、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))  # 3
    
2、成员运算 in和 not in
	# 示例2：
    s={11,222,333}
    print(11 in s)  # True
    
3、关系运算：交集& 并集| 差集- 对称差集^ 等集== 父集>= 子集<=
	# 示例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)  # 3

3、s.remove，删除指定元素，如果元素存在则删除并返回None；若元素不存在则报错
	# 案例3：
    s = {"aaa", 22, 3, "bbb"}
    res=s.remove("bbb")
    print(s)  # {3, 22, 'aaa'}
    print(res)  # None

4、s.discard，和remove差不多，删除指定元素，存在则删除并返回None，不存在不会报错也返回None，
	# 案例4：
    s = {"aaa", 22, 3, "bbb"}
    res = s.discard("cccccccccc")
    print(s)  # {'bbb', 3, 22, 'aaa'}
	print(res)  # None
    
5、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