【Python】リスト（list）のソート方法 ~sort, sorted~

Pythonのリスト（list）をソートする方法（sortメソッド、sorted関数）の基本について解説します。また、key引数でキーを指定してソートする方法についても説明します。

Pythonのリスト（list）をソートする

Pythonでは、リストをソートするためにsortメソッドとsorted関数が用意されており、簡単に並べ替えを行うことができます。

名称が非常に似たものですが、以下のような違いがあります。「リストそのものをソートする」か「ソートしたリストを返却するか」といった違いがあります。

この記事では、基本的なsortメソッドやsorted関数を使ったリストのソート方法を紹介します。

また、ソートでよく実施するkey引数にソート条件を指定する応用例を紹介します。具体的には、lambda関数を使用した方法とoperatorモジュールのitemgetter、attrgetterを使用した方法を説明します。

sortメソッド、sorted関数の基本的な使い方

リスト（list）を昇順に並べ替える方法

sortメソッドを使用する場合

sortメソッドを使用する場合は、以下の例のように使用します。

# リストのデータそのものをソートする。（sortメソッド）
data = [15, 5, 20, 1, 10, 25]
data.sort()
print(f"data: {data}")

【実行結果】
data: [1, 5, 10, 15, 20, 25]

上記例を見ると、元のリスト自体が並べ替えられていることが分かります。並べ替え対象のデータを直接並べ替えたいときにはsortメソッドを使いましょう。

sorted関数を使用する場合

sorted関数を使用する場合は、以下のようにsorted関数に対象のリストを渡して使用します。

# リストを昇順に並べ替えたリストを返却する。（sorted関数）
data = [15, 5, 20, 1, 10, 25]
sorted_data = sorted(data)
print(f"data: {data}")
print(f"sorted_data: {sorted_data}")

【実行結果】
data: [15, 5, 20, 1, 10, 25]
sorted_data: [1, 5, 10, 15, 20, 25]

上記例を見ると、元のリストは変更されていません。もともとのデータは残したまま、並べ替えたデータを用意したいときにはsorted関数を使いましょう。

リスト（list）を降順に並べ替える方法

sortメソッドを使用する場合

リストを降順に並べ替える際には、以下のようにsortメソッドのreverseオプションにTrueを設定します。

# リストのデータそのものを降順でソートする。（sortメソッド、reverse）
data = [15, 5, 20, 1, 10, 25]
data.sort(reverse=True)
print(f"data: {data}")

【実行結果】
data: [25, 20, 15, 10, 5, 1]

結果を見ると降順でソートができていることが分かるかと思います。

sorted関数を使用する場合

sorted関数もsortメソッド同様で、以下のようにreverseオプションにTrueを設定することで、降順での並べ替えることができます。

# リストを降順に並べ替えたリストを返却する。（sorted、reverse）
data = [15, 5, 20, 1, 10, 25]
sorted_data = sorted(data, reverse=True)
print(f"data: {data}")
print(f"sorted_data: {sorted_data}")

【実行結果】
data: [15, 5, 20, 1, 10, 25]
sorted_data: [25, 20, 15, 10, 5, 1]

結果を見ると降順でソートができていることが分かるかと思います。

keyを指定してリストをソートする

上記では非常にシンプルなソート例を見てきました。Pythonのリストでは、リストのリストや辞書のリスト、クラスオブジェクトのリスト等も作れます。このような場合には、特定キーを指定してソートが必要になるケースが多いです。

sortメソッドやsortedメソッドにはkey引数があり、この引数を指定することで特定キーとして指定した値を基準にデータをソートすることができます。以降では、よく使用されるlambda関数を使った指定方法とoperatorモジュールの関数であるitemgetterやattrgetterを使用した方法を解説していきます。

lambda関数を用いたkeyの指定方法

sortメソッドやsort関数でkey引数を指定する場合には、lambda関数でキーの情報を指定する方法が一般的に利用されます。ここでは、sortメソッド、sort関数それぞれで簡単な例を使って紹介していきます。

