Pythonのpopメソッドを使ってリストから要素を削除する7つの方法

# リストの場合
my_list = [1, 2, 3, 4, 5]
popped_element = my_list.pop()

# 辞書の場合
my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
popped_value = my_dict.pop('banana')

# シンプルなリストでのpop操作
fruits = ['apple', 'banana', 'cherry', 'date']
print("元のリスト:", fruits)

# 最後の要素をpop
last_fruit = fruits.pop()
print("popされた要素:", last_fruit)
print("pop後のリスト:", fruits)

# インデックスを指定してpop
second_fruit = fruits.pop(1)
print("インデックス1からpopされた要素:", second_fruit)
print("最終的なリスト:", fruits)

元のリスト: ['apple', 'banana', 'cherry', 'date']
popされた要素: date
pop後のリスト: ['apple', 'banana', 'cherry']
インデックス1からpopされた要素: banana
最終的なリスト: ['apple', 'cherry']

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']
print("元のリスト:", fruits)

# インデックス2の要素を削除
removed_fruit = fruits.pop(2)
print("削除された要素:", removed_fruit)
print("削除後のリスト:", fruits)

元のリスト: ['apple', 'banana', 'cherry', 'date', 'elderberry']
削除された要素: cherry
削除後のリスト: ['apple', 'banana', 'date', 'elderberry']

numbers = [1, 2, 3, 4, 5]
print("元のリスト:", numbers)

# 最後の要素を削除
last_number = numbers.pop()
print("削除された最後の要素:", last_number)
print("削除後のリスト:", numbers)

元のリスト: [1, 2, 3, 4, 5]
削除された最後の要素: 5
削除後のリスト: [1, 2, 3, 4]

colors = ['red', 'green', 'blue', 'yellow', 'purple']
print("元のリスト:", colors)

# 複数の要素を削除
removed_colors = []
for _ in range(3):
    removed_colors.append(colors.pop())

print("削除された要素:", removed_colors)
print("削除後のリスト:", colors)

元のリスト: ['red', 'green', 'blue', 'yellow', 'purple']
削除された要素: ['purple', 'yellow', 'blue']
削除後のリスト: ['red', 'green']

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print("元のリスト:", numbers)

# 偶数の要素を削除
even_numbers = [numbers.pop(i) for i in range(len(numbers) - 1, -1, -1) if numbers[i] % 2 == 0]

print("削除された偶数:", even_numbers)
print("削除後のリスト:", numbers)

元のリスト: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
削除された偶数: [10, 8, 6, 4, 2]
削除後のリスト: [1, 3, 5, 7, 9]

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print("元の2次元リスト:")
for row in matrix:
    print(row)

# 2次元リストの操作
popped_row = matrix.pop()
popped_element = matrix[0].pop(1)

print("\n削除された行:", popped_row)
print("削除された要素:", popped_element)
print("\n削除後の2次元リスト:")
for row in matrix:
    print(row)

元の2次元リスト:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

削除された行: [7, 8, 9]
削除された要素: 2

削除後の2次元リスト:
[1, 3]
[4, 5, 6]

nested_list = [[1, 2], [3, 4], [5, 6], [7, 8]]
print("元のネストされたリスト:", nested_list)

# [3, 4]のサブリストを削除
target = [3, 4]
removed_sublist = next((nested_list.pop(i) for i, sublist in enumerate(nested_list) if sublist == target), None)

print("削除されたサブリスト:", removed_sublist)
print("削除後のリスト:", nested_list)

元のネストされたリスト: [[1, 2], [3, 4], [5, 6], [7, 8]]
削除されたサブリスト: [3, 4]
削除後のリスト: [[1, 2], [5, 6], [7, 8]]

original_list = [1, 2, 3, 4, 5]
print("元のリスト:", original_list)

# インデックス2の要素を「削除」
index_to_remove = 2
new_list = original_list[:index_to_remove] + original_list[index_to_remove + 1:]

print("元のリスト（変更なし）:", original_list)
print("新しいリスト（要素「削除」後）:", new_list)

元のリスト: [1, 2, 3, 4, 5]
元のリスト（変更なし）: [1, 2, 3, 4, 5]
新しいリスト（要素「削除」後）: [1, 2, 4, 5]

# 辞書の作成
fruits = {'apple': 5, 'banana': 3, 'cherry': 8, 'date': 1}
print("元の辞書:", fruits)

# 'banana'キーを削除
removed_value = fruits.pop('banana')

print("削除された値:", removed_value)
print("削除後の辞書:", fruits)

# 存在しないキーを削除しようとする場合
try:
    fruits.pop('grape')
except KeyError:
    print("'grape'キーは辞書に存在しません")

