041-57第五章、组合数据类型

华为数通小白

已于 2024-06-27 08:23:47 修改

阅读量874

点赞数 38

文章标签： python 笔记

于 2024-06-24 19:04:39 首次发布

本文链接：https://blog.csdn.net/weixin_57825644/article/details/139931422

版权

序列：是一个用于储存多个值的连续空间，每个值都对应一个整数的编号，称为索引
    有序序列：字符串、列表、元组
    无序序列：集合、字典
索引：序列当中元素的编号就是索引
    正向递增索引：0 ~ n-1
    反向递减索引：-n ~ -1

1.序列的索引和切片操作

1.1正向递增索引

s = 'helloworld'
for i in range(0, len(s)):
    print(i, s[i], '   ', end='') # 这里就是字符串的切片操作
    # 0 h    1 e    2 l    3 l    4 o    5 w    6 o    7 r    8 l    9 d
print()

1.2反向递减索引

x = 'helloworld'
for i in range(-len(s), 0): # 其实s[0]索引为'h'，但是range是包左不包右，所以相当于-10 ~ -1
    print(i, s[i], '   ', end='')
    # -10 h    -9 e    -8 l    -7 l    -6 o    -5 w    -4 o    -3 r    -2 l    -1 d
print()

1.3序列/字符串的切片操作

# 字符串的切片操作
y = 'helloworld'
# 字符串[开始位置:结束位置:步长]     步长可以省略，默认为1
print(y[0:5:2])    # hlo  从0开始到5结束不包含5。 步长为2
# 省略了开始位置则默认为0开始,结束位置默认为结尾
print('_________________________________________')
# 步长为负数时，默认逆序。
print(y[::-1])  # dlrowolleh    相当于print(y[-1:-11:-1])
print(y[::-2])  # drwle 步长为负数为逆序，2表示步长为2

1.4序列的相关操作

"""
序列的操作符、函数
    +           连接符，'hello' + 'world' = 'helloworld'
    *           print(s1 * 5)   # hellohellohellohellohello
    x in s      如果x是s的元素结果为True，否则结果为False
    x not in s  如果x不是s的元素结果为True，否则结果为False
    len(s)      序列s中元素的长度
    max(s)      序列s中元素的最大值。将字符通过ASCII码转换为整型，比较大小
    min(s)      序列s中元素的最小值。将字符通过ASCII码转换为整型，比较大小
    s.index(x)  序列s中第一次出现元素x的位置
    s.count(x)  序列s中x出现的总次数
"""
s = 'helloword'
print('e' in s)         # True
print('e' not in s)     # False
print(len(s))           # 9
print(max(s))           # w  将字符通过ASCII码转换为整型，比较大小
print(min(s))           # d
print(s.index('l'))     # 2
print(s.count('l'))     # 2

2.列表类型

列表：
    一系列的按特定顺序排列的元素组成
    是Python中内置的可变序列
    使用[]定义列表，元素与元素之间使用英文的逗号分隔
    列表中的元素可以是任意的数据类型

2.1列表的创建

# 直接使用[]创建列表
lst = ['hello', 'world', 1998, 160.5]
print(lst)          # ['hello', 'world', 1998, 160.5]
# 可以使用内置的函数list()创建列表
lst2 = list('helloworld')
print(lst2)        # ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']
lst3 = list(range(1, 10, 2))    # 从1开始到10结束不包含10，步长为2，步长默认为1,和字符串的切片相同
print(lst3)         # [1, 3, 5, 7, 9]

2.2列表使用序列的相关操作

# 列表是序列的一种，所以对序列的操作符、运算符、函数均可以使用
lst = ['hello', 'world', 1998, 160.5]
lst3 = [1, 3, 5, 7, 9]
# 序列的相加操作
print(lst + lst3)   # ['hello', 'world', 1998, 160.5, 1, 3, 5, 7, 9]
# 序列的相乘操作
print(lst3 * 2)     # [1, 3, 5, 7, 9, 1, 3, 5, 7, 9]
# 序列的长度(元素个数)
print(len(lst))     # 4
# 序列的最大值
print(max(lst3))    # 9
# 序列的最小值
print(min(lst3))    # 1
# 序列中统计o出现的次数
print(lst.count('world'))   # 1
# 序列中得到第一个o的索引
print(lst.count('world'))   # 1

