2  列表、字典和元组

2.1 引言Python复合数据类型概述

在金融数据分析中,我们经常需要处理成组的相关数据。Python提供了三种内置的复合数据类型:列表(List)、字典(Dictionary)和元组(Tuple)。这些类型使得数据的组织和操作变得更加高效和直观。

2.2 本章学习目标

通过本章学习,你将能够:

  1. 创建列表、字典、元组,并根据”有序可变、键值查找、不可变”的特征为金融数据(持仓清单、股票信息、固定配置)选择合适的结构
  2. 使用 append()、remove()、len()、enumerate() 动态维护投资组合列表
  3. 使用键访问、update() 与 in 运算读写字典,并解释字典 O(1) 查找的哈希原理与键必须不可变的限制
  4. 对元组执行索引与切片,说出不可变性对哈希支持与数据完整性的意义
  5. 区分浅拷贝与深拷贝,判断嵌套结构的修改是否会波及副本

先修:章节 1(第1章 常用基本数据类型)

2.3 列表(List)

列表是Python中最常用的数据结构之一,它是可变的(Mutable)、有序的(Ordered)序列。在金融应用中,列表常用于存储时间序列数据、投资组合成分等。

2.3.1 列表的创建与基本操作

任务要求:创建一个混合类型列表 x,元素依次为字符串 'finance'、'risk management'、'金融风险管理' 和数值 8.88,并用 print() 整体输出该列表。请将代码原样输入教学平台(注释除外),判定以平台为准。

列表 2.1: 平台原始代码 (1) 
# ⚠️ 平台原始代码 - 请原样输入至教学平台（注释除外），平台才会判定答案正确
#列表应用
x=['finance','risk management','金融风险管理',8.88]
print(x)  # 输出混合类型列表的内容（含字符串、数值等多种数据类型）

预期输出(本机 Python 实际运行结果,具体以平台运行结果为准):['finance', 'risk management', '金融风险管理', 8.88](方括号、引号与小数均为 print 列表的标准显示形式)。

代码深度解析:

  1. 列表的异构性: Python列表可以包含不同类型的元素,这在金融数据预处理中非常有用。例如,可以将股票代码(字符串)、价格(浮点数)和成交量(整数)存储在同一个列表中。

  2. 内存模型: 列表存储的是对象的引用而非对象本身。这意味着:

    • 修改可变对象会影响所有引用它的列表
    • 列表赋值是浅拷贝(Shallow Copy)

  3. 时间复杂度分析:

    • x[i]: O(1) - 直接索引访问
    • x[a:b]: O(k) - k为切片长度
    • len(x): O(1) - 列表对象存储长度信息
    • x.append(item): 均摊O(1) - 动态数组扩容

2.3.2 列表在金融投资组合中的应用

列表 2.2: 使用列表管理投资组合 
# =============================================================================
# 题目：管理股票投资组合
# =============================================================================
# 本任务演示如何使用列表存储和管理投资组合中的股票代码
# 列表的可变性使得我们可以动态添加、删除持仓股票

# ==================== 创建初始投资组合 ====================
portfolio = ['600519.SH', '000858.SZ', '600036.SH', '000002.SZ']  # 存储股票代码列表
# 这些是A股市场的股票代码格式：
# 6位数字.SH（上海证券交易所）或.SZ（深圳证券交易所）

# ==================== 添加新股票到投资组合 ====================
portfolio.append('601318.SH')  # 在列表末尾添加元素：'601318.SH'（中国平安）
# append()方法直接修改原列表，不返回新列表
# 时间复杂度：均摊O(1)，大多数情况下非常快

# ==================== 从投资组合中移除股票 ====================
portfolio.remove('000002.SZ')  # 移除指定的元素：'000002.SZ'（万科A）
# remove()方法删除第一个匹配的元素
# 如果元素不存在会抛出ValueError异常
# 时间复杂度：O(n)，需要遍历查找