なお、lambda関数については「ラムダ（lambda）関数：無名関数の使い方」でまとめていますので参考にしてください。

sortメソッドを使用する場合

リストのリスト

sortメソッドのkey引数指定方法をリストのリストデータを対象に使用例をみてみましょう。以下の例は、ID、名前、値を持っているリストを複数持っているようなリストです。このデータを各列(属性)の値を基準にソートしてみましょう。

data = [
    ["ID002", "john", 70],
    ["ID001", "mike", 20],
    ["ID005", "jane", 1],
    ["ID004", "aiko", 50],
    ["ID003", "taro", 5],
]

# ===== keyを指定してソートする (sortメソッド)
# 0列目でソートする場合
data.sort(key=lambda d: d[0])
print(f"data: {data}")
# 1列目でソートする場合
data.sort(key=lambda d: d[1])
print(f"data: {data}")
# 2列目でソートする場合
data.sort(key=lambda d: d[2])
print(f"data: {data}")

【実行結果】
data: [['ID001', 'mike', 20], ['ID002', 'john', 70], ['ID003', 'taro', 5], ['ID004', 'aiko', 50], ['ID005', 'jane', 1]]
data: [['ID004', 'aiko', 50], ['ID005', 'jane', 1], ['ID002', 'john', 70], ['ID001', 'mike', 20], ['ID003', 'taro', 5]]
data: [['ID005', 'jane', 1], ['ID003', 'taro', 5], ['ID001', 'mike', 20], ['ID004', 'aiko', 50], ['ID002', 'john', 70]]

リストに含まれる各リストのどの列をキーにするかはlambda関数で指定します。

例えば、「lambda d: d[0]」という関数は、引数dを受け取ってdの0番目を返却する関数です。この処理をするlambda関数をkey引数に渡してあげることで、sortメソッド内部では対象データリストをlambda関数を通した返却値をもとにソートをします。

実行結果を見ると指定した列番号の値でリストがソートされていることが分かるかと思います。

辞書のリストデータ

辞書のリストでも考え方は同じです。以下の例で見てみましょう。

data = [
    {"id": "ID002", "name": "john", "value": 70},
    {"id": "ID001", "name": "mike", "value": 20},
    {"id": "ID005", "name": "jane", "value": 1},
    {"id": "ID004", "name": "aiko", "value": 50},
    {"id": "ID003", "name": "taro", "value": 5},
]

# ===== keyを指定してソートする (sortメソッド)
# idでソートする場合
data.sort(key=lambda d: d["id"])
print(f"data: {data}")
# nameでソートする場合
data.sort(key=lambda d: d["name"])
print(f"data: {data}")
# valueでソートする場合
data.sort(key=lambda d: d["value"])
print(f"data: {data}")

【実行結果】
data: [{'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID002', 'name': 'john', 'value': 70}, {'id': 'ID003', 'name': 'taro', 'value': 5}, {'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID005', 'name': 'jane', 'value': 1}]
data: [{'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID005', 'name': 'jane', 'value': 1}, {'id': 'ID002', 'name': 'john', 'value': 70}, {'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID003', 'name': 'taro', 'value': 5}]
data: [{'id': 'ID005', 'name': 'jane', 'value': 1}, {'id': 'ID003', 'name': 
'taro', 'value': 5}, {'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID002', 'name': 'john', 'value': 70}]

辞書のリスト場合は「lambda d: d["id"]」のように辞書のキーに対応する値を返すようなlambda関数を指定します。

クラスオブジェクトのリストデータ

クラスのオブジェクトのリストデータの場合には、オブジェクトの属性を使ってソートすることが可能です。以下の例で見てみましょう。

class Sample:
    """サンプルクラス"""

    def __init__(self, id, name, value) -> None:
        self.id = id
        self.name = name
        self.value = value

    def __repr__(self) -> str:
        return repr((self.id, self.name, self.value))