2.3列表的删除操作

lst4 = [10, 20, 30]
del lst4
# print(lst4)  报错，找不到

2.4列表的遍历操作

lst5 = ['hello', 'world', 1998, 160.5]
# 1.使用for循环遍历
for i in lst:
    print(i, end='   ')         # hello   world   1998   160.5
print()
# 2.使用for循环 + range函数 + len函数根据索引进行遍历
for i in range(0, len(lst5)):
    print(lst[i], end='   ')    # hello   world   1998   160.5
print()
# 3.使用 enumerate函数遍历
# index 和 item 是自己取的名字，分别代表是序号和元素
for index, item in enumerate(lst5):
    print(index, item, end='   ')   # 0 hello   1 world   2 1998   3 160.5
print()
# 可以手动修改序号的起始值
for index, item in enumerate(lst5, start=1):  # 序号起始值改为从1开始，默认为0,
    #   for index, item in enumerate(lst5, 1): start省略也可以
    print(index, item, end='   ')   # 1 hello   2 world   3 1998   4 160.5
print()

2.5列表的相关操作方法

'''
列表的相关操作方法：
    lst.append(x)       列表lst最后增加一个元素
    lst.insert(index, x)列表中第index的位置增加一个元素。  如果是1,则是第二个元素插入
    lst.clear()         清除列表lst中所有元素
    lst.pop(index)      将列表lst中第index位置的元素取出，并从列表中将其删除
    lst.remove(x)       将列表中第一次出现的x元素删除
    lst.reverse()       将列表中的元素反转
    lst.copy()          拷贝列表lst中的所有元素，生成一个新的列表
'''
lst6 = ['hello', 'world', 1998, 160.5]
# 列表增加元素
lst6.append('火车')
print(lst6)     # ['hello', 'world', 1998, 160.5, '火车']
# 列表中第index的位置增加一个元素
lst6.insert(1, '开')
print(lst6)     # ['hello', '开', 'world', 1998, 160.5, '火车']
# 清除列表lst中所有元素
lst6.clear()
print(lst6)     # []
# 将列表lst中第index位置的元素取出，并从列表中将其删除
lst6 = ['hello', 'world', 1998, 160.5]
print(lst6.pop(1))  # world
print(lst6)     # ['hello', 1998, 160.5]
# 将列表中第一次出现的x元素删除
lst6.remove(160.5)
print(lst6)     # ['hello', 1998]
# 将列表中的元素反转
lst6.reverse()
print(lst6)     # [1998, 'hello']
# 拷贝列表lst中的所有元素，生成一个新的列表
lst7 = lst6.copy()
print(lst7)     # [1998, 'hello']
# 列表中元素的修改——根据索引直接修改
lst6[1] = '你好'
print(lst6)     # [1998, '你好']

2.6列表排序的方法

2.6.1列表中整型类型的排序

lst8 = [1, 32, 23, 98, 56]
# 排序，默认升序
lst8.sort()     # 排序是在原列表的基础上进行的，不会产生新的列表对象
print('升序：', lst8)  # 升序： [1, 23, 32, 56, 98]
# 排序，降序
lst8.sort(reverse=True)
print('降序：', lst8)  # 降序： [98, 56, 32, 23, 1]

2.6.2列表中字符串类型的排序

lst9 = ['banana', 'apple', 'Cat', 'Orange']
# 升序——先排大写再排小写，因为大写字母的ASCII编码值小
lst9.sort()
print('升序：', lst9)     # 升序： ['Cat', 'Orange', 'apple', 'banana']
# 降序
lst9.sort(reverse=True)
print('降序：', lst9)     # 降序： ['banana', 'apple', 'Orange', 'Cat']
# 忽略大小写进行比较
lst9.sort(key=str.lower) # 都转成小写字母再进行比较
print(lst9)              # ['apple', 'banana', 'Cat', 'Orange']