# ==================== 统计持仓股票数量 ====================
holdings = len(portfolio)  # 计算列表长度：4
print(f"当前持仓股票数量: {holdings}")  # 输出：当前持仓股票数量: 4
# f-string是Python 3.6+的格式化字符串，用{}插入变量值

# ==================== 遍历投资组合 ====================
print("当前持仓:")  # 输出标题
for i, stock in enumerate(portfolio, start=1):  # 遍历列表，同时获取索引和元素
    print(f"  {i}. {stock}")  # 格式化输出：序号. 股票代码
# enumerate()函数返回(索引, 元素)对
# start=1参数让索引从1开始而不是0

2.4 字典(Dictionary)

字典是Python中最重要的数据结构之一,它是可变的、无序的(Python 3.7+保持插入顺序)键值对(Key-Value Pair)集合。在金融应用中,字典非常适合存储结构化数据,如股票信息、交易记录等。

2.4.1 字典的创建与基本操作

任务要求:创建字典 dict1,用”指数名称、证券代码、交易日期、涨跌幅”四个键存储沪深300指数的信息(名称 '沪深300'、代码 '000300'、日期 '2022-09-14'、涨跌幅 0.42),并用 print() 整体输出该字典。判定以平台为准。

列表 2.3: 平台原始代码 (2) 
# ⚠️ 平台原始代码 - 请原样输入至教学平台（注释除外），平台才会判定答案正确
#字典应用
dict1={'指数名称':'沪深300',
      '证券代码':'000300',  # 沪深300指数的证券代码
      '交易日期':'2022-09-14',  # 交易日期
      '涨跌幅':0.42  # 当日涨跌幅（百分比）
    }  # 创建沪深300指数信息字典
print(dict1)  # 输出沪深300指数信息字典

预期输出(本机 Python 实际运行结果,具体以平台运行结果为准):{'指数名称': '沪深300', '证券代码': '000300', '交易日期': '2022-09-14', '涨跌幅': 0.42}(以花括号显示的键值对形式)。

代码深度解析:

  1. 哈希表的实现原理: Python字典底层使用哈希表(Hash Table)实现:

    • 通过hash(key)计算哈希值
    • 哈希值决定存储位置(桶)
    • 处理哈希冲突:开放寻址法或链地址法

    这使得字典的查找、插入和删除操作的平均时间复杂度为O(1)。

  2. 键的要求:

    • 必须是不可变类型(int, float, str, tuple)
    • 不能是可变类型(list, dict, set)
    • 原因:可变对象的哈希值会变化,破坏字典结构

  3. 时间复杂度分析:

    • d[key]: 平均O(1), 最坏O(n)(哈希冲突时)
    • d.get(key): 平均O(1)
    • key in d: 平均O(1)
    • d.items(): O(n)

2.4.2 字典在股票信息管理中的应用

列表 2.4: 使用字典存储和管理股票信息 
# =============================================================================
# 题目：存储和操作股票信息
# =============================================================================
# 本任务演示如何用字典存储股票的多维信息，并进行计算和更新操作
# 字典非常适合存储结构化数据，如股票的代码、名称、价格、成交量、流通股本等

# ==================== 创建股票信息字典 ====================
stock_info = {
    'code': '600519.SH',        # 股票代码（贵州茅台）
    'name': '贵州茅台',          # 股票名称
    'price': 1850.00,           # 股价（元）
    'volume': 2500000,          # 成交量（股）
    'float_share': 1256197800,  # 流通股本（股）
    'turnover': 4625000000.00   # 成交额（元）
}

# ==================== 计算换手率 ====================
turnover_rate = stock_info['volume'] / stock_info['float_share'] * 100  # 计算换手率（%）
# 换手率 = 成交量 / 流通股本 × 100
# 换手率反映股票的流动性，换手率高说明交易活跃
print(f"换手率: {turnover_rate:.2f}%")  # 输出：换手率: 0.20%
# :.2f表示保留2位小数的浮点数格式化

# ==================== 更新股价 ====================
stock_info['price'] = 1860.00  # 修改键'price'对应的值
# 字典是可变的，可以直接修改键值对
# 如果键不存在，会添加新的键值对

