04.序列的应用

• 列表（list）

• 元组（tuple）

• 字典（dictionary）

• 集合（set）

索引：

    verse = ["今有物不知其数", "三三数之剩二", "五五数之剩三", "七七数之剩二", "问几何?"]
    # 索引从0开始
    print(verse[0])  # 今有物不知其数
    # 采用负数作为索引值时，从-1开始
    print(verse[-1])  # 问几何?

切片：

    snum = ['1', '2', '3', '4', '5', '6']
    # 范围从第1个到第5个元素，步长为1，从0开始不包括5
    print(snum[1:5])  # ['2', '3', '4', '5']
    # 范围从第0个到第3个元素，步长为2，从0开始不包括第3个
    print(snum[0:6:3])  # ['1', '4']
    print(snum[0:3:3])  # ['1']
    

序列相加和乘法：

    n1 = ['a', 'b', 'c']
    n2 = ['1', '2', '3']
    n3 = ['4', '5', '6']
    n4 = [4, 5, 6]
    print(n1 + n2)  # ['a', 'b', 'c', '1', '2', '3']
    print(n1 + n3)  # ['a', 'b', 'c', '4', '5', '6']
    print(n1 + n4)  # ['a', 'b', 'c', 4, 5, 6]
    print(n1 * 3)  # ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
    # 列表的每个元素都是None
    emptylist = [None] * 5
    print(emptylist)  # [None, None, None, None, None]

检查某个元素是否是序列的成员：

    verse = ["今有物不知其数", "三三数之剩二", "五五数之剩三", "七七数之剩二", "问几何?"]
    # 检查某个元素是否是序列的成员
    print("今有物不知其数" in verse)  # True
    print("今有物不知其" not in verse)  # True

序列的内置函数：

  num = [6, 7, 8, 24, 14, 1, 2, 100]
    print("序列的长度:", len(num))  # 序列的长度: 8
    print("序列中的最大值:", max(num))  # 序列中的最大值: 100
    print("序列中的最小值:", min(num))  # 序列中的最小值: 1
    print("序列转换为列表:", list(num), "类型是:", type(list(num)))  # 序列转换为列表: [6, 7, 8, 24, 14, 1, 2, 100] 类型是: <class 'list'>
    print("序列转换为字符串:", str(num), "类型是:", type(str(num)))  # 序列转换为字符串: [6, 7, 8, 24, 14, 1, 2, 100] 类型是: <class 'str'>
    print("序列各元素求和:", sum(num))  # 序列各元素求和: 162
    print("序列排序:", sorted(num))  # 序列排序: [1, 2, 6, 7, 8, 14, 24, 100]
    print("反向序列:", reversed(num))  # 反向序列: <list_reverseiterator object at 0x108162eb8>
    print("将序列组合为一个索引序列:", enumerate(num))  # 将序列组合为一个索引序列: <enumerate object at 0x1081c95e8>
    for i in reversed(num):
        print(i, end=' ')  # 100 2 1 14 24 8 7 6 
    print()
    for k, i in enumerate(num):
        print("索引:", i, " 值:", k, end=' ')
        # 索引: 6  值: 0 索引: 7  值: 1 索引: 8  值: 2 索引: 24  值: 3 索引: 14  值: 4 索引: 1  值: 5 索引: 2  值: 6 索引: 100  值: 7

列表：

 列表的创建于访问：

    # 创建一个空列表
    emptylist = []
    # 创建2～10之间(不包括10)所以偶数的列表
    print(list(range(2, 10, 2)))  # [2, 4, 6, 8]
    # 已经创建的列表，不再使用时，可以使用del语句将其删除
    del emptylist
    # 访问不存在的列表会报错
    # print(emptylist)  # NameError: name 'emptylist' is not defined

    mylist = ['1', 21, "aa", ["12", '21']]
    print(mylist[3])  # ['12', '21']
    print(mylist[3][1])  # 21

增删改查：

   listnum = []
    # 添加元素
    listnum.append(1)
    print(listnum)  # [1]
    listnum2 = [1, 2, 3, 4]
    # 插入0到2的位置
    listnum2.insert(2, 0)
    print(listnum2)  # [1, 2, 0, 3, 4]
    listnum3 = [100]
    # 将listnum2的内容追加到listnum3
    listnum3.extend(listnum2)
    print(listnum3)  # [100, 1, 2, 0, 3, 4]
    listnum4 = [1, 2, 3, 4]
    # 修改元素
    listnum4[2] = 33
    print(listnum4)  # [1, 2, 33, 4]
    # 根据索引删除元素，删除最后一个
    del listnum4[-1]
    print(listnum4)  # [1, 2, 33]
    # 根据元素值删除
    if listnum4.count(33) > 0:  # 判断元素是否存在
        listnum4.remove(33)
    print(listnum4)  # [1, 2]
    listnum4.remove(332)# ValueError: list.remove(x): x not in list
    

