3程序流程控制

最新推荐文章于 2024-09-09 00:00:00 发布

ACTIONTNT

最新推荐文章于 2024-09-09 00:00:00 发布

阅读量57

点赞数

分类专栏： Python基础文章标签： python 开发语言

本文链接：https://blog.csdn.net/ACTIONTNT/article/details/131136826

版权

Python基础专栏收录该内容

10 篇文章 1 订阅

订阅专栏

本文详细介绍了Python中的程序流程控制，包括顺序结构、选择结构和分支结构。顺序结构按照代码顺序执行，选择结构根据条件执行不同分支，而分支结构则根据条件选择不同执行路径。文章还深入探讨了循环结构，讲解了for循环、while循环、循环嵌套、break和continue语句的用法，以及range对象和可迭代对象的概念。此外，还提到了循环的else子句和实用的enumerate()、zip()、map()函数。最后，通过案例展示了如何使用嵌套循环实现图像处理算法。

摘要由CSDN通过智能技术生成

3.1顺序结构

Python中的顺序结构是指程序按照代码书写的顺序依次执行，每一行代码都按照顺序被执行一遍，没有跳过或者重复执行的情况。

以下是一个简单的Python顺序结构的示例，它将两个整数相加并输出结果：

# 定义两个整数
a = 10
b = 20

# 计算两个整数的和
c = a + b

# 输出结果
print("a + b = ", c)

在这个例子中，程序首先定义了两个整数a和b，然后计算了它们的和并将结果保存在变量c中。最后，程序使用print()函数输出了结果。

这个程序是一个典型的顺序结构，因为它按照代码书写的顺序依次执行，每一行代码都按照顺序被执行一遍，没有跳过或者重复执行的情况。当程序运行时，它会依次执行每一行代码，并输出结果a + b = 30。

3.2选择结构

在Python中，选择结构是指程序根据条件的不同，执行不同的代码分支。常见的选择结构包括if语句、if-else语句、if-elif-else语句等等。

以下是一个使用if-else语句实现选择结构的示例，它根据输入的整数判断该数是正数、负数还是零，并输出相应的信息：

# 输入一个整数
x = int(input("请输入一个整数："))

# 判断整数的正负性
if x > 0:
    print("这是一个正数")
elif x < 0:
    print("这是一个负数")
else:
    print("这是零")

在这个例子中，程序首先使用input()函数获取一个整数x的输入。然后，它使用if-elif-else语句判断x的正负性，并输出相应的信息。

当输入的整数x为正数时，程序会执行if语句块中的代码，输出字符串"这是一个正数"；当x为负数时，程序会执行elif语句块中的代码，输出字符串"这是一个负数"；当x为零时，程序会执行else语句块中的代码，输出字符串"这是零"。

总之，Python中的选择结构是指程序根据条件的不同，执行不同的代码分支。常见的选择结构包括if语句、if-else语句、if-elif-else语句等等。在这些语句中，根据条件的不同，程序会选择执行不同的代码块。

3.3分支结构

在Python中，分支结构是指程序根据条件的不同，选择不同的代码路径执行。常见的分支结构包括for循环、while循环、break语句、continue语句等等。

以下是一个使用for循环实现分支结构的示例，它遍历一个列表中的元素，并根据元素的类型输出不同的信息：

# 定义一个列表
my_list = [1, "hello", 3.14, True]

# 遍历列表中的元素
for item in my_list:
    # 判断元素的类型
    if type(item) == int:
        print(f"{item} 是一个整数")
    elif type(item) == str:
        print(f"{item} 是一个字符串")
    elif type(item) == float:
        print(f"{item} 是一个浮点数")
    elif type(item) == bool:
        print(f"{item} 是一个布尔值")

在这个例子中，程序首先定义了一个列表my_list，其中包含整数、字符串、浮点数和布尔值等不同类型的元素。然后，程序使用for循环遍历列表中的每个元素，并使用if-elif语句判断元素的类型，并输出相应的信息。

当遍历到整数1时，程序会执行if语句块中的代码，输出字符串"1 是一个整数"；当遍历到字符串"hello"时，程序会执行elif语句块中的代码，输出字符串"‘hello’ 是一个字符串"；以此类推。