data = [
    Sample("ID002", "john", 70),
    Sample("ID001", "mike", 20),
    Sample("ID005", "jane", 1),
    Sample("ID004", "aiko", 50),
    Sample("ID003", "taro", 5),
]

# ===== keyを指定してソートする (sortメソッド)
# id属性でソートする場合
data.sort(key=lambda d: d.id)
print(f"data: {data}")
# name属性でソートする場合
data.sort(key=lambda d: d.name)
print(f"data: {data}")
# value属性でソートする場合
data.sort(key=lambda d: d.value)
print(f"data: {data}")

【実行結果】
data: [('ID001', 'mike', 20), ('ID002', 'john', 70), ('ID003', 'taro', 5), ('ID004', 'aiko', 50), ('ID005', 'jane', 1)]
data: [('ID004', 'aiko', 50), ('ID005', 'jane', 1), ('ID002', 'john', 70), ('ID001', 'mike', 20), ('ID003', 'taro', 5)]
data: [('ID005', 'jane', 1), ('ID003', 'taro', 5), ('ID001', 'mike', 20), ('ID004', 'aiko', 50), ('ID002', 'john', 70)]

クラスオブジェクトのリスト場合は「lambda d: d.id」のようにすることで、クラスオブジェクトの属性値を取得するようなlambda関数を指定します。

複数キーで優先順位をつけてソートする場合

上記の例では、一つのキーでソートする例を見てきました。複数キーで優先順位をつけてソートする場合には以下の例のように指定することができます。

data = [
    [3, 20, "b"],
    [1, 20, "b"],
    [2, 10, "a"],
    [1, 10, "a"],
    [2, 20, "b"],
    [3, 10, "a"],
    [1, 30, "c"],
    [3, 30, "c"],
    [2, 30, "c"],
]

# ===== 複数keyを指定してソートする (sortメソッド)
data.sort(key=lambda d: (d[0], d[1]))
print(f"data: {data}")

【実行結果】
data: [[1, 10, 'a'], [1, 20, 'b'], [1, 30, 'c'], [2, 10, 'a'], [2, 20, 'b'], [2, 30, 'c'], [3, 10, 'a'], [3, 20, 'b'], [3, 30, 'c']]

この例では、第1優先で0列目、第2優先で1列目の値を参考にソートしています。優先順位順にデータを持つtupleを返すようにlambda関数を指定します。

sorted関数を使用する場合

sorted関数についても、key引数に指定するという点においてsortメソッドと同じです。sortメソッドで紹介した例のsorted関数版にしたソースと結果を紹介します。

リストのリストデータ

data = [
    ["ID002", "john", 70],
    ["ID001", "mike", 20],
    ["ID005", "jane", 1],
    ["ID004", "aiko", 50],
    ["ID003", "taro", 5],
]

# ===== keyを指定してソートする (sorted関数)
# 0列目でソートする場合
sorted_data = sorted(data, key=lambda d: d[0])
print(f"sorted_data: {sorted_data}")
# 1列目でソートする場合
sorted_data = sorted(data, key=lambda d: d[1])
print(f"sorted_data: {sorted_data}")
# 2列目でソートする場合
sorted_data = sorted(data, key=lambda d: d[2])
print(f"sorted_data: {sorted_data}")

【実行結果】
sorted_data: [['ID001', 'mike', 20], ['ID002', 'john', 70], ['ID003', 'taro', 5], ['ID004', 'aiko', 50], ['ID005', 'jane', 1]]
sorted_data: [['ID004', 'aiko', 50], ['ID005', 'jane', 1], ['ID002', 'john', 70], ['ID001', 'mike', 20], ['ID003', 'taro', 5]]
sorted_data: [['ID005', 'jane', 1], ['ID003', 'taro', 5], ['ID001', 'mike', 
20], ['ID004', 'aiko', 50], ['ID002', 'john', 70]]

辞書のリストデータ

data = [
    {"id": "ID002", "name": "john", "value": 70},
    {"id": "ID001", "name": "mike", "value": 20},
    {"id": "ID005", "name": "jane", "value": 1},
    {"id": "ID004", "name": "aiko", "value": 50},
    {"id": "ID003", "name": "taro", "value": 5},
]

