# 列表的定义
# ---------------------------------------------------------------------------------------
# 列表（list）是Python中最常用的数据结构之一，是一个有序、可变、可重复的元素集合，使用方括号 [] 定义，元素之间用逗号分隔。
# 使用 list() 函数将其他可迭代对象转换为列表。
# 列表推导式（list comprehension）也是创建列表的一种常用方式。
# 列表的基本特征
# 1. 有序：元素按插入顺序排列
# 2. 可变：可以修改、添加、删除元素
# 3. 可包含任意类型：数字、字符串、列表、字典等
# 4. 可重复：允许相同元素多次出现
# -------------------------------------------------------
# 方法1：使用方括号定义
fruits =['apple','banana','orange']
numbers =[1,2,3,4,5]
mixed = [1,'hello',3.14,True,[1,2,3,4,5]]
travel =['sanya','guilin','lijiang','kunming','wulumuqi','chengdu']
animals = ['cat', 'dog', 'tigger', 'shizi', 'xingxing', 'pig']
# -------------------------------------------------------
# 方法2：使用list()函数
empty_list = list()
from_string = list('i love you')
# ['i', ' ', 'l', 'o', 'v', 'e', ' ', 'y', 'o', 'u']
print(f"使用list()函数将字符串转化为列表：{from_string}")
# -------------------------------------------------------
# 方法3：使用range()函数创建数字列表
list(range(1,6))
print(f"使用range()函数创建数字列表：{list(range(1,6))}，其中列表中最大：{max(list(range(1,6)))},列表中最小值：{min(list(range(1,6)))}，列表中所有元素之和：{sum(list(range(1,6)))}")
even_numbers = list(range(2,110,2))
print(f"使用range()函数创建数字-偶数-列表：{even_numbers}")
# -------------------------------------------------------
# 方法4：使用列表推导式
squaress = [value **2 for value in range(1,11)]
print(f"使用列表推导式创建的列表：{squaress}")
# 使用列表推导式构建奇数列表
jishu = [js for js in range(1,20,2)]
print(jishu)
# 使用列表推导式构建能被3整除的列表
zhengchu = [zc for zc in range(0,33,3)]
print(zhengchu)
# 使用列表推导式构建立方数列表
lifang = [lf ** 3 for lf in range(1,10)]
print(lifang)
# -------------------------------------------------------
# 对于列表推导式的理解，可以从以下进行理解
# 遍历列表
squares = []
for value in list(range(1,11)):
square = value ** 2
squares.append(square)
print(squares)
print(squares)
# 对于列表推导式的理解2
squares = []
for value in range(1,11):
square = value ** 2
squares.append(square)
print(squares)
print(squares)
# -------------------------------------------------------
#方法5：使用*运算符重复元素
repeated_list = [0] *5
print(f"使用*运算符重复元素构建列表：{repeated_list}")
# -------------------------------------------------------
# 空列表的定义
# 方法1：使用方括号定义空列表
empty_list_1 = []
print(f"使用方括号定义空列表：{empty_list_1},其类型为：{type(empty_list_1)}")
# -------------------------------------------------------
# 方法2：使用list()函数
empty_list_2 = list()
print(f"使用list()函数创建列表:{empty_list_2},其类型为：{type(empty_list_2)}")
# 访问列表的元素
# ------------------------------------------------------------------------------------------------------
# 方法1:正向索引（从0开始）
print(f"通过列表索引的方式访问列表：{fruits[0]}-------------{numbers[0]}-----------{travel[1]}---------{animals[1]}")
# 方法2：负向索引（从-1开始）
print(f"通过列表负向索引的方式访问列表：{fruits[-1]}---------{numbers[-1]}-----------{travel[-1]}---------{animals[-1]}")
# 方法3：访问嵌套列表
matrix = [[1,2,3],[4,5,6],[7,8,9]]
print(f"访问嵌套列表：{matrix[1][-1]}")
# 切片
# -----------------------------------------------------------------------------------------------------
# 基本切片语法：list[start:end:step]
players =['charles','martina','michael','florence','eli']
my_foods =['pizza','falafel','carrot cake']
# 索引从0，1，2，不包括3
print(players[0:3])
# 从开始到索引3，不包括4
print(players[:4])
# 从索引2到列表结束
print(players[2:])
#从索引倒数第3个到列表结束
print(players[-3:])
# 完整的列表浅拷贝
print(f"完整的列表浅拷贝：{players[:]}")
# 步长为2,结果：['charles', 'michael', 'eli']
print(f"步长为2：{players[::2]}")
# 反转列表,结果：['eli', 'florence', 'michael', 'martina', 'charles']
print(f"反转列表：{players[::-1]}")
# 负索引切片,列表最后3个元素
print(f"负向索引切片：{players[-3:]}")
# 除去最后3个元素外的其他元素
print(f"除去列表最后3个元素外的其他列表元素：{players[:-3]}")
# -------------------------------------------------------------
# 遍历切片
for player in players[:3]:
print(player.title())
# 尝试将一个列表赋值给另一个变量，查看各自添加内容后是否一致
friend_foods = my_foods
print(f"将my_foods赋值给friend_foods后，分别得到两个列表内容：{my_foods},friend_foods:{friend_foods}")
my_foods.append('cannoll')
friend_foods.append('ice cream')
print(f"分别向my_foods及friend_foods,添加不同的元素内容，分别得到my_foods:{my_foods},friend_foods:{friend_foods}")
# 分别向原来的列表，以及切片添加内容
friend_foods = my_foods[:]
my_foods.append('cannoll')
friend_foods.append('ice cream')
print(f"查看切片与原来列表添加内容后是否一致：{my_foods}----------{friend_foods}")
# 检查元素是否存在
# ---------------------------------------------------------------
# 使用 in 关键字
print('martina' in players)
print('florence' in players)
print('score' in players)
# 检查多个元素是否存在
check_list = ['apple','grape','martina','florence']
# 检查是否check_list 中的元素是否都在players中存在
print(all(item in players for item in check_list))
# 检查是否check_list中的某元素在players中存在
print(any(item in players for item in check_list))
# 等价于以下：
for item in check_list:
if item in players:
print(True)
break
else:
print(False)
#添加元素到列表 append()
# ----------------------------------------------------------------------------------
# append()在末尾添加单个元素
# 添加单个元素
players.append('qiaodan')
print(f"添加元素后列表内容的展示：{players}")
# 添加列表(整个列表作为一个元素)
players.append(['kebi','yaoming'])
print(f"添加整个列表后列表的内容更新：{players}")
# extend()----扩展列表(添加多个元素)
players_append =['Mayer','zhongmin']
players.extend(players_append)
print(f"players 通过append方法扩展列表后的列表展示内容：{players}")
# extend() 与append() 的区别
# 添加整个列表后列表的内容更新：['charles', 'martina', 'michael', 'florence', 'eli', 'qiaodan', ['kebi', 'yaoming']]
# players 通过append方法扩展列表后的列表展示内容：['charles', 'martina', 'michael', 'florence', 'eli', 'qiaodan', ['kebi', 'yaoming'], 'Mayer', 'zhongmin']
# insert() 在指定位置插入元素
players_1 =['charles','martina','michael','florence','eli']
my_foods_1 =['pizza','falafel','carrot cake']
# 在索引为1 的地方插入‘grape’
my_foods_1.insert(1,'grape')
print(f"在my_foods列表序号为1的地方插入：grape{my_foods_1}")
#在列表开头处插入
my_foods_1.insert(0,'orange')
print(f"在列表开头处插入orange后展示：{my_foods_1}")
# 在列表末尾处插入
my_foods_1.insert(len(my_foods_1),'mianbao')
print(f"在列表末尾处插入mianbao后：{my_foods_1}")
# 使用+运算符合并列表
list_1 = [1,2,3,4,5]
list_2 =[5,6,7,8,9,10]
combined = list_1 +list_2
print(f"列表合并后的列表：{combined},列表1：{list_1},列表2：{list_2}")
list_1 +=list_2
print(f"此时list_1调整为：{list_1}")
# --------------------------------------------------------------------------------------
#
# --------------------------------------------------------------------------------------
#修改元素列表
# 通过索引直接修改
players_2 =['charles','martina','michael','florence','eli']
my_foods_2 =['pizza','falafel','carrot cake']
# 修改单个元素
players_2[0] ='charles2'
print(f"通过索引修改列表players_2:{players_2}")
# 修改切片
players_2[1:3] = ['yingjie','jiehao']
print(f"通过切片修改列表内容：{players_2}")
# 使用切片插入多个元素
my_foods_2[3:5] =['bingjiling','jidangtan','congbaoniurou']
print(f"使用切片插入多个元素到列表里边：{my_foods_2}")
# 使用列表推导式修改
numbers =[1,2,3,4,5,6,7,8,9]
# 将所有元素立方
lifang =[x **2 for x in numbers]
print(f"使用列表推导式将所有元素立方：{lifang}")
# 有条件的修改
even_lifang =[x ** 2 for x in numbers if x % 2 == 0]
print(f"使用列表推导式使偶数立方：{even_lifang}")
# 删除列表元素
# ---------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------
# 1.del 语句
players_3 =['charles','martina','michael','florence','eli']
my_foods_3 =['pizza','falafel','carrot cake']
# 1)方法1：删除指定索引的元素
del players_3[0]
print(f"通过索引删除players_3中索引为'0'的元素：{players_3}")
# 2)方法2：删除切片
del players_3[0:2]
print(f"通过删除切片的形式删除players_3列表中的切片：{players_3}")
# 3)方法3：删除整个列表
del players_3
# 执行print函数会报错，因为列表已经删除了
# print(f"删除整个列表：{players_3}")
# -----------------------------------------------------------------------------------
# 2.pop()方法删除并返回元素
players_4 =['charles','martina','michael','florence','eli']
my_foods_4 =['pizza','falafel','carrot cake']
# 删除最后一个元素并返回
last =players_4.pop()
print(f"使用pop()删除最后一个元素后列表变为：{players_4},返回的元素为：{last}")
# 删除指定索引的元素
second_element = players_4.pop(1)
print(f"使用pop()删除序号为1的元素后列表变为：{players_4},返回的元素为；{second_element}")
# -------------------------------------------------------------------------------------
# 3.remove()删除指定值的第一个匹配项
players_5 =['charles','martina','michael','florence','eli']
players_5.remove('michael')
print(f"使用remove()删除指定的元素'michael'后列表变成：{players_5}")
# 删除不存在的元素会报错
try:
players_5.remove('jodan')
except ValueError as e:
print(f"错误：{e}")
# 4.clear()清除列表
# ----------------------------------------------------------------------------------
players_6 =['charles','martina','michael','florence','eli']
players_6.clear()
print(f"clear()删除列表后变为：{players_6}")
#
# --------------------------------------------------------------------------------
#
# --------------------------------------------------------------------------------
# 列表排序与反转
# 1.sort() 原地排序
# -----------------------------------
numbers = [3, 1, 4, 1, 5, 9, 2]
players_7 =['charles','martina','michael','florence','eli']
# 升序排序
numbers.sort()
print(f"使用sort()方法升序排序：{numbers}")
# 降序排序
numbers.sort(reverse=True)
print(f"使用sort()方法降序排序：{numbers}")
# 按字符串长度排序
players_7.sort(key=len)
print(f"按照字符串长度排序：{players_7}")
# 复杂排序
students = [
{'name': 'Alice', 'score': 85},
{'name': 'Bob', 'score': 92},
{'name': 'Charlie', 'score': 78}
]
students.sort(key=lambda x:x['score'],reverse=True)
print(students)
# lambda函数
# lambda x: x['score'] 是一个匿名函数
# 等价于
# def get_score(student):
# return student['score']
# key 参数的作用
# sort() 根据 key 函数返回的值进行排序,比较的是分数，而不是整个字典
# 2.sorted()-----------返回新的排序列表
#
# ----------------------------------------------
# sorted()返回新的排序列表，原列表不变
numbers_2 = [3, 1, 4, 1, 5, 9, 2]
sorted_numbers = sorted(numbers_2)
print(f"使用sorted()返回新的排序列表，原列表不变：{sorted_numbers}-------------原来的列表为：{numbers_2}")
# sorted()降序序排序
sorted_numbers_jiangxu = sorted(numbers_2,reverse=True)
print(f"使用sorted()降序排序返回新的列表：{sorted_numbers_jiangxu}")
#
# 3.reverse()-------反转列表
# ----------------------------------------------
# 原地反转
numbers_3 = [3, 1, 4, 1, 5, 9, 2]
numbers_3.reverse()
print(f"使用reverse()反转列表后为:{numbers_3}")
# 使用切片反转
reversed_numbers = numbers_3[::-1]
print(f"使用切片反转:{reversed_numbers}")
# 使用reversed()函数
reversed_liter = reversed(numbers_3)
# reversed() 是 Python 中的一个内置函数，用于返回一个反转的迭代器。它不会修改原序列，而是返回一个新的反向迭代器对象。
print(f"使用reversed()函数反转列表:{list(reversed_liter)}")
# 列表搜索与统计
# -------------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------------
# 1.index()查找元素索引
players_8 =['charles','martina','michael','florence','eli','michael','martina','jodan','michael']
# 查找元素的第一个出现位置
index = players_8.index('michael')
print(f"index()查找元素第一个出现的位置:{index}")
# 在指定范围内查找
index = players_8.index('michael',3)
print(f"从列表中元素序号为2开始执行查找:{index}")
# 查找不存在的元素会报错
try:
index = players_8.index('mac')
except ValueError as e:
print(f"错误:{e}")
# 统计列表中元素出现的次数
# ----------------------------------------------------------------------
# ---------------------------------------------------------------------
# 统计元素'michael'出现的次数
count = players_8.count('michael')
print(f"统计出现的次数:{count}")
# 统计不存在的元素
count_not_exist = players_8.count('Mayer')
print(f"统计不存在的元素:{count_not_exist}")
# 查找最大值最小值
# -------------------------------------------------------------
numbers_4 = [3, 1, 4, 1, 5, 9, 2]
print(f"查找列表中的最大值:{max(numbers_4)},查找列表中的最小值:{min(numbers_4)}")
# 比较字符串中的第一个字符的acsII码,逐个比较
players_9 =['charles','martina','michael','florence','eli','michael','martina','jodan','michael']
print(f"{max(players_9)}------------{min(players_9)}")
# -----------------------------------------------------------------
# 自定义规则查找
# --------------------------------------------------------------
students_2 = [
{'name': 'Alice', 'score': 85},
{'name': 'Bob', 'score': 92},
{'name': 'Charlie', 'score': 78}
]
print(f"按照自定义规则查找:{max(students_2,key=lambda x:x['score'] )}")
# max()函数语法:
# max(iterable, *[, default=obj, key=func])
#
# iterable：必选的位置参数，一个可迭代对象（如列表、元组、字符串等）
# *[, ...]：特殊的语法表示
# * 表示后面的参数必须使用关键字参数的形式传递
# [, ...] 表示方括号内的参数是可选的
# 合起来就是：星号后面的参数必须用关键字指定，且都是可选的
# default=obj：可选的关键字参数，当可迭代对象为空时返回的默认值
# key=func：可选的关键字参数，用于指定比较规则的函数
# max(arg1, arg2, *args[, key=func])
# arg1、arg2：至少需要两个位置参数
# *args：可变数量的位置参数（0个或多个）
# 表示可以接受任意多个额外参数
# [, key=func]：可选的关键字参数 key
# ----------------------------------------------------------------
# 列表复制
# ----------------------------------------------------------------
# 浅拷贝(只复制第一层)
original = [1,2,3,4,5,[6,7,8,9]]
# 方法1: [1, 2, 3, 4, 5, [6, 7, 8, 9]]
shallow_copy = original.copy()
# 方法2: [1, 2, 3, 4, 5, [6, 7, 8, 9]]
shallow_copy_2 = original[:]
# 方法3: [1, 2, 3, 4, 5, [6, 7, 8, 9]]
shallow_copy_3 = list(original)
# 方法4; [1, 2, 3, 4, 5, [6, 7, 8, 9]]
shallow_copy_4 = original * 1
# 修改浅拷贝 [1000000, 2, 3, 4, 5, [6, 7, 8, 9]] original = [1,2,3,4,5,[6,7,8,9]]
shallow_copy[0] =1000000
# 修改嵌套列表 [1000000, 2, 3, 4, 5, [6000000000, 7, 8, 9]] [1, 2, 3, 4, 5, [6000000000, 7, 8, 9]]
shallow_copy[5][0] =6000000000
print(f"浅拷贝:{shallow_copy}----------{original} ")
# -------------------------------------------------------------------------------------------------
# 深拷贝 [1000000, 2, 3, 4, 5, [6000000000, 7, 8, 9]] [1, 2, 3, 4, 5, [6, 7, 8, 9]] 完全独立,不受影响
import copy
original_2 = [1,2,3,4,5,[6,7,8,9]]
deep_copy = copy.deepcopy(original_2)
deep_copy[5][0] = 6000000000
print(f"深拷贝:{shallow_copy}----------{original_2} ")
# 列表推导式高级用法
# ----------------------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------------------
# 1.基本列表推导式用法
numbers_5 = [3, 1, 4, 1, 5, 9, 2]
# 生成平方数列表 [9, 1, 16, 1, 25, 81, 4]
squres_2 = [x ** 2 for x in numbers_5]
# 生成偶数列表 [4, 2]
even_numbers_2 =[x for x in numbers_5 if x % 2 ==0]
# 2.嵌套列表推导式用法
# 矩阵转置
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in matrix:
print(row[0])
transpose = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print(transpose)
# 等价于
transpose = []
for i in range(len(matrix[0])):
transpose.append([row[i] for row in matrix])
# 等价于 [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
transpose = []
for i in range(len(matrix[0])):
result = []
for row in matrix:
result.append(row[i])
transpose.append(result)
#复杂列表推导式
# ---------------------------------------------------
#
# ---------------------------------------------------------
# 生成可能的所有坐标对
points = [(x,y) for y in range(4) for x in range(5)]
print(points)
# 条件表达式
numbers_6 = [3, 1, 4, 1, 5, 9, 2]
result_4 = ['even'if i % 2 == 0 else 'odd' for i in numbers_6]
print(result_4)
# 嵌套循环带条件
result_5 = [(m,x) for x in numbers_6 if x % 2 == 0 for m in numbers_6 if m % 2 ==1]
print(result_5)
# 方法 描述 示例
# append(x) 在末尾添加元素 list.append(1)
# extend(iterable) 扩展列表 list.extend([1, 2])
# insert(i, x) 在位置i插入x list.insert(0, 'first')
# remove(x) 删除第一个值为x的元素 list.remove('apple')
# pop([i]) 删除并返回位置i的元素 item = list.pop(0)
# clear() 清空列表 list.clear()
# index(x[, start[, end]]) 返回x的索引 idx = list.index('apple')
# count(x) 返回x出现的次数 cnt = list.count(1)
# sort(key=None, reverse=False) 排序 list.sort(reverse=True)
# reverse() 反转列表 list.reverse()
# copy() 浅拷贝列表 new_list = list.copy()
# -----------------------------------------------------------------------------
#遍历列表
# ------------------------------------------------------------------------------
# 遍历索引和值
"""
我们通常在使用for循环遍历一个序列（如列表、元组、字符串）时，如果想同时获取元素的索引和值，可以使用enumerate()函数。
enumerate()函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中。
语法：enumerate(iterable, start=0)
参数：
iterable -- 一个序列、迭代器或其他支持迭代的对象。
start -- 下标起始位置，默认为0。
返回值：返回一个enumerate对象，该对象生成由(索引, 元素)组成的元组。
示例：
list1 = ['a', 'b', 'c']
for index, value in enumerate(list1):
print(index, value)
输出：
0 a
1 b
2 c
也可以指定起始索引：
for index, value in enumerate(list1, start=1):
print(index, value)
输出：
1 a
2 b
3 c
除了用于for循环，我们也可以将enumerate()返回的对象转换为列表，列表中的每个元素就是(索引, 元素)的元组。
list2 = list(enumerate(list1))
print(list2) # 输出：[(0, 'a'), (1, 'b'), (2, 'c')]
注意：enumerate()返回的是一个迭代器，所以它不会一次性生成所有元组，而是每次迭代生成一个，这样可以节省内存。
fruits = ['apple', 'banana', 'cherry']
# 不使用 enumerate
for i in range(len(fruits)):
print(i, fruits[i])
# 使用 enumerate（更优雅）
for index, fruit in enumerate(fruits):
print(index, fruit)
"""
# ----------------------------
# enumerate（）函数
# ----------------------------
#场景1： 同时获取索引和值
names = ['Alice', 'Bob', 'Charlie']
for i, name in enumerate(names):
print(f"第{i+1}个名字是：{name}")
#------------------------------
# 场景2： 处理列表时需要索引
scores = [85, 92, 78, 90]
# 找出最高分及其位置
max_score = -1
max_index = -1
for i, score in enumerate(scores):
if score > max_score:
max_score = score
max_index = i
print(f"最高分 {max_score} 在第 {max_index} 个位置")
# ---------------------------------
# 同时遍历多个列表
list1 = ['a', 'b', 'c']
list2 = [1, 2, 3]
for i, (item1, item2) in enumerate(zip(list1, list2)):
print(i, item1, item2)
# -----------------------------------
# 创建字典映射
keys = ['a', 'b', 'c']
# 创建 {0: 'a', 1: 'b', 2: 'c'}
dict1 = dict(enumerate(keys))
print(dict1) # {0: 'a', 1: 'b', 2: 'c'}
# 创建 {'a': 0, 'b': 1, 'c': 2}
dict2 = {value: key for key, value in enumerate(keys)}
print(dict2) # {'a': 0, 'b': 1, 'c': 2}
# -------------------------------------
# 嵌套解包
data = [('Alice', 25), ('Bob', 30), ('Charlie', 35)]
for i, (name, age) in enumerate(data):
print(f"{i}: {name} 年龄 {age}")
# -----------------------------------------
# 配合条件判断
numbers = [10, 20, 30, 40, 50]
# 找出所有偶数的索引和值
for i, num in enumerate(numbers):
if num % 2 == 0:
print(f"索引 {i}: 值 {num}")
# -----------------------------------------
# 在列表推导式中使用
# 创建带索引的元素列表
fruits = ['apple', 'banana', 'cherry']
indexed_fruits = [(i, fruit) for i, fruit in enumerate(fruits)]
print(indexed_fruits) # [(0, 'apple'), (1, 'banana'), (2, 'cherry')]
# 过滤带条件
result = [fruit for i, fruit in enumerate(fruits) if i % 2 == 0]
print(result) # ['apple', 'cherry']
# ------------------------------------------
# 注意事项；
#1. 返回的是迭代器
enum_obj = enumerate(fruits)
print(type(enum_obj)) # <class 'enumerate'>
print(list(enum_obj)) # 转换为列表查看内容
# 2.只能遍历一次
enum_obj = enumerate(fruits)
print(list(enum_obj)) # [(0, 'apple'), (1, 'banana'), (2, 'cherry')]
print(list(enum_obj)) # [] 第二次为空
# 3.对字典使用时返回键的索引
d = {'a': 1, 'b': 2, 'c': 3}
for i, key in enumerate(d):
print(i, key, d[key])
# -----------------------------------------
# 应用场景1：文件处理
text_ready_towrite =['咖啡文化的深度探索：清晨的第一缕阳光透过窗棂，轻轻唤醒沉睡的城市。在这宁静的时刻，一杯手冲咖啡的香气逐渐弥漫开来，它不仅仅是提神的饮料，更是一种生活态度的象征。从埃塞俄比亚高原的古老传说，到意大利街头的浓缩咖啡文化，每一粒咖啡豆都承载着跨越大陆的故事。咖啡的烘焙程度决定了风味的层次，浅焙保留果酸与花香，深焙则带来巧克力般的醇厚。而在全球化的今天，独立咖啡馆成为创意与社区的聚集地，人们在这里交流思想、寻找灵感。咖啡因刺激着我们的神经，也连接着不同文化背景的人们，成为现代社会不可或缺的社交媒介。',
'时间本质的哲学思考：时间如同一条无声的河流，从远古流淌至今，从未停歇。我们在其中挣扎、奋进，试图抓住它的每一瞬间，却总在指尖流逝后感叹不已。哲学家奥古斯丁曾言：“时间是什么？若无人问我，我便知晓；若要我解释，我便茫然。”这种矛盾恰恰揭示了时间的抽象性与相对性。在物理学家眼中，时间是宇宙的第四维度，与空间交织成时空的连续体；而在诗人心里，时间却是记忆中泛黄的信笺，承载着悲欢离合。现代社会对效率的追逐，让我们将时间切割成碎片，却忘了它原本的绵延本质。或许，真正的智慧在于学会与时间共处，而非试图征服它。',
'城市漫步的偶然诗意：漫步在雨后湿漉漉的街道上，砖石缝隙间冒出青苔的绿意，斑驳的墙面上涂鸦与旧海报重叠出时间的层次。转角处面包店飘出黄油的暖香，混合着远处传来电车的叮当声，构成城市特有的交响。每一个擦肩而过的行人都是一本未打开的书——那位提着菜篮的老妇人，是否曾在这个街区度过整个青春？窗台上打盹的猫咪，见证过多少相聚与别离？这种漫无目的的行走，让我们从日常的焦虑中抽离，重新发现被忽略的细节：铁艺栏杆上的露珠、咖啡店窗内的灯光、梧桐叶飘落的弧线。城市在步履间展露它温柔的内里，如同一位卸下妆容的故人。',
'阅读行为的双重性：翻开书页的瞬间，我们便踏入一个由文字构建的平行世界。油墨的气味与纸张的触感，构成了最原始的阅读仪式。然而在这个数字时代，电子屏幕的冷光逐渐取代了物理书页的温暖，滚动代替了翻动，收藏夹堆积着永远读不完的文章。深度阅读正在被碎片化信息蚕食，我们习惯了浏览标题、跳跃段落，失去了沉浸于长篇叙事的耐心。但真正伟大的作品需要缓慢的咀嚼——托尔斯泰笔下战争的硝烟，普鲁斯特记忆中玛德琳蛋糕的滋味，都需要在沉思中逐渐浮现。阅读不仅是获取信息，更是一场与自我对话的精神修行。',
'季节变换的情感映射：初春的樱花以每秒五厘米的速度飘落，这种温柔的决绝仿佛在诉说生命绚烂而短暂的本質。夏日骤雨过后，泥土蒸腾出的热气裹挟着草木的辛辣，蝉鸣如潮水般涨落。秋日黄昏时，银杏大道铺成金色的河流，每片叶子都是一封寄往大地的信笺，写着关于轮回的密语。而冬夜壁炉里的火焰跳跃着，将影子投在书架上，窗外寂静的雪覆盖了所有喧嚣。季节不仅是自然现象，更是人类情感的容器——春的希望、夏的激情、秋的沉思、冬的内省，都在这周而复始的循环中找到共鸣点。',
'烹饪过程中的创造力：当刀刃与砧板接触发出有节奏的声响，食材在手中完成形态的转变，烹饪便成了一场微观的艺术创作。橄榄油在锅中泛起细密气泡时，蒜瓣与迷迭香的香气分子开始舞蹈；西红柿在高温下释放出深藏的鲜甜，与罗勒的清香交织成地中海的微风。每一道菜都是时间与温度的精确游戏：舒芙蕾必须在出炉后三分钟内享用，炖牛肉则需要三小时的文火慢煮。而在味道的平衡中，咸味提升甜味，酸味化解油腻，苦味衬托回甘——这些味觉的辩证法，背后是无数代人的经验传承。厨房因此成为最具创造力的实验室。'
]
with open( r'E:\pythonfile\practice2.csv','w',encoding='utf-8') as f:
for line_num,line in enumerate(text_ready_towrite):
f.write(f"{line_num}.{line}\n")
# -----------------------------------------------------------------------------------------------
# -----------------------------------------------------------------------------------------------
# 使用enumerate同时获取索引和值
my_fruits = ["apple", "banana", "cherry","lizhi","orange","longyan"]
print(list(enumerate(my_fruits)))
for index, fruit in enumerate(my_fruits):
print(f"Index {index}: {fruit}")
# 指定起始索引
for index, fruit in enumerate(fruits, start=1):
print(f"第{index}个水果: {fruit}")
# while循环遍历
my_fruits = ["apple", "banana", "cherry","lizhi","orange","longyan"]
i = 0
while i < len(fruits):
print(fruits[i])
i += 1
# --------------------------
# 列表推导式遍历
# 遍历并处理元素
upper_fruits = [fruit.upper() for fruit in my_fruits]
print(upper_fruits)
# ----------------------------
# 使用内置函数遍历
"""
map() 是 Python 中的一个内置函数，用于将一个函数应用到可迭代对象（如列表、元组等）的每个元素上，并返回一个迭代器。
语法：
map(function, iterable, ...)
function: 要应用的函数
iterable: 一个或多个可迭代对象
返回值：一个 map 对象（迭代器），可以使用 list()、tuple() 等转换为具体的数据结构
其中，function是一个函数，iterable是一个或多个可迭代对象。如果传递多个可迭代对象，则函数必须接受相同数量的参数，并且map会并行地从每个可迭代对象中取一个元素作为函数的参数。
示例1：将一个列表中的每个数字平方
numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared)) # 输出：[1, 4, 9, 16]
示例2：将两个列表对应位置的数字相加
a = [1, 2, 3]
b = [4, 5, 6]
result = map(lambda x, y: x + y, a, b)
print(list(result)) # 输出：[5, 7, 9]
但是，在Python中，如果要将map的结果多次使用，可能需要将其转换为列表，因为迭代器只能遍历一次。
例如：
mapped = map(lambda x: x**2, [1,2,3])
print(list(mapped)) # 输出：[1,4,9]
print(list(mapped)) # 输出：[]，因为迭代器已经耗尽了
"""
# -------------------------------------
fruits = ["apple", "banana", "cherry"]
# 使用map处理每个元素
result = list(map(str.upper, fruits))
print(f"使用map处理每个元素:{result}") # ['APPLE', 'BANANA', 'CHERRY']
# ------------------------------------
# zip()函数（同时遍历多个列表）
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
print(f"{name} is {age} years old")
# ------------------------------------
# 使用迭代器
fruits = ["apple", "banana", "cherry"]
fruit_iter = iter(fruits)
print(next(fruit_iter)) # apple
print(next(fruit_iter)) # banana
print(next(fruit_iter)) # cherry
# ------------------------------------
# 反向遍历
fruits = ["apple", "banana", "cherry"]
# 方法1：使用reversed()
for fruit in reversed(fruits):
print(fruit) # cherry, banana, apple
# 方法2：使用负索引
for i in range(len(fruits)-1, -1, -1):
print(fruits[i])
# ------------------------------------
# 嵌套列表遍历
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 方法1：嵌套循环
for row in matrix:
for element in row:
print(element)
# 方法2：使用索引
for i in range(len(matrix)):
for j in range(len(matrix[i])):
print(f"matrix[{i}][{j}] = {matrix[i][j]}")
# -------------------------------------------------
# 同时遍历索引和值（不使用enumerate）
fruits = ["apple", "banana", "cherry"]
for i in range(len(fruits)):
print(f"Index {i}: {fruits[i]}")
# ------------------------------------------------
# 方法 适用场景 特点
# for item in list 只需元素值 最简单，最常用
# enumerate() 需要索引和值 代码简洁，Pythonic
# while循环 需要更灵活的控制 可以动态修改循环条件
# 列表推导式 需要生成新列表 简洁高效
# map()函数 对每个元素应用相同函数 函数式编程风格
# ------------------------------------------------
# 列表内嵌套字典的遍历
# 示例1：列表中的每个元素是一个字典
students = [
{"name": "Alice", "age": 20, "grades": [85, 90, 88]},
{"name": "Bob", "age": 21, "grades": [78, 82, 80]},
{"name": "Charlie", "age": 19, "grades": [92, 95, 96]}
]
# 方法1：遍历列表中的每个字典
for student in students:
print(f"类型：{type(student)},Name:{student['name']},age:{student['age']}")
for key,value in student.items():
# 如果需要遍历字典中的每个键值对
print(f"{key}:{value}")
# 如果只关心特定键，比如grades，可以进一步遍历
for grade in student['grades']:
print(f"grades:{grade}")
# 示例2:列表中嵌套元组的遍历
student_scores = [
("Alice", [85, 90, 88]),
("Bob", [78, 82, 80]),
("Charlie", [92, 95, 96])
]
# # 遍历列表，每个元素是一个元组
for student_score in student_scores:
print(f"遍历列表中的元组：{student_score},列表中元素的类型：{type(student_score)}")
my_student,my_score = student_score
# 可以解包元组
print(f"解包元组：{my_student},{my_score}")
# 或者直接解包在循环中
for my_student_2,my_score_2 in student_scores:
print(f"直接解包在循环中：{my_student_2},{my_score_2}")
# 示例4：列表中的元组，元组内可能有多个元素
my_records = [("Alice", 20, "Math"), ("Bob", 21, "Science"), ("Charlie", 22, "Art")]
for my_record in my_records:
# 解元组包
my_name,my_age,my_major = my_record
print(f"解元组包：{my_name},---------{my_age}---------{my_major}")
# 如果不需要所有元素，可以用下划线忽略
for my_name,_,my_major in my_records:
print(f"直接解元组包：{my_name},------{my_major}")
# 列表内嵌套列表（多维列表）
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# 遍历行
for row in matrix:
# 遍历行中的每个元素
for element in row:
print(f"内嵌列表中的元素：{element}")
# 混合嵌套结构
# 示例6：列表中包含多种嵌套结构
mixed_list = [
{"name": "Alice", "scores": (85, 90, 88)},
["Bob", 21, {"Math": 90, "English": 85}],
("Charlie", 22, [92, 95, 96])
]
# 遍历混合列表，需要根据类型处理
for item in mixed_list:
if isinstance(item,list):
print(f"list item:{item}")
if isinstance(item,dict):
print(f"dict item:{item}")
if isinstance(item,tuple):
print(f"tuple item:{item}")
# 深度嵌套结构的遍历（递归）
# 示例7：不确定嵌套层数的情况
# 复杂嵌套结构
complex_data = [
{
"name": "Alice",
"courses": [
{"name": "Math", "grades": [90, 85]},
{"name": "Science", "grades": [88, 92]}
]
},
{
"name": "Bob",
"courses": [
{"name": "History", "grades": [78, 80]}
]
}
]
def traverse_nested(data,depth = 0):
indent = " " * depth
if isinstance(data,list):
for item in data:
print(f"不确定嵌套层数的情况{item}")
traverse_nested(item,depth+1)
elif isinstance(data,dict):
for key,value in data.items():
print(f"不确定嵌套层数的情况 key:{key},---------value:{value}")
traverse_nested(value,depth+1)
else:
print(f"不确定嵌套层数的情况{indent}{data}")
traverse_nested(complex_data)
# 使用 itertools 进行复杂遍历
# 示例8：使用 itertools.chain 扁平化嵌套列表（仅限一层嵌套）
import itertools
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
"""
nested_list = [[1, 2, 3], [4, 5], [6]]
# *nested_list 相当于：
# [1, 2, 3], [4, 5], [6]
# 就是把嵌套列表拆成三个独立的参数
"""
"""
# chain(序列1, 序列2, 序列3)
# 把多个序列连接成一个连续的序列
# 就像把三节火车车厢连成一列：
itertools.chain([1,2,3], [4,5], [6])
# 结果相当于一个迭代器：[1,2,3,4,5,6]
"""
flattened = list(itertools.chain(*nested_list))
print(flattened)
# -----------------------------------------------------------------
# map()函数
# -----------------------------------------------------------------
#------------------------------------------------------------------
# 将列表中的每个数字平方
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x**2, numbers)
print(list(squared)) # [1, 4, 9, 16, 25]
# 对单个可迭代对象使用
# 使用内置函数
words = ['hello', 'world', 'python']
"""
在Python中，map(len, words)是一个内置函数map的应用。map函数接收两个参数：第一个是一个函数，第二个是一个可迭代对象（如列表、元组等）。
这里，len是一个内置函数，用于返回对象的长度（例如，字符串中字符的数量，列表中元素的数量等）。words应该是一个可迭代对象，比如一个字符串列表。
map(len, words)的作用是：将len函数依次应用到words中的每一个元素上，并返回一个迭代器（在Python 3中，map返回一个迭代器，如果需要列表，可以用list()转换）。
例如，如果words = ['apple', 'banana', 'cherry']，那么map(len, words)会依次计算：
len('apple') -> 5
len('banana') -> 6
len('cherry') -> 6
然后返回一个迭代器，该迭代器依次产生5, 6, 6。
我们可以通过将其转换为列表来查看结果：list(map(len, words)) 得到 [5, 6, 6]。
语法：
map(function, iterable)
map() 是一个内置函数
第一个参数 function：要应用的函数
第二个参数 iterable：可迭代对象（如列表、元组等）
返回一个map对象（可迭代对象）
# 使用map
result1 = map(len, words)
等价于：
# 使用列表推导式
result2 = [len(word) for word in words]
"""
lengths = map(len, words)
print(list(lengths)) # [5, 5, 6]
# -----------------------------------------------
# 对多个可迭代对象使用
# 两个列表对应位置相加
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = map(lambda x, y: x + y, list1, list2)
print(list(result)) # [5, 7, 9]
# 三个列表对应位置相乘
a = [1, 2, 3]
b = [4, 5, 6]
c = [2, 2, 2]
result = map(lambda x, y, z: x * y * z, a, b, c)
print(list(result)) # [8, 20, 36]
# -----------------------------------------------
# 使用自定义函数
def to_upper(name):
return name.upper()
names = ['alice', 'bob', 'charlie']
uppercase_names = map(to_upper, names)
print(list(uppercase_names)) # ['ALICE', 'BOB', 'CHARLIE']
# -------------------------------------------------
# 与列表推导式的比较
# 使用 map()
numbers = [1, 2, 3, 4]
result1 = list(map(lambda x: x * 2, numbers))
# 使用列表推导式
result2 = [x * 2 for x in numbers]
print(result1) # [2, 4, 6, 8]
print(result2) # [2, 4, 6, 8]
# ------------------------------------------------
# 应用场景
# ------------------------------------------------
# 应用场景1：类型转换
# 字符串列表转整数列表
str_numbers = ['1', '2', '3', '4']
int_numbers = list(map(int, str_numbers))
print(int_numbers) # [1, 2, 3, 4]
# -----------------------------------------------
# 应用场景2：数据清洗
# 去除字符串两端的空格
raw_data = [' apple ', 'banana ', ' cherry']
""""
str.strip是一个方法，但是当我们将它作为参数传递给map()函数时，我们并不立即调用它，而是传递这个函数本身。map()函数会接受一个函数和一个可迭代对象，然后将该函数应用于可迭代对象的每一个元素。
如果写成str.strip()，那么这就变成了一个函数调用，它会立即执行，并且期望传入参数。但是在这里，我们并不想立即调用strip方法，而是想告诉map()函数：“对每一个元素，请调用strip方法。”
实际上，str.strip是一个方法，它可以被调用。当我们使用map(str.strip, raw_data)时，map会遍历raw_data中的每一个元素（假设这些元素都是字符串），并对每一个元素调用str.strip.
注意，str.strip在调用时需要一个字符串作为调用者（即它是一个方法），但是map会以每个元素作为参数传递给str.strip函数，这实际上相当于对每个元素执行element.strip()。
但是，为什么我们可以这样写呢？因为str.strip是一个函数，它属于字符串类，当我们用字符串对象调用时，通常写成" string ".strip()。
然而，在map中，我们使用str.strip，它实际上是一个未绑定的方法（在Python 3中，类的方法就是函数），它需要一个字符串作为第一个参数。
map会将每个元素作为这个第一个参数传递进去，所以对于每个元素x，实际上执行的是str.strip(x)，而str.strip(x)等价于x.strip()。
map(str.strip, raw_data)等价于：
[x.strip() for x in raw_data]
函数作为参数传递
# 带括号 - 立即调用函数
result = str.strip(" hello ") # 返回 "hello"
# 不带括号 - 传递函数本身
function_reference = str.strip # 这是一个函数对象
---------------------------------------------------
raw_data = [" abc ", " def ", " ghi "]
# map() 需要的是一个函数，它会自己调用这个函数
mapped = map(str.strip, raw_data)
# 相当于：对于 raw_data 中的每个元素 x，执行 str.strip(x)
# 如果带括号：
# mapped = map(str.strip(), raw_data) # 错误！需要参数
---------------------------------------------------
执行过程：
# 在内部，map() 大致这样做：
result = []
for item in raw_data:
# 调用我们传递的函数，并传入当前元素
cleaned = str.strip(item) # 等同于 item.strip()
result.append(cleaned)
"""
cleaned = list(map(str.strip, raw_data))
print(cleaned) # ['apple', 'banana', 'cherry']
# --------------------------------------------------------------------------------------
# 多参数函数映射
def calculate_total(price, quantity, discount=0.1):
return price * quantity * (1 - discount)
prices = [10, 20, 30]
quantities = [2, 3, 1]
totals = map(calculate_total, prices, quantities)
print(list(totals)) # [18.0, 54.0, 27.0]
# --------------------------------------------------------------------------------------
# map 对象是一次性的
numbers = [1, 2, 3]
mapped = map(lambda x: x * 2, numbers)
# 第一次使用
print(list(mapped)) # [2, 4, 6]
# 第二次使用（map对象已耗尽）
print(list(mapped)) # []
# -------------------------------------------------------------------------------------
# 长度不同时的处理
# 以最短的可迭代对象为准
list1 = [1, 2, 3, 4]
list2 = [10, 20, 30]
result = map(lambda x, y: x + y, list1, list2)
print(list(result)) # [11, 22, 33]（只计算前3个）
# ---------------------------------------------------------------------------------------
浙公网安备 33010602011771号