元组、集合、字典的定义以及内置函数

元组

元组：
    1、也是容器，也可以存放多个元素
    2、元组特点：
        类似列表不支持删除、添加、修改
        元组支持下标和切片(下标方式同列表,切片的方式也同列表)
切片切的是什么类型的得到的值就是什么类型，如：切的是元组，得到的就是元组类型
    3、声明元组：
        tuple = ()
    4、元组的内置函数：
        不支持：添加、删除、修改
        在元组中添加元素： 借助于list与tuple之间的转换完成
    首先将元组转成列表，在列表状态进行添加删除，添加完成后，再转换成元组
s1 = ('q', 'w', 'r')
d1 = list(s1)
print(type(d1))
print(d1)
d1.append('qwe')
print(d1)
s1 = tuple(d1)
print(s1)

        支 持：
            查找 idenx() 如存在返回第一个的位置，不存在报错：ValueError: tuple.index(x): x not in tuple
            个数 count()  查找元组中一个元素存在的次数
    5、元组的排序：
        sorted(tuple) 升序，可以进行排序，但是得到的值类型为列表

    6、类型的转换
        str --- int
        list  --- tuple

tuple = (1,3,4)
print(type(tuple))
#获取,下标和切片
tuple1 = (1, 3, 4, 9, 5, 2)
print(tuple1[2])
print(tuple1[:3])
print(tuple1[::-1])   #倒序输出
print(tuple1.index(2))  #输出第一个2的位置
print(tuple1.count(9))  #输出元组的和

w = (1, 4, 3, 2)
对元组的升序
e = sorted(w)    #对元组进行升序，但是的到的是列表
print(e)
s = tuple(e)    #将列表转换位元组
print(s)
降序
a = [2, 4, 6, 9] 
print(sorted(a, reverse = True))    #对列表的降序输出

    6、用元组类型实现：最大值、最小值、求和
    max()
    min()
    sum()

t = (1, 2, 3, 4)
print(max(t))  #查找最大值
print(min(t))  #查找最小值
print(sum(t))  #求和

元组支持的符号：
        +     #将两个元组合并
        *     #将元组输出多少遍
        []    #切片
        [:]   #
        in    #判断是否在元组中,在返回True，不存在返回False
        is    #判断两个元组是否相同，相同返回True，不相同返回False
t1 = (1, 2, 3, 4)
t2 = (5, 6, 7, 8)
print(t1 + t2)
print(t1 * 2)
print(1 in t1)
print(t1 is t2)

集合

集合(set )
    特点：无序（存放的顺序与打印的顺序是不一致的）、不重复（在集合中不能出现重复的元素）
        底层原理：哈希表
        哈希表： 无序、不重复
    总结：可以用于保存一些不重复的元素

    声明集合：
set1 = set()  #这是定义了一个空的集合
print(type(set1))
#注意以下这个方法
set2 = {}   #这是定义了一个空字典，空集合不能这样声明
print(type(set2))
set3 = {'tang', 'jian', 'feng'}   #这就是声明一个有元素的集合
print(set3)
print(type(set3))
#列表的快速去重
list1 = ['1', '6', '6', '4', '4']
set4 = set(list1)
print(list(set(list1)))

    是否支持下标和切片：
        列表中那些内置函数与下标有关：
            insert()
            pop()
            idenx()
            del
    集合里面的函数：
        添加：
# add() 添加,单个元素的添加
set1 = {1, 2, 7, 4, 5}  #集合中的整型默认会排序
print(set1)
set1.add(9)    #再集合中添加一个元素
print(set1)

# update()  添加多个
set2 = {11, 43, 23}
set2.update(set1)     #将一组可迭代的元素，类似与列表的extend
print(set2)

        删除：
# discard() 指定元素删除，集合中没有该元素，则什么都不做 
# remove() 删除指定元素，如果集合中没有该元素则抛异常
set1 = {1, 2, 3, 4, 7}
set1.remove(3)      #删除集合中的元素3
print(set1)
# pop（）  随机删除（每次都会删除第一个），返回删除的元素
set2 = {'ww','rr','ff','gg'}
s = set2.pop()
print(s)
# clear（）  清空
set3 = {1, 3, 5, 6}
t = set3.clear()
print(t)

        不支持修改和查询，如果非要修改可以修改类型为列表然后修改，
        符号：
            +       不支持
            *       不支持
            []      不支持
            [:]     不支持
            in      支持，存在返回True，不存在返回False
            is      支持，相同返回True，不相同返会False
        集合中特有的符号：
            交集： &
            并集： |
            差集： -
