元组和字典

元组 tuple：

元组是不可改变的序列，同list一样，元组可以存放任意类型元素
元组一旦创建将不可改变

元组的表示方式：

    用小括号()括起来，单个元素括起来后加逗号(,)
    区分单个对象还是元组

创建空元组的字面值表达式：

    t = ()      #()是创建一个空的元组对象

创建非空元组的字面值表达式：

    t = 200,
    t = (20,)
    t = (1,2,3)
    t = 100,200,300
    注：

        type(x)函数，可以返回对象x的类型

创建元组的错误示例：

    t = (200)                   #绑定200这个对象，不是元组
    x, y, z = 100, 200 ,300     #序列赋值
    x, y, z = (1, 2, 3)         #序列赋值
    x, y, z = [1, 2, 3]         #序列赋值
    x, y, z = 'abc'             #序列赋值

创建元组的构造函数：

    tuple() 生成一个空元组，等同于()
    tuple(iterable)　用可迭代对象生成一个元组

    示例：

        t = tuple()
        t = tuple("abc")
        t = tuple(range(1, 10, 2))

元组的运算：

    +       用拼接方式创建一个新的元组
    *       用于生成新的重复的元组

元组的比较运算：

    <  <=  >  >=  ==  !=        规则与列表的比较运算完全相同

元组的 in/not in 运算符：

    用于判断元素是否存在于元组中，规则与列表完全相同

索引　index：

    用法等同于列表索引
    元组不支持索引赋值

切片：

    用法和列表切片相同
    元组的切片返回一个新的元组
    元组不能切片赋值

元组的方法：

    index(v[,begin[,end]])
    返回对应元素的索引下标，begin为开始索引，end为结束索引，当v
    不存在时，触发ValueError错误

    count(x)
    返回元组中对应的元素的个数

序列小结：

字符串 　    str
列表  　    list
元组　　　    tuple
字节串　　    bytes
字节数组    bytearray

序列相关函数：

reversed(x)     返回反向顺序的可迭代对象
sum(x)
...

字典 dict：

什么是字典：

    １．字典是一种可变的容器，可以存储任意类型的数据
    ２．字典中的每个数据都是用'键(key)'进行索引，而不像序列可以用下标索引
    ３．字典中的数据没有先后顺序关系，字典的存储是无序的
    ４．字典中的数据以键－值对(key-value)形式进行映射存储的
    ５．字典的键不能重复，且只能用不可改表类型作为字典的键

字典的字面值的表示方法：

    以{}括起来，以冒号(:)分隔键－值对，各键值对用逗号分隔开

创建空字典：

    d = {}              #{}表达式用来创建一个空的字典

创建非空字典：

    d = {'name': 'gzw', 'age': 22}
    d = {'a': 100}
    d = {'a': tuple("ABC")}
    d = {'abc': list('abc')}
    d = {'a': {'b': 100, 'c': 200}}
    d = {True: '真值', False: '假值', None: '空', 100: '一百'}
    d = {(1970, 1, 1): '计算机元年'}

字典的构造函数：

    dict()              创建一个空字典，等同于{}
    dict(iterable)      用可迭代对象创建新字典
    dict(**kwargs)      用关键字传参形式创建一个新字典

    示例：

        d = dict()
        d = dict([('name', 'tarena'), ('age', 15)])
        d = dict((['name', 'gzw'], 'ab'))
        d = dict(name='tarena', age=15)

字典的操作：

    字典的键索引：

        用[]运算符可以获取字典内“键”对应的“值”

        语法：

            v = 字典[键]

        示例：

            d = {'name': 'tarena', 'age': 15}
            print(d['name'], '今年', d['age'], '岁')

 ###    添加/修改字典的元素：

        语法：

            字典[键] = 表达式

        示例：

            d = {}
            d['name'] = 'tarena'        #创建新的键'name'同时关联值
            d['age'] = 15               #创建键'age'并绑定15
            d['age'] = 16               #修改原来的键'age'重新绑定16

        说明：

            键不存在，创建键并绑定值
            键存在，修改键的绑定关系

    删除字典元素del语句：

        del 字典[键]

        示例：

            d = {1: '__', 'hello': 'world', False: '假值'}
            del d['hello']

字典的in/not in 运算符：

    in 用来判断一个键是否存在于字典中，如果存在返回True,否则返回False
    not in 作用与in相反

    示例：

        d = {"name": "zhang", "age": 20}
        'name' in d             #True
        'age' not in d          #False
        'zhang' in d            #False
        20 in d                 #False

字典的迭代访问：

    字典是可迭代对象，字典只能对'键'进行访问

    示例：
        d = {'aaa': 111, 'bbb': 222, 'ccc': 333}
        for k in d:
            print(k)

用于字典的函数：

    len(x)  返回字典的'键－值'对个数
    max(x)  返回字典'键'的最大值
    min(x)  返回字典'键'的最小值
    sum(x)  返回字典所有'键'的和
    any(x)  真值测试，只对'键'进行测试
    all(x)  真值测试，全部'键'为真，结果为真

    示例：

        d = {0: '零', 5: '伍', 8: '捌', 3:　'叁'}
        len(d)  # 4 
        max(d)  # 8
        min(d)  # 0
        sum(d)  # 16
        any(d)  # True
        all(d)  # False

字典的方法：

    d.clear()                 清空字典

    d.pop(key)                移除键，同时返回此键对应的值

    d.copy()                  返回字典的副本（浅拷贝）

    d.update(d2)              将字典d2合并到d中，如果键相同，
                            　　则此键的值取d2的值作为新值

d.get(key, default) 返回键key所对应的值，
　　如果没有此键，则返回default值

    d.keys()                  返回可迭代的dict_keys集合对象

    d.values()                返回可迭代的dict_value集合对象

    d.items()                 返回可迭代的dict_item对象

    示例：

        d = {1: 'One', 2: 'Two'}
        d2 = {2: '二', 3: '三'}
        d3 = d.copy()           #复制
        d3.pop(1)               #d3 = {2: 'Two'}
        d.update(d2)            #d = {1: 'One', 2:　'二',  d = {1: '__', 'hello': 'world', False: '假值'}
            del d['hello']

字典的in/not in 运算符：

    in 用来判断一个键是否存在于字典中，如果存在返回True,否则返回False
    not in 作用与in相反3: '三'}

字典推导式：

    用可迭代对象生成字典的表达式

    语法：

        {键表达式: 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}

        注：[]表示其中的内容可省略   

    示例：

        #生成一个字典，键为数字１～９，值为键的平方
        d = {x: x ** 2 for x in range(1, 10)}

    字典推导式嵌套：

        等同于列表推导式的嵌套

字典和列表：

１．都是可变对象
２．索引方式，字典用'键'索引，列表用整数索引
３．字典的插入，删除，修改的速度可能会快于列表
４．列表的存储是有序的，字典的存储是无序的