読み込み中...

Pythonにおけるsorted関数の優れた使い方とポイント10選

Pythonのsorted関数 Python
この記事は約34分で読めます。

【サイト内のコードはご自由に個人利用・商用利用いただけます】

この記事では、プログラムの基礎知識を前提に話を進めています。

説明のためのコードや、サンプルコードもありますので、もちろん初心者でも理解できるように表現してあります。

本記事のサンプルコードを活用して機能追加、目的を達成できるように作ってありますので、是非ご活用ください。

※この記事は、一般的にプロフェッショナルの指標とされる『実務経験10,000時間以上』を満たす現役のプログラマチームによって監修されています。

※Japanシーモアは、常に解説内容のわかりやすさや記事の品質に注力しております。不具合、分かりにくい説明や不適切な表現、動かないコードなど気になることがございましたら、記事の品質向上の為にお問い合わせフォームにてご共有いただけますと幸いです。
(送信された情報は、プライバシーポリシーのもと、厳正に取扱い、処分させていただきます。)

●Pythonのsorted関数とは？基礎から徹底解説

データの並べ替えに頭を悩ませたことはありませんか？

特に、大量のデータを扱うプロジェクトや、複雑なデータ構造を整理する必要がある場合、効率的なソート方法を知ることは非常に重要です。

そこで今回は、Pythonの強力な武器となるsorted関数について、基礎から徹底的に解説していきます。

sorted関数は、Pythonの組み込み関数の一つで、イテラブル（リストや辞書、タプルなど）を新しいソートされたリストとして返す関数です。

この関数を使いこなすことで、コードの可読性を高めつつ、効率的なデータ処理が可能になります。

○sorted関数の基本構文と使い方

sorted関数の基本的な構文は非常にシンプルです。

sorted(iterable, key=None, reverse=False)

ここで、iterableは並べ替えたいデータ、keyはソートの基準となる関数、reverseは降順にするかどうかを指定するブール値です。

keyとreverseは省略可能なパラメータです。

実際に使ってみましょう。

例えば、数値のリストをソートする場合は次のようになります。

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

実行結果

[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

このように、sorted関数を使うことで、元のリストを変更せずに新しいソートされたリストを得ることができます。

○listのsort()メソッドとの違い

ここで、多くの方が疑問に思うのは、「listのsort()メソッドとsorted関数の違いは何なのか？」ということでしょう。

確かに、両者はリストをソートするという点では同じ機能を持っています。

しかし、大きな違いがあります。

listのsort()メソッドは、リスト自体を直接変更します。

一方、sorted関数は元のリストを変更せず、新しいソートされたリストを返します。

この違いは、特に大規模なプロジェクトや他の開発者と協業する際に重要になってきます。

例を見てみましょう。

# sort()メソッドの例
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
numbers.sort()
print("sort()後の numbers:", numbers)

# sorted()関数の例
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers)
print("sorted()後の numbers:", numbers)
print("sorted_numbers:", sorted_numbers)

実行結果

sort()後の numbers: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
sorted()後の numbers: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

この結果から、sort()メソッドは元のリストを直接変更するのに対し、sorted()関数は元のリストを変更せず、新しいソートされたリストを返すことがわかります。

○サンプルコード1：基本的な数値リストのソート

それでは、sorted関数を使って基本的な数値リストをソートする具体例を見てみましょう。

# 整数のリストをソート
numbers = [5, 2, 8, 1, 9, 3, 7]
sorted_numbers = sorted(numbers)
print("ソートされた整数リスト:", sorted_numbers)

# 浮動小数点数のリストをソート
floats = [3.14, 2.71, 1.41, 0.58, 1.73]
sorted_floats = sorted(floats)
print("ソートされた浮動小数点数リスト:", sorted_floats)

# 負の数を含むリストをソート
mixed_numbers = [-5, 2, -8, 1, -9, 3, 7]
sorted_mixed = sorted(mixed_numbers)
print("ソートされた混合数値リスト:", sorted_mixed)