# ===== keyを指定してソートする (sortdメソッド)
# idでソートする場合
sorted_data = sorted(data, key=lambda d: d["id"])
print(f"sorted_data: {sorted_data}")
# nameでソートする場合
sorted_data = sorted(data, key=lambda d: d["name"])
print(f"sorted_data: {sorted_data}")
# valueでソートする場合
sorted_data = sorted(data, key=lambda d: d["value"])
print(f"sorted_data: {sorted_data}")

【実行結果】
sorted_data: [{'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID002', 
'name': 'john', 'value': 70}, {'id': 'ID003', 'name': 'taro', 'value': 5}, {'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID005', 'name': 'jane', 'value': 1}]
sorted_data: [{'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID005', 
'name': 'jane', 'value': 1}, {'id': 'ID002', 'name': 'john', 'value': 70}, {'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID003', 'name': 'taro', 'value': 5}]
sorted_data: [{'id': 'ID005', 'name': 'jane', 'value': 1}, {'id': 'ID003', 'name': 'taro', 'value': 5}, {'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID002', 'name': 'john', 
'value': 70}]

クラスオブジェクトのリストデータ

class Sample:
    """サンプルクラス"""

    def __init__(self, id, name, value) -> None:
        self.id = id
        self.name = name
        self.value = value

    def __repr__(self) -> str:
        return repr((self.id, self.name, self.value))


data = [
    Sample("ID002", "john", 70),
    Sample("ID001", "mike", 20),
    Sample("ID005", "jane", 1),
    Sample("ID004", "aiko", 50),
    Sample("ID003", "taro", 5),
]

# ===== keyを指定してソートする (sorted関数)
# id属性でソートする場合
sorted_data = sorted(data, key=lambda d: d.id)
print(f"sorted_data: {sorted_data}")
# name属性でソートする場合
sorted_data = sorted(data, key=lambda d: d.name)
print(f"sorted_data: {sorted_data}")
# value属性でソートする場合
sorted_data = sorted(data, key=lambda d: d.value)
print(f"sorted_data: {sorted_data}")

【実行結果】
sorted_data: [('ID001', 'mike', 20), ('ID002', 'john', 70), ('ID003', 'taro', 5), ('ID004', 'aiko', 50), ('ID005', 'jane', 1)]
sorted_data: [('ID004', 'aiko', 50), ('ID005', 'jane', 1), ('ID002', 'john', 70), ('ID001', 'mike', 20), ('ID003', 'taro', 5)]
sorted_data: [('ID005', 'jane', 1), ('ID003', 'taro', 5), ('ID001', 'mike', 
20), ('ID004', 'aiko', 50), ('ID002', 'john', 70)]

複数キーで優先順位をつけてソートする場合

data = [
    [3, 20, "b"],
    [1, 20, "b"],
    [2, 10, "a"],
    [1, 10, "a"],
    [2, 20, "b"],
    [3, 10, "a"],
    [1, 30, "c"],
    [3, 30, "c"],
    [2, 30, "c"],
]

# ===== 複数keyを指定してソートする (sorted関数)
sorted_data = sorted(data, key=lambda d: (d[0], d[1]))
print(f"sorted data: {sorted_data}")

【実行結果】
sorted data: [[1, 10, 'a'], [1, 20, 'b'], [1, 30, 'c'], [2, 10, 'a'], [2, 20, 'b'], [2, 30, 'c'], [3, 10, 'a'], [3, 20, 'b'], [3, 30, 'c']]

operatorモジュールの関数を使用したkeyの指定方法

上記で説明したlambda関数を用いたkey引数の指定は一般的に使われます。しかし、lambda関数で指定しなくても高速で扱いやすい関数がoperatorモジュールで提供されています。

以降で具体的にoperatorモジュールのitemgetterとattrgetterの使い方を紹介します。

sortメソッドを使用する場合

リストのリスト (itemgetter)