排序：

   # sort(),会改变原列表的元素排列顺序
    list1 = ['D', 'b', 'a', 'C', 'e']
    # 升序 不区分大小写
    list1.sort(key=str.lower)
    print(list1)  # ['a', 'b', 'C', 'D', 'e']
    # 降序，不区分大小写
    list1.sort(key=str.lower, reverse=True)
    print(list1)  # ['e', 'D', 'C', 'b', 'a']

    # 使用sorted()函数排序，不影响原列表
    list2 = ['D', 'b', 'a', 'C', 'e']
    print(sorted(list2, key=str.lower))  # ['a', 'b', 'C', 'D', 'e']
    print(list2)  # ['D', 'b', 'a', 'C', 'e']

列表推导式：

import random

if __name__ == '__main__':
    # 生成10个10～100的随机数
    newlist = [random.randint(10, 100) for i in range(10)]
    print(newlist)  # [93, 22, 79, 58, 21, 80, 40, 13, 38, 46]

    price = [1, 2, 3, 4, 5]
    sale = [int(x * 2) for x in price]
    print(sale)  # [2, 4, 6, 8, 10]

    # price中的元素如果  % 2 == 0 ,符合条件的就有2，4，才会执行for前面的表达式
    sale2 = [int(x * 2) for x in price if x % 2 == 0]
    print(sale2)  # [4, 8]

二维列表的创建：

    # 使用嵌套的for循环创建
    arr = []
    for i in range(4):
        arr.append([])
        for j in range(3):
            arr[i].append(j)

    print(arr)  # [[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]
    # 使用列表推导式创建
    arr2 = [[j for j in range(3)] for i in range(4)]
    print(arr2)  # [[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]
    print(arr2[0][0])  # 0

    verse = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    print(verse)  # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    # 逆序排列
    verse.reverse()
    print(verse)  # [[7, 8, 9], [4, 5, 6], [1, 2, 3]]

 元组：

  # 元组使用一对小括号将所有的元素括起来，但小括号并不是必须的，
    # 只要将值用逗号分隔开，就可以视其为元组
    v1 = (7, 14, 21, 28, 35, 42, 49, 56, 63)
    v2 = ("玉湖",)
    v3 = ("玉湖")
    v4 = "玉湖",
    print(type(v1))  # <class 'tuple'>
    print(type(v2))  # <class 'tuple'>
    print(type(v3))  # <class 'str'>
    print(type(v4))  # <class 'tuple'>

    # 创建空元组
    emptytuple = ()
    print(tuple(range(10, 20, 2)))  # (10, 12, 14, 16, 18)
    # 删除元祖
    del v2
    # print(v2) # NameError: name 'v2' is not defined

    # 访问元组元素
    print(v1[0])  # 7
    # 前3个元素
    print(v1[:3])  # (7, 14, 21)

    # for循环元组
    for i in v1:
        print(i, end=' ')  # 7 14 21 28 35 42 49 56 63
    print()
    co = ('a', 'b', 'c', 'd')
    # 对元组进行重新赋值
    co = ('a', 'b', 'cc', 'd')
    print(co)
    # 元组连接组合
    co = co + ('e',)
    print(co)  # ('a', 'b', 'cc', 'd', 'e')
    # tuple元组的不可变是指元素对象的引用不可变，不能对其再次赋值，但是在其中可变元素对象的引用不被修改前提下，仍旧可以对可变元素对象修改
    co2 = ([1], [2], [3])
    a = co2[0]
    a += [4]
    print(co2)  # ([1, 4], [2], [3])

元组推导式：

    randomnumber = (i * 2 for i in range(5) if i % 2 != 0)
    print(randomnumber)  # <generator object <genexpr> at 0x108bccde0>
    randomnumber = tuple(randomnumber)
    print(randomnumber)  # (2, 6)
    num = (i for i in range(3))
    print(num.__next__())  # 0
    print(num.__next__())  # 1
    print(num.__next__())  # 2

元组与列表的区别：

组和列表都属于序列，而且它们又都可以按照特定顺序存放一组元素，类型又不受限制，只要是python支持的类型都可以。那么它们之间有什么区别呢？

列表和元组的区别主要体现在以下几个方面：