実行結果

ソートされた整数リスト: [1, 2, 3, 5, 7, 8, 9]
ソートされた浮動小数点数リスト: [0.58, 1.41, 1.73, 2.71, 3.14]
ソートされた混合数値リスト: [-9, -8, -5, 1, 2, 3, 7]

このように、sorted関数は数値のリストを簡単にソートすることができます。

整数、浮動小数点数、負の数を含むリストなど、さまざまな種類の数値リストに対応できることがわかります。

●sorted関数の活用テクニック5選

Pythonのsorted関数の基本を理解したところで、より実践的な活用方法に踏み込んでいきましょう。

データ構造が複雑になればなるほど、ソートの重要性は増します。

ここでは、sorted関数を使いこなすための5つのテクニックを紹介します。

このテクニックを習得することで、より効率的なコーディングが可能になり、データ分析や機械学習プロジェクトでのデータ前処理スキルも向上するでしょう。

○サンプルコード2：文字列リストのソート

まずは、文字列のリストをソートする方法を見てみましょう。

文字列のソートは、辞書順（アルファベット順）で行われます。

# 文字列リストの定義
fruits = ["banana", "apple", "cherry", "date", "elderberry"]

# 文字列リストのソート
sorted_fruits = sorted(fruits)

print("ソート前:", fruits)
print("ソート後:", sorted_fruits)

実行結果

ソート前: ['banana', 'apple', 'cherry', 'date', 'elderberry']
ソート後: ['apple', 'banana', 'cherry', 'date', 'elderberry']

ご覧のように、文字列リストは辞書順でソートされました。大文字と小文字が混在する場合、デフォルトでは大文字が小文字よりも先にソートされます。

大文字小文字を区別せずにソートしたい場合は、keyパラメータを使用します。

# 大文字小文字混在リストの定義
mixed_case = ["Apple", "banana", "Cherry", "date", "Elderberry"]

# 大文字小文字を区別せずにソート
case_insensitive_sort = sorted(mixed_case, key=str.lower)

print("大文字小文字区別なしソート:", case_insensitive_sort)

実行結果

大文字小文字区別なしソート: ['Apple', 'banana', 'Cherry', 'date', 'Elderberry']

○サンプルコード3：辞書のソート

次に、辞書のソートを見ていきましょう。

辞書は、キーでソートするのが一般的ですが、値でソートすることも可能です。

# 辞書の定義
scores = {"Alice": 85, "Bob": 92, "Charlie": 78, "David": 95}

# キーでソート
sorted_by_key = sorted(scores.items())

# 値でソート
sorted_by_value = sorted(scores.items(), key=lambda x: x[1], reverse=True)

print("キーでソート:", sorted_by_key)
print("値で降順ソート:", sorted_by_value)

実行結果

キーでソート: [('Alice', 85), ('Bob', 92), ('Charlie', 78), ('David', 95)]
値で降順ソート: [('David', 95), ('Bob', 92), ('Alice', 85), ('Charlie', 78)]

辞書をソートする際は、items()メソッドを使用してキーと値のペアのリストを取得し、それをソートします。

値でソートする場合は、keyパラメータにlambda関数を使用して、タプルの2番目の要素（値）を基準にソートしています。

○サンプルコード4：タプルのソート

タプルのリストをソートする場合、デフォルトでは各タプルの最初の要素を基準にソートされます。

# タプルのリストの定義
students = [("Alice", 85), ("Bob", 92), ("Charlie", 78), ("David", 95)]

# タプルのリストをソート
sorted_students = sorted(students)

print("デフォルトソート:", sorted_students)

# 成績（2番目の要素）でソート
sorted_by_score = sorted(students, key=lambda x: x[1], reverse=True)

print("成績で降順ソート:", sorted_by_score)

実行結果

デフォルトソート: [('Alice', 85), ('Bob', 92), ('Charlie', 78), ('David', 95)]
成績で降順ソート: [('David', 95), ('Bob', 92), ('Alice', 85), ('Charlie', 78)]