2.6.3sorted函数排序并赋值给新的列表对象——原列表不会改变

lst10 = sorted(lst9)    # 升序
print(lst10)            # ['Cat', 'Orange', 'apple', 'banana']
print(lst9)             # 原列表 ['apple', 'banana', 'Cat', 'Orange']
# 降序
lst11 = sorted(lst9, reverse=True)
print(lst11)            # ['banana', 'apple', 'Orange', 'Cat']
print(lst9)             # ['apple', 'banana', 'Cat', 'Orange']
# 忽略大小写排序
lst12 = sorted(lst9, key=str.lower)
print(lst12)            # ['apple', 'banana', 'Cat', 'Orange']
print(lst9)             # ['apple', 'banana', 'Cat', 'Orange']

2.7列表生成式的使用

import random   # 生成随机数
lst13 = [item for item in range(1, 11)]     # item是自定义的标识符，可改成i
print(lst13)    # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst14 = [item * item for item in range(1, 11)]
print(lst14)    # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
lst15 = [random.randint(1, 100) for i in range(1, 11)]  #random.randint(1, 100) = 1~99
print(lst15)    # 产生10个元素的随机数  列表[72, 85, 34, 27, 87, 35, 53, 93, 99, 54]

# 从列表中选择符合条件的元素 组成 新的列表
lst16 = [i for i in range(10) if i%2==0]  # range(10)相当于 0~10不包含10,符合if语句中的表达式才录入
print(lst16)    # [0, 2, 4, 6, 8]

2.8二维列表

2.8.1创建二维列表

lst17 = [
    ['城市', '环比', '同比'],
    ['衢州', 101, 202],
    ['杭州', 102, 203],
    ['宁波', 104, 204]
]
print(lst17)
# [['城市', '环比', '同比'], ['衢州', 101, 202], ['杭州', 102, 203], ['宁波', 104, 204]]

2.8.2遍历二维列表

for row in lst17:     # 行
    for col in row:     #列
        print(col, end='\t')
    print()
    # 衢州    101 202
    # 杭州    102 203
    # 宁波    104 204

2.8.3列表生成式生成一个4行5列的二维列表

lst17 = [[col for col in range(5)] for row in range(4)]
print(lst17)    # [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

3.元组

元组：是Python中内置的不可变序列
    没有增、删、改的一系列操作
    使用()定义元组，元素直接用,分隔
    元组中只有1个元素时，逗号不可省略

3.1元组的创建和删除

# 直接()创建元组
t = ('hello', [10, 20, 30], 150, 'world')   # 列表可作为元组的元素
print(t)    # ('hello', [10, 20, 30], 150, 'world')
# 使用内置函数tuple()创建元组
t = tuple('helloworld')
print(t)    # ('h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd')

# 删除元组
del t       # 删除元组
# print(t)     报错

3.2元组关于序列的相关操作

# 元组关于序列的相关操作
print('10在元组中是否存在', 10 in t)        # False
print('10在元组中是否不存在', 10 not in t)   # True
# print('最大值', max(t))
# print('最小值', min(t))
# 需要元组内的元素是同一类型才能获取最大值和最小值，例如字符串类型比较ASCII码表，整型直接比较
print('元素的个数：', len(t))             # 元素的个数： 4
print('查找999元素在元组中的索引', t.index(999))   # 3    如果元组中不存在此索引会报错
print('999在元组中出现的次数', t.count(999))     # 1     可通过if查询次数，次数大于0则寻找该元素索引
print(type(t))      # <class 'tuple'>   tuple就是元组类型

# 如果元组中只有1个元素，逗号不能省
t = (10)
print(type(t))  # <class 'int'>  如果元组内只有1个元素，省略了逗号，类型可能发生变化
t = (10,)
print(type(t))  # <class 'tuple'>

3.3元组的访问

t = ('hello', [10, 20, 30], 150, 'world')
# 根据索引访问元组
print(t[0])     # hello
# 元组也可切片操作，有序序列都可切片操作
t2 = t[0:4:2]   # 0~4不包含4，步长为2
print(t2)       # ('hello', 150)

3.4列表类型元组类型可以互相转换

