推荐|Python-VBA函数之旅-range函数

一、range函数的常见应用场景

二、range函数使用注意事项

三、如何用好range函数？

1、range函数：

1-1、Python：

1-2、VBA：

一、range函数的常见应用场景

range函数在Python编程中有广泛的应用场景，因为它为迭代提供了方便的方式，特别是在需要生成一系列连续整数时，常见的应用场景有：

1、循环遍历固定次数的操作：当你需要执行某个操作固定次数时，可以使用range()函数来生成一个数字序列，并在循环中遍历这个序列。

2、索引访问列表/元组/字符串：虽然range()函数本身不直接支持索引，但结合len()函数和列表解析等，可以轻松地对列表/元组/字符串等进行索引操作。

3、生成步进序列：当需要生成一个步长不为1的序列时，可以使用range()函数的第三个参数，这在创建图形、处理数组或矩阵时特别有用。

4、创建数字列表：通过结合list()函数和range()函数，可以轻松创建数字列表。

5、随机选择或打乱顺序：虽然range()函数本身不直接用于随机选择或打乱顺序，但结合其他库(如random)可以很容易地实现这些功能。

6、数学计算：在需要进行数学计算，如求和、求积或计算某个数学公式在不同整数点上的值时，range()函数可以生成所需的整数序列。

7、生成器表达式和列表解析：range()函数常与生成器表达式(generator expressions)和列表解析(list comprehensions)一起使用，以简洁的方式处理数据。

8、图形和动画：在创建图形或动画时，range()函数可以生成坐标点或时间步长。

9、算法和数据结构：在实现各种算法和数据结构时，range()函数可以用于初始化数组、遍历数据结构或模拟算法的执行步骤。

10、科学计算和数据分析：在科学计算和数据分析中，经常需要迭代一组连续的整数或浮点数，虽然numpy等库提供了更高效的数组和矩阵操作，但range()函数在处理简单迭代时仍然很有用。

总之，range()函数是Python编程中非常实用的一个工具，它简化了对连续数字序列的处理和操作。

二、range函数使用注意事项

在使用Python中的range()函数时，需牢记以下事项：

1、不包括结束值：range()函数生成的序列是左闭右开的，即它会包含起始值，但不包含结束值，这意味着range(1, 5)将生成序列[1, 2, 3, 4]，而不是[1, 2, 3, 4, 5]。

2、步长可以是负数：虽然range()函数通常用于生成递增序列，但你也可以使用负数作为步长来生成递减序列。例如，range(5, 0, -1)将生成序列[5, 4, 3, 2, 1]。

3、不支持直接索引：range()函数返回的是一个可迭代对象，而不是列表或数组，这意味着你不能像使用列表那样直接通过索引访问range()对象中的元素；如果你需要索引访问，可以将range()对象转换为列表或其他序列类型。

4、内存效率：由于range()对象是可迭代的，它不会一次性生成整个序列并存储在内存中，这使得range()在处理大数据集时非常高效，因为它按需生成值，而不是预先生成所有值，然而，如果你需要将range()对象转换为列表或其他序列类型，则需要注意内存使用情况。

5、Python 2和Python 3的差异：在Python 2中，range()函数返回的是一个列表，而在Python 3中，它返回的是一个范围对象(range object)，这种变化使得Python 3在处理大数据集时更加内存高效，如果你在使用Python 2并且希望获得与Python 3相似的内存效率，可以考虑使用xrange()函数(注意：在Python 3中，xrange()已被移除，并被range()取代)。

6、避免不必要的转换：如果你只是需要迭代range()对象中的值，而不需要将它们存储在一个列表中，那么就没有必要将range()对象转换为列表，直接迭代range()对象更加高效。

7、步长不能为0：range()函数的步长参数不能为0，因为这会导致无限循环，如果你尝试使用0作为步长，Python将抛出一个ValueError异常。

8、避免在循环中修改索引：虽然Python允许你在循环中修改循环变量(如i)，但在使用range()函数的循环中，这通常是没有意义的，因为range()生成的序列是不可变的，修改循环变量不会影响下一次迭代中的值。

