Python-VBA函数之旅-reversed函数

目录

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

二、reversed函数使用注意事项

三、如何用好reversed函数？

1、reversed函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

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

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

        reversed函数在Python中有多种实际应用场景，它使得在处理序列时能够灵活地反向迭代元素，常见的应用场景有：

1、序列反转：当你需要反向打印一个列表、元组或字符串中的元素时，可以使用reversed()函数配合循环或字符串的join()方法。

2、与生成器表达式结合： 你可以将reversed()函数与生成器表达式结合使用，以在迭代过程中实时反转序列的一部分。

3、图形和图像处理：在图形和图像处理中，reversed()函数可以用于处理像素数组或其他数据结构，以实现各种翻转或镜像效果。

4、与集合操作结合：尽管集合本身是无序的，但你可以先将集合转换为列表，然后反转列表，这在处理某些需要特定顺序的集合操作时可能很有用。

5、算法和数学问题：在解决某些算法和数学问题时，可能需要从后向前遍历序列。例如，在寻找子序列或进行某些类型的数学计算时，可能需要从序列的末尾开始。

6、与内置函数结合：reversed()函数可以与map(), filter(), zip()等内置函数结合使用，以在迭代过程中反转结果。

7、文件路径处理：在处理文件路径时，有时你可能需要反转路径中的部分组件，虽然这不是reversed()函数的直接应用，但你可以使用它来反转路径组件列表，然后重新组合它们。

8、处理栈或队列数据结构：在计算机科学中，栈是一种后进先出(LIFO)的数据结构，而队列是一种先进先出(FIFO)的数据结构。虽然Python没有内建的栈类型，但列表可以模拟栈的行为(使用append()添加元素到末尾，pop()从末尾删除元素)，reversed()函数可以与列表结合使用，以从后向前遍历元素，这在模拟栈的某些操作时可能很有用。

9、与切片结合：虽然切片也可以用来获取序列的反向副本(如lst[::-1])，但在某些情况下，使用reversed()函数可能更加直观或灵活，尤其是当你只需要迭代而不需要实际的反向副本时。

10、与文件操作结合：在处理文件时，你可以使用reversed()函数来反转文件中的行或其他数据块，但这通常需要先将文件内容读入一个列表或类似的数据结构中。

        总之，reversed()函数提供了在Python中处理序列时反向迭代元素的灵活方式，并且可以在多种实际应用场景中使用。

二、reversed函数使用注意事项

        在Python中，reversed()函数是一个内置函数，它返回一个反转的迭代器，这意味着你可以遍历序列(如列表、元组或字符串)的元素，但顺序是相反的，使用reversed()函数时需要注意以下事项：

1、不会修改原始数据：reversed()函数返回的是一个迭代器，它只是提供了一个反向遍历原始数据的方式，并不会修改原始数据。
2、迭代器只能遍历一次：一旦你开始遍历reversed()返回的迭代器，你就不能再次从头开始遍历，因为迭代器是一种消耗型的数据结构，元素在被访问后就会从迭代器中“消失”。
3、适用于序列类型：reversed()函数主要用于序列类型(如列表、元组、字符串等)，对于非序列类型(如集合、字典等)，reversed()函数可能无法正常工作或产生不可预测的结果。
4、内存使用：虽然reversed()函数本身不会显著增加内存使用(因为它只返回一个迭代器)，但如果你将迭代器转换为列表(例如，使用list(reversed(some_list)))，那么将会创建一个新的列表，并可能占用更多的内存。
5、注意循环引用：如果你在创建迭代器后长时间保持对它的引用，并且原始数据也保持活跃(例如，在类实例中)，那么可能会导致循环引用和内存泄漏，但是，这通常不是reversed()函数特有的问题，而是Python中任何涉及迭代器和引用计数的问题。
6、与切片相比：对于列表，你可以使用切片(例如，some_list[::-1])来获取一个反向的列表副本；与reversed()函数相比，切片会立即创建一个新的列表，并消耗更多的内存，然而，切片的结果是一个列表，可以多次遍历，而reversed()函数的结果是一个迭代器，只能遍历一次。
7、与Python 2的xrange()不同：在Python 2中，xrange()函数返回一个类似于迭代器的对象，但它可以反向迭代(尽管这并不是其设计的主要目的)；在Python 3中，range()函数返回的是一个真正的迭代器，并且不能直接反向迭代(但你可以使用reversed(range(start, stop, step)))。
8、与for循环一起使用：reversed()函数经常与for循环一起使用，以反向遍历序列。例如：for i in reversed(some_list): print(i)。

