Pythonでリストを降順にソートするにはどうすればよいですか？

sorted()またはlist.sort()にreverse=Trueパラメータを追加してください。例: sorted([3, 1, 4], reverse=True)は[4, 3, 1]を返します。数値、文字列、日付など、自然な順序を持つ任意のデータ型で使用できます。

Pythonで辞書を値でソートできますか？

辞書自体は従来の意味での順序を持ちませんが、key関数を使ったsorted()で値によってアイテムをソートできます: sorted(dict.items(), key=lambda x: x[1])。これは値でソートされたタプルのリストを返します。必要に応じてdict(sorted(...))で辞書に変換できますが、順序が保持されるのはPython 3.7以降のみです。

辞書のリストを特定のキーでソートするにはどうすればよいですか？

キーを抽出するlambda関数とともにsorted()を使用してください: sorted(list_of_dicts, key=lambda x: x['keyname'])。より良いパフォーマンスのためにはoperator.itemgetterを使用してください: sorted(list_of_dicts, key=itemgetter('keyname'))。どちらのアプローチも単一または複数のキーによるソートに対応しています。

Pythonのソート関数の時間計算量はどのくらいですか？

Pythonのsorted()とlist.sort()はTimsortアルゴリズムを使用し、最悪ケースの時間計算量はO(n log n)、部分的にソートされたデータの最良ケースはO(n)です。空間計算量はsorted()がO(n)（新しいリストを作成）、list.sort()がO(1)（インプレース）です。大きなデータセットから上位k個の要素を見つけるには、heapq.nlargest()がO(n log k)の計算量を提供します。

ソート時にNone値を処理するにはどうすればよいですか？

None値は他の型と混在すると比較エラーを引き起こします。先頭または末尾に配置するkey関数を使用してください: sorted(data, key=lambda x: (x is None, x))はNoneを末尾に置き、sorted(data, key=lambda x: (x is not None, x))は先頭に置きます。キーが欠落している辞書には、x.get('key', default_value)でデフォルト値を提供してください。

Pythonのソートは安定していますか？

はい、Pythonのソートは安定していることが保証されています。つまり、キーが等しい要素は元の相対的な順序を維持します。これにより、1つの基準でソートし、次に別の基準でソートする多段ソートが可能で、同点の場合に最初のソートが保持されます。安定性はPythonで使用されるTimsortアルゴリズムによって保証されています。

Pythonソート：sorted()、list.sort()、カスタムソートの完全ガイド

Q: Pythonのsorted()とlist.sort()の違いは何ですか？

sorted()関数は新しいソート済みリストを返し、任意のイテラブルで動作し、元のデータを変更しません。list.sort()メソッドはリストをその場で変更し、Noneを返し、リストオブジェクトにのみ使用できます。元のデータを保持したい場合やリスト以外のシーケンスをソートする場合はsorted()を使用し、大きなリストのメモリ効率のためにはlist.sort()を使用してください。

Name: Soren Atelier

Updated on 2026/2/11

データのソートはプログラミングにおける最も基本的な操作の1つですが、Pythonの sorted() 関数と list.sort() メソッドのどちらを選ぶべきかで迷う開発者は少なくありません。学生のスコアの順位付け、商品の価格整理、ファイル一覧の処理など、どの場面でもPythonのソート機構を理解しておけば時間を節約でき、バグも防げます。このガイドでは、基本的な数値リストから複雑なカスタム比較まで、Pythonソートのあらゆる側面を、すぐに使える実践例とともに解説します。

📚

sorted() vs list.sort(): 決定的な違い

Pythonには一見似ていても、本質的に動作が異なる2つの主要なソート手段があります。sorted() 関数は新しいソート済みリストを生成して返し、元のデータは変更しません。一方、list.sort() メソッドはリスト自体をその場で並び替え、返り値は None です。

# sorted() returns a new list
numbers = [3, 1, 4, 1, 5]
sorted_nums = sorted(numbers)
print(sorted_nums)  # [1, 1, 3, 4, 5]
print(numbers)      # [3, 1, 4, 1, 5] - original unchanged
 
# list.sort() modifies in place
numbers = [3, 1, 4, 1, 5]
result = numbers.sort()
print(numbers)      # [1, 1, 3, 4, 5] - original modified
print(result)       # None