# 列表类型转元组类型
lst = ['hello', 'world', 160.1, 999]
t = tuple(lst)
print(t)    # ('hello', 'world', 160.1, 999)
# 元组类型转列表类型
lst = list(t)
print(lst)   # ['hello', 'world', 160.1, 999]

3.5元组的遍历

# 元组的遍历
for i in t2:
    print(i)
    # hello
    # 150

# 使用for + range() + len()遍历
for i in range(len(t2)):
    print(i, t2[i])
    # 0 hello
    # 1 150

# 使用enumerate()遍历
for index, item in enumerate(t2):   # index表示序号，item表示元素
    print(index, item)
    # 0 hello
    # 1 150

# 使用enumerate()遍历,并改变起始序号
for index, item in enumerate(t2, start=10): # 起始序号改为10
    print(index, item)
    # 10 hello
    # 11 150

3.6元组生成式

t = (i for i in range(1, 4))
print(t)    # <generator object <genexpr> at 0x0000020D8A4CCB80>
# t = tuple(t)    # 元组生成式生成后  需要转化
# 遍历
# for i in t:
#    print(i, end='')    #1 2 3

# __next__的作用
# 元组生成式生成之后，如果不转化可通过__next__取出元素进行输出
# __next__的前提是上面注释代码不能执行，否则报错
print(t.__next__())    # 1 经过__next__之后，元素取出   元组生成式内该元素消失
print(t.__next__())    # 2
print(t.__next__())    # 3
t = tuple(t)
print(t)        # ()    # 经过__next__之后，元素取出   元组生成式内该元素消失

4.字典类型

字典类型：根据一个信息查找另一个信息的方式 构成了‘键值对’
    它表示索引  用的键 和  对应的值 构成的成对关系
    是无序序列
    字典中的key值是无序的，打印看到的内容有序是因为Python3.6版本之后的解释器进行处理

4.1字典的创建

# 直接只用{}创建字典
# 语法：d = {key1: value1, key2: value2,...}
d = {10: 'cat', 20: 'dag', 30: 'pet', 20: 'zoo'}    # 当key值相同时，value值进行了覆盖
print(d)    # {10: 'cat', 20: 'zoo', 30: 'pet'}
# 使用参数创建字典
d = dict(cat=10, dog=20)    # 左值cat是key，右值是value
print(d)    # {'cat': 10, 'dog': 20}
print('max', max(d))

4.2元组可作为key值/键值

# 元组也可以作为key值
t = (10, 20, 30)
print({t: 10})  # {(10, 20, 30): 10}

# 列表不可以作为key值，因为列表是可变数据类型，可变数据类型不能作为字典中的键
# lst = [10, 20, 30]
# print({lst:10})   报错

4.3zip函数的使用

# 将2个列表类型合成为zip类型,zip类型 可转为字典或者列表类型
lst1 = [10, 20, 30, 40]
lst2 = ['cat', 'dog', 'zoo', 'pet']
z = zip(lst1, lst2)
print(z)    # <zip object at 0x0000022E8093F780>
# print(list(z))  # [(10, 'cat'), (20, 'dog'), (30, 'zoo'), (40, 'pet')] 将zip类型转回列表类型打印
d = dict(z)     # 将zip类型转为字典类型
print(d)        # {10: 'cat', 20: 'dog', 30: 'zoo', 40: 'pet'}

4.4字典的访问

# （1）使用 d(key)
d = {10: 'cat', 20: 'dag', 30: 'pet', 40: 'zoo'}
print(d[10])    # cat
# （2）使用 d.get(key)
print(d.get(20))    # dag
# 两者的区别,d(key)中key如果不存在则会报错,  d.get(key)可以指定默认值
# print(d(100))  报错
print(d.get(100, '不存在'))    # 不存在

4.5字典关于序列的相关操作

# 字典属于序列
d = {'cat': 10, 'dog': 20}
print(max(d))       # dog
print(min(d))       # cat
print(len(d))       # 2
# 字典的删除
del d
# print(d)  报错

4.6字典类型的相关操作