总之，Python中的分支结构是指程序根据条件的不同，选择不同的代码路径执行。常见的分支结构包括for循环、while循环、break语句、continue语句等等。在这些语句中，根据条件的不同，程序会选择执行不同的代码块。

3.3循环结构

3.3.1可迭代对象

Python中包括多种可迭代对象，以下是其中一些常见的可迭代对象：

列表（list）：列表是一种有序的可变序列，可以通过下标访问、添加、删除、修改其中的元素。例如：[1, 2, 3, 4, 5]
元组（tuple）：元组是一种有序的不可变序列，可以通过下标访问其中的元素。例如：(1, 2, 3, 4, 5)
字符串（string）：字符串是一种有序的不可变序列，可以通过下标访问其中的字符。例如："hello world"
集合（set）：集合是一种无序的可变序列，其中的元素具有唯一性，支持并、交、差等集合运算。例如：{1, 2, 3, 4, 5}
字典（dict）：字典是一种无序的可变键值对集合，其中的键具有唯一性，可以通过键访问、添加、删除、修改其中的值。例如：{"name": "Alice", "age": 20, "gender": "female"}

除了这些常见的可迭代对象外，Python中还有许多其他的可迭代对象，例如文件对象、生成器对象、迭代器对象等等。这些对象都支持使用for循环进行遍历，并提供了一些额外的方法来操作它们。

总之，Python中包括多种可迭代对象，常见的包括列表、元组、字符串、集合、字典等等。这些对象都支持使用for循环进行遍历，并提供了一些额外的方法来操作它们。

3.3.2range对象

在Python中，range()函数可以用来生成一个整数序列，它返回一个range对象，该对象表示一个左闭右开区间的整数序列。range()函数可以接受1、2或3个参数，分别表示开始值、结束值和步长（默认为1）。

range()函数的语法格式如下：

range(stop)
range(start, stop[, step])

其中，参数的含义如下：

start：可选，表示整数序列的起始值（默认为0）。
stop：必选，表示整数序列的结束值（不包含在序列中）。
step：可选，表示整数序列的步长（默认为1）。

以下是使用range()函数生成整数序列的示例：

# 生成一个整数序列，从0到4（左闭右开）
my_range = range(0, 4)

# 遍历整数序列中的元素
for num in my_range:
    print(num)

在这个例子中，程序使用range()函数生成一个整数序列，从0到4（左闭右开）。然后，程序使用for循环遍历整数序列中的每个元素，并使用print()函数输出每个元素的值。

当程序运行时，它会依次输出整数序列中的每个元素，即0、1、2、3。

除了用于生成整数序列外，range()函数还常用于控制循环的次数。例如，以下代码使用range()函数控制for循环的次数：

# 循环10次
for i in range(10):
    print("Hello, World!")

在这个例子中，程序使用range()函数生成一个整数序列，从0到9（左闭右开），并将其作为for循环的循环次数。因此，程序会循环10次，并在每次循环中输出字符串"Hello, World!"。
在这里插入图片描述

总之，range()函数是用来生成整数序列的函数，它返回一个range对象，该对象表示一个左闭右开区间的整数序列。range()函数可以接受1、2或3个参数，分别表示开始值、结束值和步长（默认为1）。range对象常用于循环控制和生成序列。

3.3.3for循环

在Python中，for循环是一种常用的循环结构，它用于遍历可迭代对象中的元素。for循环的语法格式如下：

for variable in iterable:
    # 执行语句

其中，variable表示循环变量，iterable表示可迭代对象，执行语句表示要在循环中执行的语句块。

以下是一个使用for循环遍历列表的示例：

# 定义一个列表
my_list = ["apple", "banana", "orange"]

# 遍历列表中的元素
for fruit in my_list:
    print(fruit)

在这个例子中，程序首先定义了一个列表my_list，包含三个字符串元素。然后，程序使用for循环遍历列表中的每个元素，并使用print()函数输出每个元素的值。

当程序运行时，它会依次输出列表中的每个元素，即字符串"apple"、“banana"和"orange”。

除了遍历列表外，for循环还可以遍历其他类型的可迭代对象，例如元组、字典、集合、字符串等等。以下是一个使用for循环遍历字符串的示例：