この違いは、メモリ効率とデータ保持の観点で重要です。元のリストを保持したい場合や、tupleのようなイミュータブルなシーケンスをソートする場合は sorted() を使います。コピー作成がメモリを圧迫しやすい大きなリストを扱う場合は list.sort() を使うのが適しています。

# sorted() works with any iterable
tuple_data = (42, 17, 93, 8)
sorted_list = sorted(tuple_data)  # Returns [8, 17, 42, 93]
 
# list.sort() only works on lists
# tuple_data.sort()  # AttributeError: 'tuple' object has no attribute 'sort'

基本のソート：数値・文字列・混在型

Pythonのデフォルトのソート挙動は「自然順序」です。数値は数値として、文字列はアルファベット順（辞書順）でソートされます。型が混在するリストは明示的な扱いが必要です。

# Numeric sorting
integers = [42, -7, 0, 93, 15]
print(sorted(integers))  # [-7, 0, 15, 42, 93]
 
floats = [3.14, 2.71, 1.41, 9.81]
print(sorted(floats))    # [1.41, 2.71, 3.14, 9.81]
 
# String sorting (lexicographic order)
words = ['zebra', 'apple', 'mango', 'banana']
print(sorted(words))     # ['apple', 'banana', 'mango', 'zebra']
 
# Mixed types cause errors in Python 3
mixed = [3, 'apple', 1.5]
# sorted(mixed)  # TypeError: '<' not supported between instances

数値として並べたい「数値文字列」をアルファベット順ではなく数値順で並べるには、ソート時に変換します。

# String numbers sort alphabetically
string_nums = ['10', '2', '100', '21']
print(sorted(string_nums))  # ['10', '100', '2', '21']
 
# Convert to int for numeric sorting
print(sorted(string_nums, key=int))  # ['2', '10', '21', '100']

reverse=True による逆順ソート

sorted() と list.sort() はどちらも reverse パラメータを受け取り、ソート順を反転できます。デフォルトは False（昇順）です。

scores = [88, 92, 75, 95, 82]
 
# Descending order using reverse=True
print(sorted(scores, reverse=True))  # [95, 92, 88, 82, 75]
 
# In-place descending sort
scores.sort(reverse=True)
print(scores)  # [95, 92, 88, 82, 75]
 
# Reverse alphabetical order
names = ['Alice', 'David', 'Bob', 'Charlie']
print(sorted(names, reverse=True))  # ['David', 'Charlie', 'Bob', 'Alice']

key パラメータ：カスタムソートロジック

key パラメータには「比較前に各要素を変換する関数」を渡します。これにより、元データを変更せずに、特定属性・計算値・複雑な条件でソートできます。

# Sort by string length
words = ['python', 'is', 'awesome', 'for', 'data']
print(sorted(words, key=len))  # ['is', 'for', 'data', 'python', 'awesome']
 
# Sort by absolute value
numbers = [-5, -2, 3, -8, 1]
print(sorted(numbers, key=abs))  # [1, -2, 3, -5, -8]
 
# Sort case-insensitive
names = ['alice', 'Bob', 'CHARLIE', 'david']
print(sorted(names, key=str.lower))  # ['alice', 'Bob', 'CHARLIE', 'david']

Lambda関数でインラインソート

Lambda関数は、単純な key 関数を簡潔に書くための構文です。1回しか使わない変換で、関数定義が冗長になる場合に特に便利です。

# Sort tuples by second element
pairs = [(1, 'b'), (3, 'a'), (2, 'd'), (4, 'c')]
print(sorted(pairs, key=lambda x: x[1]))
# [(3, 'a'), (1, 'b'), (4, 'c'), (2, 'd')]
 
# Sort strings by last character
words = ['python', 'java', 'ruby', 'go']
print(sorted(words, key=lambda s: s[-1]))
# ['java', 'go', 'ruby', 'python']
 
# Sort by distance from target value
target = 50
values = [45, 62, 38, 55, 48]
print(sorted(values, key=lambda x: abs(x - target)))
# [48, 45, 55, 38, 62]

複数条件でのソート

複数の優先度が必要な場合は、key 関数からtupleを返します。Pythonはtupleを左から順に比較するため、自然に多段ソートを実現できます。

