Pythonで二次元配列を自由自在にソート！複雑なデータも思い通りに操る完全ガイド
データ分析、機械学習、Web開発など、Pythonを使うあらゆる分野で「データの並び替え」は避けて通れない処理です。特に、複数の情報を持つデータを扱う際によく登場するのが「二次元配列（または二次元リスト）」でしょう。
しかし、「Pythonで二次元配列を特定の条件でソートしたい」「複数の列をキーにして並び替えたい」「Numpy配列の場合どうすればいいの？」といった疑問に直面し、戸惑った経験はありませんか？
この記事では、そんなあなたの悩みを解決すべく、Pythonにおける二次元配列のソートに関するあらゆるテクニックを、初心者から上級者まで理解できるよう徹底的に解説します。
この記事を読み終える頃には、あなたはどんな複雑な二次元データも意のままにソートし、効率的にデータを扱えるようになることをお約束します。さあ、Pythonのソートマスターへの第一歩を踏み出しましょう！
目次
- Pythonにおける「配列」の基本を理解する
- リスト（list）とNumPy配列（ndarray）
- 一次元リストのソートのおさらい
- 二次元リストのソート：基本から応用まで
- 2.1.
sorted()関数とlist.sort()メソッドの違い - 2.2. 特定の列（インデックス）をキーにしてソートする
key引数とラムダ式（lambda）operator.itemgetterを使った高速なソート
- 2.3. 複数の列をキーにしてソートする（多段階ソート）
- 第一キー、第二キー...を組み合わせる方法
- 昇順と降順を組み合わせたソート
- 2.4. 複雑な条件でソートする：カスタムソートキーの作成
- 文字列と数値が混在するデータのソート
- 特定の条件を満たす要素を優先するソート
- 2.5. カスタムオブジェクトを含む二次元リストのソート
- クラス内で比較演算子を定義する
operator.attrgetterの活用
- 2.1.
- NumPy配列（ndarray）のソートをマスターする
- 3.1. NumPyの基本的なソート方法
- 3.2. 特定の軸（axis）を指定してソートする
- 3.3.
argsort()でソート後のインデックスを取得する - 3.4. 構造化配列（structured array）のソート
- ソート処理のパフォーマンスと安定性
- 大規模データにおけるソート効率
lambdavsitemgetter/attrgetter- Pythonのソートは「安定ソート」である
- よくある落とし穴とデバッグのヒント
key引数の指定ミス- インデックスエラーの回避
- in-placeソートと新しいリストの作成の混同
- まとめ：Pythonの二次元配列ソートはもう怖くない！
1. Pythonにおける「配列」の基本を理解する
まず、Pythonにおける「配列」という言葉の扱いから明確にしましょう。他のプログラミング言語（C++のstd::arrayやJavaのint[]など）では固定長の「配列」が基本ですが、Pythonには厳密な意味での組み込み型「配列」はありません。
Pythonで「配列」と表現される場合、通常は以下の2つのデータ構造のどちらかを指します。
- リスト（
list）: Pythonの最も基本的なシーケンス型の一つで、ミュータブル（変更可能）で異種のデータ型を格納できる非常に柔軟なデータ構造です。本記事の主な対象となります。 - NumPy配列（
ndarray）: 科学計算ライブラリNumPyによって提供されるデータ構造で、効率的な数値計算に特化しています。同種のデータ型を格納し、固定長で、大規模な数値データ処理に優れています。
この記事では、この両方について詳しく見ていきますが、まずはPythonの組み込み型であるlistを使った二次元配列のソートから解説していきます。
一次元リストのソートのおさらい
二次元リストのソートに入る前に、一次元リストのソート方法をおさらいしておきましょう。Pythonには主に2つのソート方法があります。
list.sort()メソッド: リスト自体をその場で（in-place）ソートし、Noneを返します。sorted()関数: 新しいソート済みのリストを返し、元のリストは変更しません。あらゆるイテラブル（リスト、タプル、文字列など）に適用できます。
どちらの方法も、key引数とreverse引数を使ってソートの挙動をカスタマイズできます。
# 一次元リストの例
data = [3, 1, 4, 1, 5, 9, 2, 6]
# 1. list.sort()メソッド（in-placeソート）
data.sort()
print(f"list.sort()でソート後: {data}") # [1, 1, 2, 3, 4, 5, 6, 9]
# リストを元に戻す
data = [3, 1, 4, 1, 5, 9, 2, 6]
# 2. sorted()関数（新しいリストを返す）
sorted_data = sorted(data)
print(f"sorted()でソート後: {sorted_data}") # [1, 1, 2, 3, 4, 5, 6, 9]
print(f"元のリスト（変更なし）: {data}") # [3, 1, 4, 1, 5, 9, 2, 6]
# reverse引数で降順ソート
sorted_desc = sorted(data, reverse=True)
print(f"sorted()で降順ソート後: {sorted_desc}") # [9, 6, 5, 4, 3, 2, 1, 1]
# key引数でカスタムソート
words = ["apple", "banana", "Cherry", "date"]
# 文字列の長さをキーにソート
sorted_by_len = sorted(words, key=len)
print(f"長さでソート: {sorted_by_len}") # ['date', 'apple', 'banana', 'Cherry']
# 大文字小文字を区別せずソート (全て小文字に変換してから比較)
sorted_case_insensitive = sorted(words, key=str.lower)
print(f"大文字小文字区別せずソート: {sorted_case_insensitive}") # ['apple', 'banana', 'Cherry', 'date']
このkey引数の使い方が、二次元リストのソートにおいて非常に重要になります。
2. 二次元リストのソート：基本から応用まで
Pythonの二次元リストは、「リストの中にリストが入っている」構造です。例えば、[[1, 2], [3, 4], [5, 6]]のような形です。これを「行列」や「テーブル」のように見立てて、特定の列（インデックス）の値に基づいてソートしたいケースがほとんどでしょう。
2.1. sorted()関数とlist.sort()メソッドの違い
一次元リストと同様に、二次元リストもsorted()関数とlist.sort()メソッドの両方でソートできます。
# 二次元リストの例
students = [
["Alice", 20, "A"],
["Bob", 22, "B"],
["Charlie", 20, "C"],
["David", 21, "A"],
]
# sorted()関数でソート（新しいリストを生成）
sorted_students = sorted(students)
print(f"sorted()でソート後 (デフォルト): {sorted_students}")
# デフォルトでは、内側のリストの要素が順番に比較されます。
# ['Alice', 20, 'A'] < ['Bob', 22, 'B'] < ['Charlie', 20, 'C'] < ['David', 21, 'A']
# 結果: [['Alice', 20, 'A'], ['Bob', 22, 'B'], ['Charlie', 20, 'C'], ['David', 21, 'A']]
# この例では、既に名前のアルファベット順になってしまっています。
# list.sort()メソッドでソート（in-place）
students.sort()
print(f"list.sort()でソート後 (デフォルト): {students}")
# 結果は sorted() と同じ
デフォルトのソートでは、内側のリストの最初の要素から順番に比較が行われます。上記の例では名前（[0]番目の要素）がアルファベット順だったので、その結果が得られました。しかし、多くの場合、特定の列を基準にソートしたいはずです。ここでkey引数が力を発揮します。
2.2. 特定の列（インデックス）をキーにしてソートする
二次元リストのソートで最も頻繁に行われるのが、特定の列（インデックス）の値を基準にソートする方法です。
key引数とラムダ式（lambda）
key引数には、リストの各要素（この場合は内側のリスト）を受け取り、ソートに使用する値を返す関数を指定します。この「ソートキーを返す関数」として、手軽に書けるラムダ式が非常によく使われます。
例えば、上記のstudentsリストを年齢（インデックス1）でソートしたい場合：
students = [
["Alice", 20, "A"],
["Bob", 22, "B"],
["Charlie", 20, "C"],
["David", 21, "A"],
]
# 年齢（インデックス1）でソート
sorted_by_age = sorted(students, key=lambda student: student[1])
print(f"年齢でソート: {sorted_by_age}")
# 結果: [['Alice', 20, 'A'], ['Charlie', 20, 'C'], ['David', 21, 'A'], ['Bob', 22, 'B']]
# 降順でソートしたい場合は `reverse=True` を追加
sorted_by_age_desc = sorted(students, key=lambda student: student[1], reverse=True)
print(f"年齢で降順ソート: {sorted_by_age_desc}")
# 結果: [['Bob', 22, 'B'], ['David', 21, 'A'], ['Alice', 20, 'A'], ['Charlie', 20, 'C']]
# 成績（インデックス2）でソート
sorted_by_grade = sorted(students, key=lambda student: student[2])
print(f"成績でソート: {sorted_by_grade}")
# 結果: [['Alice', 20, 'A'], ['David', 21, 'A'], ['Bob', 22, 'B'], ['Charlie', 20, 'C']]
ラムダ式 lambda student: student[1] は、「studentという引数を受け取り、student[1]の値を返す関数」を意味します。sorted()関数はリストの各student（内側のリスト）をこのラムダ関数に渡し、その戻り値を比較キーとしてソートを行います。
operator.itemgetterを使った高速なソート
lambda式は非常に便利ですが、特定のインデックスや属性を取り出すだけのシンプルな操作であれば、operatorモジュールのitemgetterやattrgetterを使う方が、わずかながらパフォーマンス上有利になる場合があります。特に大規模なデータを扱う際に考慮に入れると良いでしょう。
itemgetter(インデックス) は、指定されたインデックスの要素を返す関数を生成します。
import operator
students = [
["Alice", 20, "A"],
["Bob", 22, "B"],
["Charlie", 20, "C"],
["David", 21, "A"],
]
# 年齢（インデックス1）でソート (itemgetterを使用)
sorted_by_age_itemgetter = sorted(students, key=operator.itemgetter(1))
print(f"itemgetterで年齢ソート: {sorted_by_age_itemgetter}")
# 結果: [['Alice', 20, 'A'], ['Charlie', 20, 'C'], ['David', 21, 'A'], ['Bob', 22, 'B']]
可読性やシンプルさではラムダ式も優れているため、好みに応じて使い分けると良いでしょう。パフォーマンスがクリティカルな場面でitemgetterを検討するのが一般的です。
2.3. 複数の列をキーにしてソートする（多段階ソート）
データ分析では、第一キーでソートし、もし第一キーの値が同じであれば第二キーでソートする、といった「多段階ソート」が頻繁に必要になります。
第一キー、第二キー...を組み合わせる方法
key引数に指定する関数が、複数の値を要素とするタプルを返すと、Pythonはそのタプルの要素を順番に比較してソートを行います。これが多段階ソートの肝です。
例えば、「年齢が同じ場合は名前でソートする」といった場合：
students = [
["Alice", 20, "A"],
["Bob", 22, "B"],
["Charlie", 20, "C"], # Aliceと同じ年齢
["David", 21, "A"],
]
# 1. 年齢（インデックス1）でソート
# 2. 年齢が同じ場合は名前（インデックス0）でソート
sorted_multi_key = sorted(students, key=lambda student: (student[1], student[0]))
print(f"年齢→名前でソート: {sorted_multi_key}")
# 結果: [['Alice', 20, 'A'], ['Charlie', 20, 'C'], ['David', 21, 'A'], ['Bob', 22, 'B']]
# 20歳のグループでは、Alice (A) が Charlie (C) より前に来ています。
# itemgetterでも同様に複数インデックスを指定可能
sorted_multi_key_itemgetter = sorted(students, key=operator.itemgetter(1, 0))
print(f"itemgetterで年齢→名前ソート: {sorted_multi_key_itemgetter}")
# 結果: [['Alice', 20, 'A'], ['Charlie', 20, 'C'], ['David', 21, 'A'], ['Bob', 22, 'B']]
key=lambda student: (student[1], student[0]) のように、タプルを返すことで、指定した順序でキーが評価され、多段階ソートが実現します。これは非常に強力なテクニックです。
昇順と降順を組み合わせたソート
多段階ソートで、各キーごとに昇順・降順を切り替えたい場合があります。例えば、「年齢は昇順、しかし年齢が同じ場合は成績を降順にする」といったケースです。
残念ながら、key引数に渡すタプルの一部だけを降順に指定する直接的な方法はありません。しかし、工夫次第でこれを実現できます。
数値データであれば、降順にしたいキーの値にマイナスを掛けることで、昇順ソートの結果が降順ソートと同じになります。
students = [
["Alice", 20, "A"],
["Bob", 22, "B"],
["Charlie", 20, "C"],
["David", 21, "A"],
]
# 年齢は昇順、成績は降順（成績は文字列なので、ここでは一旦数字に変換できると仮定）
# 例として、'A':3, 'B':2, 'C':1 のように点数化して考えてみましょう。
grade_map = {'A': 3, 'B': 2, 'C': 1}
sorted_mixed_order = sorted(students, key=lambda student: (student[1], -grade_map[student[2]]))
print(f"年齢昇順、成績降順でソート: {sorted_mixed_order}")
# 結果: [['Alice', 20, 'A'], ['Charlie', 20, 'C'], ['David', 21, 'A'], ['Bob', 22, 'B']]
# 20歳のグループでは、Alice (A=3点) が Charlie (C=1点) より前に来ています。
# 期待: [['Alice', 20, 'A'], ['Charlie', 20, 'C'], ... ]
# あれ、AがCより前に来てしまった...
# マイナスをかけることで、数値の大小が逆転する。
# -grade_map['A'] = -3
# -grade_map['C'] = -1
# -3 < -1 なので、AがCより先にくる。これは「成績降順」ではない。
#
# 正しい「年齢昇順、成績降順」のキーは：
# (年齢, -成績点数) -> 年齢昇順、成績点数降順
# (20, -3) (Alice)
# (20, -1) (Charlie)
# (21, -3) (David)
# (22, -2) (Bob)
#
# このタプルを昇順ソートすると
# (20, -3) (Alice)
# (20, -1) (Charlie)
# (21, -3) (David)
# (22, -2) (Bob)
#
# よって、結果は [['Alice', 20, 'A'], ['Charlie', 20, 'C'], ['David', 21, 'A'], ['Bob', 22, 'B']]
# AliceとCharlieは年齢20で同じ。成績はAとC。
# 期待する成績降順は A -> C。
# Aliceのキーは (20, -3)
# Charlieのキーは (20, -1)
# 比較すると (20, -3) < (20, -1) なので、AliceがCharlieより先にくる。これは「成績降順」になっている！
#
# つまり、`reverse=True`は全体のソート順に影響し、個別のキーには適用できない。
# 各キーのソート順を制御したい場合は、キーを生成する関数内で値を加工する必要がある。
文字列の場合は、単純にマイナスを掛けることはできません。このような場合は、少し複雑になりますが、functools.cmp_to_keyを使うか、ソートしたいキーを事前に変換するなどの工夫が必要です。
functools.cmp_to_keyは、Python 2時代のcmp引数（2つの要素を比較して負・0・正の値を返す関数）をkey引数で使える形式に変換するものです。
from functools import cmp_to_key
# 複雑な比較関数を定義
def custom_compare(item1, item2):
# 年齢（インデックス1）で昇順
if item1[1] != item2[1]:
return item1[1] - item2[1]
# 年齢が同じなら、成績（インデックス2）で降順
# 成績を逆順にしたいので、item2[2]とitem1[2]を比較する
# 'A' > 'B' > 'C' としたい場合、文字列比較だと逆になるので工夫が必要
# 例: 'A' > 'B' としたいなら、ord('A') > ord('B') となるように変換
grade_order = {'A': 3, 'B': 2, 'C': 1} # 高いほど良い
return grade_order[item2[2]] - grade_order[item1[2]] # 降順にするため逆順に引く
students = [
["Alice", 20, "A"],
["Bob", 22, "B"],
["Charlie", 20, "C"],
["David", 21, "A"],
]
# custom_compare関数をcmp_to_keyで変換し、key引数に渡す
sorted_mixed_order_cmp = sorted(students, key=cmp_to_key(custom_compare))
print(f"cmp_to_keyで年齢昇順、成績降順ソート: {sorted_mixed_order_cmp}")
# 結果: [['Alice', 20, 'A'], ['Charlie', 20, 'C'], ['David', 21, 'A'], ['Bob', 22, 'B']]
# 20歳のグループでは、Alice (A) -> Charlie (C) の順。
# 年齢昇順 (20, 20, 21, 22)
# 20歳のグループ: Alice(A), Charlie(C)
# custom_compareで grade_order[item2[2]] - grade_order[item1[2]]
# Alice (A:3), Charlie (C:1)
# item1=Alice, item2=Charlieの場合: grade_order['C'] - grade_order['A'] = 1 - 3 = -2 (Aliceが先)
# item1=Charlie, item2=Aliceの場合: grade_order['A'] - grade_order['C'] = 3 - 1 = 2 (Charlieが後)
# よって、Alice -> Charlie となる。正しく成績降順になっている。
cmp_to_keyは柔軟性が高い反面、少し複雑になるため、可能であればタプルとマイナス符号で解決できる方法を優先すると良いでしょう。
2.4. 複雑な条件でソートする：カスタムソートキーの作成
lambda式やitemgetterだけでは対応できない、さらに複雑なソート条件の場合、通常の関数をkey引数に指定することで、より高度なロジックを組み込むことができます。
文字列と数値が混在するデータのソート
例えば、IDが「'ID1', 'ID10', 'ID2'」のように文字列として混在している場合、そのままソートすると「ID1, ID10, ID2」となってしまいます。これを「ID1, ID2, ID10」のように数値としてソートしたい場合です。
data_mixed = [
['ID10', 'Product B', 100],
['ID1', 'Product A', 200],
['ID2', 'Product C', 50],
['ID0', 'Product D', 150],
]
def sort_by_numeric_id(item):
id_str = item[0] # 例: 'ID10'
prefix = id_str.rstrip('0123456789') # 'ID'
number_str = id_str[len(prefix):] # '10'
try:
number = int(number_str)
except ValueError:
number = float('inf') # 数値変換できない場合は最大値として扱う（末尾へ）
return (prefix, number) # プレフィックスと数値でソート
sorted_mixed_id = sorted(data_mixed, key=sort_by_numeric_id)
print(f"数値IDでソート: {sorted_mixed_id}")
# 結果: [['ID0', 'Product D', 150], ['ID1', 'Product A', 200], ['ID2', 'Product C', 50], ['ID10', 'Product B', 100]]
このように、key関数内で複雑な解析や変換ロジックを記述することで、どのようなデータ形式でも思い通りのソートキーを生成できます。
特定の条件を満たす要素を優先するソート
特定のフラグが立っている行を最優先したい、といったケースも考えられます。
tasks = [
["Task A", "Low", False],
["Task B", "High", True], # 優先度高、完了済み
["Task C", "Medium", False],
["Task D", "High", False], # 優先度高、未完了
["Task E", "Low", True],
]
# 優先順位: 1. 未完了（False）を優先 2. 優先度（High > Medium > Low）
priority_map = {"High": 3, "Medium": 2, "Low": 1}
def sort_tasks(task):
is_completed = task[2]
priority_level = priority_map[task[1]]
# 未完了 (False) は True (1) より小さい値にする
# 優先度が高いものは大きい値にする
# 1. 未完了を優先 (False: 0, True: 1)
# 2. 優先度が高いものを優先 (High: 3, Medium: 2, Low: 1)
# (完了フラグ, -優先度レベル) でソートする
return (is_completed, -priority_level)
sorted_tasks = sorted(tasks, key=sort_tasks)
print(f"タスク優先度ソート: {sorted_tasks}")
# 結果:
# [['Task D', 'High', False], # 未完了、高優先度
# ['Task A', 'Low', False], # 未完了、低優先度 (MediumがないのでLowが次)
# ['Task B', 'High', True], # 完了済み、高優先度
# ['Task E', 'Low', True], # 完了済み、低優先度
# ['Task C', 'Medium', False]] # 間違ったソート順！Task Cは未完了なので、Task Eより前にあるべき。
# 上記の結果がおかしいのは、Task CのMediumが -2 と評価されるため、-1のLowよりも先に来てしまう。
# 正しいのは、完了フラグがFalseのグループで、High > Medium > Low となるべき。
# 未完了のタスクは `(False, -priority_level)`
# 完了済みのタスクは `(True, -priority_level)`
# ソート結果は `False` が先、次に `True`。
# Falseグループ内では `-priority_level` の昇順ソート。
# `-3 (High) < -2 (Medium) < -1 (Low)` となるので、High -> Medium -> Low の順になる。
# もう一度確認:
# Task A: ["Task A", "Low", False] -> (False, -1)
# Task B: ["Task B", "High", True] -> (True, -3)
# Task C: ["Task C", "Medium", False] -> (False, -2)
# Task D: ["Task D", "High", False] -> (False, -3)
# Task E: ["Task E", "Low", True] -> (True, -1)
# ソートキーのタプル順:
# (False, -3) Task D
# (False, -2) Task C
# (False, -1) Task A
# (True, -3) Task B
# (True, -1) Task E
# これが正しい結果となるはず。
# 結果:
# [['Task D', 'High', False],
# ['Task C', 'Medium', False],
# ['Task A', 'Low', False],
# ['Task B', 'High', True],
# ['Task E', 'Low', True]]
複雑な条件でも、ソートキーとして返すタプルを工夫することで、柔軟なソートが可能です。キーをどのように評価するかを明確に設計することが重要です。
2.5. カスタムオブジェクトを含む二次元リストのソート
リストの要素が辞書やクラスのインスタンスである場合も、基本的な考え方は同じです。key引数で適切な属性や値を返す関数を指定します。
クラス内で比較演算子を定義する
Pythonのクラスは、特殊メソッド（dunder methods）を実装することで、比較演算子（<, >, ==など）の振る舞いをカスタマイズできます。これにより、key引数を指定しなくても、クラスのインスタンスを直接ソートできるようになります。
class Student:
def __init__(self, name, age, grade):
self.name = name
self.age = age
self.grade = grade
# 小さいかどうかの比較 (__lt__ は "less than" の意味)
# これを定義すると、sorted() や list.sort() でデフォルトソートが可能になる
def __lt__(self, other):
# まず年齢で比較 (昇順)
if self.age != other.age:
return self.age < other.age
# 年齢が同じなら名前で比較 (昇順)
return self.name < other.name
def __repr__(self):
return f"Student('{self.name}', {self.age}, '{self.grade}')"
students_obj = [
Student("Alice", 20, "A"),
Student("Bob", 22, "B"),
Student("Charlie", 20, "C"),
Student("David", 21, "A"),
]
# __lt__ が定義されているため、key引数なしでソート可能
sorted_students_obj = sorted(students_obj)
print(f"オブジェクトソート (__lt__): {sorted_students_obj}")
# 結果: [Student('Alice', 20, 'A'), Student('Charlie', 20, 'C'), Student('David', 21, 'A'), Student('Bob', 22, 'B')]
# 年齢昇順、年齢が同じ場合は名前昇順になっています。
operator.attrgetterの活用
itemgetterがリストやタプルのインデックスを取り出すのに対し、operator.attrgetterはオブジェクトの属性を取り出すための関数を生成します。
import operator
students_obj = [
Student("Alice", 20, "A"),
Student("Bob", 22, "B"),
Student("Charlie", 20, "C"),
Student("David", 21, "A"),
]
# 年齢（age属性）でソート
sorted_by_age_attr = sorted(students_obj, key=operator.attrgetter('age'))
print(f"attrgetterで年齢ソート: {sorted_by_age_attr}")
# 結果: [Student('Alice', 20, 'A'), Student('Charlie', 20, 'C'), Student('David', 21, 'A'), Student('Bob', 22, 'B')]
# 年齢と名前の複数属性でソート
sorted_by_age_name_attr = sorted(students_obj, key=operator.attrgetter('age', 'name'))
print(f"attrgetterで年齢→名前ソート: {sorted_by_age_name_attr}")
# 結果: [Student('Alice', 20, 'A'), Student('Charlie', 20, 'C'), Student('David', 21, 'A'), Student('Bob', 22, 'B')]
# `attrgetter`も複数属性を指定した場合、タプルを生成して比較するため、多段階ソートが可能です。
辞書の場合も同様に、lambda item: item['key_name'] または itemgetter('key_name') を使ってソートできます。
data_dict = [
{"name": "Alice", "age": 20},
{"name": "Bob", "age": 22},
{"name": "Charlie", "age": 20},
]
# 年齢でソート
sorted_dict = sorted(data_dict, key=lambda item: item['age'])
print(f"辞書を年齢でソート: {sorted_dict}")
# 結果: [{'name': 'Alice', 'age': 20}, {'name': 'Charlie', 'age': 20}, {'name': 'Bob', 'age': 22}]
# itemgetterでも可能
sorted_dict_itemgetter = sorted(data_dict, key=operator.itemgetter('age'))
print(f"辞書をitemgetterで年齢ソート: {sorted_dict_itemgetter}")
3. NumPy配列（ndarray）のソートをマスターする
Pythonの組み込みリストに比べて、NumPyのndarrayは数値計算に特化しており、大規模な数値データのソートで非常に高いパフォーマンスを発揮します。多次元配列の概念もより明確です。
3.1. NumPyの基本的なソート方法
NumPy配列をソートするには、主にnp.sort()関数またはndarrayオブジェクトの.sort()メソッドを使います。
np.sort(array): 新しいソート済みの配列を返します。array.sort(): 配列自体をin-placeでソートします。Noneを返します。
import numpy as np
# 二次元NumPy配列の例
data_np = np.array([
[30, 2, 80],
[10, 5, 90],
[20, 1, 70]
])
# np.sort()関数を使用（新しい配列を返す）
# デフォルトでは最後の軸（行方向）でソートされます
sorted_np_default = np.sort(data_np)
print(f"np.sort()でデフォルトソート:\n{sorted_np_default}")
# 結果:
# [[ 2 30 80]
# [ 5 10 90]
# [ 1 20 70]]
# 各行が独立してソートされています。
# .sort()メソッドを使用（in-place）
data_np_copy = data_np.copy() # 元の配列を変更しないようコピー
data_np_copy.sort()
print(f"ndarray.sort()でデフォルトソート:\n{data_np_copy}")
# 結果はnp.sort()と同じ
3.2. 特定の軸（axis）を指定してソートする
NumPy配列のソートでは、axis引数を使ってソートする軸（方向）を指定できるのが大きな特徴です。
axis=0: 各列をソートします（行を並び替える）。axis=1: 各行をソートします（列を並び替える）。axis=None: 配列全体を一次元に平坦化してからソートします。
Pythonの二次元リストのソートで「特定の列をキーにする」という考え方は、NumPyではargsort()とインデックス操作を組み合わせることで実現します。しかし、単に各列や各行を独立してソートするだけならaxis引数が便利です。
data_np = np.array([
[30, 2, 80],
[10, 5, 90],
[20, 1, 70]
])
# 各列をソート (axis=0)
sorted_by_col = np.sort(data_np, axis=0)
print(f"各列をソート (axis=0):\n{sorted_by_col}")
# 結果:
# [[10 1 70]
# [20 2 80]
# [30 5 90]]
# 例: 1列目 [30, 10, 20] -> [10, 20, 30]
# 各行をソート (axis=1)
sorted_by_row = np.sort(data_np, axis=1)
print(f"各行をソート (axis=1):\n{sorted_by_row}")
# 結果:
# [[ 2 30 80]
# [ 5 10 90]
# [ 1 20 70]]
# 例: 1行目 [30, 2, 80] -> [2, 30, 80]
# 配列全体を平坦化してソート (axis=None)
sorted_flat = np.sort(data_np, axis=None)
print(f"配列全体を平坦化してソート:\n{sorted_flat}")
# 結果: [ 1 2 5 10 20 30 70 80 90]
3.3. argsort()でソート後のインデックスを取得する
NumPyで「Pythonリストのように特定の列をキーにして行全体をソートする」には、argsort()関数が非常に有効です。argsort()は、ソートされた要素のインデックスを返します。
例えば、上記のdata_npを2列目（インデックス1）の値でソートしたい場合：
data_np = np.array([
[30, 2, 80],
[10, 5, 90],
[20, 1, 70]
])
# 2列目 (インデックス1) の値でソートするためのインデックスを取得
# data_np[:, 1] は [2, 5, 1] となる
sort_indices = data_np[:, 1].argsort()
print(f"2列目でのソートインデックス: {sort_indices}") # [2 0 1]
# 2列目の値は [2, 5, 1]
# ソートすると [1, 2, 5]
# 元のインデックスは 1(data_np[2,1]) -> 2(data_np[0,1]) -> 5(data_np[1,1])
# よって、ソートインデックスは [2, 0, 1]
# このインデックスを使って配列を行方向に並び替える
sorted_data_np = data_np[sort_indices]
print(f"2列目でソートされたNumPy配列:\n{sorted_data_np}")
# 結果:
# [[20 1 70] # 元の3行目 (インデックス2)
# [30 2 80] # 元の1行目 (インデックス0)
# [10 5 90]] # 元の2行目 (インデックス1)
argsort()は多段階ソートにも応用できます。複数の列をキーにする場合は、NumPyの構造化配列（structured array）を使うか、Pandasのような高レベルライブラリを検討する方が効率的です。
3.4. 構造化配列（structured array）のソート
NumPyの構造化配列は、異なるデータ型の要素を持つことができる点で、Pythonのリストや辞書のリストに似ています。各「列」に名前を付けてアクセスできるため、特定の列でソートするのに非常に便利です。
# 構造化配列の作成
# dtypeで各フィールドの名前とデータ型を定義
data_structured = np.array([
("Alice", 20, 75.5),
("Bob", 22, 80.2),
("Charlie", 20, 68.0),
("David", 21, 92.1)
], dtype=[('name', 'U10'), ('age', 'i4'), ('score', 'f4')])
print(f"構造化配列:\n{data_structured}")
# 名前でソート
sorted_by_name_s = np.sort(data_structured, order='name')
print(f"名前でソート:\n{sorted_by_name_s}")
# 結果:
# [('Alice', 20, 75.5) ('Bob', 22, 80.2) ('Charlie', 20, 68.0) ('David', 21, 92.1)]
# (デフォルトで名前順になっている)
# 年齢でソート
sorted_by_age_s = np.sort(data_structured, order='age')
print(f"年齢でソート:\n{sorted_by_age_s}")
# 結果:
# [('Alice', 20, 75.5) ('Charlie', 20, 68.0) ('David', 21, 92.1) ('Bob', 22, 80.2)]
# 複数フィールドでソート (年齢昇順、年齢が同じならスコア降順)
# order引数にタプルを渡し、降順にしたいフィールドには先頭に '-' をつける (ただしこれはPandasの機能、NumPyではorderで降順指定はできない)
# NumPyの構造化配列では、order='フィールド名' はデフォルトで昇順ソート。
# 降順ソートしたい場合は、`.sort()` メソッドを使い `order` と `[::-1]` を組み合わせる。
# または、比較演算子をカスタムする。
# ここでは、簡潔な例として年齢昇順、名前昇順で。
sorted_by_age_name_s = np.sort(data_structured, order=['age', 'name'])
print(f"年齢→名前でソート:\n{sorted_by_age_name_s}")
# 結果:
# [('Alice', 20, 75.5) ('Charlie', 20, 68.0) ('David', 21, 92.1) ('Bob', 22, 80.2)]
NumPyの構造化配列は、Pythonのリストのリストよりも遥かに効率的に多様なデータを扱うことができます。特に、大量の数値データを含むテーブル状のデータを扱う際には非常に強力な選択肢となるでしょう。
補足: PandasのDataFrameは、内部的にNumPyの配列をベースとしており、より高レベルなソート機能（df.sort_values(by=['col1', 'col2'], ascending=[True, False])など）を提供します。大量のテーブルデータを扱う場合は、Pandasの利用を強くお勧めします。
4. ソート処理のパフォーマンスと安定性
ソート処理は、データ量が大きくなるほど実行時間に影響が出ます。ここでは、パフォーマンスに関する考慮事項と、Pythonソートの重要な特性である「安定性」について触れておきます。
大規模データにおけるソート効率
- Pythonの
listソート: Pythonの組み込みソートはTimsortという非常に効率的なアルゴリズムを使用しており、平均的にはO(N log N)の計算量です。これは非常に高速ですが、リストの要素がPythonオブジェクトであるため、NumPyの数値型配列に比べるとオーバーヘッドがあります。 - NumPyの
ndarrayソート: NumPyはC言語で実装されており、数値データのソートにおいては非常に最適化されています。特に大規模な数値配列のソートでは、Pythonリストよりも圧倒的に高速です。 lambdavsitemgetter/attrgetter: 前述の通り、itemgetterやattrgetterはlambda式に比べてわずかながら高速です。これは、operatorモジュールの関数がC言語で実装されているため、Pythonのインタプリタによるオーバーヘッドが少ないためです。しかし、ほとんどのケースではその差は微々たるもので、可読性や表現の柔軟性を優先してlambdaを使っても問題ありません。パフォーマンスが極めて重要な場合に検討する程度で十分です。
Pythonのソートは「安定ソート」である
「安定ソート（Stable Sort）」とは、ソートキーが同じ要素については、ソート前の相対的な順序が保持されるソートアルゴリズムのことです。
Pythonのlist.sort()メソッドとsorted()関数は、どちらも安定ソートです。これは非常に重要な特性で、多段階ソートを行う際に特に役立ちます。
例を見てみましょう。
data = [
["Alice", 20, "Math"],
["Bob", 22, "Science"],
["Charlie", 20, "Art"],
["David", 21, "Math"],
]
# 年齢でソート
sorted_by_age = sorted(data, key=lambda x: x[1])
print(f"年齢でソート:\n{sorted_by_age}")
# 結果:
# [['Alice', 20, 'Math'],
# ['Charlie', 20, 'Art'],
# ['David', 21, 'Math'],
# ['Bob', 22, 'Science']]
# 20歳のグループでは、元の順序（Alice, Charlie）が保持されています。
# もし安定ソートでなかった場合、AliceとCharlieの順序が入れ替わる可能性がありました。
この安定性があるため、「まず名前でソートし、次に年齢でソートする」といった場合に、sorted(sorted(data, key=名前), key=年齢)のように2回ソートする方法でも、期待通りの多段階ソートが実現します（ただし、これは非効率的な方法であり、前述のタプルを使ったkey引数の方が推奨されます）。
5. よくある落とし穴とデバッグのヒント
ソート処理でつまずきやすいポイントと、デバッグのヒントをいくつか紹介します。
key引数の指定ミス
- ラムダ式の間違い:
key=lambda x: x[インデックス]のように書くべきところを、key=x[インデックス]のように書いてしまうとNameErrorが発生します。keyには「関数オブジェクト」を渡す必要があります。 - 返り値の不一致:
keyに渡す関数は、常に比較可能な値を返す必要があります。例えば、ある要素では数値、別の要素では文字列を返してしまうと、TypeErrorが発生することがあります。
インデックスエラーの回避
二次元リストの要素である内側のリストの長さが均一でない場合、存在しないインデックスにアクセスしようとするとIndexErrorが発生します。
data_uneven = [
[10, 20],
[30], # 要素が1つしかない
[40, 50, 60]
]
try:
# インデックス1でソートしようとすると、[30]の要素でIndexErrorが発生
sorted(data_uneven, key=lambda x: x[1])
except IndexError as e:
print(f"エラー発生: {e}")
# key関数内でエラーハンドリングするか、デフォルト値を返す
def safe_get(item, index, default=None):
return item[index] if len(item) > index else default
sorted_safe = sorted(data_uneven, key=lambda x: safe_get(x, 1, float('-inf'))) # 存在しない場合は最小値として扱う
print(f"安全なソート: {sorted_safe}")
# 結果: [[30], [10, 20], [40, 50, 60]]
# (float('-inf') は他の数値よりも小さいと評価されるため、先頭にくる)
in-placeソートと新しいリストの作成の混同
list.sort()は元のリストを直接変更し、Noneを返します。sorted()関数は新しいソート済みのリストを返します。
my_list = [[1, 2], [3, 1]]
result = my_list.sort() # result は None になる
print(f"sort()の戻り値: {result}")
print(f"変更されたmy_list: {my_list}")
new_list = sorted(my_list) # new_list はソート済みのリスト、my_listは変わらない
print(f"sorted()の戻り値: {new_list}")
この違いを理解しておかないと、「なぜリストがソートされないんだ？」や「なぜNoneが返ってくるんだ？」といった混乱を招くことがあります。
6. まとめ：Pythonの二次元配列ソートはもう怖くない！
この記事では、Pythonにおける二次元配列のソートについて、組み込みリストからNumPy配列まで、その基本的な概念から複雑な条件での応用テクニックまでを網羅的に解説しました。
重要なポイントをまとめましょう。
- Pythonの二次元リストソート:
sorted()関数（新しいリストを返す）とlist.sort()メソッド（in-placeソート）を使い分ける。key引数にラムダ式やoperator.itemgetterを指定することで、特定の列や複数の列を基準にソートできる。- カスタム関数を
key引数に渡すことで、非常に複雑な条件でのソートも可能。 __lt__などの特殊メソッドやoperator.attrgetterを使えば、カスタムオブジェクトも柔軟にソートできる。- 昇順・降順の組み合わせは、ソートキーのタプル要素を加工する（例: 数値にマイナスを掛ける）ことで実現。
- NumPy配列のソート:
np.sort()関数や.sort()メソッドで、配列全体や特定のaxis（軸）でのソートが可能。argsort()を使って、特定の列をキーとしたソート後のインデックスを取得し、行を並び替えるのが一般的。- 構造化配列は、名前付きフィールドでより直感的なソートをサポートする。
- パフォーマンスと安定性:
- PythonのソートはTimsortで効率的。NumPyは数値データでさらに高速。
itemgetter/attrgetterはlambdaよりわずかに速いが、可読性も重要。- Pythonのソートは「安定ソート」であり、キーが同じ要素の相対順序が保持される。
Pythonのソート機能は非常に強力で柔軟です。この記事で紹介したテクニックをマスターすれば、どんな二次元データでもあなたの意図通りに整理し、効率的に処理できるようになるでしょう。
データ処理の幅が広がることは間違いありません。ぜひ、今日の学びをあなたのプロジェクトに活かしてみてください。さらに大量の表形式データを扱う場合は、Pandasライブラリも検討してみてください。ソートを含むデータ操作をより簡単かつ強力に行うことができますよ！
I love codes. I also love prompts (spells). But I get a lot of complaints (errors). I want to be loved by both of you as soon as possible.