○サンプルコード5：カスタムオブジェクトのソート

カスタムクラスのオブジェクトをソートする場合、keyパラメータを使用して、ソートの基準となる属性を指定します。

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def __repr__(self):
        return f"Student(name='{self.name}', score={self.score})"

# 学生オブジェクトのリストを作成
students = [
    Student("Alice", 85),
    Student("Bob", 92),
    Student("Charlie", 78),
    Student("David", 95)
]

# 名前でソート
sorted_by_name = sorted(students, key=lambda x: x.name)

# スコアで降順ソート
sorted_by_score = sorted(students, key=lambda x: x.score, reverse=True)

print("名前でソート:", sorted_by_name)
print("スコアで降順ソート:", sorted_by_score)

実行結果：

名前でソート: [Student(name='Alice', score=85), Student(name='Bob', score=92), Student(name='Charlie', score=78), Student(name='David', score=95)]
スコアで降順ソート: [Student(name='David', score=95), Student(name='Bob', score=92), Student(name='Alice', score=85), Student(name='Charlie', score=78)]

○サンプルコード6：多次元リストのソート

最後に、多次元リストのソート方法を見てみましょう。

多次元リストは、複数の基準でソートする必要がある場合に便利です。

# 多次元リストの定義
data = [
    ["Alice", 85, "A"],
    ["Bob", 92, "A"],
    ["Charlie", 78, "B"],
    ["David", 95, "A"],
    ["Eve", 88, "B"]
]

# 成績（2列目）で降順ソート、同点の場合は名前（1列目）で昇順ソート
sorted_data = sorted(data, key=lambda x: (-x[1], x[0]))

print("ソート結果:")
for item in sorted_data:
    print(item)

実行結果

ソート結果:
['David', 95, 'A']
['Bob', 92, 'A']
['Eve', 88, 'B']
['Alice', 85, 'A']
['Charlie', 78, 'B']

この例では、lambda関数を使用して複数の基準でソートしています。

-x[1]は成績の降順ソート、x[0]は名前の昇順ソートを意味します。

●keyパラメータの使いこなし

sorted関数の真の力を引き出すには、keyパラメータを使いこなすことが不可欠です。

keyパラメータを使いこなせば、複雑なデータ構造も思いのままにソートできるようになり、コードの可読性と効率性を両立させることができます。

keyパラメータは、ソートの基準となる値を返す関数を指定するためのものです。

この関数は、ソート対象の各要素に対して呼び出され、その戻り値を基にソートが行われます。

keyパラメータを使いこなすことで、複雑なソート条件を簡潔に表現できるようになります。

○lambdaを使ったカスタムキーの指定

lambda関数は、keyパラメータと相性が良く、よく使用されます。

lambdaを使うと、その場で簡単に関数を定義できるため、コードがすっきりとします。

例えば、数値と文字列が混在したリストをソートする場合を考えてみましょう。

mixed_list = [5, 'apple', 2, 'banana', 8, 'cherry']

# 数値を先に、文字列を後にソート
sorted_mixed = sorted(mixed_list, key=lambda x: (isinstance(x, str), x))

print("ソート結果:", sorted_mixed)

実行結果

ソート結果: [2, 5, 8, 'apple', 'banana', 'cherry']

この例では、lambdaを使って各要素が文字列かどうかをチェックし、文字列の場合はTrueを返すようにしています。

Pythonでは、ブール値のFalseはTrueよりも小さいとみなされるため、数値（isinstance(x, str)がFalseを返す）が先にソートされ、その後に文字列がソートされます。

○サンプルコード7：複数条件でのソート

実際のプロジェクトでは、複数の条件でソートしたい場合がよくあります。

例えば、社員のリストを部署ごとにソートし、さらに各部署内で給与の高い順にソートするケースを考えてみましょう。

employees = [
    ('Alice', 'Sales', 50000),
    ('Bob', 'Engineering', 60000),
    ('Charlie', 'Sales', 55000),
    ('David', 'Engineering', 65000),
    ('Eve', 'Marketing', 45000)
]