# Sort students by grade (descending), then name (ascending)
students = [
    ('Alice', 85),
    ('Bob', 92),
    ('Charlie', 85),
    ('David', 92)
]
 
sorted_students = sorted(students, key=lambda x: (-x[1], x[0]))
print(sorted_students)
# [('Bob', 92), ('David', 92), ('Alice', 85), ('Charlie', 85)]
 
# Sort dates by year (descending), then month (ascending)
dates = ['2024-03', '2023-12', '2024-01', '2023-08']
print(sorted(dates, key=lambda d: (-int(d[:4]), int(d[5:]))))
# ['2024-01', '2024-03', '2023-08', '2023-12']

operator.itemgetter と operator.attrgetter

operator モジュールには、よくあるソートパターン向けの最適化された代替手段があります。これらはlambdaより高速に動作することが多く、可読性も向上します。

from operator import itemgetter, attrgetter
 
# Sort by specific dictionary keys
data = [
    {'name': 'Alice', 'age': 30, 'score': 85},
    {'name': 'Bob', 'age': 25, 'score': 92},
    {'name': 'Charlie', 'age': 30, 'score': 78}
]
 
# Sort by age, then score
sorted_data = sorted(data, key=itemgetter('age', 'score'))
print([d['name'] for d in sorted_data])  # ['Bob', 'Charlie', 'Alice']
 
# Sort by tuple elements
records = [(1, 'b', 300), (2, 'a', 100), (1, 'a', 200)]
print(sorted(records, key=itemgetter(0, 1)))
# [(1, 'a', 200), (1, 'b', 300), (2, 'a', 100)]

オブジェクト属性には attrgetter を使います。

from operator import attrgetter
 
class Employee:
    def __init__(self, name, salary, department):
        self.name = name
        self.salary = salary
        self.department = department
 
    def __repr__(self):
        return f'{self.name}({self.department}, ${self.salary})'
 
employees = [
    Employee('Alice', 75000, 'Engineering'),
    Employee('Bob', 65000, 'Marketing'),
    Employee('Charlie', 75000, 'Engineering')
]
 
# Sort by department, then salary (descending)
sorted_emps = sorted(employees, key=attrgetter('department'))
print(sorted_emps)

dictionary のソート

dictionary自体は（Python 3.7+ では挿入順を保持するものの）本質的には順序付きコレクションではありませんが、キー・値・itemsをソートできます。

# Sort dictionary by keys
data = {'zebra': 3, 'apple': 1, 'mango': 2}
sorted_keys = sorted(data.keys())
print(sorted_keys)  # ['apple', 'mango', 'zebra']
 
# Create new dict with sorted keys
sorted_dict = {k: data[k] for k in sorted_keys}
print(sorted_dict)  # {'apple': 1, 'mango': 2, 'zebra': 3}
 
# Sort by values
sorted_by_value = sorted(data.items(), key=lambda x: x[1])
print(sorted_by_value)  # [('apple', 1), ('mango', 2), ('zebra', 3)]
 
# Convert back to dictionary
sorted_dict = dict(sorted_by_value)

値が複雑な型の場合は次のように扱います。

# Sort dictionary by nested values
products = {
    'laptop': {'price': 999, 'stock': 5},
    'phone': {'price': 599, 'stock': 12},
    'tablet': {'price': 399, 'stock': 8}
}
 
# Sort by price
by_price = sorted(products.items(), key=lambda x: x[1]['price'])
print([(name, info['price']) for name, info in by_price])
# [('tablet', 399), ('phone', 599), ('laptop', 999)]
 
# Sort by stock (descending)
by_stock = sorted(products.items(), key=lambda x: -x[1]['stock'])
print([(name, info['stock']) for name, info in by_stock])
# [('phone', 12), ('tablet', 8), ('laptop', 5)]

tuple のリストのソート

tupleは左から右へ要素を比較することで自然にソートされます。key 関数でこの挙動をカスタマイズできます。

# Default tuple sorting (compares element by element)
tuples = [(1, 'z'), (2, 'a'), (1, 'a'), (2, 'z')]
print(sorted(tuples))
# [(1, 'a'), (1, 'z'), (2, 'a'), (2, 'z')]
 