# ==================== 添加新字段 ====================
stock_info['PE_ratio'] = 45.5  # 添加市盈率字段
# 市盈率（P/E）是股票估值的重要指标
# PE_ratio = 股价 / 每股收益

# ==================== 检查字段是否存在 ====================
if 'market_cap' in stock_info:  # 检查键'market_cap'是否在字典中
    print(f"市值: {stock_info['market_cap']}")  # 如果存在则输出市值
else:
    print("市值信息缺失")  # 如果不存在则输出提示信息
# in运算符用于检查键是否存在于字典中，时间复杂度O(1)

# ==================== 批量更新字段 ====================
stock_info.update({
    'price': 1870.00,    # 更新股价为1870元
    'volume': 2600000    # 更新成交量为260万股
})
# update()方法可以批量更新字典
# 参数是一个字典，包含要更新的键值对
# 如果键已存在则更新，不存在则添加

补充说明:字典视图对象

dict.keys(), dict.values(), dict.items()返回的是视图对象(View Objects),它们:

  • 是动态的:反映字典的实时变化
  • 支持集合操作:交集、并集等
  • 不能直接索引:需转换为list
列表 2.5: 字典视图对象的使用 
# =============================================================================
# 题目：演示字典视图对象的集合操作
# =============================================================================
# 字典视图对象支持类似集合的操作，如交集、并集等
# 这在比较两个字典的键或值时非常有用

# ==================== 创建两个字典 ====================
dict_a = {'a': 1, 'b': 2, 'c': 3}  # 字典A
dict_b = {'b': 2, 'c': 3, 'd': 4}  # 字典B

# ==================== 计算键的交集 ====================
common_keys = dict_a.keys() & dict_b.keys()  # 使用&运算符计算交集
print(common_keys)  # 输出：{'b', 'c'}
# 交集是两个字典共有的键：'b'和'c'
# 字典视图支持集合运算符：&（交集）、|（并集）、-（差集）、^（对称差）

# ==================== 计算值的交集 ====================
common_values = set(dict_a.values()) & set(dict_b.values())  # 将值转为集合后再计算交集
print(common_values)  # 输出：{2, 3}
# 两个字典都有值2和3
# 注意：dict.values()不直接支持集合运算，需先转换为set

2.5 元组(Tuple)

元组是不可变的(Immutable)有序序列。在金融应用中,元组常用于存储固定配置、数据库记录返回值等。

2.5.1 元组的创建与基本操作

任务要求:创建元组 tup=('finance','风险管理',2022,88.88),输出其切片 tup[1:3](即索引 1、2 两个元素组成的新元组)。判定以平台为准。

列表 2.6: 平台原始代码 (3) 
# ⚠️ 平台原始代码 - 请原样输入至教学平台（注释除外），平台才会判定答案正确
#元组应用
tup=('finance','风险管理',2022,88.88)
print(tup[1:3])  # 输出元组切片（索引1到2的元素：'风险管理'和2022）

预期输出(本机 Python 实际运行结果,具体以平台运行结果为准):('风险管理', 2022)(切片返回的仍是元组,用圆括号显示)。

代码深度解析:

  1. 不可变性的意义:
    • 线程安全: 多线程环境下无需加锁
    • 哈希支持: 可作为字典键或集合元素
    • 性能优化: Python可以进行内存优化
    • 数据完整性: 防止意外修改
  2. 命名元组(NamedTuple): 标准元组只能通过索引访问,降低了代码可读性。collections.namedtuple提供了命名字段的元组:
列表 2.7: 命名元组在金融数据中的应用 
# =============================================================================
# 题目：使用命名元组存储股票信息
# =============================================================================
# 命名元组是元组的子类，允许通过属性名而不是索引访问元素
# 这使得代码更可读、更易维护

# ==================== 导入namedtuple ====================
from collections import namedtuple  # 从collections模块导入namedtuple工厂函数