# 部署でソートし、同じ部署内では給与の降順でソート
sorted_employees = sorted(employees, key=lambda x: (x[1], -x[2]))

print("ソート結果:")
for employee in sorted_employees:
    print(employee)

実行結果

ソート結果:
('David', 'Engineering', 65000)
('Bob', 'Engineering', 60000)
('Eve', 'Marketing', 45000)
('Charlie', 'Sales', 55000)
('Alice', 'Sales', 50000)

この例では、lambdaを使って複数の条件を指定しています。x[1]は部署名（昇順）、-x[2]は給与（降順）を表しています。

マイナスをつけることで、降順ソートを実現しています。

○サンプルコード8：文字列の長さでソート

文字列のリストを、その長さでソートしたい場合もあるでしょう。

keyパラメータを使えば、簡単に実現できます。

words = ['python', 'programming', 'language', 'code', 'developer']

# 文字列の長さでソート
sorted_by_length = sorted(words, key=len)

print("文字列の長さでソート（昇順）:", sorted_by_length)

# 文字列の長さで降順ソート
sorted_by_length_desc = sorted(words, key=len, reverse=True)

print("文字列の長さでソート（降順）:", sorted_by_length_desc)

実行結果

文字列の長さでソート（昇順）: ['code', 'python', 'language', 'developer', 'programming']
文字列の長さでソート（降順）: ['programming', 'developer', 'language', 'python', 'code']

この例では、keyパラメータにlen関数を直接指定しています。

len関数は文字列の長さを返すため、各文字列の長さを基準にソートが行われます。

reverse=Trueを指定することで、降順ソートも簡単に実現できます。

○サンプルコード9：辞書のバリューでソート

最後に、辞書をバリューでソートする例を見てみましょう。

辞書は、キーと値のペアを持つデータ構造ですが、値を基準にソートしたい場合があります。

scores = {'Alice': 85, 'Bob': 92, 'Charlie': 78, 'David': 95, 'Eve': 88}

# 値でソート（降順）
sorted_by_value = sorted(scores.items(), key=lambda x: x[1], reverse=True)

print("スコアで降順ソート:")
for name, score in sorted_by_value:
    print(f"{name}: {score}")

実行結果

スコアで降順ソート:
David: 95
Bob: 92
Eve: 88
Alice: 85
Charlie: 78

この例では、scores.items()を使って辞書のキーと値のペアをタプルのリストとして取得し、それをソートしています。

lambdaを使って、各タプルの2番目の要素（値）を基準にソートするように指定しています。

●高度なソートテクニック

まだまだPythonのsorted関数には奥深い使い方があります。

ここからは、より複雑なデータ構造や要件に対応できる高度なソートテクニックを紹介します。

私たちプロのエンジニアでも、日々の業務でこうした技を駆使しているんですよ。

○サンプルコード10：部分一致でのソート

実際のプロジェクトでは、完全一致ではなく部分一致でソートしたいケースがあります。

例えば、製品コードの一部でソートするような場合です。

こんな時には、正規表現を使うと便利です。

import re

products = [
    "ABC-123-XYZ",
    "DEF-456-UVW",
    "GHI-789-RST",
    "JKL-234-MNO",
    "MNO-567-PQR"
]

# 製品コードの中央の数字部分でソート
sorted_products = sorted(products, key=lambda x: int(re.search(r'-(\d+)-', x).group(1)))

print("製品コードの数字部分でソート:")
for product in sorted_products:
    print(product)

実行結果

製品コードの数字部分でソート:
ABC-123-XYZ
JKL-234-MNO
DEF-456-UVW
MNO-567-PQR
GHI-789-RST

このコードでは、正規表現 r'-(\d+)-' を使って製品コードの中央の数字部分を抽出し、それを整数に変換してソートの基準としています。

正規表現は強力ですが、使い方を誤るとパフォーマンスに影響を与える可能性があるので、大規模なデータセットでは注意が必要です。