9、注意循环的边界条件：在使用range()函数时，确保你理解了循环的边界条件，如果你不小心设置了错误的起始值、终止值或步长，可能会导致循环不执行、执行次数太少或太多。

三、如何用好range函数？

为了充分利用Python中的range()函数，请你遵循以下建议：

1、理解参数：确保你清楚range()函数的三个参数：start(起始值，默认为0)，stop(终止值，不包括在内)和step(步长，默认为1)。

2、简洁的循环：使用range()函数可以简洁地编写循环，而无需手动创建数字列表。

3、步长迭代：利用步长参数step来迭代跳过某些值或反向迭代。

4、转换为列表：如果你需要操作整个序列，或者需要多次迭代它，可以将range()对象转换为列表。

5、避免在循环中修改索引：尽管技术上你可以在循环中修改循环变量(如i)，但这通常是不必要的，因为range()函数生成的序列是不可变的。

6、使用切片：虽然range()对象本身不支持切片，但你可以将其转换为列表后再进行切片操作。

7、数学运算：结合sum()、min()、max()等内置函数，对range()生成的序列进行数学运算。

8、避免不必要的转换：如果你不需要整个序列，那么就没有必要将其转换为列表，直接使用range()对象进行迭代更加内存友好。

9、与其他序列类型结合使用：你可以使用range()函数生成的索引来访问列表、元组或其他序列类型的元素。

10、理解range()与xrange()的区别(Python 2)：如果你正在使用Python 2，请注意range()函数会生成一个列表，而xrange()会生成一个类似迭代器的对象，更加节省内存；在Python 3中，range()的功能与Python 2中的xrange()相同。

11、利用列表推导式(List Comprehensions)：虽然这不是直接使用range()，但你可以结合使用列表推导式和range()来创建更复杂的列表。

12、文档和示例：经常查阅Python官方文档，以及查找和阅读使用range()函数的示例代码，这有助于你更好地理解其用法和最佳实践。

1、range函数：

1-1、Python：


# 1.函数：range
# 2.功能：用于生成一个新的range类型，多用于for循环语句中，用于生成指定范围的整数
# 3.语法：
# 3-1、range(stop)
# 3-2、range(start, stop)
# 3-3、range(start, stop[, step])
# 4.参数：
# 4-1、start：表示起始整数(包括起始整数)，默认起始值为0，起始整数可以省略，若省略，则默认从0开始
# 4-2、stop：表示结束整数(但不包括结束整数)，结束整数不能省略
# 4-3、step：表示步长，即两个数之间的间隔，如果省略step参数，则默认步长为1
# 5.返回值：返回的是一个不可变的序列类型，但它本身并不是列表，而是一个range对象
# 6.说明：
# 6-1、参数stop可以大于0，也可以小于或等于0，但是当stop参数小于或等于0时，生成的range对象是不包含任何元素的
# 6-2、range()函数接收的参数必须是整数，不能是浮点数等其他数据类型，否则会提示类型错误
# 6-3、在使用range()函数时，如果只有1个参数，那么表示指定得是stop结束整数；如果是两个参数，则表示指定得是start起始整数和stop结束整数；只有3个参数都存在，最后一个参数才表示step步长
# 7.示例：
# 用dir()函数获取该函数内置的属性和方法
print(dir(range))
# ['__bool__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
# '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__',
# '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__',
# '__sizeof__', '__str__', '__subclasshook__', 'count', 'index', 'start', 'step', 'stop']
 
# 用help()函数获取该函数的文档信息
help(range)
 
# 应用一：循环遍历固定次数的操作
# 示例1：打印从0到4的数字
for i in range(5):
    print(i)
# 0
# 1
# 2
# 3
# 4
 
# 示例2：遍历一个列表并打印其索引和值
my_list = ['apple', 'banana', 'cherry']
for index in range(len(my_list)):
    print(f"Index: {index}, Value: {my_list[index]}")
# Index: 0, Value: apple
# Index: 1, Value: banana
# Index: 2, Value: cherry
 
