Python リストのextend()｜別のリストを追加する基礎

みなさん、Pythonで複数のリストを結合したいと思ったことはありませんか？

「複数のデータをまとめて処理したい」 「リストにリストを追加したい」 「データを効率的に結合したい」

こんな場面に遭遇したことがある方は多いはずです。

でも大丈夫です！ Pythonにはextend()メソッドという便利な機能があります。

この記事では、Pythonのリストのextend()メソッドについて基礎から詳しく解説します。 基本的な使い方から実践的な応用例まで、具体的なコード例とともに学んでいきましょう。

extend()メソッドって何だろう？

まずは、extend()メソッドの基本概念から理解していきましょう。

extend()メソッドの基本概念

extend()メソッドは、リストに別のイテラブルのすべての要素を追加するメソッドです。

append()メソッドが1つの要素を追加するのに対し、extend()メソッドは複数の要素を一度に追加できます。

# extend()の基本的な使用例
fruits = ["apple", "banana"]
more_fruits = ["orange", "grape", "mango"]

# extend()で別のリストを追加
fruits.extend(more_fruits)
print(fruits)  # ['apple', 'banana', 'orange', 'grape', 'mango']

# append()との比較
fruits1 = ["apple", "banana"]
fruits2 = ["orange", "grape"]

# append()を使った場合（リスト全体が1つの要素として追加される）
fruits1.append(fruits2)
print(fruits1)  # ['apple', 'banana', ['orange', 'grape']]

# extend()を使った場合（要素が個別に追加される）
fruits3 = ["apple", "banana"]
fruits3.extend(fruits2)
print(fruits3)  # ['apple', 'banana', 'orange', 'grape']

この例でわかるように、extend()は要素を個別に追加します。 一方、append()はリスト全体を1つの要素として追加します。

extend()メソッドの基本構文

extend()メソッドの構文はとてもシンプルです。

list.extend(iterable)

ここで重要なポイントをまとめてみましょう。

• iterable: 追加したいイテラブル（リスト、タプル、文字列など）
• 戻り値: None（元のリストが変更される）
• 動作: 元のリストの末尾にイテラブルの全要素を追加

様々なイテラブルでの使用

extend()メソッドは、リスト以外のイテラブルも受け取れます。

# リスト
numbers = [1, 2, 3]
numbers.extend([4, 5, 6])
print(f"リスト追加後: {numbers}")  # [1, 2, 3, 4, 5, 6]

# タプル
numbers.extend((7, 8, 9))
print(f"タプル追加後: {numbers}")  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 文字列（文字ごとに分解されて追加）
letters = ["a", "b"]
letters.extend("cde")
print(f"文字列追加後: {letters}")  # ['a', 'b', 'c', 'd', 'e']

# 範囲オブジェクト
numbers = [1, 2, 3]
numbers.extend(range(4, 7))
print(f"range追加後: {numbers}")  # [1, 2, 3, 4, 5, 6]

文字列を追加すると、1文字ずつ分解されて追加されることに注意しましょう。

append()との違い

extend()とappend()の違いを詳しく理解しましょう。

動作の比較

2つのメソッドの違いを実際に確認してみます。

# append()とextend()の比較
list1 = [1, 2, 3]
list2 = [1, 2, 3]
additional_data = [4, 5, 6]

# append()：リスト全体を1つの要素として追加
list1.append(additional_data)
print(f"append()結果: {list1}")  # [1, 2, 3, [4, 5, 6]]

# extend()：各要素を個別に追加
list2.extend(additional_data)
print(f"extend()結果: {list2}")  # [1, 2, 3, 4, 5, 6]

# 結果の型確認
print(f"append()後の長さ: {len(list1)}")  # 4
print(f"extend()後の長さ: {len(list2)}")  # 6

この例から、append()はリストの長さが1増えるのに対し、extend()は追加した要素数分増えることがわかります。

使い分けの例

実際の場面でどう使い分けるか見てみましょう。

# 学生の成績管理
class_a_scores = [85, 92, 78]
class_b_scores = [88, 95, 82, 90]

# 全クラスの成績をまとめたい場合（extend()を使用）
all_scores = class_a_scores.copy()
all_scores.extend(class_b_scores)
print(f"全体の成績: {all_scores}")