'''
字典类型的相关操作方法：
    d.keys()    获取所有的key数据
    d.values()  获取所有的values数据
    d.pop(key, default)     key存在获取对应的value，同时删除key-value，否则获取默认值
    d.popitem() 随机从字典中取出一个key-value对，结果为元组类型，同时将该key-value从字典删除
    d.clear()   清空字典中所有的key-value对
'''
d = {1001: '李梅', 1002: '王华', 1003: '张峰'}
# 字典中添加元素
d[1004] = ('张宇')

# 获取所有的key数据
keys = d.keys()
print(keys)     # dict_keys([1001, 1002, 1003, 1004])
print(list(keys))   # [1001, 1002, 1003, 1004] 转成列表类型查看元素
print(tuple(keys))  # (1001, 1002, 1003, 1004) 转成元组类型查看元素

# 获取所有的value数据
values = d.values()
print(values)   # dict_values(['李梅', '王华', '张峰', '张宇'])
print(list(values)) # ['李梅', '王华', '张峰', '张宇'] 转成列表类型查看元素
print(tuple(values))    # ('李梅', '王华', '张峰', '张宇') 转成元组类型查看元素

# 将字典中的数据转成key-value的形式，以元组的方式进行展现
lst = list(d.items())
print(lst)      # [(1001, '李梅'), (1002, '王华'), (1003, '张峰'), (1004, '张宇')]
# 转回字典类型
d = dict(lst)
print(d)    # {1001: '李梅', 1002: '王华', 1003: '张峰', 1004: '张宇'}

# 使用pop函数删除元素___通过key值查找取出value值并删除该数据
print(d.pop(1001, '不存在'))  # 如果字典中无该 key值则打印不存在
print(d)    # {1002: '王华', 1003: '张峰', 1004: '张宇'}

# 随机删除,随机取出value值并删除
print(d.popitem())  # (1004, '张宇')
print(d)            # {1002: '王华', 1003: '张峰'}

# 清空字典
d.clear()
print(d)        # {}
print(bool(d))  # False 空值为False

4.7字典生成式

# 字典生成式
import random
d = {item: random.randint(1, 100) for item in range(4)} # 0 1 2 3 做key值
print(d)    # {0: 33, 1: 28, 2: 22, 3: 30}
# 用两个列表合成一个字典类型
lst1 = [1001, 1002, 1003]
lst2 = ['张三', '李四']
d = {key: value for key, value in zip(lst1, lst2)}
print(d)    # {1001: '张三', 1002: '李四'}

5.集合

集合：Python中的集合和数学中集合的概念一致
    是一个无序的  不重复的 元素序列
    集合中只能储存  不可变数据类型：元组(不能存储字典、列表)
    用{}定义，逗号分隔
    与列表、字典一样，都是Python中的可变数据类型

5.1集合的创建

# {}直接创建
s = {10, 20, 30, 40}
print(s)    # {40, 10, 20, 30}
# 使用set创建集合
s = set('helloworld')
print(s)    # {'d', 'l', 'e', 'o', 'h', 'r', 'w'}   集合就是  无序并且不重复
# 用列表的数据来创建集合
s2 = set([10, 20, 30])
print(s2)       # {10, 20, 30}
# 用range()来创建集合
s3 = set(range(1, 10))
print(s3)       # {1, 2, 3, 4, 5, 6, 7, 8, 9}


# 注意！！！
# 直接用{}创建的空值是字典不是集合，创建空集合用s = set()
s = {}
print(type(s))  # <class 'dict'>  字典

5.2集合关于序列的相关操作

# 集合属于序列的一种
print('max:', max(s3))  # 9
print('min:', min(s3))  # 1
print('len:', len(s3))  # 9
print('9在集合中存在吗？', 9 in s3)         # True
print('9在集合中不存在吗？', 9 not in s3)    # False
# 删除集合
del s3

5.3集合的相关操作

# 集合中添加元素
s = {11, 12, 24, 49}
s.add(1000)
print(s)    # {1000, 11, 12, 49, 24}
# 删除集合某个元素
s.remove(12)    # 不存在也没事
print(s)    # {1000, 11, 49, 24}
# 清空集合内所有元素
s.clear()
print(s)    # set()