# Sort by second element only
print(sorted(tuples, key=lambda x: x[1]))
# [(2, 'a'), (1, 'a'), (1, 'z'), (2, 'z')]
 
# Sort by sum of numeric elements
coord_distances = [(1, 2), (3, 1), (2, 2), (1, 3)]
print(sorted(coord_distances, key=sum))
# [(1, 2), (2, 2), (1, 3), (3, 1)]

dictionary のリストのソート

リスト内のdictionaryをソートするには、比較に使うキーを指定します。

people = [
    {'name': 'Alice', 'age': 30, 'city': 'New York'},
    {'name': 'Bob', 'age': 25, 'city': 'San Francisco'},
    {'name': 'Charlie', 'age': 30, 'city': 'Austin'}
]
 
# Sort by age
by_age = sorted(people, key=lambda x: x['age'])
print([p['name'] for p in by_age])  # ['Bob', 'Alice', 'Charlie']
 
# Sort by age (descending), then name (ascending)
by_age_name = sorted(people, key=lambda x: (-x['age'], x['name']))
print([f"{p['name']} ({p['age']})" for p in by_age_name])
# ['Alice (30)', 'Charlie (30)', 'Bob (25)']
 
# Using itemgetter (more efficient)
from operator import itemgetter
by_city = sorted(people, key=itemgetter('city'))
print([p['city'] for p in by_city])
# ['Austin', 'New York', 'San Francisco']

オブジェクトのリストのソート

カスタムクラスは、比較可能な属性を取り出す key 関数が必要です。

class Product:
    def __init__(self, name, price, rating):
        self.name = name
        self.price = price
        self.rating = rating
 
    def __repr__(self):
        return f'{self.name}(${self.price}, {self.rating}★)'
 
products = [
    Product('Laptop', 999, 4.5),
    Product('Phone', 599, 4.8),
    Product('Tablet', 399, 4.2),
    Product('Monitor', 299, 4.7)
]
 
# Sort by price
by_price = sorted(products, key=lambda p: p.price)
print(by_price)
 
# Sort by rating (descending)
by_rating = sorted(products, key=lambda p: -p.rating)
print(by_rating)
 
# Sort by value score (rating / price * 100)
by_value = sorted(products, key=lambda p: (p.rating / p.price) * 100, reverse=True)
print(by_value)

別の方法として、デフォルトのソート挙動のために __lt__（less than）を実装することもできます。

class Student:
    def __init__(self, name, gpa):
        self.name = name
        self.gpa = gpa
 
    def __lt__(self, other):
        return self.gpa > other.gpa  # Higher GPA comes first
 
    def __repr__(self):
        return f'{self.name}({self.gpa})'
 
students = [Student('Alice', 3.8), Student('Bob', 3.9), Student('Charlie', 3.7)]
print(sorted(students))  # [Bob(3.9), Alice(3.8), Charlie(3.7)]

大文字・小文字を区別しない文字列ソート

文字列比較はデフォルトで大文字小文字を区別するため、大文字が小文字より先に並ぶことがあります。大文字小文字を無視するには str.lower() や str.casefold() を使います。

# Case-sensitive sorting (default)
words = ['apple', 'Banana', 'cherry', 'Date']
print(sorted(words))  # ['Banana', 'Date', 'apple', 'cherry']
 
# Case-insensitive sorting
print(sorted(words, key=str.lower))  # ['apple', 'Banana', 'cherry', 'Date']
 
# Using casefold for Unicode handling
international = ['café', 'CAFÉ', 'Apple', 'apple']
print(sorted(international, key=str.casefold))

安定ソート保証とTimsortアルゴリズム

PythonはTimsortアルゴリズムを採用しており、安定ソート（stable sort）が保証されています。安定性とは、同じキーの要素同士が元の相対順序を保つことです。

# Stable sort preserves original order for equal elements
data = [
    ('Alice', 85),
    ('Bob', 92),
    ('Charlie', 85),  # Same score as Alice
    ('David', 92)     # Same score as Bob
]
 
# Sort by score only - original order preserved for ties
by_score = sorted(data, key=lambda x: x[1])
print(by_score)
# [('Alice', 85), ('Charlie', 85), ('Bob', 92), ('David', 92)]
# Alice appears before Charlie (both 85) because she came first

