【Python】学习笔记 -- CH5. 组合数据类型

于 2025-04-14 20:31:54 发布
阅读量610 收藏 19
点赞数 20
CC 4.0 BY-SA版权
分类专栏： Python学习 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Fu_Lin_13/article/details/147232221

文章目录

CH5. 组合数据类型

序列和索引

  • 序列是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引

  • 索引分为**正向递增索引和反向递减索引**，正向递增从0开始，反向递减从-1开始

切片

  • 序列[start: end: ​step]
s='HelloWorld'

# 切片操作
s1 = s[0:5:2] # 索引从0开始，到5结束（不包含5），步长为2
print(s1) # 输出：Hlo

print(::-1)  # 字符串逆序输出

序列的操作

序列相加和相乘

  • 如字符串相加和相乘
s1 = 'hello'
s2 = 'world'
print(s1 + s2)

print('-'*40)

序列的常用操作符/函数

操作符/函数描述说明
x in s如果x是s的元素，结果为True，否则结果为False
x not in s如果x不是s的元素，结果为True，否则结果为False
len(s)序列s中元素的个数（即序列的长度）
max(s)序列s中元素的最大值
min(s)序列s中元素的最小值
s.index(x)序列s中第一次出现元素x的位置
s.count(x)序列s中出现x的总次数

列表

列表的定义

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

列表的创建

  1. 可以使用[]直接创建列表
    • 语法结构如下：列表名 = [element1,element2,...,elementN]
  2. 使用内置函数list()创建列表
    • 语法结构如下：列表名 = list(序列)
  3. 列表的删除
    • 语法结构如下：del 列表名
lst = ['hello', 'world', 98, 100, 0]
print(lst)

lst2 = list('helloworld')
lst3 = list(range(1,10,2))# 从1到10，步长为2，不包含10

列表的遍历操作

  • 使用for循环
lst = ['hello', 'world', 'python', 'go']

for item in lst:
    print(item)

for i in range(0, len(lst)):
    print(lst[i])

for index,item in enumerate(lst):
    print(index, item)   # index是序号，不是索引，默认从0开始
    
# 可以手动设置序号
for index,item in enumerate(lst, start=1):
    print(index, item)  # index从1开始

列表的相关操作

列表的方法描述说明
lst.append(x)在列表lst最后增加一个元素
lst.insert(index, x)在列表中第index位置增加一个元素
lst.clear()清除列表lst中所有元素
lst.pop(index)将列表lst中第index位置的元素取出，并从列表中将其删除
lst.remove(x)将列表lst中出现的第一个元素x删除
lst.reverse()将列表lst中的元素反转
lst.copy()拷贝列表lst中的所有元素，生成一个新的列表
lst.sort()列表的排序，默认升序（降序：st.sort(reverse=True)）
sorted(lst)产生一个新的列表，默认升序

列表生成式

  • 语法结构：

    lst = [expression for item in range]

    lst = [expression for item in range if condition]

import random

lst = [item for item in range(1, 11)]
print(lst)

lst = [item*item for item in range(1, 11)]
print(lst)

lst = [random.randint(1, 100) for _ in range(10)]
print(lst)

lst = [i for i in range(10) if i%2 == 0]
print(lst)

'''
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[53, 9, 32, 69, 18, 17, 93, 97, 86, 14]
[0, 2, 4, 6, 8]
'''

二维列表

  • 二维列表：表格数据
  • 二维列表创建
# 二维列表的创建
lst = [
    ['城市', '环比', '同比'],
    ['北京', 102, 103],
    ['上海', 104, 504],
    ['深证', 100, 39]
]

# 二维列表的遍历
for row in lst: # 行
    for item in row:  # 列
        print(item, end='\t')
    print()

# 列表生成式
lst2 = [ [j for j in range(5)] for i in range(4)]
print(lst2)

'''
城市	环比	同比	
北京	102	103	
上海	104	504	
深证	100	39	
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
'''

元组

元组的定义

  • 基本定义

    • 元组是Python中内置的不可变序列
    • 在Python使用()定义元组，元素与元素之间使用英文的逗号,分隔
    • 元素中只有一个元素的时候，逗号也不能省略

  • 元组的创建方式

    • 使用()直接创建元组

      • 语法结构如下：元组名 = (element1, element2, ..., elementN)

    • 使用内置函数tuple()创建元组

      • 语法结构如下：元组名 = tuple(序列)

  • 删除元组：

    • del 元组名
# 使用()创建元组
t = ('hello', [10,20,30], 'python', 'world')
print(t)

# 使用内置函数tuple()
t1 = tuple('helloworld')
print(t1)

t2 = tuple([10, 20, 30, 40])
print(t2)

t3 = (10)
print(t3, type(t3)) # int

t3 = (10,)
print(t3, type(t3))  # 元组中只有一个元素，逗号不能省略

'''
('hello', [10, 20, 30], 'python', 'world')
('h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd')
(10, 20, 30, 40)
10 <class 'int'>
(10,) <class 'tuple'>
'''