# 集合的相关操作
A = {10, 20, 30, 40, 50, 60}
B = {55, 23, 30}
# 交集操作      有相同元素
print(A & B)    # {30}
# 并集操作      合并不重复
print(A | B)    # {40, 10, 50, 20, 23, 55, 60, 30}
# 差集操作      A减去与b重复的部分
print(A - B)    # {40, 10, 50, 20, 60}
# 补集操作      A + B - 重复的部分
print(A ^ B)    # {40, 10, 50, 20, 23, 55, 60}

5.4集合的遍历操作

s = {11, 12, 24, 49}
# 集合的遍历操作
for i in s:
    print(i, end=' ')   # 24 49 11 12
print()

# 使用enumerate()函数
for index, item in enumerate(s):    # 可在enumerate函数中加参数start控制起始序号
    print(index, item, end='     ') # 0 24     1 49     2 11     3 12
print()

5.5集合的生成式

# 集合的生成式
s = {i for i in range(1, 10)}
print(s)    # {1, 2, 3, 4, 5, 6, 7, 8, 9}

# 加入if语句判断
s = {i for i in range(1, 10) if i % 2 == 0}     # 1~10不包含10 录入偶数
print(s)    # {8, 2, 4, 6}

6.Python3.11新特性

6.1增加了模式匹配 match

date = eval(input('请输入要匹配的数据：'))
match date:
    case {'name': 'ljh', 'age': 20}:
        print('这是字典')
    case [10, 20, 30]:
        print('这是列表')
    case (10, 20, 40):
        print('这是元组')
    case _:
        print('相当于if语句的else语句，上面都没匹配上，就执行这条语句')

6.2合并字典的运算符

d1 = {'a': 10, 'b': 20}
d2 = {'c': 30, 'd': 40, 'e': 50}
d3 = d1 | d2
print(d3)   # {'a': 10, 'b': 20, 'c': 30, 'd': 40, 'e': 50}

6.3同步迭代

# fruits = {'apple', 'orange', 'pear', 'grape'}    # 集合 有问题，因为集合是无序的
fruits = ['apple', 'orange', 'pear', 'grape']
counts = [10, 3, 4, 5]                      # 列表
for f,c in zip(fruits, counts):
    match f, c:
        case 'apple', 10:
            print('10个苹果')
        case 'orange', 3:
            print('3个橙子')
        case 'pear', 4:
            print('4个梨')
        case 'grape', 5:
            print('5串葡萄')
'''
10个苹果
3个橙子
4个梨
5串葡萄
'''

7.列表、元组、字典、集合的比较

数据类型	列表list	元组tuple	字典dict	集合set
序列类型	可变序列	不可变序列	可变序列	可变序列
是否有序？元素是否可以重复？	有序、可重复	有序、可重复	无序、key不可重复、value可重复	无序、不可重复
类型创建	lst = ['hello', 'world', 1998, 160.5]} # 可由多种类型一起组成	t = ('hello', [10, 20, 30], 150, 'world') # 列表可作为元组的元素	d = {key1: value1, key2: value2,...} d = {10: 'cat', 20: 'dag', 30: 'pet', 20: 'zoo'}	s = {10, 20, 30, 40, 'red', 2.22}
	lst2 = list('helloworld') # 用于字符串类型	t = tuple('helloworld') # 用于字符串类型	d = dict(cat=10, dog=20) # 左值cat是key，右值是value	s = set('helloworld') # 用于字符串类型
	lst3 = list(range(1, 10, 2)) # 用于整型类型			s = set(range(1, 10))