sortメソッドのkey引数に指定する場合には、以下のようにitemgetterを使用できます。

from operator import itemgetter

data = [
    ["ID002", "john", 70],
    ["ID001", "mike", 20],
    ["ID005", "jane", 1],
    ["ID004", "aiko", 50],
    ["ID003", "taro", 5],
]

# ===== keyを指定してソートする (sortメソッド)
# 0列目でソートする場合
data.sort(key=itemgetter(0))
print(f"data: {data}")
# 1列目でソートする場合
data.sort(key=itemgetter(1))
print(f"data: {data}")
# 2列目でソートする場合
data.sort(key=itemgetter(2))
print(f"data: {data}")

【実行結果】
data: [['ID001', 'mike', 20], ['ID002', 'john', 70], ['ID003', 'taro', 5], ['ID004', 'aiko', 50], ['ID005', 'jane', 1]]
data: [['ID004', 'aiko', 50], ['ID005', 'jane', 1], ['ID002', 'john', 70], ['ID001', 'mike', 20], ['ID003', 'taro', 5]]
data: [['ID005', 'jane', 1], ['ID003', 'taro', 5], ['ID001', 'mike', 20], ['ID004', 'aiko', 50], ['ID002', 'john', 70]]

itemgetterを使用する場合には、operatorからインポートが必要です。上記例のようにitemgetterの引数に対象とするリストの列番号を入れれば、指定した値を基準にソートがされます。lambda関数で指定するよりはシンプルに記載することができ、かつ高速です。

辞書のリストデータ (itemgetter)

辞書のリストデータの場合も、同様にitemgetterを使用できます。

from operator import itemgetter

data = [
    {"id": "ID002", "name": "john", "value": 70},
    {"id": "ID001", "name": "mike", "value": 20},
    {"id": "ID005", "name": "jane", "value": 1},
    {"id": "ID004", "name": "aiko", "value": 50},
    {"id": "ID003", "name": "taro", "value": 5},
]

# ===== keyを指定してソートする (sortメソッド)
# idでソートする場合
data.sort(key=itemgetter("id"))
print(f'data: {data}')
# nameでソートする場合
data.sort(key=itemgetter("name"))
print(f'data: {data}')
# valueでソートする場合
data.sort(key=itemgetter("value"))
print(f'data: {data}')

【実行結果】
data: [{'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID002', 'name': 'john', 'value': 70}, {'id': 'ID003', 'name': 'taro', 'value': 5}, {'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID005', 'name': 'jane', 'value': 1}]
data: [{'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID005', 'name': 'jane', 'value': 1}, {'id': 'ID002', 'name': 'john', 'value': 70}, {'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID003', 'name': 'taro', 'value': 5}]
data: [{'id': 'ID005', 'name': 'jane', 'value': 1}, {'id': 'ID003', 'name': 
'taro', 'value': 5}, {'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID002', 'name': 'john', 'value': 70}]

クラスオブジェクトのリストデータ (attrgetter)

クラスオブジェクトのリストデータの場合は、itemgetterではなくattrgetterを使用します。

from operator import attrgetter


class Sample:
    """サンプルクラス"""

    def __init__(self, id, name, value) -> None:
        self.id = id
        self.name = name
        self.value = value

    def __repr__(self) -> str:
        return repr((self.id, self.name, self.value))


data = [
    Sample("ID002", "john", 70),
    Sample("ID001", "mike", 20),
    Sample("ID005", "jane", 1),
    Sample("ID004", "aiko", 50),
    Sample("ID003", "taro", 5),
]

# ===== keyを指定してソートする (sortメソッド)
# id属性でソートする場合
data.sort(key=attrgetter("id"))
print(f"data: {data}")
# name属性でソートする場合
data.sort(key=attrgetter("name"))
print(f"data: {data}")
# value属性でソートする場合
data.sort(key=attrgetter("value"))
print(f"data: {data}")