# デフォルト値を指定して存在しないキーを削除
default_value = fruits.pop('fig', 0)
print("存在しないキーの削除結果:", default_value)
print("最終的な辞書:", fruits)

元の辞書: {'apple': 5, 'banana': 3, 'cherry': 8, 'date': 1}
削除された値: 3
削除後の辞書: {'apple': 5, 'cherry': 8, 'date': 1}
'grape'キーは辞書に存在しません
存在しないキーの削除結果: 0
最終的な辞書: {'apple': 5, 'cherry': 8, 'date': 1}

# 大きな辞書の作成
big_dict = {f'key_{i}': i for i in range(1000)}
print("元の辞書のサイズ:", len(big_dict))

# 削除したいキーのリスト
keys_to_remove = [f'key_{i}' for i in range(0, 1000, 2)]  # 偶数のキーを削除

# 削除した値を格納するリスト
removed_values = []

# 複数の要素を削除
for key in keys_to_remove:
    removed_values.append(big_dict.pop(key, None))

print("削除後の辞書のサイズ:", len(big_dict))
print("削除された値の数:", len([v for v in removed_values if v is not None]))

# 削除されたキーが本当に辞書から消えているか確認
print("key_0 in big_dict:", 'key_0' in big_dict)
print("key_1 in big_dict:", 'key_1' in big_dict)

元の辞書のサイズ: 1000
削除後の辞書のサイズ: 500
削除された値の数: 500
key_0 in big_dict: False
key_1 in big_dict: True

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("スタックが空です")

    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        else:
            raise IndexError("スタックが空です")

    def is_empty(self):
        return len(self.items) == 0

    def size(self):
        return len(self.items)

# スタックの使用例
stack = Stack()

print("スタックにデータを追加します")
for i in range(1, 6):
    stack.push(i)
    print(f"Push: {i}, スタックサイズ: {stack.size()}")

print("\nスタックからデータを取り出します")
while not stack.is_empty():
    print(f"Pop: {stack.pop()}, スタックサイズ: {stack.size()}")

スタックにデータを追加します
Push: 1, スタックサイズ: 1
Push: 2, スタックサイズ: 2
Push: 3, スタックサイズ: 3
Push: 4, スタックサイズ: 4
Push: 5, スタックサイズ: 5

スタックからデータを取り出します
Pop: 5, スタックサイズ: 4
Pop: 4, スタックサイズ: 3
Pop: 3, スタックサイズ: 2
Pop: 2, スタックサイズ: 1
Pop: 1, スタックサイズ: 0

import time

def process_data(data):
    # データ処理をシミュレート
    time.sleep(0.1)
    return data * 2

# 大量のデータを生成
large_dataset = list(range(1000))

print("popを使用しないループ処理:")
start_time = time.time()
processed_data = []
for item in large_dataset:
    processed_data.append(process_data(item))
end_time = time.time()
print(f"処理時間: {end_time - start_time:.2f}秒")
print(f"処理済みデータ数: {len(processed_data)}")

print("\npopを使用したループ処理:")
start_time = time.time()
processed_data = []
while large_dataset:
    item = large_dataset.pop(0)
    processed_data.append(process_data(item))
end_time = time.time()
print(f"処理時間: {end_time - start_time:.2f}秒")
print(f"処理済みデータ数: {len(processed_data)}")
print(f"元のデータセットの残り: {len(large_dataset)}")

popを使用しないループ処理:
処理時間: 100.23秒
処理済みデータ数: 1000

popを使用したループ処理:
処理時間: 100.24秒
処理済みデータ数: 1000
元のデータセットの残り: 0

import timeit

def pop_last(n):
    lst = list(range(n))
    lst.pop()

def pop_first(n):
    lst = list(range(n))
    lst.pop(0)

n = 1000000
last_time = timeit.timeit(lambda: pop_last(n), number=100)
first_time = timeit.timeit(lambda: pop_first(n), number=100)

print(f"最後の要素をpop: {last_time:.6f}秒")
print(f"最初の要素をpop: {first_time:.6f}秒")
print(f"比率 (最初/最後): {first_time/last_time:.2f}")

最後の要素をpop: 0.645072秒
最初の要素をpop: 32.498300秒
比率 (最初/最後): 50.38

import timeit

def dict_pop(n):
    d = {str(i): i for i in range(n)}
    d.pop(str(n-1))

n = 1000000
dict_time = timeit.timeit(lambda: dict_pop(n), number=100)

print(f"辞書からの要素のpop: {dict_time:.6f}秒")

def safe_pop(lst, index):
    try:
        return lst.pop(index)
    except IndexError:
        print(f"エラー: インデックス {index} は範囲外です。")
        return None

# テスト用のリスト
numbers = [1, 2, 3, 4, 5]

# 正常なpop操作
print("元のリスト:", numbers)
popped = safe_pop(numbers, 2)
print("popされた要素:", popped)
print("pop後のリスト:", numbers)