列表、元组、集合能够相互转换数据类型，例如：t = tuple(lst)
删除类型	del lst	del t	del d	del s
访问元素	lst[0] # 集合第一个元素	t[0]	d[key] #没有会报错 d.get(100, '不存在') # 通过key值查找value，如果字典不存在key值即提示‘不存在’	s[0]
是否支持切片操作	lst[0:2:2]	t[0:2:2]	否	s[0:2:2] # 语法不会报错但是不能使用，因为无序
遍历操作	for i in lst: print(i, end=' ') print() # 直接遍历	for i in t2: print(i) # 直接遍历	for i in d : print(i, [i])	for i in s: print(i, end=' ') # 直接遍历
	for i in range(0, len(lst5)): print(lst[i], end=' ') # for+range+len	for i in range(len(t2)): print(i, t2[i]) # for+range+len
	for index, item in enumerate(lst5): print(index, item, end=' ') # enumerate函数	for index, item in enumerate(t2): print(index, item) # enumerate		for index, item in enumerate(s): print(index, item, end=' ') # enumerate
生成式	lst13 = [item for item in range(1, 11)] # 生成1~10整数	t = tuple((i for i in range(1, 4)))	import random d = {item: random.randint(1, 100) for item in range(4)} # 0~3作为key值，value值为1-99随机数	s = {i for i in range(1, 10)} # 生成1-9的集合
	lst14 = [item * item for item in range(1, 11)] # 生成1-10的平方		lst1 = [1001, 1002, 1003] lst2 = ['张三', '李四'] d = {key: value for key, value in zip(lst1, lst2)} # 两个列表类型合成一个字典类型	s = {i for i in range(1, 10) if i % 2 == 0} # 1~10不包含10 录入偶数 # 加入if判断
	import random lst15 = [random.randint(1, 100) for i in range(1, 11)] # 产生10个元素的随机数
	lst16 = [i for i in range(10) if i%2==0] # range+if语句，生成0~10之间的偶数

序列的操作和数据专属操作

序列的相关操作	+ 连接符，'hello' + 'world' = 'helloworld' * print(s1 * 5) # hellohellohellohellohello x in s 如果x是s的元素结果为True，否则结果为False x not in s 如果x不是s的元素结果为True，否则结果为False len(s) 序列s中元素的长度 max(s) 序列s中元素的最大值。将字符通过ASCII码转换为整型，比较大小 min(s) 序列s中元素的最小值。将字符通过ASCII码转换为整型，比较大小 s.index(x) 序列s中第一次出现元素x的位置 s.count(x) 序列s中x出现的总次数
列表的操作	st6 = ['hello', 'world', 1998, 160.5] lst6.append('火车') # 列表增加元素 lst6.insert(1, '开') # 索引1的位置插入一个元素 lst6.clear() # 第index的位置增加一个元素 print(lst6.pop(1)) # world # 将列表lst中第index位置的元素取出，并从列表中将其删除 lst6.remove(160.5) # 将列表中第一次出现的x元素删除 lst6.reverse() # 将列表中的元素反转 lst7 = lst6.copy() # 拷贝列表lst中的所有元素，生成一个新的列表 lst6[1] = '你好' # 根据索引直接修改
元组的操作	无，可使用序列的相关操作
字典的操作	d.keys() 获取所有的key数据 d.values() 获取所有的values数据 d.pop(key, default) key存在获取对应的value，同时删除key-value，否则获取默认值 d.popitem() 随机从字典中取出一个key-value对，结果为元组类型，同时将该key-value从字典删除 d.clear() 清空字典中所有的key-value对
集合的操作	s = {11, 12, 24, 49} s.add(1000) # 集合中添加元素 s.remove(12) # 删除集合某个元素，不存在也没事 s.clear() # 清空集合内所有元素 A = {10, 20, 30, 40, 50, 60} B = {55, 23, 30} print(A & B) # {30} 交集操作有相同元素 print(A \| B) # {40, 10, 50, 20, 23, 55, 60, 30} 并集操作合并不重复 print(A - B) # {40, 10, 50, 20, 60} # 差集操作 A减去与b重复的部分 print(A ^ B) # {40, 10, 50, 20, 23, 55, 60} # 补集操作 A + B - 重复的部分

8.实战练习

8.1千足虫

# 实战一、千年虫是什么虫
'''
已知一个列表储存的是员工的出生年份[88, 89, 90, 00, 99]
由于时间比较久，出生的年月均为2位整数,现在需要2位年份前加上19
如果年份是00，前面则加200
'''