# クラス別に成績を管理したい場合（append()を使用）
class_scores = []
class_scores.append(class_a_scores)
class_scores.append(class_b_scores)
print(f"クラス別成績: {class_scores}")

extend()は要素をフラットに結合したい場合に、append()は構造を保持したい場合に使います。

実践的な使用例

extend()メソッドの実用的な活用方法を見てみましょう。

データ収集と統合

複数のデータソースからデータを収集する例です。

class DataCollector:
    """データ収集クラス"""
    
    def __init__(self):
        self.all_data = []
        self.source_count = 0
    
    def add_data_source(self, data_source, source_name):
        """データソースから情報を追加"""
        print(f"{source_name}からデータを収集中...")
        initial_count = len(self.all_data)
        
        # データを追加
        self.all_data.extend(data_source)
        
        added_count = len(self.all_data) - initial_count
        self.source_count += 1
        
        print(f"  {added_count}件のデータを追加しました")
        print(f"  総データ数: {len(self.all_data)}件")
    
    def get_statistics(self):
        """統計情報を取得"""
        if not self.all_data:
            return {"count": 0, "average": 0, "min": 0, "max": 0}
        
        return {
            "count": len(self.all_data),
            "average": sum(self.all_data) / len(self.all_data),
            "min": min(self.all_data),
            "max": max(self.all_data)
        }

このDataCollectorクラスでは、extend()を使って複数のデータソースを効率的に統合しています。

次に使用例を見てみましょう。

# 使用例
collector = DataCollector()

# 複数のデータソースから収集
web_api_data = [23, 45, 67, 89, 34]
database_data = [12, 56, 78, 90, 23, 45]
file_data = [34, 67, 89, 12, 45, 78, 90]

collector.add_data_source(web_api_data, "Web API")
collector.add_data_source(database_data, "データベース")
collector.add_data_source(file_data, "ファイル")