三、如何用好reversed函数？

1、基本用法：

1-1、字符串的反转：

s = "hello"
for char in reversed(s):
    print(char, end="")
# 输出: "olleh"

1-2、列表的反转：

lst = [1, 2, 3, 4, 5]
for num in reversed(lst):
    print(num)
# 输出: 5, 4, 3, 2, 1

1-3、元组的反转：

tup = (1, 2, 3, 4, 5)
for num in reversed(tup):
    print(num)
# 输出: 5, 4, 3, 2, 1

2、高级用法：

2-1、反转字典的键或值(注意：字典本身没有顺序，但你可以反转它的键或值的列表)：

d = {'a': 1, 'b': 2, 'c': 3}
for key in reversed(list(d.keys())):
    print(key, d[key])
# 输出可能是: c 3, b 2, a 1（取决于Python版本和哈希种子）

for value in reversed(sorted(d.values())):
    for key, val in d.items():
        if val == value:
            print(key, value)
            break
# 输出: c 3, b 2, a 1（这次顺序是确定的）

2-2、反转文件行(如果你有一个大文件并且不想一次性加载到内存中)：

with open('large_file.txt', 'r') as file:
    for line in reversed(list(file)):
        print(line.strip())  # strip()用于移除行尾的换行符
# 注意：这会将整个文件加载到内存中，对于大文件可能会导致内存问题
# 对于大文件，你可能需要逐行读取并存储在列表中，然后反转列表

2-3、与其他迭代器结合使用：你可以将reversed()函数与其他迭代器(如range()或其他生成器)结合使用，但通常range()是从低到高生成数字，所以直接使用reversed(range(...))可能不太直观，但你可以创建一个反向的range类似物。

def reverse_range(start, end):
    return reversed(range(end, start - 1, -1))

for num in reverse_range(5, 1):
    print(num)
# 输出: 5, 4, 3, 2

2-4、在列表推导式中使用：虽然直接在列表推导式中使用reversed()可能不太常见，但你可以这样做。

lst = [1, 2, 3, 4, 5]
reversed_lst = [x * 2 for x in reversed(lst)]
print(reversed_lst)  # 输出: [10, 8, 6, 4, 2]

1、reversed函数：

1-1、Python：

# 1.函数：reversed
# 2.功能：用于反转一个序列对象，将其元素从后向前颠倒构建成一个新的迭代器
# 3.语法：reversed(seq)
# 4.参数：seq，表示序列，如列表/元组/字符串/range对象等
# 5.返回值：返回一个反转的迭代器
# 6.说明：反向迭代器只有在待处理对象拥有可确定的大小，并且该对象实现了__reversed__()魔法方法时，才能奏效
# 7.示例：
# 用dir()函数获取该函数内置的属性和方法
print(dir(reversed))
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__',
# '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__length_hint__', '__lt__', '__ne__', '__new__',
# '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__']

# 用help()函数获取该函数的文档信息
help(reversed)

# 应用一：序列反转
# 示例1：字符串反转
s = "myelsa"
reversed_s = ''.join(reversed(s))
print(reversed_s)
# asleym

# 示例2：列表反转
lst = [3, 5, 6, 8, 10, 11, 24]
reversed_lst = list(reversed(lst))
print(reversed_lst)
# [24, 11, 10, 8, 6, 5, 3]