set1 = {1, 3, 4}
print(len(set1))
set2 = {2, 3, 5}
#集合运算 交集（&）、并集（|）、差集（-） 对称差集（^）
# None(空值) 、 and(与) or(或) not(非)
t = set1 & set2     #查找交集，两个集合中的相同的元素
print(t)
s = set1.intersection(set2)    #这样也可得到交集
print(s)
t1 = set1 | set2    #查找并集，两个元素合并到一起
print(t1)
#set1.intersection_update(set2)    #这里是将得到的差集重新定义到set1中，定义新的set1
print(set1)
t2 = set1 - set2    #查找差集
print(t2)
t3 = set1 ^ set2     #对称差集，就是将两个集合中不一样的元素合并到一起
print(t3)

字典

字典
    字典的使用场景
            [key：value]
            [key: value]
    字典的特点：里面不是存放单独的元素，而是以键值对出现的key和volue（一个key绑定一个value）
        1、键值对保存
        2、键不能重复，值可以重复
        3、没有下标，因为底层实现也是哈希表的方式
    字典的声明：
        空字典：
dict1 = dict()
print(type(dict1))
dict2 = {}
print(type(dict2))
        有内容的字典：
dict3 = {'tang': 24, 'li': 20, 'wang': 20}  #key不能重复value可以重复
print(dict3)

    字典的获取：都是根据key得到value
        dict[key]    有则返回key对应的value的值，没有则报错
        内置方法： get()
            dict.get('key')  返回的为key对应的value值，没有且没有设置默认值则返回None（空）
            dict.get('key', 1) 这里是当没有找到指定的key时，就返回默认值1
dict4 = {'tang': 24, 'xu': 25, 'li': 25,'wang': 24 }
print(dict4['tang'])
print(dict4.get('tang'))
print(dict4.get('tan',18))  #这是当没有找到key时就返回默认值18

    字典的增、删、改、查
    增、改：
        格式: dict['key'] = value   #修改和添加的格式一样，
            当字典里没有这个key就是添加，有这个key就是修改
dict5 = {}
dict5['tang'] = 18   #
print(dict5)
dict5['tang'] = 19
print(dict5)

    删：
        dict.pop('key')   #根据key删除键值对，返回value
        dict.popitm()     #随机删除键值对（从后往前删除），并以元组的形式返回
        dict.clear()      #清除
        del dict['key']   #根据key删除键值对，类似pop（）
        del dict          #清空内容并回收内存
dict6 = {'t': 12, 'x': 13, 'e': 14, 'r': 15}
print(dict6.pop('r'))   #根据key删除键值对，并返回value
print(dict6.popitem())  #随机删除键值对
print(dict6)
#dict6.clear()      #清除
#print(dict6)
del dict6['x']     #根据key删除键值对，类似pop（）
print(dict6)
del dict6

    查：
        不支持查找
    取值：
    dict.keys()     #取出所有的key
    dict.values()   #取出所有的value
    dict.itms()     #取出所有值，每队键值对是一个元组
dict7 = {'a': 12, 's': 34, 'd': 45}
ks = dict7.keys()   #取所有的key
print(list(ks))
vs = dict7.values() #取所有的value
print(list(vs))
ts = dict7.items()  #取所有的键值对
print(list(ts))
print(list(ks),list(vs))

    构建一个新的字典，通过iterable
dict8 = dict.fromkeys(['z','x','c'], 100)
print(dict8)

    支持的符号：
        in
        is
dict8 = {'q': 12,'www': 13,'e':14}
for i in dict8:
    print(i)   #这是通过for循环遍历所有的key
for key,value in dict8.items():
    print(key,value)    #这就是遍历输出键值对
if 'www' in dict8:    #通过www根字典中的每一个key进行比较，如果有相同的则返回True
    print('能')
else:
    print('不能')

    转换：
list1 = [1, 3, 4, 5]
#dict2 = dict(list1)     #不能转为字典
#print(dict2)
list2 = [('q', 100), ('s', 200), ('w',300)]
dict3 = dict(list2)  #需要满足字典的格式才能转为字典，否则无法转换
print(dict3)
list3 = list(dict3)    #字典转列表，只会保留key的值
print(list3)
总结：列表转字典需要满足条件，否则无法转换，字典转列表只会保留key的值