python学习十（元组，字典，集合）

元组(tuple)
元组是一个不可变的序列，它的操作基本上和列表一致，一般当我们希望数据不改变时就使用元组其余情况使用列表

创建元组使用()
    my_tuple=() # 创建一个空元组
    print(type(my_tiple))
    my_tuple=(1,2,3,4,5)
    print(my_tuple)
元组是一个不可变对象本能尝试为元组中的元素重新赋值
    my_tuple=(1,2,3,4,5)
    my_tuple[1]=10  # 报错信息：TypeError: 'tuple' object does not support item assignment
元组可以使用切片
    print(my_tuple[::-1])
    print(my_tuple[0:2])
    print(my_tuple[0:3:2])
    ....
当元组不是空元组十，可以省略()
    my_tuple = 1,2,3,4
    print(my_tuple,type(my_tuple))
如果元组不是空元组，它里面至少要有一个,号
    my_tuple = 1
    print(my_tuple,type(my_tuple)) # 不是一个元组
    my_tuple = 1,
    print(my_tuple,type(my_tuple)) # 是一个元组

元组的解包
    解包指将元组当中每一个元素都赋值给一个变量
        my_tuple = 1,2,3,4
        a,b,c,d = my_tuple
        print(a)
        print(b)
        print(c)
        print(d)
    在对元组解包时，变量的数量必须和元组中的元素数量一致，也可以在变量前面加一个*号，这样变量获得元组所有剩余的元素
    不能同时出现多个*号变量
        a,b,*c = my_tuple
        print(a,b)
        print(c)
只要是一个序列都可以解包

可变对象
    - 每个对象中都保存了三个数据：
        id(标示)  type(类型) value(值)

    - 列表是一个可变对象
        a = [1,2,3]
    - a[0] = 10（改对象）
        - 这个操作是在通过变量去修改对象的值
        - 不会改变变量所指向的对象

    - a = [4,5,6]（改变量）
        - 这个操作是在给变量重新赋值
        - 会改变对象所指向的对象
    例子：
        a = [1,2,3]
        print(a,id(a))
        通过索引修改对象
        a[0] = 10
        print(a,id(a)) # id号不会改变
        为变量重新赋值
        a = [4,5,6]
        print(a,id(a))  # id号会改变

字典(dict)
    - 字典属于一种新的数据结构，称为映射
    - 字典的作用和列表类似，都是用来储存对象的容器
    - 列表储存数据的性能横好，但是查询数据的性能很差
    - 在字典中每一个元素都有一个唯一的名字，通过名字可以快速查询到指定的与元素
    - 在查询元素时，字典的效率是非常快的

     使用{}创建字典
        d = {} # 空字典
        print(type(d))
        语法：
            {key:value,key:value....}
            d = {"a":"A","b":"B","c":"C"}  # 一个key:value(键:值)
            字典的值(value)可以是任意对象，但是字典的键(key)可以是任意的不可变对象
            字典的键是不能重复的，如果查询重复的后面的会替换掉前面的
            d = {"a":"A","b":"B","c":"C","a":"Aa"}  # 前面的a被替换成了换a

字典的使用：
    使用dict()函数来创建字典
        d = dict(name="小明",age="12")  # 每一个参数都是一个键值对（这种方式创建的字典，key都是字符串）
        print(d,type(d))

    也可以将一个包含双值子序列的序列转换为字典，
    双值序列，序列中只有两个值，[1,2],(a,2),"ab"
        d = dict([("a","A"),("b","B")])
        print(d,type(d))

    len()可以获取字典中键值对的个数
        len(d)

    in 检查字典是否包含指定的键
        print("a" in d)

    not in 检查字典是否不包含指定的键
        print("c" not in d )

    需要根据键来获取值
        print(d["a"],d["c"],d["b"])

    get(key[,default]) 改方法用来根据键来获取字符串，如果获取的值没有，返回一个None
    d = dict(name="小明",age="12")
    print(d.get("a"))  # 返回一个None
    print(d.get("a","默认值")) # 可以指定一个默认值,来作为第二个参数，这样获取不到值时将返回默认值

修改字典
    d = dict(name="小明",age="12")
    d["name"] = "小红"  # key存在则覆盖
    print(d)

    d["address"] = "上海" # key不存在则添加
    print(d)

    x.setdefault(,default)可以用来向字典中添加键值对，如果字典中已存就不会对字典做出操作，如果不存在就会添加，
        d = dict(name="小明",age="12")
        d.setdefault("address","上海")
        print(d)

    x.update([other]) 将其他的字典中的键值对添加到当前字典中
        d = {"a":"A","b":"B","c":"C"}
        a = {"e":"E","f":"F","g":"G"}
        d.update(a)
        print(d)

    删除，可以使用del来删除字典的键值对
        d = {"a": "A", "b": "B", "c": "C"}
        del d["b"]

    x.pop(key[,default])根据key删除字典中的键值对，会将键值对删除并返回，如果指定了默认值，在删除不存在的key时，不会报错，而是直接返回默认值
        d = {"a": "A", "b": "B", "c": "C"}
        d.pop("b")
        print("b")
        d.pop("z","这是一个默认值")
        print(d)

    x.clear()用来清除字典的使用键值对
        d = {"a": "A", "b": "B", "c": "C"}
        d.clear()
遍历字典
    x.keys()该方法会返回字典的所有的key
        d = dict(name="小明",age="12")
        for i in d.keys():
            print(d[i])

    x.values()该方法会返回字典的所有的values
        d = dict(name="小明",age="12")
            for i in d.values():
                print(i)

    x.items()该方法会返回字典中所有的键值对，它会返回一个序列，序列中包含有双值子序列,双值分别是字典中的key和values
        d = dict(name="小明",age="12")
            for k,v in d.items():
            print(k,"=",v)

集合(set)
    - 集合和列表非常相似
    - 不同点：
        1.集合中只能储存不可变对象
        2.集合中储存的对象是无序的
        3.集合中本能出现重复的元素
    使用{}创建集合
        s = {10,23,13,-4}
        print(s,type(s))

    使用set()创建集合
        s= set()  #创建一个空集合s = {} 是一个空字典
        可以通过set()将序列和字典转换我集合
         s = set({"a":1,"v":2})
         print(s,type(s))    # 使用set()将字典转换为集合时，只会包含字典中的键

    使用x.add()添加元素
        s = {10,23,13,-4}
        s.add(1333) # add()只能传递单个参数
        print(s)

    使用x.update()将一个集合中的元素添加到当前集合中,update()中可以传递序列和字典作为参数，字典值会使用key
        s = {10,23,12}
        s2 = set("hello")
        s.update(s2)
        print(s)

    使用x.pop()随机删除一个集合中的元素
        s = {10,23,12,"a","dgf","fg"}
        print(s.pop())
        print(s)

    使用x.remove()删除集合中的指定元素
        s = {10,23,12,"a","dgf","fg"}
        s.remove("dgf")
        print(s)

    使用x.clear()清空集合
        s = {10,23,12,"a","dgf","fg"}
        s.clear()
        print(s)