この安定性により「複数回に分けたソート（multi-pass sorting）」が可能です。

# Multi-pass sorting using stability
records = [
    {'name': 'Alice', 'dept': 'HR', 'salary': 60000},
    {'name': 'Bob', 'dept': 'IT', 'salary': 75000},
    {'name': 'Charlie', 'dept': 'HR', 'salary': 65000},
    {'name': 'David', 'dept': 'IT', 'salary': 70000}
]
 
# First sort by salary
records.sort(key=lambda x: x['salary'], reverse=True)
# Then sort by department (stable, so salary order preserved within dept)
records.sort(key=lambda x: x['dept'])
 
for r in records:
    print(f"{r['dept']}: {r['name']} (${r['salary']})")
# HR: Charlie ($65000)
# HR: Alice ($60000)
# IT: Bob ($75000)
# IT: David ($70000)

パフォーマンス比較：ソート手法

Pythonのソートは最悪計算量が O(n log n) で、多くのデータセットに対して十分効率的です。用途に応じて適切な方法を選びましょう。

Method	Time Complexity	Space	Use Case
`list.sort()`	O(n log n)	O(1)	インプレースソート、大きなリスト
`sorted()`	O(n log n)	O(n)	元データ保持、任意のiterableをソート
`heapq.nsmallest(k, items)`	O(n log k)	O(k)	大規模データから上位k件（小さい方）
`heapq.nlargest(k, items)`	O(n log k)	O(k)	大規模データから上位k件（大きい方）
`bisect.insort(list, item)`	O(n)	O(1)	挿入しながらソート済みリストを維持

import heapq
 
# When you only need top 3 scores from 1 million records
scores = list(range(1000000))
top_3 = heapq.nlargest(3, scores)  # Much faster than sorted()[-3:]
print(top_3)  # [999999, 999998, 999997]
 
# When you need bottom 5 values
bottom_5 = heapq.nsmallest(5, scores)
print(bottom_5)  # [0, 1, 2, 3, 4]

頻繁に挿入しつつソート済みを保ちたい場合は次のようにします。

import bisect
 
# Maintain sorted list efficiently
sorted_list = []
for value in [5, 2, 8, 1, 9, 3]:
    bisect.insort(sorted_list, value)
 
print(sorted_list)  # [1, 2, 3, 5, 8, 9]

互換用：functools.cmp_to_key とレガシー比較関数

Python 2では -1/0/1 を返す比較関数が使われていました。Python 3では key 関数が必要ですが、functools.cmp_to_key を使うと古い比較関数を変換できます。

from functools import cmp_to_key
 
# Custom comparison: sort by remainder when divided by 3
def compare_mod3(x, y):
    return (x % 3) - (y % 3)
 
numbers = [10, 11, 12, 13, 14, 15]
sorted_nums = sorted(numbers, key=cmp_to_key(compare_mod3))
print(sorted_nums)  # [12, 15, 10, 13, 11, 14]
# Groups: [12,15] (mod 0), [10,13] (mod 1), [11,14] (mod 2)
 
# Complex comparison: version strings
def compare_versions(v1, v2):
    parts1 = list(map(int, v1.split('.')))
    parts2 = list(map(int, v2.split('.')))
 
    for p1, p2 in zip(parts1, parts2):
        if p1 != p2:
            return p1 - p2
    return len(parts1) - len(parts2)
 
versions = ['1.10.2', '1.9.0', '1.10.15', '2.0.0', '1.10']
sorted_versions = sorted(versions, key=cmp_to_key(compare_versions))
print(sorted_versions)  # ['1.9.0', '1.10', '1.10.2', '1.10.15', '2.0.0']

None を含むソート

None が他の型と混在すると比較エラーになります。None を先頭/末尾に寄せるなど、明示的に扱います。

# None values cause errors
data = [3, None, 1, 5, None, 2]
# sorted(data)  # TypeError: '<' not supported between 'NoneType' and 'int'
 
# Place None values at the end
sorted_data = sorted(data, key=lambda x: (x is None, x))
print(sorted_data)  # [1, 2, 3, 5, None, None]
 
