Pythonでリストを逆順にする基本的な方法と活用例10選

reversed_prices = list(reversed(stock_prices))
print(reversed_prices)

def is_palindrome(s):
    return s == ''.join(reversed(s))

test_string = "racecar"
print(is_palindrome(test_string))

original_list = [1, 2, 3, 4, 5]
reversed_iterator = reversed(original_list)
reversed_list = list(reversed_iterator)
print(reversed_list)

original_list = [1, 2, 3, 4, 5]
reversed_list = original_list[::-1]
print(reversed_list)

original_list = [1, 2, 3, 4, 5]
original_list.reverse()
print(original_list)

original_list = [1, 2, 3, 4, 5]
reversed_list = []
for i in range(len(original_list) - 1, -1, -1):
    reversed_list.append(original_list[i])
print(reversed_list)

from collections import deque

original_list = [1, 2, 3, 4, 5]
deque_object = deque(original_list)
deque_object.reverse()
reversed_list = list(deque_object)
print(reversed_list)

original_string = "Python"
reversed_string = original_string[::-1]
print(reversed_string)

original_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
reversed_list = [sublist[::-1] for sublist in original_list[::-1]]
print(reversed_list)

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
reverse_sorted = sorted(numbers, reverse=True)
print(reverse_sorted)

def reverse_generator(iterable):
    for item in reversed(list(iterable)):
        yield item

numbers = range(1000000)  # 大きな範囲のデータ
for num in reverse_generator(numbers):
    print(num)
    if num > 999995:
        break

999999
999998
999997
999996

class ReverseIterator:
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index -= 1
        return self.data[self.index]

my_list = [1, 2, 3, 4, 5]
reverse_iter = ReverseIterator(my_list)
for item in reverse_iter:
    print(item)

5
4
3
2
1

import time

def measure_time(func, *args):
    start = time.time()
    func(*args)
    end = time.time()
    return end - start

# テスト用の大きなリスト
big_list = list(range(1000000))

# reversed()関数
reversed_time = measure_time(list, reversed(big_list))

# スライス
slice_time = measure_time(lambda x: x[::-1], big_list)

# list.reverse()メソッド
reverse_time = measure_time(big_list.copy().reverse)

# for文でカスタム逆順
def custom_reverse(lst):
    return [lst[i] for i in range(len(lst)-1, -1, -1)]
custom_time = measure_time(custom_reverse, big_list)

print(f"reversed(): {reversed_time:.6f} 秒")
print(f"スライス: {slice_time:.6f} 秒")
print(f"list.reverse(): {reverse_time:.6f} 秒")
print(f"カスタム逆順: {custom_time:.6f} 秒")

reversed(): 0.000017 秒
スライス: 0.022893 秒
list.reverse(): 0.020738 秒
カスタム逆順: 0.276304 秒

import sys

# メモリ使用量を測定する関数
def get_size(obj):
    return sys.getsizeof(obj)

# テスト用のリスト
test_list = list(range(100000))

# 元のリストのサイズ
original_size = get_size(test_list)

# reversed()のサイズ
reversed_size = get_size(reversed(test_list))

# スライスのサイズ
slice_size = get_size(test_list[::-1])

# list.reverse()のサイズ
reverse_list = test_list.copy()
reverse_list.reverse()
reverse_size = get_size(reverse_list)

print(f"元のリスト: {original_size} バイト")
print(f"reversed(): {reversed_size} バイト")
print(f"スライス: {slice_size} バイト")
print(f"list.reverse(): {reverse_size} バイト")

元のリスト: 824456 バイト
reversed(): 48 バイト
スライス: 824456 バイト
list.reverse(): 824456 バイト

numbers = [1, 2, 3, 4, 5]
reversed_numbers = reversed(numbers)
print(reversed_numbers[0])  # エラーが発生

numbers = [1, 2, 3, 4, 5]
reversed_numbers = list(reversed(numbers))
print(reversed_numbers[0])  # 問題なく動作

numbers = [1, 2, 3, 4, 5]
for i in range(len(numbers), -1, -1):
    print(numbers[i])  # 最後のイテレーションでエラーが発生

numbers = [1, 2, 3, 4, 5]
for i in range(len(numbers) - 1, -1, -1):
    print(numbers[i])  # 問題なく動作

5
4
3
2
1

big_data = range(10**8)  # 非常に大きなデータセット
reversed_data = list(reversed(big_data))  # メモリエラーの可能性あり

def reverse_generator(data):
    for item in reversed(data):
        yield item

big_data = range(10**8)  # 非常に大きなデータセット
for item in reverse_generator(big_data):
    print(item)
    if item > 99999999:
        break  # 最初の5個の要素だけを表示

99999999
99999998
99999997
99999996
99999995

   simple_list = [1, 2, 3, 4, 5]
   reversed_list = simple_list[::-1]
   print(reversed_list)

   big_data = range(1000000)
   for item in reversed(big_data):
       print(item)
       if item > 999995:
           break  # 最初の5個の要素だけを表示

   999999
   999998
   999997
   999996
   999995

   mutable_list = [1, 2, 3, 4, 5]
   mutable_list.reverse()
   print(mutable_list)

   class CustomReverseIterator:
       def __init__(self, data):
           self.data = data
           self.index = len(data)

       def __iter__(self):
           return self

       def __next__(self):
           if self.index == 0:
               raise StopIteration
           self.index -= 1
           return self.data[self.index]

   custom_data = [1, 2, 3, 4, 5]
   for item in CustomReverseIterator(custom_data):
       print(item)

   5
   4
   3
   2
   1

   # 悪い例
   def r(d):
       return d[::-1]

   # 良い例
   def reverse_list(data):
       return data[::-1]

   def custom_reverse(data):
       # データの長さを取得
       length = len(data)
       # 中央のインデックスを計算
       mid = length // 2
       # リストの前半と後半を入れ替える
       for i in range(mid):
           data[i], data[length - 1 - i] = data[length - 1 - i], data[i]
       return data

   # 非効率的で読みにくい例
   def manual_reverse(data):
       result = []
       for i in range(len(data) - 1, -1, -1):
           result.append(data[i])
       return result

   # 効率的で読みやすい例
   def efficient_reverse(data):
       return list(reversed(data))

   class ReversibleList:
       def __init__(self, data):
           self.data = data

       def forward(self):
           return iter(self.data)

       def backward(self):
           return reversed(self.data)

   my_list = ReversibleList([1, 2, 3, 4, 5])
   print("Forward:", list(my_list.forward()))
   print("Backward:", list(my_list.backward()))

   Forward: [1, 2, 3, 4, 5]
   Backward: [5, 4, 3, 2, 1]