遍历

在Python中，遍历（Traversal）是指按顺序访问数据结构（如列表、元组、字典、集合或字符串等）中的每一个元素，并对它们执行某种操作的过程。Python提供了多种遍历数据结构的方法，包括使用for循环、while循环、列表推导式、生成器表达式以及迭代器等。但最常见和直接的遍历方式是使用for循环。

那么接下来我们来介绍一下数据容器的遍历：

直接遍历

nun_list = [1,5,6.7,10,19,27]
#遍历列表
for i in nun_list:
    print(i,end=" ")
#本身不输入end=""，输出结果本身具有换行"\n"效果，改变end中的输入就会取代"\n"换行效果
    #比如输入空格，输出之间插入空格
------------------------------
输出结果：
1 5 6.7 10 19 27

索引遍历

有序的数据容器才可以使用索引遍历，比如list列表、tuple元组

list列表

#列表
nun_list = [1,5,6.7,10,19,27]
for i in range(len(nun_list)):		#取出列表的长度，在长度范围内遍历循环，否则会索引越界哦
    print(nun_list[i])
------------------------------
输出结果：
1
5
6.7
10
19
27

tuple元组

num_tuple = (12,15,23,34,47,56)
#元组
for i in range(len(num_tuple)):		#取出元组的长度，在长度范围内遍历循环，否则会索引越界哦
    print(num_tuple[i])
-----------------------------
输出结果：
12
15
23
34
47
56

字典遍历

列表和元组可以通过索引遍历，那么字典如何遍历呢？

get（）方法

通过找到健(key)来获取值（value）。而get（）方法可以通过健获取值。

num_dict = {1:2,5:9,"a":"b",(1,2):[6,7]}
#字典的遍历
for k in num_dict.keys():	#遍历字典的健
    print(k,num_dict.get(k))	#通过健得到值将它输出
--------------------------
输出结果：
1 2
5 9
a b
(1, 2) [6, 7]

items()方法

字典的items()方法是一个非常有用的功能，它返回字典中所有（键，值）对的视图对象，这个视图对象显示字典中的每一项。

num_dict = {1:2,5:9,"a":"b",(1,2):[6,7]}
# 通过items返回的二元组去接收返回值 然后用两个变量去接收二元组内的值
for k,v in num_dict.items():
    print(k,v)
-------------------------------
1 2
5 9
a b
(1, 2) [6, 7]

enumerate()函数与zip()函数

针对元组和列表！！

enumerate()函数

在Python中，enumerate()函数函数是一个非常有用的内置函数，它用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。这意味着，通过enumerate()函数，你可以获取到每个元素的索引（或位置）以及该元素的值。

故此，我们可以通过enumerate()函数来进行遍历操作，并且能将可遍历的数据对象的索引位置和对应元素同时取出：

num_tuple = (12,15,23,34,47,56)
# 元组和列表，因为索引
# 同时取出 列表或元组的 索引和值
for ind,val in enumerate(num_tuple):
    print(ind,val)
---------------------------
输出结果：
0 12
1 15
2 23
3 34
4 47
5 56

zip()函数

可将列表和元组同时遍历输出。

nun_list = [1,5,6.7,10,19,27]
num_tuple = (12,15,23,34,47,56)
# 同时遍历列表和元组
for li,tup in zip(nun_list,num_tuple):
    print(li,tup)
----------------------------
输出结果：
1 12
5 15
6.7 23
10 34
19 47
27 56

列表生成式

在Python中，列表生成式（List Comprehension）是一种简洁而强大的方式来创建列表。它允许你从已有的列表或任何可迭代对象中通过表达式来生成新的列表。列表生成式比使用循环（如for循环）来生成列表的代码更加简洁易读。

语法表现形式

[expression for item in iterable]

或者，带有条件的列表生成式：

[expression for item in iterable if condition]

这里，expression是对 iterable （可迭代对象，如列表、元组、字符串、集合等）中的每个item执行的表达式，其结果将被用于生成新的列表。

编写

我们来尝试编写下面几个内容：

基本的列表生成式

1. 正常我们如何生成一个十以内的列表呢？可以通过for循环遍历得到的对吧，比如：

a = []	#定义一个空列表
for i in range(10):		#遍历0~10的数字，左闭右开哦
    a.append(i)	#将遍历得到的值放进列表中存放、
print(a)
-------------------------
输出结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

那么这样的列表我们如何通过列表生成式生成呢？记住：

“expression是对 iterable （可迭代对象，如列表、元组、字符串、集合等）中的每个item执行的表达式”

编写：

[expression for item in iterable]

b = [i for i in range(10)]
print(b)
-------------
输出结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

带有条件的列表生成式

2. 生成10以内的偶数

先用for循环遍历生成列表试试：

c = []
for i in range(10):
    if i % 2 == 0:
        c.append(i)
print(c)
---------------------
输出结果：
[0, 2, 4, 6, 8]

如何将上述的代码用列表生成式表示呢？

[expression for item in iterable if condition]

d = [i for i in range(10) if i % 2 == 0]
print(d)
-------------
输出结果：
[0, 2, 4, 6, 8]

嵌套列表生成式

接下来我们尝试一个复杂的：

字符串与列表之间的转换

在编写之前呢，我们先了解一下，字符串与列表之间的转换：

# 字符串和列表之间的转换
strs = "abcd"
str_list = list(strs)
print(list(strs))

# 字符列表怎么转成一个字符串
#join() 方法是一个字符串方法，用于将序列中的元素以指定的字符连接生成一个新的字符串。
print("\n".join(str_list))
--------------------------------
输出结果：
['a', 'b', 'c', 'd']
a
b
c
d

接下来让我们试试：

3. 生成99乘法表

我们还是先用正常方法编写：

# 生成99乘法表
nine = []
for i in range(1,10):
    num = []
    for j in range(1,i+1):
        num.append(f"{i} * {j} = {i * j}")		# 在Python中，f""是一种在字符串中嵌入表达式的简便方式。
												# 它允许你在字符串中直接包含变量的值或表达式的结果
    nine.append(num)
print(nine)

输出结果：

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

哦吼，我们发现这有两个for循环在里面，这该怎么转成列表生成式呢？

我们一步一步来，先将里面的for循环转成列表生成式：

nine = []
for i in range(1, 10):
    num = [f"{i} * {j} = {i * j}" for j in range(1, i + 1)]
    nine.append("\t".join(num))
print(nine)

接下来我们再将外面的for循环转成列表生成式：

ninenine = "\n".join(["\t".join([f"{j} * {i} = {i * j}" for j in range(1, i + 1)]) for i in range(1, 10)])
#上述代码实现输出很乱，我们进行一下优化
#转义字符.join()实现换行和制表，使输出结果优化完美
print(ninenine)		

输出结果：

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

总结

本篇我们介绍了：

遍历：

1. 直接遍历
2. 针对有序的list列表和tuple元组的索引遍历，以及enumerate()函数与zip()函数
   1. enumerate()函数：将遍历对象的索引位置和对应的元素同时遍历出来
   2. zip()函数：同时遍历列表和元组
3. 字典遍历时使用的get（）方法和items()方法
   1. get（）方法：通过找到健(key)来获取值（value）
   2. items()方法：通过items返回的二元组去接收返回值 然后用两个变量去接收二元组内的值

列表生成式

1. 基本的列表生成式：表现形式：

[expression for item in iterable]

2. 带有条件的列表生成式、嵌套列表生成式：表现形式：

[expression for item in iterable if condition]

3. 字符串与列表之间的转换:字符列表转成一个字符串使用join()方法。