# 示例3：使用range()生成一个包含奇数的列表
odd_numbers = [i for i in range(1, 10, 2)]
print(odd_numbers)
# [1, 3, 5, 7, 9]
 
# 示例4：使用range()进行固定次数的操作(例如，重复一个操作10次)
for _ in range(10):  # 使用 _ 作为循环变量，因为我们不关心它的具体值
    # 这里放你想要重复的操作
    print("This operation is repeated 10 times.")
# This operation is repeated 10 times.
# This operation is repeated 10 times.
# This operation is repeated 10 times.
# This operation is repeated 10 times.
# This operation is repeated 10 times.
# This operation is repeated 10 times.
# This operation is repeated 10 times.
# This operation is repeated 10 times.
# This operation is repeated 10 times.
# This operation is repeated 10 times.
 
# 示例5：从10倒数到1(包括1和10)
for i in range(10, 0, -1):  # 从10开始，到0(不包括)，步长为-1
    print(i)
# 10
# 9
# 8
# 7
# 6
# 5
# 4
# 3
# 2
# 1
 
# 应用二：索引访问列表/元组/字符串
# 示例1：访问列表的元素
my_list = ['apple', 'banana', 'cherry', 'date', 'elderberry']
# 使用range()和len()来遍历列表的索引
for index in range(len(my_list)):
    print(f"Index {index}: {my_list[index]}")
# Index 0: apple
# Index 1: banana
# Index 2: cherry
# Index 3: date
# Index 4: elderberry
 
# 示例2：访问元组的元素
my_tuple = ('apple', 'banana', 'cherry')
# 直接使用range()和已知的长度来遍历元组的索引
for index in range(len(my_tuple)):
    print(f"Index {index}: {my_tuple[index]}")
# Index 0: apple
# Index 1: banana
# Index 2: cherry
 
# 示例3：访问字符串的字符(索引)
my_string = "myelsa"
# 使用range()和len()来遍历字符串的索引
for index in range(len(my_string)):
    print(f"Index {index}: {my_string[index]}")
# Index 0: m
# Index 1: y
# Index 2: e
# Index 3: l
# Index 4: s
# Index 5: a
 
# 示例4：使用enumerate()函数(range()函数的替代方案，更简洁高效)
my_list = ['apple', 'banana', 'cherry']
# 使用enumerate()来遍历列表的索引和值
for index, value in enumerate(my_list):
    print(f"Index {index}: {value}")
my_tuple = ('apple', 'banana', 'cherry')
# 类似地，使用enumerate()来遍历元组
for index, value in enumerate(my_tuple):
    print(f"Index {index}: {value}")
my_string = "hello"
# 对于字符串，enumerate()仍然适用
for index, char in enumerate(my_string):
    print(f"Index {index}: {char}")
# Index 0: apple
# Index 1: banana
# Index 2: cherry
# Index 0: apple
# Index 1: banana
# Index 2: cherry
# Index 0: h
# Index 1: e
# Index 2: l
# Index 3: l
# Index 4: o
 
# 应用三：生成步进序列
# 示例1：生成从0开始，步长为2的序列，直到但不包括10
# 使用range(start, stop, step)的形式
for i in range(0, 10, 2):
    print(i)
# 0
# 2
# 4
# 6
# 8
 
# 示例2：生成从5开始，步长为3的序列，直到但不包括20
for i in range(5, 20, 3):
    print(i)
# 5
# 8
# 11
# 14
# 17
 
# 示例3：生成从5开始，步长为-1的序列，直到但不包括0
# 这是一个递减的步进序列
for i in range(5, 0, -1):
    print(i)
# 5
# 4
# 3
# 2
# 1
 
# 示例4：使用列表推导式生成步进序列的列表
# 生成一个包含从0到18之间所有偶数的列表
even_numbers = [i for i in range(0, 19, 2)]
print(even_numbers)
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
 
# 示例5：生成一个包含负数的步进序列，并计算其平方
# 生成一个包含从-5到5之间(包括-5但不包括5)所有奇数的序列，并计算它们的平方
for i in range(-5, 5, 2):
    square = i ** 2
    print(f"{i} 的平方是 {square}")