【実行結果】
data: [('ID001', 'mike', 20), ('ID002', 'john', 70), ('ID003', 'taro', 5), ('ID004', 'aiko', 50), ('ID005', 'jane', 1)]
data: [('ID004', 'aiko', 50), ('ID005', 'jane', 1), ('ID002', 'john', 70), ('ID001', 'mike', 20), ('ID003', 'taro', 5)]
data: [('ID005', 'jane', 1), ('ID003', 'taro', 5), ('ID001', 'mike', 20), ('ID004', 'aiko', 50), ('ID002', 'john', 70)]

attrgetterを使用する場合には、operatorからインポートが必要です。itemgetter同様に、attrgetterの引数に対象とする属性名を指定します。

複数キーで優先順位をつけてソートする場合

itemgetterやattrgetterで複数キーで優先順位を指定する場合には、以下の例のように優先順位順に引数を指定します。

from operator import itemgetter

data = [
    [3, 20, "b"],
    [1, 20, "b"],
    [2, 10, "a"],
    [1, 10, "a"],
    [2, 20, "b"],
    [3, 10, "a"],
    [1, 30, "c"],
    [3, 30, "c"],
    [2, 30, "c"],
]

# ===== 複数keyを指定してソートする (sortメソッド)
data.sort(key=itemgetter(0, 1))
print(f"data: {data}")

【実行結果】
data: [[1, 10, 'a'], [1, 20, 'b'], [1, 30, 'c'], [2, 10, 'a'], [2, 20, 'b'], [2, 30, 'c'], [3, 10, 'a'], [3, 20, 'b'], [3, 30, 'c']]

sorted関数を使用する場合

sorted関数についても、key引数に指定する方法はsortメソッドと同じです。sortメソッドで紹介した例のsorted関数版について以下にソースと結果を紹介します。

リストのリストデータ (itemgetter)

from operator import itemgetter

data = [
    ["ID002", "john", 70],
    ["ID001", "mike", 20],
    ["ID005", "jane", 1],
    ["ID004", "aiko", 50],
    ["ID003", "taro", 5],
]

# ===== keyを指定してソートする (sorted関数)
# 0列目でソートする場合
sorted_data = sorted(data, key=itemgetter(0))
print(f"sorted_data: {sorted_data}")
# 1列目でソートする場合
sorted_data = sorted(data, key=itemgetter(1))
print(f"sorted_data: {sorted_data}")
# 2列目でソートする場合
sorted_data = sorted(data, key=itemgetter(2))
print(f"sorted_data: {sorted_data}")

【実行結果】
sorted_data: [['ID001', 'mike', 20], ['ID002', 'john', 70], ['ID003', 'taro', 5], ['ID004', 'aiko', 50], ['ID005', 'jane', 1]]
sorted_data: [['ID004', 'aiko', 50], ['ID005', 'jane', 1], ['ID002', 'john', 70], ['ID001', 'mike', 20], ['ID003', 'taro', 5]]
sorted_data: [['ID005', 'jane', 1], ['ID003', 'taro', 5], ['ID001', 'mike', 
20], ['ID004', 'aiko', 50], ['ID002', 'john', 70]]

辞書のリストデータ (itemgetter)

from operator import itemgetter

data = [
    {"id": "ID002", "name": "john", "value": 70},
    {"id": "ID001", "name": "mike", "value": 20},
    {"id": "ID005", "name": "jane", "value": 1},
    {"id": "ID004", "name": "aiko", "value": 50},
    {"id": "ID003", "name": "taro", "value": 5},
]

# ===== keyを指定してソートする (sortdメソッド)
# idでソートする場合
sorted_data = sorted(data, key=itemgetter("id"))
print(f"sorted_data: {sorted_data}")
# nameでソートする場合
sorted_data = sorted(data, key=itemgetter("name"))
print(f"sorted_data: {sorted_data}")
# valueでソートする場合
sorted_data = sorted(data, key=itemgetter("value"))
print(f"sorted_data: {sorted_data}")