元组的遍历

  • 与列表的遍历和访问相同

元组生成式

  • 元组生成式创建元组，创建的是一个生成器对象，需要通过内置函数进行转换
t = (i for i in range(1,4))
print(t)   # 生成器对象

# 元组生成式需要使用内置函数进行转换
t = tuple(t)
print(t)

'''
<generator object <genexpr> at 0x000001753D2B7A00>
(1, 2, 3)
'''
  • t.__next__()可以取出生成器对象中的元素
t = (i for i in range(1,4))
print(t)   # 生成器对象

print(t.__next__())
print(t.__next__())
print(t.__next__())
print(t)  # 生成器对象中的元素已取出，此时t为空

'''
<generator object <genexpr> at 0x0000020860797A00>
1
2
3
()
'''

元组和列表的区别

元组列表
不可变序列可变序列
无法实现添加、删除和修改元素等操作append()、insert()、remove()、pop()等方法实现添加和删除列表元素
支持切片访问元素，不支持修改操作支持切片访问和修改列表中的元素
访问和处理速度快访问和处理速度慢
可以作为字典的键不能作为字典的键

字典

字典的定义

  • 字典类型是根据一个信息查找另一个信息的方式构成了“键值对”，它表示索引用的键和对应的值构成的成对关系

  • 可变的数据类型

  • key不可重复

  • 可变序列不能作为key

  • 注意：字典中的key是无序的，Python3.5及其之前的版本字典的key是在输出时无序，但是从Python3.6版本之后Python解释器进行了处理，所以才会看到输出的顺序与添加的顺序”一致’

字典的创建方式

  • 使用{}直接创建字典

    • d={key1:value, key2:value2, ...}

  • 使用内置函数dict()创建字典

    • dict(key1=value1, key2=value2, ...)

  • 通过映射函数zip()创建字典

    • zip(lst1, lst2)，key:value自动映射，lst1和lst2中的值一一对应

  • 删除字典：del 字典名

# 创建字典

d = {10:'cat', 20:'dog', 30:'pet', 20:'zoo'}
print(d)   # key相同时，value进行了覆盖

# 映射函数
lst1 = [10,20,30,40]
lst2 = ['cat', 'dog', 'pet', 'zoo', 'car']
zipobj = zip(lst1, lst2)
print(zipobj) # 打印出来是一个zip obj对象
# print(list(zipobj))  # 可以将zip object转换为一个列表
d = dict(zipobj)
print(d)

# 内置函数创建字典
d = dict(cat=10, dog=20)
print(d)

# 使用元组作为key
t = (10,20,30)
print({t:10})

# list不能作为key
# lst = [10,20,30]
# print({lst:10})  # TypeError: unhashable type: 'list'

'''
{10: 'cat', 20: 'zoo', 30: 'pet'}
<zip object at 0x000001ECD44E3200>
{10: 'cat', 20: 'dog', 30: 'pet', 40: 'zoo'}
{'cat': 10, 'dog': 20}
{(10, 20, 30): 10}
'''

字典遍历

  • 字典元素的取值

    • d[key]：当key不存在时，会报错
    • d.get(key, default)：default不指定时，key不存在会返回None；指定默认值，当key不存在时会返回默认值

  • 遍历出key与value的元组

    for element in d.items():
    pass

  • 分别遍历出key和value

    for key,value in d.items():
    pass

字典的相关操作方法

字典的方法描述说明
d[key]=value添加字典元素
d.keys()获取所有的key数据
d.values()获取所有的value数据
d.pop(key, default)key存在时获取相应的value，同时删除key-value对，否则获取默认值
d.popitem()随机从字典中取出一个key-value对，结果为元组类型，同时将该key-value从字典中删除
d.clear()清空字典中所有key-value对

字典生成式

  • d = {key:value for item in range}

    import random
d = {item:random.randint(1,100) for item in range(4)}
print(d) # {0: 67, 1: 55, 2: 43, 3: 74}

  • d = {key:value for key,value in zip(lst1, lst2)}

    lst=[1001,1002,1003]
lst2=['cat','dog','bee']
d = {key:value for key,value in zip(lst,lst2)}
print(d) # {1001: 'cat', 1002: 'dog', 1003: 'bee'}

集合类型

集合的定义

  • Python中集合与数学中集合的概念一致
  • Python中的集合是一个无序的不重复元素序列
  • 集合中只能存储不可变数据类型
  • 在Python中集合使用{}定义
  • 与列表、字典一样，都是Python中的可变数据类型

集合的创建方式

  • 使用{}直接创建集合
    • s = {element1, element2, element3, ...}
  • 使用内置函数set()创建集合
    • s = set(可迭代对象)
  • 删除集合：del 集合名
s = set() #创建一个空集合
print(s, type(s))

s = {} # 创建的是一个空字典
print(s, type(s))

s = set('helloworld')
print(s)
# {'w', 'e', 'o', 'l', 'r', 'd', 'h'}
# => 无序不可重复

集合类型的操作符

  • 交集 A&B
  • 并集 A|B
  • 差集 A-B
  • 补集 A^B