# Place None values at the beginning
sorted_data = sorted(data, key=lambda x: (x is not None, x))
print(sorted_data)  # [None, None, 1, 2, 3, 5]
 
# Replace None with specific value for sorting
sorted_data = sorted(data, key=lambda x: x if x is not None else float('-inf'))
print(sorted_data)  # [None, None, 1, 2, 3, 5]

キー欠損の可能性があるdictionaryの場合は次のようにします。

records = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob'},  # Missing score
    {'name': 'Charlie', 'score': 92},
    {'name': 'David'}  # Missing score
]
 
# Sort with default value for missing keys
sorted_records = sorted(records, key=lambda x: x.get('score', 0))
print([r['name'] for r in sorted_records])
# ['Bob', 'David', 'Alice', 'Charlie']

実例：学生のパフォーマンス順位付け

複数のソート技法を組み合わせて、総合的なランキングを作る例です。

class StudentRecord:
    def __init__(self, name, test_scores, attendance, extra_credit=0):
        self.name = name
        self.test_scores = test_scores
        self.attendance = attendance
        self.extra_credit = extra_credit
 
    @property
    def average_score(self):
        return sum(self.test_scores) / len(self.test_scores) if self.test_scores else 0
 
    @property
    def final_grade(self):
        base = self.average_score * 0.8 + self.attendance * 0.2
        return min(100, base + self.extra_credit)
 
    def __repr__(self):
        return f'{self.name}: {self.final_grade:.1f}'
 
students = [
    StudentRecord('Alice', [85, 90, 88], 95, 5),
    StudentRecord('Bob', [92, 88, 95], 80, 0),
    StudentRecord('Charlie', [78, 82, 80], 100, 10),
    StudentRecord('David', [90, 92, 88], 90, 2),
    StudentRecord('Eve', [85, 85, 85], 95, 0)
]
 
# Rank by final grade (highest first), then name
rankings = sorted(students, key=lambda s: (-s.final_grade, s.name))
 
print("Student Rankings:")
for rank, student in enumerate(rankings, 1):
    print(f"{rank}. {student}")

実例：ファイル一覧の処理

ファイルメタデータのソートでは、複数データ型や独自の並び順ロジックの扱いが必要になります。

import os
from datetime import datetime
 
class FileInfo:
    def __init__(self, path):
        self.name = os.path.basename(path)
        self.path = path
        self.size = os.path.getsize(path)
        self.modified = os.path.getmtime(path)
        self.extension = os.path.splitext(path)[1].lower()
 
    def __repr__(self):
        size_kb = self.size / 1024
        mod_time = datetime.fromtimestamp(self.modified).strftime('%Y-%m-%d %H:%M')
        return f'{self.name} ({size_kb:.1f} KB, {mod_time})'
 
# Simulate file information
files = [
    FileInfo('/data/report.pdf'),
    FileInfo('/data/summary.txt'),
    FileInfo('/data/analysis.xlsx'),
    FileInfo('/data/backup.pdf'),
]
 
# Sort by extension, then size (largest first)
by_type_size = sorted(files, key=lambda f: (f.extension, -f.size))
 
# Sort by modification time (most recent first)
by_recent = sorted(files, key=lambda f: -f.modified)
 
# Sort by size, handling different units
def format_size(bytes_size):
    if bytes_size < 1024:
        return f"{bytes_size} B"
    elif bytes_size < 1024 * 1024:
        return f"{bytes_size/1024:.1f} KB"
    else:
        return f"{bytes_size/(1024*1024):.1f} MB"
 
by_size = sorted(files, key=lambda f: f.size, reverse=True)
for f in by_size:
    print(f"{f.name}: {format_size(f.size)}")

PyGWalkerによるインタラクティブなデータソート

大規模データセットを可視化しながら探索し、対話的にソートしたい場合、PyGWalkerはpandas DataFrameをTableau風のインターフェースに変換します。複雑なソートロジックを書く代わりに、列をドラッグ＆ドロップして視覚的にソート・フィルタ・分析ができます。

import pandas as pd
import pygwalker as pyg
 