# 示例3：元组反转
tup = (1, 2, 3, 4, 5)
reversed_tup = tuple(reversed(tup))
print(reversed_tup)
# (5, 4, 3, 2, 1)

# 示例4：字典的键或值反转
d = {'a': 1, 'b': 2, 'c': 3}
reversed_keys = list(reversed(list(d.keys())))
print(reversed_keys)  # 输出可能是: ['c', 'b', 'a']（取决于Python版本和哈希种子）
reversed_values = list(reversed(sorted(d.values())))
print(reversed_values)  # 输出: [3, 2, 1]
# ['c', 'b', 'a']
# [3, 2, 1]

# 示例5：文件行反转
with open('test.txt', 'r') as f:
    lines = f.readlines()
reversed_lines = reversed(lines)
for line in reversed_lines:
    print(line.strip())  # 移除行尾的换行符并打印
# 6666
# 5555
# 4444
# 3333
# 2222
# 11111

# 示例6：使用range和reversed创建递减序列
for i in reversed(range(1, 6)):
    print(i)
# 5
# 4
# 3
# 2
# 1

# 示例7：在列表推导式中使用reversed
lst = [1, 2, 3, 4, 5]
squared_reversed = [x**2 for x in reversed(lst)]
print(squared_reversed)
# [25, 16, 9, 4, 1]

# 应用二：与生成器表达式结合
# 示例1：将生成器表达式的值转换为列表，然后使用reversed()
# 生成器表达式，产生0到9的偶数
even_numbers = (x for x in range(10) if x % 2 == 0)
# 将生成器表达式的值转换为列表
even_numbers_list = list(even_numbers)
# 使用reversed()反转列表
reversed_even_numbers = reversed(even_numbers_list)
# 遍历反转后的序列
for num in reversed_even_numbers:
    print(num)
# 8
# 6
# 4
# 2
# 0

# 示例2：直接使用列表推导式与reversed()结合(无需生成器表达式)
# 列表推导式，产生0到9的偶数
even_numbers_list = [x for x in range(10) if x % 2 == 0]
# 使用reversed()反转列表
reversed_even_numbers = reversed(even_numbers_list)
# 遍历反转后的序列
for num in reversed_even_numbers:
    print(num)
# 8
# 6
# 4
# 2
# 0

# 示例3：模拟一个只能遍历一次的迭代器，并使用列表存储其值以便反转
# 假设我们有一个只能遍历一次的迭代器
def one_time_iterator(n):
    for i in range(n):
        yield i
# 使用迭代器
it = one_time_iterator(5)
# 将迭代器的值存储在一个列表中
values = list(it)
# 使用reversed()反转列表
reversed_values = reversed(values)
# 遍历反转后的序列
for value in reversed_values:
    print(value)
# 4
# 3
# 2
# 1
# 0

# 应用三：图形和图像处理
# 示例1：反转图像的像素值(仅用于说明，通常不这样做)
from PIL import Image
import numpy as np
# 加载图像
image = Image.open('input.jpg')
# 将图像转换为NumPy数组
image_array = np.array(image)
# 假设我们有一个简单的示例，只反转红色通道的值(这通常不会得到有用的结果)
# 注意：这里仅用于演示，不是实际的图像处理操作
reversed_red_channel = reversed(image_array[:, :, 0].flatten())
# 由于reversed()返回的是一个迭代器，我们需要将其转换回数组
# 但由于这通常不是一个有用的操作，所以我们只打印几个值作为示例
for value in list(reversed_red_channel)[:5]:
    print(value)
# 如果你真的想将修改后的值应用回图像(但请记住，这通常不是一个好的图像处理实践)
# 你需要创建一个新的数组，并将值复制回去，但这里我们仅展示概念
# new_image_array = ... # 你需要在这里实现适当的逻辑来创建新的数组
# 显示原始图像(如果需要)
image.show()

