Python-VBA函数之旅-enumerate函数

1、enumerate函数：

1-1、Python：

1-2、VBA：

2、相关文章：

个人主页：非风V非雨-CSDN博客

enumerate函数在Python中是一个强大的内置函数，用于将一个可迭代对象转换为一个索引序列，同时返回每个元素的索引和对应的值。常见的应用场景有：

1、索引处理：enumerate()函数允许我们对索引进行起始位自定义、反转、动态添加步长等处理。

2、遍历操作：enumerate()函数可用于遍历可迭代对象，例如，列表、字典、元组、字符串、文件等。

3、位置跟踪：enumerate()函数可用于数据点、对象等的位置标记及相关信息获取。

4、图形可视化：在开发图形用户界面时，enumerate()函数可用于处理屏幕对象的相关信息。

5、多重枚举：与zip()函数结合使用，可实现多个可迭代对象的枚举。

6、条件枚举：enumerate()函数可以在循环内部，配合条件语句来跳过某些元素，实现条件枚举。

7、配合其他函数使用：enumerate()函数本身就可以和许多其他函数或结构配合使用，特别是那些需要处理序列或迭代器的函数和结构。

总之，在需要访问可遍历对象的索引和值的场景中，enumerate()函数都非常有用。

1、enumerate函数：

1-1、Python：