# 定义一个字符串
my_str = "hello world"

# 遍历字符串中的字符
for char in my_str:
    print(char)

在这个例子中，程序首先定义了一个字符串my_str，包含11个字符。然后，程序使用for循环遍历字符串中的每个字符，并使用print()函数输出每个字符的值。

当程序运行时，它会依次输出字符串中的每个字符，即"h"、“e”、“l”、“l”、“o”、" "、“w”、“o”、“r”、“l"和"d”。

3.3.4while循环

在Python中，while循环是一种常用的循环结构，它用于在满足一定条件的情况下执行一段代码块。while循环的语法格式如下：

while condition:
    # 执行语句

其中，condition表示循环条件，执行语句表示要在循环中执行的语句块。当循环条件为真时，程序会不断地执行循环中的语句块，直到循环条件为假时结束循环。

以下是一个使用while循环计算1到10的和的示例：

# 初始化变量和
sum = 0

# 初始化计数器i
i = 1

# 计算1到10的和
while i <= 10:
    sum += i
    i += 1

# 输出结果
print("1到10的和为：", sum)

在这个例子中，程序首先初始化变量sum和计数器i，然后使用while循环计算1到10的和。循环条件为i <= 10，当i小于等于10时，程序会执行循环中的语句块，即将i加到sum中，并将i加1。当i大于10时，循环结束。

最后，程序使用print()函数输出计算结果。

当程序运行时，它会输出1到10的和，即55。

除了计算数值之外，while循环还可以用于处理序列、文件等对象。以下是一个使用while循环遍历列表的示例：

# 定义一个列表
my_list = ["apple", "banana", "orange"]

# 初始化计数器i
i = 0

# 遍历列表中的元素
while i < len(my_list):
    print(my_list[i])
    i += 1

在这个例子中，程序首先定义了一个列表my_list，包含三个字符串元素。然后，程序使用while循环遍历列表中的每个元素，并使用print()函数输出每个元素的值。循环条件为i < len(my_list)，当i小于列表的长度时，程序会执行循环中的语句块，即输出列表中第i个元素，并将i加1。当i等于列表的长度时，循环结束。

当程序运行时，它会依次输出列表中的每个元素，即字符串"apple"、“banana"和"orange”。

总之，while循环是一种常用的循环结构，用于在满足一定条件的情况下执行一段代码块。while循环的语法格式为while condition:，其中condition表示循环条件。while循环可以用于处理数值、序列、文件等对象。

3.3.5循环的嵌套

要打印99乘法表，可以使用两个嵌套的for循环来实现。外层循环控制行数，内层循环控制列数，每次输出两个数的乘积即可。

以下是打印99乘法表的示例代码：

# 循环嵌套打印99乘法表
for i in range(1, 10):
    for j in range(1, i+1):
        print(f"{j}*{i}={i*j}", end="\t")
    print()

在这个例子中，程序使用两个嵌套的for循环，外层循环控制行数，内层循环控制列数。循环变量i表示行数，循环变量j表示列数。内层循环中，每次输出两个数的乘积，并使用制表符\t使输出对齐。在内层循环结束后，使用print()函数输出换行符，以便开始下一行的输出。

当程序运行时，它会依次输出99乘法表的每一行，输出结果如下：

1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

3.3.6break语句

在Python中，break是一种控制语句，用于跳出当前循环。当程序执行到break语句时，程序会立即跳出当前循环，执行循环后面的代码。

以下是一个使用break语句跳出循环的示例：

# 使用break语句跳出循环
for i in range(1, 11):
    if i == 6:
        break
    print(i)

在这个例子中，程序使用for循环输出1到10之间的整数。在循环中，使用if语句判断当前循环变量是否等于6。当循环变量等于6时，程序会执行break语句，跳出循环。当循环变量不等于6时，程序会使用print()函数输出循环变量的值。

当程序运行时，它会输出1到5之间的整数，因为当循环变量等于6时，程序会跳出循环，不再执行后续的语句。

除了在for循环中使用break语句，break语句还可以在while循环、try...except语句等其他语句结构中使用，用于跳出当前循环或异常处理。