# ==================== 定义命名元组类型 ====================
Stock = namedtuple('Stock', ['code', 'name', 'price', 'volume'])
# namedtuple(类型名, 字段名列表)
# 返回一个新的类型类Stock，可以创建实例
# 字段名列表也可以是用空格或逗号分隔的字符串：'code name price volume'

# ==================== 创建命名元组实例 ====================
stock = Stock('600519.SH', '贵州茅台', 1850.00, 2500000)
# Stock类型构造函数接受4个参数，对应4个字段

# ==================== 通过字段名访问（更直观）====================
print(stock.name)  # 输出：'贵州茅台'
# 可以像访问对象属性一样使用.语法访问字段
# 这比使用索引stock[1]更清晰

print(stock.price)  # 输出：1850.0
# 不需要记住字段的位置顺序

# ==================== 仍然支持索引访问 ====================
print(stock[0])  # 输出：'600519.SH'
# 命名元组仍然是元组，支持所有元组操作
# 这保证了向后兼容性
  1. 时间复杂度:
    • 与列表相同,但列表底层是可动态扩容的数组,而元组是长度固定的不可变序列,创建后不再动态调整大小
    • t[i]: O(1)
    • t[a:b]: O(k)

2.6 数据类型选择指南

在金融编程中,选择合适的数据类型至关重要:

理论背景:数据结构的选择

要做出正确的选择,先要理解这三种类型在计算机科学层面代表了不同的抽象层次:

  • 列表: 动态数组,提供O(1)的随机访问和O(n)的插入/删除
  • 字典: 哈希表(Hash Table),提供平均O(1)的查找、插入和删除
  • 元组: 不可变序列,适用于存储固定配置和作为字典键

选择合适的数据结构对程序性能有决定性影响,尤其是在处理大规模金融数据时。

表:数据类型选择决策表

场景 推荐类型 理由 示例
时间序列数据 列表/NumPy数组 有序、可变 股价历史
键值对数据 字典 快速查找 股票信息
固定配置 元组 不可变、安全 交易参数
去重数据 集合 自动去重 唯一股票代码
矩阵运算 NumPy数组 高性能数值计算 相关性矩阵

补充说明:性能考虑

在处理大规模金融数据时,性能差异变得显著:

列表 2.8: 列表与字典的性能比较 
# =============================================================================
# 题目：比较列表和字典的查找性能
# =============================================================================
# 本任务通过实验演示列表和字典在查找操作上的性能差异
# 列表查找是O(n)，字典查找是O(1)，在大数据量时差异巨大

# ==================== 导入时间模块 ====================
import time  # Python标准库，用于时间相关操作

# ==================== 生成测试数据 ====================
n = 1000000  # 数据量：100万元素
test_list = list(range(n))  # 创建包含0到999999的列表
test_dict = {i: f"value_{i}" for i in range(n)}  # 创建字典，键是0到999999
# 字典推导式：{key: value for key in iterable}
# 每个键对应的值是字符串"value_<key>"

# ==================== 测试列表查找性能（O(n)）====================
start = time.time()  # 记录开始时间
result = 999999 in test_list  # 在列表中查找999999，需要遍历整个列表
list_time = time.time() - start  # 计算耗时
# in运算符对列表需要逐个比较，平均需要检查n/2个元素

# ==================== 测试字典查找性能（O(1)）====================
start = time.time()  # 记录开始时间
result = 999999 in test_dict  # 在字典中查找999999，通过哈希直接定位
dict_time = time.time() - start  # 计算耗时
# 字典通过哈希表实现，查找时间几乎不随数据量增长

# ==================== 输出性能对比结果 ====================
print(f"列表查找时间: {list_time:.6f}秒")  # 输出列表查找耗时
print(f"字典查找时间: {dict_time:.6f}秒")  # 输出字典查找耗时
speedup_ratio = list_time / dict_time if dict_time > 0 else float('inf')  # 防止除零错误
print(f"性能提升: {speedup_ratio:.1f}倍" if speedup_ratio != float('inf') else "性能提升: 字典查找时间趋近于零，提升倍数极大")  # 输出性能提升倍数
# 在100万元素下，字典通常比列表快数千倍甚至上万倍

