基础数据结构

1. 元组

固定长度，不可变的python对象序列
元组被创建后，各位置上的对象是无法修改的，但是元组中存储的对象其自身是可变的
可以使用+号连接元组生成更长的元组
将元组乘以整数，则会和列表一样，生成含有多份拷贝的元组
元组方法：只有一个count计算某个数值在元组中出现的次数

if __name__ == '__main__':
    # 元组的创建
    tup = 4, 5, 6
    print(tup)
    lst = [1, 2, 3, 4]
    tup2 = tuple(lst)  # 从list转换成tuple
    # 元组对象内部的修改
    tup3 = ("test", [1, 3, 4], "aaa")
    tup3[1].append(10)
    print(tup3)

1.1 元组拆包

将元祖型的表达式赋值给变量，会对等号右边的值进行拆包

    # 按照tuple的长度拆包赋值
    tup4 = (1, 2, 3, 4)
    a, b, c, d = tup4
    print(a, b, c, d)

    # 获取任意长度
    a1, b1, *rest = tup4
    print(a1, b1)
    # 丢弃部分数据
    a2, b2, *_ = tup4
    print(a2, b2)

2. 列表

列表的长度是可变的，内容也是可以修改的，声明时直接用[]或者list函数

2.1 添加元素

添加元素有append和insert两种方式

append直接追加到尾部
insert插入到指定位置
insert要比append计算代价更高，因为要内部移动元素为新元素提供空间

	a = [1, 4, 2, 6, 4, 3, 7, 2]
    a.append(10)
    a.insert(1, 90)
    # [1, 90, 4, 2, 6, 4, 3, 7, 2, 10]
    print(a)

2.2 删除元素

删除函数有pop和remove

pop是将特定位置的内容移除
remove会将定位到的第一个符合条件的值移除

    a.pop(2)
    a.remove(1)
    # [90, 2, 6, 4, 3, 7, 2, 10]
    print(a)

2.3 切片

# 连接和联合列表
    b = [3, 4]
    a = a + b
    a.extend(b)
    # [90, 2, 6, 4, 3, 7, 2, 10, 3, 4, 3, 4]
    print(a)

    # [2, 6, 4, 3]
    b = a[1:5]# 取a中第1到第5个位置

    # [90, 2, 6, 4, 3]
    c = a[:5]  # 取a中第0到第5个位置

    # [4, 3, 7, 2, 10, 3, 4, 3, 4]
    d = a[3:]  # 取a中第3到结尾,包括第三个

    # [3, 4, 3, 4] 负数表示从尾部开始索引
    e = a[-4:]

    # [2, 10, 3, 4]
    f = a[-6:-2]

    # [90, 6, 3, 2, 3, 3] 第三个参数是步长
    g = a[::2]

    # [4, 3, 4, 3, 10, 2, 7, 3, 4, 6, 2, 90] 反转列表
    h = a[::-1]

3. 字典

是一种键值对的数据结构

3.1 访问

两种访问方式，一种是用[]，一种是用get
用get在获取不到key时，不会报错，可以给默认值，如果没有默认值就返回None

    dict_test = {"test": 56, "test2": 56, "test3": 89}
    print(dict_test["test"])  # 输出56
    print(dict_test.get("test4", 45))  # 输出45，取不到test4时，赋默认值

3.2 删除

删除有两种方式，分别为del和pop
pop删除时，会返回被删除的值

3.3 更新

update可以将两个字典进行合并

    dict_test.update({"test4": 60})
    print(dict_test)

4. 集合

集合是一种无序 元素唯一 的容器
声明可以直接用set() 或者用{}
集合的操作：联合，交集，并集等

if __name__ == '__main__':
    a = {1, 2, 3, 4, 5, 6}
    b = {4, 5, 6, 7, 9, 8, 70}
    a.add(90)

    print("a:", a)
    print("b:", b)

    # a和b中所有不同的元素
    print("a union b :", a.union(b))
    print("a | b :", a | b)

    # a和b中同时包含的元素
    print("a intersection b :", a.intersection(b))
    print("a & b :", a & b)

    # 将a设置为a和b的交集
    print("a intersection_update b :", a.intersection_update(b))

    # 在a中不在b中的元素
    print("a difference b :", a.difference(b))
    print("a-b:", a - b)

    # 将a设置为在a不在b中的元素
    print("a difference_update b :", a.difference_update(b))

    # 所有在a或者b中，但不是同时在a和b中的元素
    print("a union b :", a.symmetric_difference(b))

    # 将a设置为所有在a或者b中，但不是同时在a和b中的元素
    print("a union b :", a.symmetric_difference_update(b))

    # 如果a包含于b，返回True
    print("a issubset b :", a.issubset(b))

    # 如果a包含b，则返回true
    print("a ", a.issuperset(b))

    # ab没有交集返回True
    print("a ", a.isdisjoint(b))

5. 列表集合和字典的推到式

用一种简介的方式生成一个新的列表
形式为：

[expr for val in collection if condition]

	strings = ['a', 'as', 'bat', 'car', 'dove', 'dog']
    # 列表的推导式
    result = [x.upper() for x in strings if len(x) > 2]
    print(result)

    set1 = {x.upper() for x in strings if len(x) > 2}
    print(set1)