# Create sample sales data
sales_data = pd.DataFrame({
    'product': ['Laptop', 'Phone', 'Tablet', 'Monitor', 'Keyboard'] * 100,
    'region': ['North', 'South', 'East', 'West', 'Central'] * 100,
    'revenue': [999, 599, 399, 299, 49] * 100,
    'units_sold': [50, 120, 80, 95, 200] * 100,
    'date': pd.date_range('2024-01-01', periods=500)
})
 
# Launch interactive visualization
pyg.walk(sales_data)

PyGWalkerでできること：

視覚的フィードバック付きの複数列ソート
ソートと組み合わせた動的フィルタリング
コードを書かずに計算フィールドでソート
ソート済みビューをチャート/テーブルとしてエクスポート

このアプローチは、初見のデータセットを探索するときや、Pythonコードを実行せずにデータの傾向を理解したい非技術系ステークホルダーへ結果を示すときに特に有効です。

FAQ

Pythonのsorted()とlist.sort()の違いは何ですか？

sorted() は新しいソート済みリストを返し、任意のiterableに対して動作し、元のデータは変更しません。list.sort() はリストをインプレースで並べ替え、返り値は None で、listオブジェクトにのみ使えます。元のデータを保持したい場合やtupleなどの非listシーケンスをソートしたい場合は sorted() を、巨大なリストをメモリ効率よくソートしたい場合は list.sort() を使います。

Pythonでリストを降順にソートするには？

sorted() または list.sort() に reverse=True を指定します。例：sorted([3, 1, 4], reverse=True) は [4, 3, 1] を返します。数値、文字列、日付など、自然順序を持つあらゆるデータ型で使えます。

Pythonでdictionaryを値でソートできますか？

dictionary自体は伝統的な意味で順序を持ちませんが、sorted() と key 関数でitemsを値でソートできます：sorted(dict.items(), key=lambda x: x[1])。これは値でソートされたtupleのリストを返します。必要なら dict(sorted(...)) でdictionaryに戻せますが、順序が保持されるのは Python 3.7+ です。

dictionaryのリストを特定キーでソートするには？

sorted() に、キーを取り出すlambdaを渡します：sorted(list_of_dicts, key=lambda x: x['keyname'])。パフォーマンス面では operator.itemgetter の利用が有利です：sorted(list_of_dicts, key=itemgetter('keyname'))。いずれも単一キー・複数キーのソートに対応できます。

Pythonのsort関数の計算量は？

Pythonの sorted() と list.sort() はTimsortを使い、最悪計算量は O(n log n)、部分的に整列済みデータでは最良で O(n) になります。空間計算量は、sorted() が O(n)（新しいリストを作る）、list.sort() が O(1)（インプレース）です。大規模データから上位k件を求める場合は heapq.nlargest() が O(n log k) で有利です。

ソート時にNoneをどう扱えばいいですか？

None は他の型と混在すると比較エラーになります。key 関数で先頭/末尾に寄せます：sorted(data, key=lambda x: (x is None, x)) は None を末尾へ、sorted(data, key=lambda x: (x is not None, x)) は先頭へ置きます。キー欠損のあるdictionaryでは x.get('key', default_value) でデフォルト値を与えます。

Pythonのソートは安定ですか？

はい。Pythonのソートは安定で、同じキーの要素は元の相対順序を保ちます。そのため、ある基準でソートしてから別基準でソートする「複数回ソート」を行っても、同値（tie）に対して最初の並びが維持されます。これはTimsortによって保証されています。

まとめ

Pythonのソート機能は、データを効率よく整理するための強力な道具立てを提供します。sorted() と list.sort() の違いを理解すれば、メモリとデータ保持を意識した選択ができます。また key パラメータやlambdaを使うことで、高度なカスタムソートロジックも実装できます。安定ソート、複数条件の並び替え、パフォーマンス特性を押さえることで、状況に応じて最適な方法を選べるようになります。

学生の成績順位付け、ファイルメタデータの処理、ビジネスメトリクスの分析など、これらのソート技法はデータ操作ワークフローの基盤です。さらに、視覚的なデータ探索と対話的なソートが必要なら、PyGWalkerがドラッグ＆ドロップのUIでプログラムによるソートを補完してくれます。

これらのソートパターンを身につければ、より読みやすいコードを書けるようになり、性能も改善し、複雑なデータ整理の課題にも自信を持って対応できるようになります。

📚