总之，break语句是一种控制语句，用于跳出当前循环。当程序执行到break语句时，程序会立即跳出当前循环，执行循环后面的代码。break语句可以在for循环、while循环、try...except语句等其他语句结构中使用。

3.3.7 continue语句

在Python中，continue是一种控制语句，用于跳过当前循环中的某些代码，继续执行下一次循环。

以下是一个使用continue语句跳过循环的示例：

# 使用continue语句跳过循环
for i in range(1, 11):
    if i == 6:
        continue
    print(i)

在这个例子中，程序使用for循环输出1到10之间的整数。在循环中，使用if语句判断当前循环变量是否等于6。当循环变量等于6时，程序会执行continue语句，跳过当前循环，继续执行下一次循环。当循环变量不等于6时，程序会使用print()函数输出循环变量的值。

当程序运行时，它会输出1到10之间的整数，但不会输出6，因为当循环变量等于6时，程序会跳过当前循环。

除了在for循环中使用continue语句，continue语句还可以在while循环等其他语句结构中使用，用于跳过当前循环中的某些代码，继续执行下一次循环。

总之，continue语句是一种控制语句，用于跳过当前循环中的某些代码，继续执行下一次循环。当程序执行到continue语句时，程序会终止当前循环中的剩余代码，开始下一次循环。continue语句可以在for循环、while循环等其他语句结构中使用。

3.3.8死循环

在Python中，死循环是一种循环结构，其循环条件永远为真，导致程序一直在循环中执行，无法跳出循环。通常情况下，死循环是由于程序设计错误或者逻辑错误导致的。

以下是一个使用while循环实现的死循环示例：

# 使用while循环实现死循环
while True:
    print("Hello, world!")

在这个例子中，程序使用while循环实现死循环。循环条件为True，表示循环条件永远为真，程序会不断地执行循环中的代码块，打印出"Hello, world!"的字符串。程序无法跳出循环，只能通过强制停止程序来终止死循环。

除了使用while循环实现死循环，还可以使用for循环、if语句等语句结构实现死循环。但不管使用哪种方式，死循环都是一种非常危险的编程错误，应该尽量避免。

总之，死循环是一种循环结构，其循环条件永远为真，导致程序一直在循环中执行，无法跳出循环。死循环通常是由于程序设计错误或逻辑错误导致的，应该尽量避免。

3.3.9else子句

在Python中，else子句是一种可选的语句块，用于在循环或条件语句执行完毕后执行一些额外的代码。else子句的语法格式与if语句和while循环类似，可以放在循环体的后面，也可以与if语句配合使用。

当循环正常结束时，else子句会被执行；当循环被break语句中断时，else子句不会被执行。

以下是一个在for循环中使用else子句的示例：

# 在for循环中使用else子句
for i in range(1, 6):
    print(i)
else:
    print("Loop finished!")

在这个例子中，程序使用for循环输出1到5之间的整数。在循环后面，使用else子句打印出"Loop finished!"的字符串。当循环正常结束时，即循环变量遍历完1到5之间的整数时，else子句会被执行，打印出"Loop finished!"的字符串。

以下是一个在while循环中使用else子句的示例：

# 在while循环中使用else子句
i = 1
while i <= 5:
    print(i)
    i += 1
else:
    print("Loop finished!")

在这个例子中，程序使用while循环输出1到5之间的整数。在循环后面，使用else子句打印出"Loop finished!"的字符串。当循环正常结束时，即循环变量遍历完1到5之间的整数时，else子句会被执行，打印出"Loop finished!"的字符串。

需要注意的是，在for循环和while循环中使用else子句时，如果在循环中使用了break语句跳出循环，else子句就不会被执行。

总之，else子句是一种可选的语句块，用于在循环或条件语句执行完毕后执行一些额外的代码。else子句的语法格式与if语句和while循环类似，可以放在循环体的后面，也可以与if语句配合使用。在for循环和while循环中使用else子句时，如果循环正常结束，else子句会被执行；如果循环被break语句中断，else子句不会被执行。

3.3.10enumberate（）函数和循环