# 示例2：反转图像的行或列(更实际的图像处理操作)
from PIL import Image
import numpy as np
# 加载图像
image = Image.open('input.jpg')
# 将图像转换为NumPy数组
image_array = np.array(image)
# 反转图像的行(上下翻转)
reversed_rows = image_array[::-1, :, :]
# 或者反转图像的列(左右翻转)
reversed_cols = image_array[:, ::-1, :]
# 将NumPy数组转换回PIL图像并显示
reversed_rows_image = Image.fromarray(reversed_rows)
reversed_rows_image.show()
reversed_cols_image = Image.fromarray(reversed_cols)
reversed_cols_image.show()
image.show()

# 应用四：与集合操作结合
# 示例1：将集合转换为列表并使用reversed()
s = {1, 2, 3, 4, 5}
reversed_list = list(reversed(list(s)))
print(reversed_list)
# [5, 4, 3, 2, 1]

# 示例2：使用集合操作后转换为列表并使用reversed()
s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}
# 找出两个集合的交集
intersection = s1.intersection(s2)
# 将交集转换为列表并使用reversed()
reversed_intersection = list(reversed(list(intersection)))
print(reversed_intersection)  # 输出：[5, 4]，但注意顺序可能因集合无序而有所不同
# [5, 4]

# 示例3：使用集合操作后转换为有序集合(如果需要保持顺序)
from collections import OrderedDict
# 假设你有一个保持插入顺序的“集合”(使用OrderedDict的键)
ordered_set = OrderedDict.fromkeys([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
# 转换为列表并使用reversed()
reversed_list = list(reversed(list(ordered_set)))
print(reversed_list)
# [6, 2, 9, 5, 4, 1, 3]

# 应用五：算法和数学问题
# 示例1：反转数组并计算其和
def reverse_and_sum(arr):
    reversed_arr = list(reversed(arr))
    return sum(reversed_arr)
# 示例数组
numbers = [3, 5, 6, 8, 10, 11, 24]
print(reverse_and_sum(numbers))
# 67

# 示例2：回文数检测
def is_palindrome(num):
    # 将整数转换为字符串
    str_num = str(num)
    # 反转字符串
    reversed_str = ''.join(reversed(str_num))
    # 比较反转后的字符串和原字符串是否相同
    return str_num == reversed_str
# 示例数字
num = 66866
print(is_palindrome(num))
# True

# 示例3：反转链表
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def reverse_linked_list(head):
    prev = None
    current = head
    while current:
        # 保存下一个节点，因为在反转当前节点后，我们将失去对它的引用
        next_node = current.next
        # 反转当前节点的指向
        current.next = prev
        # 移动指针
        prev = current
        current = next_node
    return prev  # prev 现在是新的头节点
# 创建链表：1 -> 2 -> 3 -> 4 -> 5
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
head.next.next.next.next = ListNode(5)
# 反转链表
reversed_head = reverse_linked_list(head)
# 辅助函数：打印链表
def print_list(head):
    current = head
    while current:
        print(current.val, end=' -> ')  # 使用end参数在元素之间添加箭头和空格
        current = current.next
    print('None')  # 链表末尾打印 None
print_list(reversed_head)
# 5 -> 4 -> 3 -> 2 -> 1 -> None

# 应用六：与内置函数结合
# 示例1：使用reversed()和list()转换为一个列表
# 创建一个元组
my_tuple = (1, 2, 3, 4, 5)
# 使用reversed()和list()将其转换为反向的列表
reversed_list = list(reversed(my_tuple))
print(reversed_list)
# [5, 4, 3, 2, 1]

# 示例2：使用reversed()和sum()计算反向序列的和
# 创建一个列表
my_list = [3, 5, 6, 8, 10, 11, 24]
# 使用reversed()和sum()计算反向序列的和
sum_reversed = sum(reversed(my_list))
print(sum_reversed)
# 67

# 示例3：使用reversed()和all()或any()检查条件
# 创建一个列表
my_list = [1, 2, 3, 4, 5]
# 使用reversed()和all()检查所有元素是否都大于3(反向检查)
all_greater_than_three = all(x > 3 for x in reversed(my_list))
print(all_greater_than_three)
# 使用reversed()和any()检查是否有元素大于3(反向检查)
any_greater_than_three = any(x > 3 for x in reversed(my_list))
print(any_greater_than_three)
# False
# True

# 示例4：使用reversed()和sorted()(尽管它们通常不一起使用)
# 创建一个列表
my_list = [5, 1, 4, 2, 3]
# 先排序，然后反转
reversed_sorted = list(reversed(sorted(my_list)))
print(reversed_sorted)
# [5, 4, 3, 2, 1]

# 示例5：使用reversed()和列表推导式
# 创建一个列表
my_list = [1, 2, 3, 4, 5]
# 使用reversed()和列表推导式来创建一个新列表，其中每个元素是原列表中对应元素的平方(反向)
squared_reversed = [x ** 2 for x in reversed(my_list)]
print(squared_reversed)
# [25, 16, 9, 4, 1]

# 应用七：文件路径处理
# 示例1：反转目录名列表
# 假设你有一个目录名列表
dir_names = ['folder1', 'folder2', 'folder3']
# 使用reversed()反转列表
reversed_dir_names = list(reversed(dir_names))
# 打印反转后的列表
print(reversed_dir_names)  # 输出: ['folder3', 'folder2', 'folder1']
# 你可以使用os.path.join来构建路径（但通常不会以反转的顺序）
import os
path_components = ['/base/path'] + reversed_dir_names
full_path = os.path.join(*path_components)
print(full_path)  # 输出: /base/path/folder3/folder2/folder1(注意这不是一个常见或推荐的路径构建方式)
# ['folder3', 'folder2', 'folder1']
# /base/path\folder3\folder2\folder1

# 示例2：反转文件扩展名与基本名
import os
# 假设你有一个文件名
filename = 'test.txt'
# 使用 os.path 分割文件名和扩展名
base, ext = os.path.splitext(filename)
# 你可以“反转”它们的位置(尽管这不是真正的反转)
reversed_parts = (ext[1:] if ext else '', base)  # 注意：我们移除了扩展名前的点（.）
print(reversed_parts)
# 但通常你不会这样组合它们，除非有特殊的需求
reversed_filename = ''.join(reversed_parts) if not reversed_parts[0] else f"{reversed_parts[1]}.{reversed_parts[0]}"
print(reversed_filename)
# ('txt', 'test')
# test.txt

# 示例3：处理文件路径中的各个部分
import os
# 假设你有一个文件路径
file_path = '/home/user/documents/file.txt'
# 使用os.path.split()递归地分割路径，直到只剩下一个部分
parts = []
while True:
    head, tail = os.path.split(file_path)
    if tail:
        parts.append(tail)
        file_path = head
    else:
        if head:
            parts.append(head)
        break
# 反转部分列表(除了可能的根目录)
reversed_parts = list(reversed(parts[1:])) if len(parts) > 1 else parts  # 忽略可能的根目录（如 '/'）
# 打印反转后的部分
print(reversed_parts)
# 你可以使用 os.path.join() 以原始顺序重新组合路径（如果需要）
original_path = os.path.join(*reversed(reversed_parts[::-1]))
print(original_path)
# ['/', 'home', 'user', 'documents']
# /home\user\documents

# 应用八：处理栈或队列数据结构
# 示例1：使用reversed()遍历栈的内容
class Stack:
    def __init__(self):
        self.items = []
    def push(self, item):
        self.items.append(item)
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        else:
            raise IndexError("Pop from an empty stack")
    def is_empty(self):
        return len(self.items) == 0
    # 添加一个方法来从后向前遍历栈的内容
    def reverse_traverse(self):
        for item in reversed(self.items):
            print(item)
# 使用栈
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
# 从后向前遍历栈的内容
stack.reverse_traverse()
# 3
# 2
# 1

# 示例2：使用reversed()遍历队列的内容(虽然不常见)
from collections import deque
class Queue:
    def __init__(self):
        self.items = deque()
    def enqueue(self, item):
        self.items.append(item)
    def dequeue(self):
        if not self.is_empty():
            return self.items.popleft()
        else:
            raise IndexError("Dequeue from an empty queue")
    def is_empty(self):
        return len(self.items) == 0
    # 添加一个方法来从后向前遍历队列的内容(虽然不常见)
    def reverse_traverse(self):
        for item in reversed(list(self.items)):
            print(item)
# 使用队列
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
# 从后向前遍历队列的内容(虽然不常见)
queue.reverse_traverse()
# 3
# 2
# 1

# 应用九：与切片结合
# 示例1：先切片再反转
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 切片获取列表的前5个元素
slice_of_list = my_list[:5]
# 使用reversed()函数来反向迭代切片
for item in reversed(slice_of_list):
    print(item)
# 4
# 3
# 2
# 1
# 0

# 示例2：反转整个列表并切片
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 使用reversed()函数来反转整个列表
reversed_list = list(reversed(my_list))
# 对反转后的列表进行切片，获取最后3个元素
slice_of_reversed_list = reversed_list[-3:]
print(slice_of_reversed_list)
# [2, 1, 0]

# 示例3：使用切片和reversed()创建自定义迭代器
class ReverseSliceIterator:
    def __init__(self, lst, start, stop):
        self.lst = lst[start:stop]  # 切片
        self.lst_reversed = reversed(self.lst)  # 反转切片
    def __iter__(self):
        return self
    def __next__(self):
        try:
            return next(self.lst_reversed)  # 迭代反转的切片
        except StopIteration:
            raise StopIteration
# 使用自定义迭代器
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
iterator = ReverseSliceIterator(my_list, 3, 8)
for item in iterator:
    print(item)
# 7
# 6
# 5
# 4
# 3

# 应用十：与文件操作结合
# 示例1：逐行读取文件，然后将内容列表反转
# 假设有一个文件test.txt，内容如下：
# apple
# banana
# cherry
# date
with open('test.txt', 'r') as file:
    lines = file.readlines()  # 读取所有行到列表中
# 使用reversed()来反向迭代列表
for line in reversed(lines):
    print(line.strip())  # 去除行尾的换行符并打印
# date
# cherry
# banana
# apple

# 示例2：使用reversed()和enumerate()一起处理文件内容
with open('test.txt', 'r') as file:
    lines = file.readlines()  # 读取所有行到列表中
# 使用enumerate()和reversed()结合
for index, line in reversed(list(enumerate(lines, start=1))):
    print(f"Line {index}: {line.strip()}")
# Line 4: date
# Line 3: cherry
# Line 2: banana
# Line 1: apple

# 示例3：逐块读取大文件并反转每个块
import itertools as itl
chunk_size = 4  # 假设我们每次读取4行作为一个块
with open('test.txt', 'r') as file:
    while True:
        chunk = list(itl.islice(file, chunk_size))  # 使用islice来逐块读取文件
        if not chunk:  # 如果块为空，说明已经到达文件末尾
            break
            # 反转块内的行顺序
        reversed_chunk = reversed(chunk)
        # 处理反转后的块（例如，打印出来）
        for line in reversed_chunk:
            print(line.strip(), end='')  # 不添加换行符以保持块的连续性
        print()  # 块处理完毕后添加一个换行符以便区分不同块
# 输出会根据chunk_size和文件内容而变化
# datecherrybananaapple

1-2、VBA：

略，待后补。

2、推荐阅读：

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

Python算法之旅：Algorithm

Python函数之旅：Functions

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