2.7 深拷贝与浅拷贝

理解Python的拷贝机制对避免数据污染错误至关重要:

列表 2.9: 浅拷贝与深拷贝的区别 
# =============================================================================
# 题目：演示浅拷贝和深拷贝的区别
# =============================================================================
# 浅拷贝只复制外层容器，内层对象仍然共享
# 深拷贝递归复制所有层级，完全独立
# 这对于处理嵌套数据结构（如投资组合列表）非常重要

# ==================== 导入copy模块 ====================
import copy  # Python标准库，提供拷贝操作

# ==================== 创建原始嵌套列表 ====================
portfolio = [
    ['600519.SH', 100, 1850.00],  # 持仓1：股票代码、持有数量、成本价
    ['000858.SZ', 200, 85.50]     # 持仓2：股票代码、持有数量、成本价
]
# 这是一个嵌套列表：外层是列表，内层每个元素也是列表
# 类似二维数组或矩阵结构

# ==================== 创建浅拷贝 ====================
portfolio_shallow = portfolio.copy()  # copy()方法创建浅拷贝
# 或者使用切片：portfolio_shallow = portfolio[:]
# 浅拷贝创建新列表，但内层列表元素仍然是引用

# ==================== 创建深拷贝 ====================
portfolio_deep = copy.deepcopy(portfolio)  # deepcopy()递归复制所有层级
# 深拷贝创建完全独立的新对象，包括所有嵌套对象
# 无论多少层嵌套，都会被完全复制

# ==================== 修改原始数据 ====================
portfolio[0][2] = 1900.00  # 修改第一只股票的成本价：1850.00 -> 1900.00
# 注意：修改的是portfolio[0]这个内层列表的第3个元素

# ==================== 检查浅拷贝是否受影响 ====================
print("浅拷贝受影响:", portfolio_shallow[0][2])  # 输出：1900.00
# 浅拷贝的内层列表仍然指向原始对象
# 修改原始数据会影响浅拷贝，这可能导致意外的数据污染

# ==================== 检查深拷贝是否受影响 ====================
print("深拷贝不受影响:", portfolio_deep[0][2])  # 输出：1850.00
# 深拷贝是完全独立的副本
# 修改原始数据不会影响深拷贝，数据安全性高

最佳实践:

  • 简单列表(不含嵌套): 使用list.copy()或切片[:]
  • 嵌套结构: 使用copy.deepcopy()
  • 字典: 使用dict.copy()(浅拷贝)或copy.deepcopy()(深拷贝)

2.8 本章小结

要点:

  • 列表有序可变、支持异构元素,适合存储时间序列与持仓清单;append()/remove() 直接修改原列表
  • 字典按键存取,查找平均 O(1);键必须是不可变类型(字符串、数值、元组可以,列表不可以)
  • 元组不可变,适合固定配置与多值返回,可作字典键;命名元组 namedtuple 提升可读性
  • d.keys() 等返回动态视图对象,支持集合运算,但不能直接索引
  • 浅拷贝只复制外层容器,嵌套对象仍共享;要完全独立须用 copy.deepcopy()

易错点:

  • 赋值 b = a 不产生副本,两个名字指向同一个列表
  • remove() 只删除第一个匹配元素,元素不存在时抛 ValueError
  • 元组的不可变指结构不可变,元组内嵌的列表仍可执行 t[1].append(...)
  • dict.values() 不直接支持集合运算,需先转换为 set

2.9 动手与思考

以下练习每题附参考答案(默认折叠)。请先独立完成并写下你的判断,再点开对照,最后上机验证。

  1. 输出预测:不运行代码,先写出下面代码的输出结果,再上机检验你的判断。

    x = ['finance', 'risk management', '金融风险管理', 8.88]