【実行結果】
sorted_data: [{'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID002', 
'name': 'john', 'value': 70}, {'id': 'ID003', 'name': 'taro', 'value': 5}, {'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID005', 'name': 'jane', 'value': 1}]
sorted_data: [{'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID005', 
'name': 'jane', 'value': 1}, {'id': 'ID002', 'name': 'john', 'value': 70}, {'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID003', 'name': 'taro', 'value': 5}]
sorted_data: [{'id': 'ID005', 'name': 'jane', 'value': 1}, {'id': 'ID003', 'name': 'taro', 'value': 5}, {'id': 'ID001', 'name': 'mike', 'value': 20}, {'id': 'ID004', 'name': 'aiko', 'value': 50}, {'id': 'ID002', 'name': 'john', 
'value': 70}]

クラスオブジェクトのリストデータ (attrgetter)

from operator import attrgetter


class Sample:
    """サンプルクラス"""

    def __init__(self, id, name, value) -> None:
        self.id = id
        self.name = name
        self.value = value

    def __repr__(self) -> str:
        return repr((self.id, self.name, self.value))


data = [
    Sample("ID002", "john", 70),
    Sample("ID001", "mike", 20),
    Sample("ID005", "jane", 1),
    Sample("ID004", "aiko", 50),
    Sample("ID003", "taro", 5),
]

# ===== keyを指定してソートする (sorted関数)
# id属性でソートする場合
sorted_data = sorted(data, key=attrgetter("id"))
print(f"sorted_data: {sorted_data}")
# name属性でソートする場合
sorted_data = sorted(data, key=attrgetter("name"))
print(f"sorted_data: {sorted_data}")
# value属性でソートする場合
sorted_data = sorted(data, key=attrgetter("value"))
print(f"sorted_data: {sorted_data}")

【実行結果】
sorted_data: [('ID001', 'mike', 20), ('ID002', 'john', 70), ('ID003', 'taro', 5), ('ID004', 'aiko', 50), ('ID005', 'jane', 1)]
sorted_data: [('ID004', 'aiko', 50), ('ID005', 'jane', 1), ('ID002', 'john', 70), ('ID001', 'mike', 20), ('ID003', 'taro', 5)]
sorted_data: [('ID005', 'jane', 1), ('ID003', 'taro', 5), ('ID001', 'mike', 
20), ('ID004', 'aiko', 50), ('ID002', 'john', 70)]

複数キーで優先順位をつけてソートする場合

from operator import itemgetter

data = [
    [3, 20, "b"],
    [1, 20, "b"],
    [2, 10, "a"],
    [1, 10, "a"],
    [2, 20, "b"],
    [3, 10, "a"],
    [1, 30, "c"],
    [3, 30, "c"],
    [2, 30, "c"],
]

# ===== 複数keyを指定してソートする (sort関数)
sorted_data = sorted(data, key=itemgetter(0, 1))
print(f"sorted data: {sorted_data}")

【実行結果】
sorted data: [[1, 10, 'a'], [1, 20, 'b'], [1, 30, 'c'], [2, 10, 'a'], [2, 20, 'b'], [2, 30, 'c'], [3, 10, 'a'], [3, 20, 'b'], [3, 30, 'c']]

まとめ

Pythonのリスト（list）を並べ替える方法（sortメソッド、sorted関数）の基本的な使い方について解説しました。また、key引数でキーを指定してソートする方法についても説明しました。

key引数の指定方法については、一般的によく使われるlambda関数を使った指定方法と、Pythonのoperatorモジュールのitemgetterやattrgetterを用いた方法を紹介しました。いずれでも実装ができますが、operatorモジュールでの実装はシンプルかつ高速です。

リストのソートはプログラミングでは非常によく行う操作です。うまく使いこなせるようにしましょう。

【Python Tech】Pythonプログラミングガイド本サイトで紹介しているPython入門、応用に関する記事のまとめページです。Python文法の入門から高度な内容、おすすめの書籍についても紹介しています。また、機械学習等のデータ分析やGUI開発、近年話題の生成AI等のトピックスについても含んでいます。...