# 1.函数：enumerate
# 2.功能：
# 2-1、将一个可迭代的对象组合为一个带有数据和数据下标的索引序列，返回一个枚举类型
# 2-2、将一个可迭代的对象组合为一个带有数据和数据索引的序列，返回一个枚举类型
# 3.语法：
# 3-1、enumerate(iterable, start=0)
# 3-2、for index, item in enumerate(listname):
#      输出index和item
# 4.参数：
# 4-1. iterable：必需参数，一个可迭代对象，如列表、元组、字符串等
#      start：可选参数，用于指定计数的起始值，默认为0
# 4-2. index：用于保存元素的索引
#      item：用于保存获取到的元素值，要输出元素内容时，直接输出该变量即可
#      listname：序列名称
# 5.返回值：返回一个枚举对象
# 6.说明：
# 7.示例：
# 应用1：索引处理
# 使用enumerate函数遍历列表，并设置起始值为1
fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits, start=1):print(f"Index: {index}, Fruit: {fruit}")
# Index: 1, Fruit: apple
# Index: 2, Fruit: banana
# Index: 3, Fruit: orange# 反转索引
my_list = ['a', 'b', 'c', 'd']
for index, value in enumerate(reversed(my_list), start=1):reversed_index = len(my_list) - index + 1print(f"Reversed Index: {reversed_index}, Value: {value}")
# Reversed Index: 4, Value: d
# Reversed Index: 3, Value: c
# Reversed Index: 2, Value: b
# Reversed Index: 1, Value: a# 应用2：遍历操作
# 遍历列表并获取索引和值
fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits, start=1):print(f"Index: {index}, Fruit: {fruit}")
# Index: 1, Fruit: apple
# Index: 2, Fruit: banana
# Index: 3, Fruit: orange# 遍历文件并跟踪行号
with open('file.txt', 'r') as file:for line_number, line in enumerate(file, start=1):print(f"Line {line_number}: {line.strip()}")
# Line 1: 1111
# Line 2: 2222
# Line 3: 3333
# Line 4: 4444# 遍历字典的键和值
my_dict = {'a': 1, 'b': 2, 'c': 3}
for index, (key, value) in enumerate(my_dict.items()):print(f"Index: {index}, Key: {key}, Value: {value}")
# Index: 0, Key: a, Value: 1
# Index: 1, Key: b, Value: 2
# Index: 2, Key: c, Value: 3# 遍历字符串并处理字符位置
text = "Myelsa"
for index, char in enumerate(text):print(f"字符位置{index}: {char}")
# 字符位置0: M
# 字符位置1: y
# 字符位置2: e
# 字符位置3: l
# 字符位置4: s
# 字符位置5: a# 应用3：位置跟踪
data = [3, 5, 6, 8, 10, 11, 24]
target_value = 24
for index, value in enumerate(data):if value == target_value:print(f"Found {target_value} at index {index}")break
# Found 24 at index 6# 应用4：图形可视化
# 假设这是我们的游戏对象类
class GameObject:def __init__(self, name, x, y):self.name = nameself.x = xself.y = ydef __str__(self):return f"{self.name} at ({self.x}, {self.y})"
if __name__ == '__main__':# 创建游戏对象列表game_objects = [GameObject("Object 1", 1, 2),GameObject("Object 2", 3, 4),GameObject("Object 3", 5, 6),# ... 更多游戏对象]# 使用 enumerate 函数遍历游戏对象列表，并打印位置和名称for index, obj in enumerate(game_objects):print(f"Object at index {index}: {obj}")# 如果我们想要进行更复杂的操作，比如移动对象或检查碰撞，我们可以在循环内部添加逻辑for index, obj in enumerate(game_objects):# 假设我们移动每个对象到新的位置new_x = obj.x + 1  # 例如，向右移动一个单位new_y = obj.y + 1  # 例如，向下移动一个单位obj.x = new_xobj.y = new_yprint(f"Moved {obj.name} to ({new_x}, {new_y})")# 打印移动后的对象位置for index, obj in enumerate(game_objects):print(f"Object at index {index} after moving: {obj}")
# Object at index 0: Object 1 at (1, 2)
# Object at index 1: Object 2 at (3, 4)
# Object at index 2: Object 3 at (5, 6)
# Moved Object 1 to (2, 3)
# Moved Object 2 to (4, 5)
# Moved Object 3 to (6, 7)
# Object at index 0 after moving: Object 1 at (2, 3)
# Object at index 1 after moving: Object 2 at (4, 5)
# Object at index 2 after moving: Object 3 at (6, 7)# 应用5：多重枚举
names = ['Myelsa', 'Bruce', 'Jimmy']
ages = [18, 6, 15]
for index, (name, age) in enumerate(zip(names, ages), start=1):print(f"Index: {index}, Name: {name}, Age: {age}")
# Index: 1, Name: Myelsa, Age: 18
# Index: 2, Name: Bruce, Age: 6
# Index: 3, Name: Jimmy, Age: 15# 应用6：条件枚举
# 枚举时跳过某些元素
my_list = [1, 2, 3, 4, 5]
for index, value in enumerate(my_list):if value % 2 == 0:  # 跳过偶数continueprint(f"Index: {index}, Value: {value}")
# Index: 0, Value: 1
# Index: 2, Value: 3
# Index: 4, Value: 5# 枚举时使用自定义的索引函数
def custom_index(iterable):for i in range(len(iterable)):yield i**2  # 使用平方作为索引
if __name__ == '__main__':my_list = ['a', 'b', 'c', 'd']for index, value in zip(custom_index(my_list), my_list):print(f"Custom Index: {index}, Value: {value}")
# Custom Index: 0, Value: a
# Custom Index: 1, Value: b
# Custom Index: 4, Value: c
# Custom Index: 9, Value: d# 枚举时同时获取前一个和下一个元素
# 假设我们有一个列表
data = ['a', 'b', 'c', 'd', 'e']
# 初始化前一个元素为 None，因为在列表的第一个元素之前没有元素
prev_element = None
# 遍历列表，除了最后一个元素
for index, current_element in enumerate(data[:-1]):  # 使用切片排除最后一个元素# 获取后一个元素next_element = data[index + 1]# 打印结果print(f"Previous Element: {prev_element}, Current Element: {current_element}, Next Element: {next_element}")# 更新前一个元素为当前元素，以便在下一次循环中使用prev_element = current_element
# 注意：最后一个元素没有后一个元素，所以上面的循环没有处理它。
# 如果你需要处理最后一个元素（尽管它没有后一个元素），你可以单独处理它：
if data:  # 确保列表不为空last_index = len(data) - 1last_element = data[last_index]print(f"Last Element: {last_element}, No Next Element")
# Previous Element: None, Current Element: a, Next Element: b
# Previous Element: a, Current Element: b, Next Element: c
# Previous Element: b, Current Element: c, Next Element: d
# Previous Element: c, Current Element: d, Next Element: e
# Last Element: e, No Next Element# 枚举时动态添加步长
my_list = ['a', 'b', 'c', 'd', 'e']
for index, value in enumerate(my_list[::2]):print(f"Index: {index}, Value: {value}")
# Index: 0, Value: a
# Index: 1, Value: c
# Index: 2, Value: e# 应用7：配合其他函数或对象使用
# 与zip()函数一起组合
names = ['Myelsa', 'Bruce', 'Jimmy']
ages = [18, 6, 15]
for index, (name, age) in enumerate(zip(names, ages), start=1):print(f"Index: {index}, Name: {name}, Age: {age}")
# Index: 1, Name: Myelsa, Age: 18
# Index: 2, Name: Bruce, Age: 6
# Index: 3, Name: Jimmy, Age: 15# 与map()函数一起组合
my_list = ['a', 'b', 'c']
indexed_list = list(map(lambda x: (x[0], x[1].upper()), enumerate(my_list)))
print(indexed_list)
# [(0, 'A'), (1, 'B'), (2, 'C')]# 与filter()函数一起组合
my_list = ['a', 'b', 'c']
filtered_list = list(filter(lambda x: x[0] % 2 == 0, enumerate(my_list)))
print(filtered_list)
# [(0, 'a'), (2, 'c')]# 列表推导式(List comprehension)
my_list = ['a', 'b', 'c']
new_list = [(index, value) for index, value in enumerate(my_list)]
print(new_list)
# [(0, 'a'), (1, 'b'), (2, 'c')]# 与sorted()函数一起组合
my_list = ['c', 'a', 'b']
sorted_enum = sorted(enumerate(my_list), key=lambda x: x[1])
for index, value in sorted_enum:print(f"Index: {index}, Value: {value}")
# Index: 1, Value: a
# Index: 2, Value: b
# Index: 0, Value: c# 与Pandas的配合使用
import pandas as pd
# 创建一个简单的 DataFrame
data = {'Name': ['Myelsa', 'Bruce', 'Jimmy'],'Age': [18, 6, 15],'City': ['Guangzhou', 'Foshan', 'Zhuhai']}
df = pd.DataFrame(data)
# 使用enumerate和iterrows()遍历DataFrame的行
for index, row in enumerate(df.iterrows()):i, row_data = row  # row 是一个包含索引和行的元组print(f"Row {index} (Index: {i}):")for column, value in row_data.items():print(f"  {column}: {value}")
# 如果你只需要遍历索引和列名，可以使用iteritems()
for index, (column_name, column_data) in enumerate(df.items()):print(f"Column {index}: {column_name}")print("  Values:", column_data.tolist())
# Row 0 (Index: 0):
#   Name: Myelsa
#   Age: 18
#   City: Guangzhou
# Row 1 (Index: 1):
#   Name: Bruce
#   Age: 6
#   City: Foshan
# Row 2 (Index: 2):
#   Name: Jimmy
#   Age: 15
#   City: Zhuhai
# Column 0: Name
#   Values: ['Myelsa', 'Bruce', 'Jimmy']
# Column 1: Age
#   Values: [18, 6, 15]
# Column 2: City
#   Values: ['Guangzhou', 'Foshan', 'Zhuhai']