# 統計情報表示
stats = collector.get_statistics()
print(f"
統計情報:")
print(f"  データ数: {stats['count']}")
print(f"  平均値: {stats['average']:.2f}")
print(f"  最小値: {stats['min']}")
print(f"  最大値: {stats['max']}")

実行すると、各データソースから段階的にデータが追加されていく様子がわかります。

ショッピングカート機能

ショッピングサイトのカート機能でも活用できます。

class ShoppingCart:
    """ショッピングカートクラス"""
    
    def __init__(self):
        self.items = []
        self.quantities = []
        self.prices = []
    
    def add_item(self, item_name, quantity, price):
        """単一商品を追加"""
        self.items.append(item_name)
        self.quantities.append(quantity)
        self.prices.append(price)
        print(f"'{item_name}' を {quantity} 個追加しました")
    
    def add_bulk_items(self, item_list):
        """複数商品を一括追加"""
        print("一括商品追加中...")
        
        items = [item[0] for item in item_list]
        quantities = [item[1] for item in item_list]
        prices = [item[2] for item in item_list]
        
        self.items.extend(items)
        self.quantities.extend(quantities)
        self.prices.extend(prices)
        
        print(f"{len(item_list)}個の商品を追加しました")
    
    def merge_cart(self, other_cart):
        """別のカートと統合"""
        print("カートを統合中...")
        
        initial_count = len(self.items)
        
        self.items.extend(other_cart.items)
        self.quantities.extend(other_cart.quantities)
        self.prices.extend(other_cart.prices)
        
        added_count = len(self.items) - initial_count
        print(f"{added_count}個の商品を統合しました")
    
    def get_total_price(self):
        """合計金額を計算"""
        total = sum(price * quantity for price, quantity in zip(self.prices, self.quantities))
        return total
    
    def display_cart(self):
        """カートの内容を表示"""
        print("
=== ショッピングカート ===")
        if not self.items:
            print("カートは空です")
            return
        
        for i, (item, quantity, price) in enumerate(zip(self.items, self.quantities, self.prices), 1):
            subtotal = price * quantity
            print(f"{i}. {item} x {quantity} = {subtotal}円")
        
        print(f"
合計: {self.get_total_price()}円")

このクラスでは、一括追加とカート統合で extend() を活用しています。

ログ収集システム

ログ管理システムでもextend()が役立ちます。

class LogCollector:
    """ログ収集システム"""
    
    def __init__(self):
        self.error_logs = []
        self.warning_logs = []
        self.info_logs = []
        self.all_logs = []
    
    def add_log_batch(self, log_entries):
        """ログエントリのバッチを追加"""
        for entry in log_entries:
            level = entry.get("level", "INFO")
            message = entry.get("message", "")
            timestamp = entry.get("timestamp", "")
            
            log_entry = f"[{timestamp}] {level}: {message}"
            
            # レベル別に分類
            if level == "ERROR":
                self.error_logs.append(log_entry)
            elif level == "WARNING":
                self.warning_logs.append(log_entry)
            else:
                self.info_logs.append(log_entry)
            
            # 全ログにも追加
            self.all_logs.append(log_entry)
    
    def merge_logs_from_sources(self, *log_sources):
        """複数のログソースから統合"""
        print("ログソースを統合中...")
        
        for i, source_logs in enumerate(log_sources, 1):
            print(f"ソース{i}から{len(source_logs)}件のログを追加")
            self.all_logs.extend(source_logs)
    
    def get_summary(self):
        """ログサマリーを取得"""
        return {
            "total": len(self.all_logs),
            "errors": len(self.error_logs),
            "warnings": len(self.warning_logs),
            "info": len(self.info_logs)
        }

このシステムでは、複数のログソースを統合する際にextend()を使用しています。

パフォーマンスの比較

extend()と他の方法の性能を比較してみましょう。

extend()と+演算子の比較

import time

def compare_list_extension_methods(size):
    """リスト拡張方法のパフォーマンス比較"""
    # テストデータ
    list1 = list(range(size))
    list2 = list(range(size, size * 2))
    
    # extend()メソッドの測定
    test_list = list1.copy()
    start_time = time.time()
    test_list.extend(list2)
    extend_time = time.time() - start_time
    
    # +演算子の測定
    start_time = time.time()
    combined_list = list1 + list2
    plus_time = time.time() - start_time
    
    # +=演算子の測定
    test_list = list1.copy()
    start_time = time.time()
    test_list += list2
    plus_equal_time = time.time() - start_time
    
    print(f"リストサイズ: {size}")
    print(f"extend()メソッド: {extend_time:.6f}秒")
    print(f"+演算子: {plus_time:.6f}秒")
    print(f"+=演算子: {plus_equal_time:.6f}秒")
    print()

# 様々なサイズでテスト
for size in [1000, 10000, 100000]:
    compare_list_extension_methods(size)

一般的に、extend()と+=演算子は**+演算子より高速**です。

メモリ効率の考慮

メモリ使用量の違いも理解しておきましょう。

def demonstrate_memory_efficiency():
    """メモリ効率のデモンストレーション"""
    import sys
    
    # 元のリスト
    original_list = [1, 2, 3, 4, 5]
    print(f"元のリストID: {id(original_list)}")
    
    # extend()を使用（元のリストを変更）
    additional_data = [6, 7, 8, 9, 10]
    original_list.extend(additional_data)
    print(f"extend()後のリストID: {id(original_list)}")  # 同じID
    print(f"extend()後の内容: {original_list}")
    
    # +演算子を使用（新しいリストを作成）
    list1 = [1, 2, 3, 4, 5]
    list2 = [6, 7, 8, 9, 10]
    print(f"list1のID: {id(list1)}")
    
    new_list = list1 + list2
    print(f"新しいリストのID: {id(new_list)}")  # 異なるID
    print(f"新しいリストの内容: {new_list}")
    
    print("
メモリ使用量:")
    print(f"extend()使用時: 元のリストを変更（メモリ効率良）")
    print(f"+演算子使用時: 新しいリストを作成（メモリ使用量多）")

demonstrate_memory_efficiency()

extend()は元のリストを変更するため、メモリ効率が良いです。

エラーハンドリング

安全にextend()を使用するための方法を学びましょう。

安全なextend操作

def safe_extend(target_list, source_data):
    """安全なextend操作"""
    if not isinstance(target_list, list):
        raise TypeError("第1引数はリストである必要があります")
    
    try:
        # イテラブルかどうかチェック
        iter(source_data)
        target_list.extend(source_data)
        return True
    except TypeError:
        print(f"エラー: {source_data} はイテラブルではありません")
        return False

def robust_list_merger(lists_to_merge):
    """堅牢なリスト結合"""
    result = []
    successful_merges = 0
    
    for i, data in enumerate(lists_to_merge):
        try:
            if isinstance(data, (list, tuple, str, range)):
                result.extend(data)
                successful_merges += 1
                print(f"データ{i+1}を正常に結合しました")
            else:
                print(f"警告: データ{i+1}は非対応の型です: {type(data)}")
        except Exception as e:
            print(f"エラー: データ{i+1}の処理に失敗しました: {e}")
    
    print(f"
結合完了: {successful_merges}/{len(lists_to_merge)}件成功")
    return result

エラーハンドリングを組み込むことで、より安全な処理が可能になります。

実用的なヘルパー関数

extend()を使った便利な関数を作ってみましょう。

便利なextend関数群

class ListExtender:
    """リスト拡張のユーティリティクラス"""
    
    @staticmethod
    def extend_unique(target_list, source_data):
        """重複を避けてextend"""
        for item in source_data:
            if item not in target_list:
                target_list.append(item)
    
    @staticmethod
    def extend_with_condition(target_list, source_data, condition_func):
        """条件を満たす要素のみextend"""
        filtered_data = [item for item in source_data if condition_func(item)]
        target_list.extend(filtered_data)
    
    @staticmethod
    def extend_with_transform(target_list, source_data, transform_func):
        """変換してからextend"""
        transformed_data = [transform_func(item) for item in source_data]
        target_list.extend(transformed_data)
    
    @staticmethod
    def conditional_extend(target_list, source_data, max_size=None):
        """サイズ制限ありのextend"""
        if max_size is None:
            target_list.extend(source_data)
        else:
            remaining_space = max_size - len(target_list)
            if remaining_space > 0:
                target_list.extend(source_data[:remaining_space])
                return len(source_data[:remaining_space])
            return 0

これらのヘルパー関数を使用することで、より柔軟なリスト操作が可能になります。

使用例を見てみましょう。

# 使用例
extender = ListExtender()

# 重複を避けて追加
numbers = [1, 2, 3, 4]
new_numbers = [3, 4, 5, 6, 7]
extender.extend_unique(numbers, new_numbers)
print(f"重複なし追加: {numbers}")

# 条件付き追加
numbers = [1, 2, 3]
candidates = [0, 4, -2, 8, -5, 10]
extender.extend_with_condition(numbers, candidates, lambda x: x > 0)
print(f"正数のみ追加: {numbers}")

# 変換して追加
words = ["hello"]
new_words = ["world", "python"]
extender.extend_with_transform(words, new_words, str.upper)
print(f"大文字変換して追加: {words}")

# サイズ制限ありの追加
limited_list = [1, 2]
extender.conditional_extend(limited_list, [3, 4, 5, 6, 7], max_size=5)
print(f"サイズ制限あり: {limited_list}")

これらの関数により、様々な場面でextend()を活用できます。

まとめ：extend()をマスターしよう

Pythonのリストのextend()メソッドについて詳しく解説しました。

extend()の基本

基本機能 別のイテラブルの全要素を個別に追加する機能です。

append()との違い

• extend(): 要素を個別に追加
• append(): リスト全体を1つの要素として追加

重要なポイント

効率性 メモリ効率が良く、元のリストを変更します。

柔軟性 リスト、タプル、文字列、rangeオブジェクトなど様々なイテラブルに対応しています。

実用性 データ収集、カート機能、ログ統合などで活躍します。

応用テクニック

エラーハンドリング 型チェックと例外処理で安全な操作が可能です。

ヘルパー関数 重複回避、条件付き追加、変換処理などの拡張機能を作れます。

パフォーマンス最適化 +演算子より高速で、メモリ効率も優秀です。

学習のステップ

1. 基本理解 extend()とappend()の違いを理解しましょう。

2. 実践応用 データ収集やリスト結合で活用してみましょう。

3. 高度な活用 エラーハンドリングやヘルパー関数を作成してみましょう。

4. パフォーマンス意識 メモリ効率を考慮した使い方をマスターしましょう。

最後に

extend()メソッドは、Pythonでのリスト操作において非常に重要な機能です。

データの効率的な結合により、処理性能の向上につながります。

適切に使いこなすことで、より効果的なプログラムが作成できるようになります。

ぜひ実際のプロジェクトでextend()メソッドを活用してみてくださいね！