# -5 的平方是 25
# -3 的平方是 9
# -1 的平方是 1
# 1 的平方是 1
# 3 的平方是 9
 
# 应用四：创建数字列表
# 示例1：创建一个从0到4的数字列表
# 使用列表推导式
numbers = [i for i in range(5)]
print(numbers)
# 或者使用list()函数
numbers = list(range(5))
print(numbers)
# [0, 1, 2, 3, 4]
# [0, 1, 2, 3, 4]
 
# 示例2：创建一个从1到10的数字列表(包含10)
numbers = [i for i in range(1, 11)]
print(numbers)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
# 示例3：创建一个从10到0的递减数字列表
numbers = [i for i in range(10, -1, -1)]
print(numbers)
# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
 
# 示例4：创建一个步长为2的数字列表
numbers = [i for i in range(0, 10, 2)]
print(numbers)
# [0, 2, 4, 6, 8]
 
# 示例5：创建一个包含特定范围内偶数的列表
# 例如，包含2到18之间的所有偶数
numbers = [i for i in range(2, 19, 2)]
print(numbers)
# [2, 4, 6, 8, 10, 12, 14, 16, 18]
 
# 应用五：随机选择或打乱顺序
# 示例1：从列表中随机选择一个元素
import random
# 假设我们有一个列表
my_list = [1, 2, 3, 4, 5]
# 使用random.choice从列表中随机选择一个元素
random_element = random.choice(my_list)
print(random_element)  # 输出可能是列表中的任何一个元素
 
# 示例2：打乱列表的顺序(随机排序)
import random
# 假设我们有一个列表
my_list = [1, 2, 3, 4, 5]
# 使用random.shuffle打乱列表的顺序
random.shuffle(my_list)
print(my_list)  # 输出是一个被打乱顺序的列表
 
# 示例3：从range()生成的数字中随机选择一个
import random
# 使用range()生成一个数字范围
numbers = list(range(1, 11))  # 创建一个包含 1 到 10 的列表
# 从这个列表中随机选择一个元素
random_number = random.choice(numbers)
print(random_number)  # 输出可能是1到10之间的任何一个数字
 
# 示例4：打乱由range()生成的数字列表的顺序
import random
# 使用range()生成一个数字范围，并转换为列表
numbers = list(range(1, 11))  # 创建一个包含1到10的列表
# 打乱这个列表的顺序
random.shuffle(numbers)
print(numbers)  # 输出是一个被打乱顺序的列表，包含1到10的数字
 
# 应用六：数学计算
# 示例1：计算数字列表的和
total = 0
for i in range(1, 6):  # 迭代从1到5的数字
    total += i  # 将每个数字加到total上
print("1到5的和是:", total)
# 1到5的和是: 15
 
# 示例2：计算数字列表的平方和
total = 0
for i in range(1, 6):  # 迭代从1到5的数字
    total += i ** 2  # 将每个数字的平方加到total上
print("1到5的平方和是:", total)
# 1到5的平方和是: 55
 
# 示例3：计算阶乘
factorial = 1
n = 5
for i in range(1, n + 1):  # 迭代从1到n的数字
    factorial *= i  # 将每个数字乘到factorial上
print(f"{n} 的阶乘是:", factorial)
# 5 的阶乘是: 120
 
# 示例4：计算斐波那契数列的前几项
def fibonacci(n):
    a, b = 0, 1
    fib_sequence = [a]
    for _ in range(n):
        a, b = b, a + b
        fib_sequence.append(b)
    return fib_sequence
print(fibonacci(10))  # 打印斐波那契数列的前10项
# [0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
 
# 示例5：使用range()进行数学模拟(例如计算抛硬币正面朝上的次数)
import random
num_trials = 100  # 抛硬币的次数
num_heads = 0  # 正面朝上的次数
for _ in range(num_trials):
    if random.choice(['heads', 'tails']) == 'heads':
        num_heads += 1
print(f"抛了 {num_trials} 次硬币，正面朝上的次数是: {num_heads}")
# 抛了 100 次硬币，正面朝上的次数是: 53
 