在Python中，enumerate()枚举函数是一种内置函数，用于将一个可迭代对象（如列表、元组或字符串）转换为一个枚举对象，枚举对象中包含了可迭代对象中的每个元素的索引和值。这个函数的返回值是一个可迭代的枚举对象。

enumerate()函数的语法格式如下：

enumerate(iterable, start=0)

其中，iterable是一个可迭代对象，start是一个整数，表示枚举对象中第一个元素的索引，默认为0。

以下是一个使用enumerate()函数的示例：

# 使用enumerate()函数枚举列表中的元素
fruits = ['apple', 'banana', 'cherry']
for index, item in enumerate(fruits):
    print(index, item)

在这个例子中，程序使用enumerate()函数枚举列表fruits中的元素。在for循环中，使用enumerate()函数将列表中的每个元素转换为一个元组，元组中包含了元素的索引和值。程序使用print()函数输出每个元组中的索引和值。

当程序运行时，它会输出以下结果：

0 apple
1 banana
2 cherry

除了在for循环中使用enumerate()函数，enumerate()函数还可以在列表推导式、字典推导式、生成器表达式等语句中使用。

总之，enumerate()函数是一种内置函数，用于将一个可迭代对象转换为一个枚举对象，枚举对象中包含了可迭代对象中的每个元素的索引和值。enumerate()函数可以在for循环、列表推导式、字典推导式、生成器表达式等语句中使用。

3.3.11zip（）函数和循环

在Python中，zip()函数是一种内置函数，用于将多个可迭代对象（如列表、元组或字符串）合并成一个元组列表，其中每个元组包含了来自每个可迭代对象的相应位置的元素。如果不同的可迭代对象的长度不同，zip()函数会按照最短的可迭代对象的长度进行合并。

zip()函数的语法格式如下：

zip(*iterables)

其中，iterables是一个或多个可迭代对象，可以是列表、元组或字符串。

以下是一个使用zip()函数的示例：

# 使用zip()函数合并两个列表
numbers = [1, 2, 3]
letters = ['a', 'b', 'c']
result = list(zip(numbers, letters))
print(result)

在这个例子中，程序使用zip()函数将两个列表numbers和letters合并成一个元组列表。使用list()函数将返回的迭代器转换为列表，然后使用print()函数输出结果。

当程序运行时，它会输出以下结果：

[(1, 'a'), (2, 'b'), (3, 'c')]

除了在列表中使用zip()函数，zip()函数还可以在元组、字符串、集合等可迭代对象中使用。

需要注意的是，zip()函数返回的是一个迭代器，如果需要使用其它类型的对象，需要使用list()函数或转换成其它可迭代对象。

总之，zip()函数是一种内置函数，用于将多个可迭代对象合并成一个元组列表，其中每个元组包含了来自每个可迭代对象的相应位置的元素。zip()函数可以在列表、元组、字符串、集合等可迭代对象中使用。

x = [1,2,3]
y = [4,5,6]
zip(x,y)
list(zip(x,y))
a,b = zip(*zip(x,y))
a,b

这段代码的作用是将两个列表 x 和 y 中的元素逐一配对成为元组，返回一个 zip 对象。第二行代码将 zip 对象转换为一个元组列表。第三行代码使用了比较高级的技巧，它先将 x 和 y 中的元素逐一配对成元组，然后使用 * 运算符将元组拆分成多个参数，传递给 zip 函数。这将导致 zip 函数返回一个新的 zip 对象，其中的元组被重新排列，使得所有来自第一个参数的元素都放在了一个元组中，来自第二个参数的元素也一样。最后，这些新的元组被赋值给了变量 a 和 b，并被输出显示。因此，最终的输出结果是，变量 a 中包含了列表 x 中的所有元素，变量 b 中包含了列表 y 中的所有元素。

3.3.12 map()函数和循环

map() 函数是 Python 内置的高阶函数之一，它的作用是将一个函数应用于一个或多个可迭代对象中的每个元素，返回一个新的可迭代对象，其中包含了所有被该函数处理过的元素。

map() 函数的基本语法如下：

map(function, iterable, ...)

其中，function 是一个函数对象，iterable 是一个可迭代对象，可以传入多个可迭代对象，这些可迭代对象的长度必须相等。

