Summary  
This chapter covers using built-in higher-order functions—filter() to select elements based on a predicate and sorted() to order elements based on a key function—often implemented with lambda expressions.

General domain of usage  
Data processing

ここでは、Python の `filter()` 関数および `sorted()` 関数と **lambda** 関数を組み合わせて使用する例をさらに2つ紹介します。

これらの高階関数には、lambda の代わりにより複雑なカスタム関数を渡すことも可能です。

### filter() 
`filter()` 関数は、*関数が* **True** を返すイテラブルの要素から *イテレータ* を作成するために使用されます。以下は、リストから *奇数* を除外するために filter() と lambda 関数を使用した例です:

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

# Using a lambda function to filter out odd numbers
even_numbers = filter(lambda x: x % 2 == 0, numbers)

# Convert the filter object to a list
even_numbers_list = list(even_numbers)
print(even_numbers_list)

この例では、ラムダ関数 `lambda x: x % 2 == 0` は*数値が偶数かどうか*を判定します。`filter()` 関数はこのラムダを数値リストの各要素に適用し、偶数のみのイテレータを返します。

### sorted()

`sorted()` 関数は、任意のイテラブルの要素から**新しいソート済みリスト**を返します。
``` python
sorted(iterable, key=key, reverse=reverse)
```
* `iterable` はソート対象のシーケンス（list、dict、tuple など）;
* `key` は順序を決定するために実行される関数;
* `reverse` はブール値。False は昇順、True は降順。デフォルトは False。

以下は、各タプルの2番目の要素でリストをソートするために**lambda**関数を使った `sorted()` の例です:

tuples = [(1, 'banana'), (2, 'apple'), (3, 'orange')]

# Using a lambda function to sort by the second element of each tuple
sorted_tuples = sorted(tuples, key=lambda x: x[1])

print(sorted_tuples)

この例では、ラムダ関数 `lambda x: x[1]` は各タプルの2番目の要素を返します。`sorted()` 関数はこれらの2番目の要素に基づいてリスト tuples を並べ替え、果物名でアルファベット順にソートされたリストが得られます。


import unittest
import user_code
import ast
import re
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.books = [
            {"title": "Harry Potter and the Deathly Hallows", "pages": 640},
            {"title": "Rich Dad Poor Dad", "pages": 336},
            {"title": "The Great Gatsby", "pages": 160},
            {"title": "The Hobbit", "pages": 400}
        ]

    def test_has_many_pages_true(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'has_many_pages', None)
        book = {"title": "A", "pages": 400}
        result = func(book)
        _dynamic_test(
            self,
            result is True,
            "has_many_pages returns True for book with more than 350 pages",
            f"Expected True for book with 400 pages, got {result}."
        )

    def test_has_many_pages_false(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'has_many_pages', None)
        book = {"title": "B", "pages": 100}
        result = func(book)
        _dynamic_test(
            self,
            result is False,
            "has_many_pages returns False for book with less than 350 pages",
            f"Expected False for book with 100 pages, got {result}."
        )

    def test_has_many_pages_exactly_350(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'has_many_pages', None)
        book = {"title": "C", "pages": 350}
        result = func(book)
        _dynamic_test(
            self,
            result is False,
            "has_many_pages returns False for book with exactly 350 pages",
            f"Expected False for book with 350 pages, got {result}."
        )

    def test_filtered_books_content(self):
        import user_code
        importlib.reload(user_code)
        filtered_books_list = getattr(user_code, 'filtered_books_list', None)
        expected_titles = [
            "Harry Potter and the Deathly Hallows",
            "The Hobbit"
        ]
        _dynamic_test(
            self,
            isinstance(filtered_books_list, list),
            "filtered_books_list is a list",
            f"filtered_books_list should be a list, got {type(filtered_books_list)}."
        )
        titles = [book.get("title") for book in filtered_books_list]
        _dynamic_test(
            self,
            sorted(titles) == sorted(expected_titles),
            "filtered_books_list contains only books with pages > 350",
            f"Expected titles {expected_titles}, got {titles}."
        )

    def test_filter_function_used(self):
        # Check if 'filtered_books' is a filter object and not a list
        import user_code
        importlib.reload(user_code)
        filtered_books = getattr(user_code, 'filtered_books', None)
        _dynamic_test(
            self,
            hasattr(filtered_books, '__iter__') and not isinstance(filtered_books, list),
            "filtered_books is a filter object",
            f"filtered_books should be a filter object, got {type(filtered_books)}."
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

このコースでは、関数の引数、イテレータ、ジェネレータ、クロージャ、デコレータなどの高度なトピックを学習します。数多くの練習問題を通じて、これらのトピックを理解できます。

このトピックは楽しく学べ、単一の代入で値をパックおよびアンパックする方法を習得できます。

Pythonの関数引数、*args、**kwargsの強力な機能を探求し、関数を引数として効果的に使用する方法を学習します。

高階関数と、関数が他の関数への引数として渡される方法について学びます。

変数のスコープとは何か、そして以前はどのようにそれを管理していたのか。本トピックは、クロージャやデコレータといった次のテーマを理解するために不可欠です。このトピックは楽しく、実用的であることをお約束します。ローカル変数、ノンローカル変数、グローバル変数についての知識を身につけることができます。

このセクションでは、関数の動作を修正および強化する強力な機能であるPythonデコレータについて、詳細に解説します。受講者は独自のデコレータの作成方法、組み込みデコレータの理解、実践的なシナリオでのデコレータの活用方法を学びます。

Pythonの組み込み関数の使用

filter()

sorted()

解答