# 应用七：生成器表达式和列表解析
# 示例1：使用生成器表达式
# 生成器表达式，用于生成0到9的平方
squares = (i ** 2 for i in range(10))
# 遍历生成器并打印结果
for square in squares:
    print(square)
# 0
# 1
# 4
# 9
# 16
# 25
# 36
# 49
# 64
# 81
 
# 示例2：使用列表解析
# 列表解析，用于生成0到9的平方列表
squares = [i ** 2 for i in range(10)]
# 打印列表
print(squares)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 
# 示例3：带有条件的列表解析
# 列表解析，用于生成0到19之间所有偶数的平方列表
even_squares = [i ** 2 for i in range(20) if i % 2 == 0]
# 打印列表
print(even_squares)
# [0, 4, 16, 36, 64, 100, 144, 196, 256, 324]
 
# 示例4：使用range()的步长与列表解析
# 列表解析，用于生成从10开始，步长为3，到31结束的数字列表
numbers = [i for i in range(10, 32, 3)]
# 打印列表
print(numbers)
# [10, 13, 16, 19, 22, 25, 28, 31]
 
# 示例5：结合range()和str.format()使用列表解析
# 列表解析，用于生成一个字符串列表，其中包含从1到5的数字的字符串表示形式，格式为 'Number: X'
strings = ['Number: {}'.format(i) for i in range(1, 6)]
# 打印列表
print(strings)
# ['Number: 1', 'Number: 2', 'Number: 3', 'Number: 4', 'Number: 5']
 
# 应用八：图形和动画
# 示例1：使用matplotlib绘制一个简单的正弦波
import matplotlib.pyplot as plt
import numpy as np
# 使用 numpy 的 linspace 来生成更平滑的数据点(类似于range的连续版本)
x = np.linspace(0, 2 * np.pi, 100)  # 类似于range(0, int(2*np.pi*100), 1)但更平滑
y = np.sin(x)
# 绘制图形
plt.plot(x, y)
plt.title('Simple Sine Wave')
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.grid(True)
plt.show()
 
# 示例2：使用matplotlib.animation创建一个简单的动画
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
fig, ax = plt.subplots()
# 初始化数据
xdata, ydata = [], []
ln, = plt.plot([], [], 'ro')
def init():
    ax.set_xlim(0, 2 * np.pi)
    ax.set_ylim(-1, 1)
    return ln,
def update(frame):
    xdata.append(frame / 100)  # 使用类似于range的效果，但这里是连续的
    ydata.append(np.sin(frame / 100))
    ln.set_data(xdata, ydata)
    return ln,
# 创建一个动画对象，每帧更新一次数据
ani = animation.FuncAnimation(fig, update, frames=np.linspace(0, 2 * np.pi, 128),
                              init_func=init, blit=True)
# 显示动画
plt.show()
 
# 应用九：算法和数据结构
# 示例1：使用二分查找算法
def binary_search(arr, target):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1
# 假设我们有一个已排序的数组
arr = [2, 3, 4, 10, 40]
target = 10
# 使用 range 来模拟数组索引的迭代
for i in range(len(arr)):
    # 这里只是为了演示，实际上我们不会这样遍历数组进行二分查找
    print(f"Current index: {i}, Value: {arr[i]}")
# 使用二分查找算法查找目标值
result = binary_search(arr, target)
print(f"Target {target} found at index {result} if result != -1 else 'not found'.")
# Current index: 0, Value: 2
# Current index: 1, Value: 3
# Current index: 2, Value: 4
# Current index: 3, Value: 10
# Current index: 4, Value: 40
# Target 10 found at index 3 if result != -1 else 'not found'.
 
# 示例2：实现简单的冒泡排序算法
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):  # 最后一个元素已经是最大的，不需要再比较
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]  # 交换元素
# 示例数组
arr = [64, 34, 25, 12, 22, 11, 90]
print("Original array is:", arr)
# 对数组进行冒泡排序
bubble_sort(arr)
print("Sorted array is:", arr)
# Original array is: [64, 34, 25, 12, 22, 11, 90]
# Sorted array is: [11, 12, 22, 25, 34, 64, 90]
 