集合的相关操作方法

集合的方法描述说明
s.add(x)如果x不在集合s中，则将x添加到集合s
s.remove(x)如果x在集合中，将其删除，如果不在集合中，程序报错
s.clear()清除集合中所有元素

集合的遍历

  • 遍历元素

    for item in s:
    print(item)

  • 使用enumerate()函数

    for index,item in enumerate(s):
    print(index, '-->', item) # 序号

集合生成式

s = {i for i in range(1,10)}
print(s)
# {1, 2, 3, 4, 5, 6, 7, 8, 9}

s = {i for i in range(10) if i%2==0}
print(s)
# {0, 2, 4, 6, 8}

列表、元组、字典、集合的区别

数据类型序列类型元素是否可重复是否有序定义符号
列表list可变序列可重复有序[]
元祖tuple不可变序列可重复有序()
字典dict可变序列key不可重复，value可重复无序{key:value}
集合set可变序列不可重复无序{}

Python3.11新特性

模式匹配

  • match-case

字典合并

  • d1|d2

同步迭代

'''
match data1,data2:
	case data1,data2:
		pass
'''

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串葡萄")
# 4个梨
# fruits是集合，是无序的，输出结果是随机的

数据类型实战

实战1

  • “千年虫”是什么虫？

    • 需求：已知一个列表中存储的是员工的出生年份[88,89,90,98,00,99]，由于时间比较久，出生的年份均为2位整数，现需要2位年份前加19，如果年份是00，将需要加上200.

    • 运行效果：

      原列表：[88, 89, 90, 98, 0, 99]

      [‘1988’, ‘1989’, ‘1990’, ‘1998’, ‘2000’, ‘1999’]

# python_exercise1.py

lst1 = [88, 89, 90, 98, 0, 99]
print('员工出生年份：', lst1)
lst2 = []
for item in lst1:
    if item == 0:
        lst2.append('200' + str(item))
    else:
        lst2.append('19' + str(item))
print('员工出生年份（新）：', lst2)

实战2

  • 模拟京东购物流程
    • 需求：从键盘录入5个商品信息，添加到商品列表中，展示商品信息，提示用户选择商品，用户选中的商品添加到购物车中（购物车中的商品要逆序），用户选中的商品不存在需要有相应的提示，当用户输入“q“时循环结束，显示购物车中的商品
# python_exercise2.py

'''
    1001手机
    1002电脑
    1003水杯
    1004猫粮
    1005猫砂
'''

# 5个商品入库
lstGoods = []
for i in range(5):
    product = input('请输入商品的编号和商品的名称进行商品入库，每次只能输入一件商品：')
    lstGoods.append(product)

# 输出所有商品信息
for item in lstGoods:
    print(item)

# 购物车
cart = []
while True:
    flag = False
    num = input('请输入要购买的商品编号：')
    # 遍历商品列表，查询以下要购买的商品是否存在
    for item in lstGoods:
        if num == item[0:4]: # 切片操作，匹配到商品编号则商品存在
            flag = True
            cart.append(item) # 将商品添加到购物车列表
            print('商品已成功添加到购物车')
            break

    if not flag and num != 'q':
        print('商品不存在')
    
    if num == 'q':
        break
print('-'*50)
print('您购物车里已选择的商品为：')
cart.reverse() # 最后添加的商品，显示在最前面，即倒序输出
for item in cart:
    print(item)

实战3

  • 模拟12306火车票订票流程
    • 假设北京到天津有以下4个车次可供选择，用户选择所要购买的车次，进行购票进站
    • 在这里插入图片描述
# python_exercise3.py

train = {
    'G1569':['北京南-天津南', '18:06', '18:39', '00:33'],
    'G1567':['北京南-天津南', '18:15', '18:49', '00:34'],
    'G8917':['北京南-天津西', '18:10', '18:39', '00:59'],
    'G203':['北京南-天津南', '18:35', '19:09', '00:34']
}

print('车次\t\t出发站-到达站\t\t出发时间\t到达时间\t历时时长')
for key,value in train.items():
    print(key,end='\t\t')
    for i in range(4):
        if i < 3:
            print(value[i], end='\t\t')
        else:
            print(value[i])

number = input('请输入要购买的车次：')
info = train.get(number)
if info:
    passengers = input('请输入乘车人，如果是多位乘车人使用逗号分隔：')
    # 打印乘车信息
    print('您已购买了'+number, end=' ')
    print(info[0]+' '+info[1]+'出发，', end='')
    print('请'+passengers+'尽快换取纸质车票。【铁路客服】')
else:
    print('您要购买的车次不存在！')

实战4

  • 模拟手机通讯录
    • 从键盘录入5位好友的姓名和电话，由于通讯录是无序的，所以使用集合来实现。
# python_exercise4.py

addr_book = set()
for i in range(1,6):
    friend = input(f'请输入第{i}位好友的姓名和手机号：')
    addr_book.add(friend)

# 遍历显示，无序的
for item in addr_book:
    print(item)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值