• 列表属于可变序列，它的元素可以随时修改或者删除；元组属于不可变序列，其中的元素不可以修改，除作整体替换。
• 列表可以使用 append ( ）、 extend 耐（）、 isert ( ）、 remove ( ）和 pop ( ）等方法实现添加和修改列表元素，而元组没有这几个方法，所以不能向元组中添加和修改元素。同样，元组也不能删除元素。
• 列表可以使用切片访问和修改列表中的元素。元组也支持切片，但是它只支持通过切片访问元组中的元素，不支持修改。
• 元组比列表的访问和处理速度快，所以当只是需要对其中的元素进行访问，而不进行任何修改时，建议使用元组。
• 列表不能作为字典的键，而元组则可以。

字典：

  dic = {'1': 'a', '2': 'b', '3': 'c'}
    print(dic)  # {'1': 'a', '2': 'b', '3': 'c'}
    # 创建空字典的两种方法
    d = {}
    d1 = dict()

    # 通过映射函数创建字典
    l1 = [1, 2, 3]
    l2 = [4, 5, 6]
    # zip()函数用于将多个列表或元组对应位置的元素组合为元组，并返回包含这些内容zip对象
    z1 = zip(l1, l2)
    print(list(z1))  # [(1, 4), (2, 5), (3, 6)]
    d2 = dict(zip(l1, l2))
    print(d2)  # {1: 4, 2: 5, 3: 6}
    # 通过给定的键值对创建字典
    d3 = dict(a='1', b='2', c='3')
    print(d3)  # {'a': '1', 'b': '2', 'c': '3'}
    # fromkeys()方法创建值为空的字典
    d4 = dict.fromkeys(['a', 'b', 'c', 'd'])
    print(d4)  # {'a': None, 'b': None, 'c': None, 'd': None}
    name_t = ('a', 'b', 'c')
    sign = ['11', '22', '33']
    dict1 = {name_t: sign}
    print(dict1)  # {('a', 'b', 'c'): ['11', '22', '33']}
    name_t2 = ['a', 'b', 'c']
    # dict2 = {name_t2: sign}
    # print(dict2)#TypeError: unhashable type: 'list'

    # 字典删除
    # del dict1
    # print(dict1)#NameError: name 'dict1' is not defined
    dict1.clear()
    print(dict1)  # {}
    # 通过键值对访问字典
    dic2 = {'1': 'a', '2': 'b', '3': 'c'}
    print(dic2['1'])  # a
    # print(dic2['a'])  # KeyError: 'a'
    print(dic2['a'] if 'a' in dic2 else '不存在a')  # 不存在a
    print(dic2.get('1'))  # a
    print(dic2.get('a'))  # None
    # 遍历字典
    for i in dic2.items():
        print(i, end='')  # ('1', 'a')('2', 'b')('3', 'c')
    print()
    for k, v in dic2.items():
        print(k, '=', v, end=' ')  # 1 = a 2 = b 3 = c
    print()

 添加，修改，删除字典元素:

 # 添加，修改，删除字典元素
    d1 = dict((('1', 'a'), ('2', 'b'), ('3', 'c')))
    print(d1)  # {'1': 'a', '2': 'b', '3': 'c'}
    # 添加一个元素
    d1['4'] = 'd'
    print(d1)  # {'1': 'a', '2': 'b', '3': 'c', '4': 'd'}
    # 添加一个元素，当元素存在时，则相当于修改功能
    d1['1'] = 'aa'
    print(d1)  # {'1': 'aa', '2': 'b', '3': 'c', '4': 'd'}
    # 删除一个元素
    del d1['3']
    print(d1)  # {'1': 'aa', '2': 'b', '4': 'd'}
    # 删除不存在的保错
    # del d1['aaa']  # KeyError: 'aaa'
    # 优化：
    if 'aaa' in d1:
        del d1['aaa']

字典推导式:

    # 字典推导式
    r1 = {i: random.randint(10, 100) for i in range(1, 5)}
    print(r1)  # {1: 57, 2: 40, 3: 42, 4: 47}
    name = ['12', '34', '56']
    sign = ['aa', 'bb', 'cc']
    d2 = {i: j for i, j in zip(name, sign)}
    print(d2)  # {'12': 'aa', '34': 'bb', '56': 'cc'}

集合：

# 集合的创建
    # 直接使用'{}'创建集合
    set1 = {1, 2, 3}
    print(set1, type(set1))  # {1, 2, 3} <class 'set'>
    # 使用set()函数创建
    set2 = set([1, 2, 3])
    print(set2, type(set2))  # {1, 2, 3} <class 'set'>
    # 集合的添加和修改
    set1.add(4)
    print(set1)#{1, 2, 3, 4}
    # 移除指定元素
    set1.remove(1)
    print(set1)#{2, 3, 4}
    set1.pop()
    print(set1)#{3, 4}
    # 清空集合
    set1.clear()
    print(set1)#set()
    # 指定的内容不存在
    # set1.remove(1)#KeyError: 1
    if 1 in set2:
        set2.remove(1)

 集合的交集、并集、差集运算：

    # 集合的交集、并集、差集运算
    p1 = set(['a', 'b', 'c'])
    p2 = set(['a', '1', '2', '3'])
    # 交集
    print(p1 & p2)  # {'a'}
    # 并集
    print(p1 | p2)  # {'b', '1', 'a', '2', 'c', '3'}
    # 差集
    print(p1 - p2)  # {'b', 'c'}

 列表，元组，字典，集合的区别：