下面是一个简单的例子，将一个列表中的元素加 1 并放到一个新的列表中：

def add_one(x):
    return x + 1

numbers = [1, 2, 3, 4, 5]
new_numbers = list(map(add_one, numbers))
print(new_numbers)

输出结果为：

[2, 3, 4, 5, 6]

在这个例子中，我们定义了一个函数 add_one(x)，它将一个整数加 1 并返回结果。然后，我们创建了一个列表 numbers，其中包含了一些整数。我们使用 map() 函数将 add_one() 函数应用于 numbers 列表中的每个元素，并将结果存储在一个新的列表 new_numbers 中。最后，我们使用 print() 函数打印出 new_numbers，它包含了所有被 add_one() 函数处理过的元素。

map() 函数的使用非常灵活，可以用于各种场景中。它可以处理多个可迭代对象，并且可以使用匿名函数等方式来快速定义需要处理的函数。

案例使用嵌套循环实现图像处理算法

使用Pythond的Pillow库中PIL。Image模块的Image类的方法getpixel（）和putpixel（）来读取和修改特定位置（loc）处的像素的颜色值（pix），然后使用嵌套循环实现图像处理的基本算法

下面是使用 Pillow 库中 PIL.Image 模块的 getpixel() 和 putpixel() 方法读取和修改特定位置处像素的颜色值，以及使用嵌套循环实现图像处理的基本算法的一个例子：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ruP07crJ-1686327531638)(C:\Users\29363\Desktop\笔记\python\img\rebecca1.png)]

from PIL import Image

# 打开一张图片
img = Image.open("example.jpg")

# 获取图片的宽度和高度
width, height = img.size

# 遍历图片的每个像素
for x in range(width):
    for y in range(height):
        # 获取当前像素的颜色值
        r, g, b = img.getpixel((x, y))

        # 将颜色值进行一些处理
        r = 255 - r
        g = 255 - g
        b = 255 - b

        # 将修改后的颜色值重新写入到图像中
        img.putpixel((x, y), (r, g, b))

# 保存处理后的图像
img.save("processed.jpg")

import matplotlib.pyplot as plt 
plt.imshow(img)
plt.show()

在这里插入图片描述

在上面的代码中，我们首先使用 PIL.Image 模块的 open() 方法打开一张图片，然后使用 getpixel() 方法获取指定位置的像素颜色值，并使用 putpixel() 方法将修改后的颜色值写回到图像中。这里我们将每个像素的 RGB 值都取反，实现了一个简单的反色处理。

# 获取当前像素的颜色值
    r, g, b = img.getpixel((x, y))

    # 将颜色值进行一些处理
    r = 255 - r
    g = 255 - g
    b = 255 - b

    # 将修改后的颜色值重新写入到图像中
    img.putpixel((x, y), (r, g, b))

保存处理后的图像

img.save(“processed.jpg”)

import matplotlib.pyplot as plt
plt.imshow(img)
plt.show()


![在这里插入图片描述](https://img-blog.csdnimg.cn/87eea37fb62e4302921ab07eab7dde5e.png#pic_center)

在上面的代码中，我们首先使用 PIL.Image 模块的 open() 方法打开一张图片，然后使用 getpixel() 方法获取指定位置的像素颜色值，并使用 putpixel() 方法将修改后的颜色值写回到图像中。这里我们将每个像素的 RGB 值都取反，实现了一个简单的反色处理。

最后，我们使用 save() 方法将处理后的图像保存到磁盘上。

ACTIONTNT

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
3程序流程控制

枚举函数是一种内置函数，用于将一个可迭代对象（如列表、元组或字符串）转换为一个枚举对象，枚举对象中包含了可迭代对象中的每个元素的索引和值。函数是 Python 内置的高阶函数之一，它的作用是将一个函数应用于一个或多个可迭代对象中的每个元素，返回一个新的可迭代对象，其中包含了所有被该函数处理过的元素。在Python中，死循环是一种循环结构，其循环条件永远为真，导致程序一直在循环中执行，无法跳出循环。函数是一种内置函数，用于将一个可迭代对象转换为一个枚举对象，枚举对象中包含了可迭代对象中的每个元素的索引和值。
复制链接

扫一扫