# 示例3：使用动态规划解决斐波那契数列问题
def fibonacci(n):
    if n <= 1:
        return n
    dp = [0] * (n + 1)
    dp[0], dp[1] = 0, 1
    for i in range(2, n + 1):
        dp[i] = dp[i - 1] + dp[i - 2]
    return dp[n]
# 示例：计算斐波那契数列的第168项
print(fibonacci(168))
# 57602132235424755886206198685365216
 
# 示例4：使用栈实现逆序列表
class Stack:
    def __init__(self):
        self.stack = []
    def push(self, item):
        self.stack.append(item)
    def pop(self):
        if not self.is_empty():
            return self.stack.pop()
        return None
    def is_empty(self):
        return len(self.stack) == 0
# 使用栈逆序列表
def reverse_list_using_stack(lst):
    stack = Stack()
    for item in lst:
        stack.push(item)
    reversed_lst = []
    while not stack.is_empty():
        reversed_lst.append(stack.pop())
    return reversed_lst
# 示例列表
lst = [1, 2, 3, 4, 5]
print("Original list:", lst)
reversed_lst = reverse_list_using_stack(lst)
print("Reversed list:", reversed_lst)
# Original list: [1, 2, 3, 4, 5]
# Reversed list: [5, 4, 3, 2, 1]
 
# 应用十：科学计算和数据分析
# 示例1：计算数列和
# 计算从1到n的自然数之和
def sum_of_series(n):
    total = 0
    for i in range(1, n + 1):
        total += i
    return total
# 示例
n = 10
print(f"The sum of numbers from 1 to {n} is {sum_of_series(n)}")
# The sum of numbers from 1 to 10 is 55
 
# 示例2：使用NumPy进行数组操作
import numpy as np
# 创建一个从0到9的数组
arr = np.arange(10)
# 计算每个元素的平方
squared_arr = arr ** 2
print(squared_arr)
# [ 0  1  4  9 16 25 36 49 64 81]
 
# 示例3：计算数列的平均值
# 使用range生成数列，并计算平均值
def average_of_series(n):
    total = sum(range(1, n + 1))
    return total / n
# 示例
n = 10
print(f"The average of numbers from 1 to {n} is {average_of_series(n)}")
# The average of numbers from 1 to 10 is 5.5
 
# 示例4：使用Pandas进行数据分析
import pandas as pd
# 使用range生成索引和列名
index = range(1, 6)  # 索引从1到5
columns = ['A', 'B', 'C']
# 创建一个示例数据帧
data = {'A': [1, 2, 3, 4, 5],
        'B': [10, 20, 30, 40, 50],
        'C': [100, 200, 300, 400, 500]}
df = pd.DataFrame(data, index=index)
# 显示数据帧
print(df)
# 使用range迭代数据帧的行
for i in range(len(df)):
    row = df.iloc[i]
    print(f"Row {i + 1}: {row.values}")
#    A   B    C
# 1  1  10  100
# 2  2  20  200
# 3  3  30  300
# 4  4  40  400
# 5  5  50  500
# Row 1: [  1  10 100]
# Row 2: [  2  20 200]
# Row 3: [  3  30 300]
# Row 4: [  4  40 400]
# Row 5: [  5  50 500]
 
# 示例5：在图形中标记数据点
import matplotlib.pyplot as plt
# 假设我们有一些x和y数据点
x = [1, 2, 3, 4, 5]
y = [1, 4, 9, 16, 25]
# 绘制散点图
plt.scatter(x, y)
# 使用range生成标签并添加到图中
for i in range(len(x)):
    plt.text(x[i], y[i], f'({x[i]}, {y[i]})', ha='center', va='bottom')
plt.show()

1-2、VBA：

略，待后补。

2、推荐阅读：

2-1、Python-VBA函数之旅-property()函数

Python算法之旅：Algorithm

Python函数之旅：Functions

个人主页：https://blog.csdn.net/ygb_1024?spm=1010.2135.3001.5421

文章知识点与官方知识档案匹配，可进一步学习相关知识

算法技能树首页概览61139 人正在系统学习中

遨游码海，我心飞扬

微信名片