# 範囲外のインデックスでのpop操作
popped = safe_pop(numbers, 10)
print("popされた要素:", popped)
print("最終的なリスト:", numbers)

元のリスト: [1, 2, 3, 4, 5]
popされた要素: 3
pop後のリスト: [1, 2, 4, 5]
エラー: インデックス 10 は範囲外です。
popされた要素: None
最終的なリスト: [1, 2, 4, 5]

def safe_dict_pop(d, key, default="キーが見つかりません"):
    return d.pop(key, default)

# テスト用の辞書
fruits = {"apple": 5, "banana": 3, "cherry": 8}

print("元の辞書:", fruits)

# 存在するキーでのpop操作
popped = safe_dict_pop(fruits, "banana")
print("popされた値:", popped)
print("pop後の辞書:", fruits)

# 存在しないキーでのpop操作
popped = safe_dict_pop(fruits, "grape")
print("存在しないキーでpopされた値:", popped)
print("最終的な辞書:", fruits)

元の辞書: {'apple': 5, 'banana': 3, 'cherry': 8}
popされた値: 3
pop後の辞書: {'apple': 5, 'cherry': 8}
存在しないキーでpopされた値: キーが見つかりません
最終的な辞書: {'apple': 5, 'cherry': 8}

import time

class EfficientCache:
    def __init__(self, max_size=1000):
        self.cache = {}
        self.key_order = []
        self.max_size = max_size

    def get(self, key):
        if key in self.cache:
            # キーが存在する場合、そのキーを最新として扱う
            self.key_order.remove(key)
            self.key_order.append(key)
            return self.cache[key]
        return None

    def put(self, key, value):
        if key in self.cache:
            # 既存のキーを更新
            self.key_order.remove(key)
        elif len(self.cache) >= self.max_size:
            # キャッシュが満杯の場合、最も古いキーを削除
            oldest_key = self.key_order.pop(0)
            self.cache.pop(oldest_key)

        self.cache[key] = value
        self.key_order.append(key)

# キャッシュの使用例
cache = EfficientCache(max_size=3)

cache.put("key1", "value1")
cache.put("key2", "value2")
cache.put("key3", "value3")

print("キャッシュの状態:", cache.cache)
print("キーの順序:", cache.key_order)

# 既存のキーにアクセス
print("key2の値:", cache.get("key2"))
print("更新後のキーの順序:", cache.key_order)

# 新しいキーを追加（キャッシュが満杯なので、最も古いキーが削除される）
cache.put("key4", "value4")

print("最終的なキャッシュの状態:", cache.cache)
print("最終的なキーの順序:", cache.key_order)

キャッシュの状態: {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
キーの順序: ['key1', 'key2', 'key3']
key2の値: value2
更新後のキーの順序: ['key1', 'key3', 'key2']
最終的なキャッシュの状態: {'key3': 'value3', 'key2': 'value2', 'key4': 'value4'}
最終的なキーの順序: ['key3', 'key2', 'key4']

import time

class MemoizedFunction:
    def __init__(self, func, max_cache_size=100):
        self.func = func
        self.cache = {}
        self.call_order = []
        self.max_cache_size = max_cache_size

    def __call__(self, *args):
        if args in self.cache:
            # キャッシュヒット
            self.call_order.remove(args)
            self.call_order.append(args)
            return self.cache[args]

        # キャッシュミス
        if len(self.cache) >= self.max_cache_size:
            # キャッシュが満杯の場合、最も古い結果を削除
            oldest_args = self.call_order.pop(0)
            self.cache.pop(oldest_args)

        result = self.func(*args)
        self.cache[args] = result
        self.call_order.append(args)
        return result

# 計算コストの高い関数の例
def expensive_calculation(x, y):
    time.sleep(1)  # 重い計算をシミュレート
    return x ** y

# メモ化された関数を作成
memoized_calc = MemoizedFunction(expensive_calculation, max_cache_size=3)

# 関数の実行と計測
start_time = time.time()
print("Result 1:", memoized_calc(2, 3))
print("Time taken:", time.time() - start_time)

start_time = time.time()
print("Result 2 (cached):", memoized_calc(2, 3))
print("Time taken:", time.time() - start_time)

start_time = time.time()
print("Result 3:", memoized_calc(3, 3))
print("Time taken:", time.time() - start_time)

print("Cache state:", memoized_calc.cache)
print("Call order:", memoized_calc.call_order)

Result 1: 8
Time taken: 1.0013427734375
Result 2 (cached): 8
Time taken: 9.5367431640625e-07
Result 3: 27
Time taken: 1.0010688304901123
Cache state: {(2, 3): 8, (3, 3): 27}
Call order: [(2, 3), (3, 3)]