○reverseパラメータを使った降順ソート

sorted関数には、reverseパラメータがあります。

これを使うと、簡単に降順ソートができます。

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

# 昇順ソート
ascending = sorted(numbers)

# 降順ソート
descending = sorted(numbers, reverse=True)

print("昇順ソート:", ascending)
print("降順ソート:", descending)

実行結果

昇順ソート: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
降順ソート: [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

reverseパラメータは、keyパラメータと組み合わせて使うこともできます。

例えば、辞書を値で降順ソートする場合は次のようになります。

scores = {'Alice': 85, 'Bob': 92, 'Charlie': 78, 'David': 95}

# 値で降順ソート
sorted_scores = sorted(scores.items(), key=lambda x: x[1], reverse=True)

print("スコアで降順ソート:")
for name, score in sorted_scores:
    print(f"{name}: {score}")

実行結果

スコアで降順ソート:
David: 95
Bob: 92
Alice: 85
Charlie: 78

○複数キーを使った複雑なソート

実務では、複数の基準でソートしたいケースがよくあります。

例えば、学生のデータを学年順にソートし、同じ学年内では成績順にソートするような場合です。

Pythonのsorted関数は、タプルを比較する際に要素を順番に比較する性質を利用して、複数キーでのソートを簡単に実現できます。

students = [
    ("Alice", 2, 85),
    ("Bob", 3, 92),
    ("Charlie", 2, 78),
    ("David", 3, 95),
    ("Eve", 1, 88)
]

# 学年で昇順ソート、同じ学年内では成績で降順ソート
sorted_students = sorted(students, key=lambda x: (x[1], -x[2]))

print("学年と成績でソート:")
for student in sorted_students:
    print(f"名前: {student[0]}, 学年: {student[1]}, 成績: {student[2]}")

実行結果

学年と成績でソート:
名前: Eve, 学年: 1, 成績: 88
名前: Alice, 学年: 2, 成績: 85
名前: Charlie, 学年: 2, 成績: 78
名前: David, 学年: 3, 成績: 95
名前: Bob, 学年: 3, 成績: 92

このコードでは、keyパラメータにラムダ関数を使用し、(x[1], -x[2])というタプルを返しています。

x[1]は学年（昇順）、-x[2]は成績（降順）を表しています。マイナス記号をつけることで、その項目を降順にソートできます。

●sorted関数のパフォーマンスと内部動作

sorted関数の使い方をマスターしてきた皆さん、素晴らしい進歩です。

しかし、本当のプロフェッショナルになるためには、関数の内部動作やパフォーマンスについても理解する必要があります。

特に大規模なデータを扱う際には、この知識が重要になってきます。

では、sorted関数の裏側で何が起きているのか、一緒に見ていきましょう。

○Timsortアルゴリズムについて

Pythonのsorted関数は、Timsortと呼ばれるアルゴリズムを使用しています。

Timsortは、2002年にTim Petersによって開発された比較ベースのハイブリッドソーティングアルゴリズムです。

マージソートとインサーションソートを組み合わせることで、両者の長所を活かしたアルゴリズムとなっています。

Timsortの特徴は、実際のデータに存在する順序を利用してソートを行うことです。

例えば、部分的に既にソートされているデータに対して非常に効率的に動作します。

また、安定ソートであることも重要な特徴です。

つまり、等しいキーを持つ要素の相対的な順序が保持されます。

具体的な動作を簡単に説明すると、まずデータを小さなチャンク（通常32〜64要素）に分割し、それぞれのチャンクをインサーションソートでソートします。

その後、マージソートのように隣接するチャンクをマージしていきます。

このプロセスにはいくつかの最適化が施されており、例えばマージの際には、既にソートされている部分をうまく利用して効率を上げています。

○sorted関数の計算量

sorted関数の時間計算量は、平均的なケースと最悪のケースで O(n log n) となります。

ここで n はソートする要素の数です。

これは、多くの比較ベースのソートアルゴリズムで達成できる最適な時間計算量です。

空間計算量に関しては、sorted関数は新しいリストを作成するため、O(n) の追加の空間を必要とします。

一方、リストの sort() メソッドは元のリストを直接変更するため、追加の空間を必要としません（in-placeソート）。

実際のパフォーマンスを測定するには、timeモジュールを使用できます。

例えば、次のようなコードでsorted関数の実行時間を計測できます。

import time
import random

# ランダムな要素を持つリストを生成
data = [random.randint(1, 1000) for _ in range(10000)]

# sorted関数の実行時間を計測
start_time = time.time()
sorted_data = sorted(data)
end_time = time.time()

print(f"ソートにかかった時間: {end_time - start_time:.6f} 秒")

実行結果

ソートにかかった時間: 0.003998 秒

実行時間は環境によって異なりますが、1万個の要素をソートするのに数ミリ秒程度しかかかっていないことがわかります。

○大規模データでの注意点

大規模なデータセットをソートする際には、いくつかの注意点があります。

まず、メモリ使用量に注意が必要です。

sorted関数は新しいリストを作成するため、元のデータと同じサイズのメモリが追加で必要になります。

非常に大きなデータセットの場合、メモリ不足に陥る可能性があります。

また、keyパラメータに指定する関数の複雑さにも注意が必要です。

keyパラメータに指定した関数は各要素に対して呼び出されるため、この関数が複雑であればあるほど、全体の実行時間に大きな影響を与えます。

大規模データを扱う際のテクニックとして、ジェネレータ式を使用する方法があります。

例えば、ファイルから大量のデータを読み込んでソートする場合、次のようなコードが有効です。

# 大きなファイルから行を読み込み、ソートする
with open('large_file.txt', 'r') as file:
    sorted_lines = sorted(line.strip() for line in file)

# 結果の一部を表示
print("ソート結果の最初の5行:")
for line in sorted_lines[:5]:
    print(line)

このコードでは、ファイルの全内容をメモリに読み込むのではなく、ジェネレータ式を使用して1行ずつ読み込みながらソートを行います。

これで、メモリ使用量を抑えつつ大規模なデータをソートすることができます。

●よくあるエラーと対処法

Pythonのsorted関数を使いこなすにつれて、様々なエラーに遭遇することがあります。

エラーに直面すると焦ってしまうかもしれませんが、落ち着いて対処法を学べば、必ず解決策が見つかります。

ここでは、sorted関数を使用する際によく発生するエラーとその対処法について解説します。

このエラーを理解し、適切に対処できるようになれば、より効率的にコーディングを進められるようになるでしょう。

○TypeError: ‘<‘ not supported between instances

このエラーは、比較できない型の要素をソートしようとした時に発生します。

例えば、数値と文字列が混在するリストをソートしようとすると、このエラーが発生します。

mixed_list = [1, 'apple', 2, 'banana', 3]
sorted_list = sorted(mixed_list)

このコードを実行すると、次のようなエラーが発生します。

TypeError: '<' not supported between instances of 'str' and 'int'

このエラーを解決するには、keyパラメータを使用して、比較可能な値を返す関数を指定する必要があります。

例えば、すべての要素を文字列に変換してソートする方法があります。

mixed_list = [1, 'apple', 2, 'banana', 3]
sorted_list = sorted(mixed_list, key=str)
print(sorted_list)

実行結果

[1, 2, 3, 'apple', 'banana']

この方法では、すべての要素が文字列として比較されるため、エラーを回避できます。

ただし、数値の順序が文字列としての順序になることに注意してください。

別の方法として、型ごとにグループ化してからソートする方法もあります。

mixed_list = [1, 'apple', 2, 'banana', 3]
sorted_list = sorted(mixed_list, key=lambda x: (isinstance(x, str), x))
print(sorted_list)

実行結果

[1, 2, 3, 'apple', 'banana']

この方法では、数値が先にソートされ、その後に文字列がソートされます。

○AttributeError: ‘NoneType’ object has no attribute ‘sort’

このエラーは、Noneオブジェクトに対してsort()メソッドを呼び出そうとした時に発生します。

多くの場合、関数が期待する戻り値を返していない場合に起こります。

例えば、次のようなコードでエラーが発生する可能性があります。

def get_data():
    # データを取得する処理
    # 何らかの理由でデータが取得できなかった場合
    return None

data = get_data()
sorted_data = sorted(data)  # ここでエラーが発生する可能性がある

このエラーを防ぐには、データが None でないことを確認してからソートを行う必要があります。

def get_data():
    # データを取得する処理
    # 何らかの理由でデータが取得できなかった場合
    return None

data = get_data()
if data is not None:
    sorted_data = sorted(data)
    print(sorted_data)
else:
    print("データが取得できませんでした。")

この方法では、データが None の場合にソートを試みないため、エラーを回避できます。

○KeyError: ソートキーが存在しない場合の対処

辞書のリストをソートする際、指定したキーが存在しない場合に KeyError が発生することがあります。

例えば、次のようなコードでエラーが発生する可能性があります。

data = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie'}  # 'age' キーが存在しない
]