print(x[1])
print(x[1:3])
tup = ('finance', '风险管理', 2022, 88.88)
print(tup[-1])
d = {'指数名称': '沪深300', '涨跌幅': 0.42}
print(d['指数名称'])
print('涨跌幅' in d)

    参考答案（先写下你的预测再点开）

    解题思路：逐行推演。列表 x 有 4 个元素，索引 0 到 3 依次为 'finance'、'risk management'、'金融风险管理'、8.88。第 1 个 print 执行 x[1]，正向索引取第 2 个元素，得到 risk management；第 2 个执行 x[1:3]，切片含头不含尾，取索引 1、2 两个元素，且列表切片仍返回列表，得到 ['risk management', '金融风险管理']；第 3 个执行 tup[-1]，负索引取元组最后一个元素，得到 88.88；第 4 个执行 d['指数名称']，按键取字典的值，得到 沪深300；第 5 个执行 '涨跌幅' in d，in 对字典检查的是键是否存在，'涨跌幅' 是键，返回 True。

    # 验证脚本：逐行输出五个表达式的求值结果
x = ['finance', 'risk management', '金融风险管理', 8.88]  # 定义混合类型列表
print(x[1])  # 正向索引取第2个元素
print(x[1:3])  # 切片取索引1、2的元素，结果仍是列表
tup = ('finance', '风险管理', 2022, 88.88)  # 定义元组
print(tup[-1])  # 负索引取最后一个元素
d = {'指数名称': '沪深300', '涨跌幅': 0.42}  # 定义字典
print(d['指数名称'])  # 按键访问字典的值
print('涨跌幅' in d)  # 检查键是否存在于字典中

    预期输出（本机 peter 环境实际运行结果，具体以平台运行结果为准）：

    risk management
['risk management', '金融风险管理']
88.88
沪深300
True

    回扣本章：对应本章小结“要点”第 1—3 条——列表有序可索引、字典按键存取（in 判定的是键）、元组支持负索引访问。

  2. 概念辨析:元组是不可变的,但对 t = (1, [2, 3]) 执行 t[1].append(4) 却能成功,这是否矛盾?为什么列表不能作字典的键,而元组可以?

    参考答案（点开前请先独立完成）

    解题思路：不矛盾。元组的“不可变”指结构不可变：元组中保存的是各元素的引用，引用的个数（长度）和每个位置指向哪个对象不能改变，即不能执行 t[1] = [9] 这类重新绑定。但 t[1] 指向的列表对象本身是可变的，t[1].append(4) 修改的是那个列表的内部内容，元组里存的引用并没有变，因此操作合法——运行后 t 变为 (1, [2, 3, 4])，元组长度仍是 2。列表不能作字典的键，根源在哈希机制：字典靠 hash(key) 定位存储桶，可变对象一旦内容变化，哈希值就会随之改变，先前存进去的键就会“找不到”，因此 Python 规定键必须可哈希，而列表不可哈希（本机实测 hash((1, [2, 3])) 抛出 TypeError: unhashable type: 'list'）。元组不可变，内容固定、哈希值稳定，因此可以作键；但前提是其内部元素也都可哈希——像 (1, [2, 3]) 这种内嵌列表的元组同样不可哈希，也不能作键。

    回扣本章：对应本章小结“易错点”第 3 条（元组的不可变指结构不可变，内嵌列表仍可修改）与“要点”第 2 条（字典键必须是不可变类型）。

  3. 动手验证:对嵌套持仓列表 port = [['600519.SH', 100, 1850.00], ['000858.SZ', 200, 85.50]],分别用 port.copy() 与 copy.deepcopy(port) 生成副本后,将 port[0][1] 改为 300。输出两份副本的 port[0][1],并解释结果差异。

    参考答案（点开前请先独立完成）

    解题思路：port.copy() 是浅拷贝，只复制外层列表，副本里的元素仍是原内层列表的引用，因此修改 port[0][1]（即原第一行内层列表的第 2 个元素）后，浅拷贝副本读到的是同一个内层列表，值变为 300；copy.deepcopy(port) 递归复制了所有层级，深拷贝副本的内层列表是全新对象，不受原数据修改影响，仍读到 100。这说明对嵌套结构（如持仓清单）做副本时必须用深拷贝才能保证数据独立。

    # 验证脚本：对比浅拷贝与深拷贝在嵌套结构修改后的表现