# 使用for + range + lst来实现
lst = [88, 89, 90, 00, 99]
print(lst)  # [88, 89, 90, 0, 99]
for i in range(len(lst)):
    # 遍历一次列表，不等于0，前面加19并转换为字符串类型
    if lst[i] != 0:
        lst[i] = '19' + str(lst[i])
    # 等于0，前面加200并转换为字符串类型
    else:
        lst[i] = '200' + str(lst[i])
print(lst)      # ['1988', '1989', '1990', '2000', '1999']


# 使用enumerate()函数实现
lst = [88, 89, 90, 00, 99]
for index, item in enumerate(lst):
    if item != 0:
        lst[index] = '19' + str(item)
    else:
        lst[index] = '200' + str(item)
print(lst)      # ['1988', '1989', '1990', '2000', '1999']

8.2模拟京东的购物流程

# 实战二、模拟京东的购物流程
'''
需求：从键盘录入5个商品信息添加到商品列表，并打印商品信息
用户选中要购买的编号，将该商品加入购物车，不存在该商品也提示不存在
将购物车内的商品逆序，显示购物车中的商品
'''


# 创建一个空列表[],用于存储入库的商品信息
commodity = []
# 创建一个空列表[],用于购物车
shopping_trolley = []

for i in range(5):
    goods = input('请输入编号和商品名称，每次只能输入一件商品')
    '''
    请输入编号和商品名称，每次只能输入一件商品1001手机
    请输入编号和商品名称，每次只能输入一件商品1002电脑
    请输入编号和商品名称，每次只能输入一件商品1003耳机
    请输入编号和商品名称，每次只能输入一件商品1004手表
    请输入编号和商品名称，每次只能输入一件商品1005充电器'''
    commodity.append(goods)
print(commodity)  # ['1001手机', '1002电脑', '1003耳机', '1004手表', '1005充电器']

while True:
    number = input('请输入想购买的商品编号：输入q则退出界面')
    if number == 'q':
        break

    for i in commodity:
        if number == i[0:4]:    # 切片判断编号是否存在
            shopping_trolley.append(i[4:])
            print('加入购物车成功')
            break
    else:
        print('商品不存在加入失败')


shopping_trolley.reverse()  # 将购物车商品反转
print('您购物车的商品有：')
for i in shopping_trolley:
    print(i)

8.3模拟12306火车订票流程

'''
需求：假如北京——天津有以下4个车次选择，用户选择所要购买的车次，进行购票进站
    车次：     出发站-到达站   出发时间  到达时间  历时时长
    'G1569':['北京南-天津南','18:06','18:39','00:33'],
    'G1567':['北京南-天津南','18:15','18:49','00:34'],
    'G8917':['北京南-天津西','18:20','18:19',"00:59"],
    'G203':['北京南-天津南','18:35','19:09','00:34']
'''

# 使用字典类型来定义,车次作为key键，其他信息用列表的形式做value值
ticket = {'G1569': ['北京南-天津南', '18:06', '18:39', '00:33'],
    'G1567': ['北京南-天津南', '18:15', '18:49', '00:34'],
    'G8917': ['北京南-天津西', '18:20', '18:19', '00:59'],
    'G203': ['北京南-天津南', '18:35', '19:09', '00:34']}



# 打印所有车次信息
for i in ticket:
    print(i, ticket[i])


number = input("请输入要购买的车次：")

if ticket.get(number, '车次不存在') != '车次不存在':
    person = input("请输入乘车人, 如果是多位乘车人用逗号隔开")
    # 将列表的信息用字符串的形式连接起来，方便下面的打印
    s = number + ' ' + ticket[number][0] + ticket[number][1]
    print('您已购买了' + s + '开，请' + person + '尽快换取纸质车票【铁路客服】')
else:
    print('车次不存在，请重新输入')

8.4模拟手机通讯录

'''
需求：从键盘录入5位好友的姓名和电话，由于通讯录是无序的，所以可以通过集合来实现
'''


# 创建一个集合——作为通信录
s = set()

# 录入5位好友姓名以及电话
for i in range(5):
    info = input("请输入好友的姓名和电话")
    s.add(info)

print(s)