sorted_data = sorted(data, key=lambda x: x['age'])

このコードを実行すると、’Charlie’ の辞書に ‘age’ キーが存在しないため、KeyError が発生します。

この問題を解決するには、get()メソッドを使用して、キーが存在しない場合のデフォルト値を指定する方法があります。

data = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie'}  # 'age' キーが存在しない
]

sorted_data = sorted(data, key=lambda x: x.get('age', float('inf')))
print(sorted_data)

実行結果

[{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie'}]

この方法では、’age’ キーが存在しない場合に float(‘inf’) （無限大）を返すため、’age’ キーがない要素は常にリストの最後にソートされます。

●sorted関数の実践的な応用例

Pythonのsorted関数の基本的な使い方から高度なテクニックまで解説してきました。

ここからは、実際のプロジェクトでsorted関数がどのように活用されているかを見ていきましょう。

データ分析、ログファイルの解析、ウェブスクレイピングなど、様々な場面でsorted関数が活躍しています。

この実践的な例を通じて、sorted関数の真の力を理解し、自分のプロジェクトに応用する方法を学びましょう。

○データ分析での活用法

データ分析の現場では、大量のデータを整理し、意味のある情報を抽出することが求められます。

sorted関数は、こうした作業を効率的に行うための強力なツールとなります。

例えば、ある会社の売上データを分析する場合を考えてみましょう。

各部署の売上を降順でソートし、トップ3の部署を抽出する作業があるとします。

sales_data = [
    {'department': '営業部', 'sales': 1000000},
    {'department': '製造部', 'sales': 800000},
    {'department': 'マーケティング部', 'sales': 1200000},
    {'department': '開発部', 'sales': 950000},
    {'department': '人事部', 'sales': 500000}
]

# 売上高でソートし、上位3部署を抽出
top_3_departments = sorted(sales_data, key=lambda x: x['sales'], reverse=True)[:3]

print("売上トップ3部署:")
for rank, dept in enumerate(top_3_departments, 1):
    print(f"{rank}位: {dept['department']} (売上: {dept['sales']}円)")

実行結果

売上トップ3部署:
1位: マーケティング部 (売上: 1200000円)
2位: 営業部 (売上: 1000000円)
3位: 開発部 (売上: 950000円)

このコードでは、sorted関数を使って売上高の降順でデータをソートし、スライシングを使って上位3部署を抽出しています。

lambda関数を使ってsalesキーの値でソートするように指定し、reverse=Trueで降順ソートを行っています。

○ログファイルの解析とソート

システム管理者やデベロッパーにとって、ログファイルの解析は日常的な作業です。

大量のログエントリから必要な情報を抽出し、適切にソートすることで、問題の特定や傾向の分析が容易になります。

例えば、Webサーバーのアクセスログから、アクセス数の多いIPアドレスを抽出する作業を考えてみましょう。

import re
from collections import Counter

# ログファイルの内容（実際にはファイルから読み込みます）
log_data = """
192.168.1.1 - - [20/May/2023:10:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234
192.168.1.2 - - [20/May/2023:10:01:00 +0000] "GET /about.html HTTP/1.1" 200 2345
192.168.1.1 - - [20/May/2023:10:02:00 +0000] "GET /contact.html HTTP/1.1" 200 3456
192.168.1.3 - - [20/May/2023:10:03:00 +0000] "GET /index.html HTTP/1.1" 200 1234
192.168.1.2 - - [20/May/2023:10:04:00 +0000] "GET /products.html HTTP/1.1" 200 4567
"""

# IPアドレスを抽出
ip_pattern = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
ip_addresses = re.findall(ip_pattern, log_data)

# IPアドレスの出現回数をカウント
ip_counts = Counter(ip_addresses)

# 出現回数でソートし、上位5つを抽出
top_5_ips = sorted(ip_counts.items(), key=lambda x: x[1], reverse=True)[:5]

print("アクセス数の多いIP (上位5):")
for rank, (ip, count) in enumerate(top_5_ips, 1):
    print(f"{rank}位: {ip} (アクセス数: {count})")

実行結果

アクセス数の多いIP (上位5):
1位: 192.168.1.2 (アクセス数: 2)
2位: 192.168.1.1 (アクセス数: 2)
3位: 192.168.1.3 (アクセス数: 1)

このコードでは、正規表現を使ってログデータからIPアドレスを抽出し、Counterを使ってその出現回数をカウントしています。

その後、sorted関数を使ってアクセス数の降順でソートし、上位5つのIPアドレスを抽出しています。

○ウェブスクレイピングでの並べ替え

ウェブスクレイピングは、Webサイトから必要な情報を自動的に収集する技術です。

収集したデータを適切にソートすることで、より価値のある情報を抽出できます。

例えば、ある商品比較サイトから商品情報をスクレイピングし、価格順にソートする作業を考えてみましょう。

import requests
from bs4 import BeautifulSoup

# 実際のウェブサイトからデータを取得する代わりに、サンプルHTMLを使用
html_content = """
<html>
<body>
    <div class="product">
        <h2>商品A</h2>
        <p class="price">1500円</p>
    </div>
    <div class="product">
        <h2>商品B</h2>
        <p class="price">980円</p>
    </div>
    <div class="product">
        <h2>商品C</h2>
        <p class="price">2200円</p>
    </div>
</body>
</html>
"""

# HTMLを解析
soup = BeautifulSoup(html_content, 'html.parser')

# 商品情報を抽出
products = []
for product in soup.find_all('div', class_='product'):
    name = product.find('h2').text
    price = int(product.find('p', class_='price').text.replace('円', ''))
    products.append({'name': name, 'price': price})

# 価格で昇順ソート
sorted_products = sorted(products, key=lambda x: x['price'])

print("価格が安い順の商品リスト:")
for rank, product in enumerate(sorted_products, 1):
    print(f"{rank}位: {product['name']} (価格: {product['price']}円)")

実行結果

価格が安い順の商品リスト:
1位: 商品B (価格: 980円)
2位: 商品A (価格: 1500円)
3位: 商品C (価格: 2200円)

このコードでは、BeautifulSoupライブラリを使ってHTMLを解析し、商品名と価格を抽出しています。

その後、sorted関数を使って価格の昇順でソートしています。

まとめ

Pythonのsorted関数について、基礎から応用まで幅広く解説してきました。

この関数は、データ構造を整理する上で非常に重要なツールであり、適切に使用することで、コードの可読性と効率性を大幅に向上させることができます。

今後は、ここで学んだテクニックを実際のプロジェクトで積極的に活用し、さらに理解を深めていくことをおすすめします。

また、sorted関数以外のPythonの組み込み関数やライブラリについても学習を進めることで、より幅広い問題に対応できるプログラマーになれるでしょう。