import copy  # 导入copy模块，提供deepcopy深拷贝
port = [['600519.SH', 100, 1850.00], ['000858.SZ', 200, 85.50]]  # 嵌套持仓列表
shallow_port = port.copy()  # 浅拷贝：只复制外层列表
deep_port = copy.deepcopy(port)  # 深拷贝：递归复制所有层级
port[0][1] = 300  # 修改原数据第一行的持仓数量
print('浅拷贝副本:', shallow_port[0][1])  # 内层列表共享，读到修改后的300
print('深拷贝副本:', deep_port[0][1])  # 完全独立，仍读到100

    预期输出（本机 peter 环境实际运行结果，具体以平台运行结果为准）：

    浅拷贝副本: 300
深拷贝副本: 100

    回扣本章：对应本章小结“要点”第 5 条与“易错点”第 1 条——浅拷贝只复制外层容器、嵌套对象仍共享，要完全独立须用 copy.deepcopy()。

  4. 变式任务(平台任务二、三同型改造):仿照平台任务二,构建”上证50”指数信息字典(指数名称 '上证50'、证券代码 '000016'、交易日期 '2022-09-14'、涨跌幅 -0.15)并输出;然后把 '涨跌幅' 更新为 0.28、新增键 '成交额'(值 123456789.0)后再次输出。再仿照任务三,对元组 tup2 = ('python', '数据分析', 2023, 66.66) 分别输出 tup2[0:2] 与 tup2[::-1]。

    参考答案（点开前请先独立完成）

    解题思路：字典部分按平台任务二的结构创建 dict2 并整体输出；更新已有键直接对 dict2['涨跌幅'] 赋值，新增键值对只需对不存在的键赋值（dict2['成交额'] = ...），两者都不需要事先声明，改完再次整体输出即可对照前后差异（Python 3.7+ 字典保持插入顺序，新增的 '成交额' 排在末尾）。元组部分：tup2[0:2] 切片含头不含尾，取索引 0、1 两个元素，结果仍是元组；tup2[::-1] 步长为 -1，从末尾倒序取全部元素，实现元组反转。

    # 变式程序：上证50指数信息字典的创建、更新与元组切片反转
dict2 = {'指数名称': '上证50', '证券代码': '000016', '交易日期': '2022-09-14', '涨跌幅': -0.15}  # 创建上证50指数信息字典
print(dict2)  # 输出初始字典
dict2['涨跌幅'] = 0.28  # 更新已有键的值
dict2['成交额'] = 123456789.0  # 新增键值对（键不存在即新增）
print(dict2)  # 再次输出，对照更新与新增后的字典
tup2 = ('python', '数据分析', 2023, 66.66)  # 定义元组tup2
print(tup2[0:2])  # 切片取索引0、1的元素
print(tup2[::-1])  # 步长-1倒序取全部元素，实现反转

    预期输出（本机 peter 环境实际运行结果，具体以平台运行结果为准）：

    {'指数名称': '上证50', '证券代码': '000016', '交易日期': '2022-09-14', '涨跌幅': -0.15}
{'指数名称': '上证50', '证券代码': '000016', '交易日期': '2022-09-14', '涨跌幅': 0.28, '成交额': 123456789.0}
('python', '数据分析')
(66.66, 2023, '数据分析', 'python')

    注意：以上为本题变式的独立代码；列表 2.3 与 列表 2.6 对应平台任务的原始代码块仍须原样输入教学平台，不要用本变式替换。

    回扣本章：对应本章小结“要点”第 2 条（字典按键存取，对已有键赋值即更新、对新键赋值即新增）与第 3 条（元组支持索引与切片，切片结果仍是元组）。