Python 3 エンジニア認定基礎試験（9章）の出題傾向と対策法

Python 3 エンジニア認定基礎試験（9章）に向けて学習を進める中で、重要な概念をしっかりと理解することが求められます。この章では、Python のクラスに関連する内容を深掘りしていきます。

特にクラスに関する前半部分を学んだ後、後半部分ではクラスやインスタンスの扱い方をさらに詳しく学びます。

具体的には、名前とオブジェクトの関係、Python のスコープと名前空間、そしてクラスの定義方法に焦点を当てます。

クラス初見やクラス定義の構文、クラスオブジェクトやインスタンスオブジェクト、メソッドオブジェクトなどを理解することで、より実践的なコードを書けるようになります。

また、クラスとインスタンス変数の使い方や注意点についても解説します。継承や多重継承、プライベート変数に関しても、試験に備えてしっかりと確認しておくべき内容です。

さらに、イテレータ (iterator) やジェネレータ (generator)、ジェネレータ式に関する知識も不可欠です。

これらの概念を総合的に理解することで、Python のクラス設計やオブジェクト指向の理解が深まります。本記事では、これらのトピックをわかりやすく解説し、試験に向けた学習の手助けとなる内容を提供していきます。

他にもBe Free Techではエンジニアの人が知らないと損する情報を紹介してますのでご覧ください！

Python 3 エンジニア認定基礎試験（9章）：クラス（前半）

名前とオブジェクトについて

Pythonでは「名前」と「オブジェクト」の概念を明確に理解することが重要です。プログラム中で変数を定義すると、Pythonはその変数名を特定のオブジェクトに紐づけます。ここで重要なのは、名前そのものは単なるラベルであり、実際にメモリ上で保持されるデータの実態が「オブジェクト」であるという点です。名前はオブジェクトに対する参照の役割を果たします。

Pythonではすべてがオブジェクトです。数値、文字列、リスト、関数、さらにはクラスまでもオブジェクトとして扱われます。オブジェクトには一意のID、型、値が付与されています。オブジェクトのIDはメモリ上の位置を指し、id()関数で確認することができます。

例えば、次のコードでは、xとyという二つの名前が同じオブジェクトを参照していることがわかります。

x = 10
y = x
print(id(x), id(y))  # 同じIDが表示される

このように、変数に新たな値を代入すると、別のオブジェクトを参照するようになります。ただし、リストや辞書などのミュータブルオブジェクト（変更可能なオブジェクト）の場合は異なる挙動を示します。

次にミュータブルオブジェクトの例です。

a = [1, 2, 3]
b = a
b.append(4)
print(a)  # [1, 2, 3, 4]と表示される

このような場合、b.append(4)を実行することで、aの内容にも変更が反映されます。これはaとbが同じオブジェクトを参照しているためです。

名前とオブジェクトの理解は、変数の挙動やデータの操作、さらにはメモリ効率を意識したプログラム設計において重要な基礎知識です。

Python のスコープと名前空間

スコープと名前空間は、Pythonプログラムの変数の有効範囲と名前の管理方法を説明するための重要な概念です。スコープは変数がアクセス可能な範囲を意味し、名前空間は名前とオブジェクトの対応を管理する場所です。

Pythonではスコープが4つのレベルに分けられています。

1. ローカルスコープ（Local Scope）: 関数内部で定義された変数に適用されます。
2. エンクロージングスコープ（Enclosing Scope）: ネストされた関数内で外側の関数に定義された変数に適用されます。
3. グローバルスコープ（Global Scope）: モジュール全体で有効な変数です。
4. ビルトインスコープ（Built-in Scope）: Pythonが提供する組み込み関数や定数のスコープです。

次のコード例では、スコープの階層がどのように影響を与えるかを示します。

x = "グローバルスコープ"

def outer_function():
    x = "エンクロージングスコープ"
    
    def inner_function():
        x = "ローカルスコープ"
        print(x)
    
    inner_function()

outer_function()  # ローカルスコープが表示される

名前空間は、Pythonの内部で辞書型データ構造によって管理されています。名前空間により、同じ名前でも異なるスコープで変数が独立して扱われます。

次にグローバル変数を関数内で変更する例を示します。

count = 0

def increment():
    global count
    count += 1

increment()
print(count)  # 1と表示される

スコープと名前空間の概念を理解することで、予期しないバグを防ぎ、スムーズなコード設計が可能となります。

スコープと名前空間の例

ここでは、Pythonのスコープと名前空間の具体例を示し、理解を深めます。スコープの階層を考慮したコードの書き方を学ぶことで、複雑なコードの動作を理解できるようになります。

まず、関数内で同じ変数名を使用した場合のスコープの動作を示します。

x = 10

def example_function():
    x = 5
    print(x)  # ローカルスコープのxが表示される

example_function()
print(x)  # グローバルスコープのxが表示される

このコードでは、example_function()内でローカルスコープのxを参照しているため、関数外のグローバルスコープのxは変更されません。

また、ネストされた関数のスコープについても見てみましょう。

def outer_function():
    y = "外部スコープ"
    
    def inner_function():
        print(y)  # エンクロージングスコープのyが表示される
    
    inner_function()

outer_function()

エンクロージングスコープの変数にアクセスできるため、inner_function()は外部関数の変数yを参照します。
スコープと名前空間を正確に理解することで、Pythonプログラムの構造を効率的に設計できるようになります。

クラス初見

Pythonにおけるクラスは、オブジェクト指向プログラミングの基本要素です。クラスは複数のデータやメソッド（関数）をまとめて管理するためのテンプレートのような役割を果たします。クラスを基に作られた具体的なインスタンスが実際のデータを保持し、プログラム内で操作されます。

クラスを用いることで、コードの再利用性が向上し、プログラムの規模が大きくなった場合でも管理しやすくなります。たとえば、動物を表現する場合、各動物の名前や種類を個別に変数として扱う代わりに、クラスを作成することで一括管理が可能になります。

次の例は、動物クラスを初めて定義し、そのインスタンスを作成する基本例です。

class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species
    
    def make_sound(self):
        print(f"{self.name}は音を出します！")

# クラスインスタンスの作成
dog = Animal("ポチ", "犬")
dog.make_sound()  # ポチは音を出します！

このコードでは、__init__メソッドがインスタンス生成時に呼び出され、属性nameとspeciesが初期化されています。また、メソッドmake_sound()はインスタンスごとの動作を示します。

次にクラスの利用がより複雑な例を示します。

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
    
    def display_info(self):
        return f"この車は{self.brand}の{self.model}モデルです。"

# クラスのインスタンス作成
my_car = Car("トヨタ", "カローラ")
print(my_car.display_info())  # この車はトヨタのカローラモデルです。

このように、クラスを活用することでオブジェクトの状態を保持し、関連する機能をまとめることができます。初めてクラスを使う際は、インスタンスの作成とメソッドの活用を意識すると良いでしょう。

クラス定義の構文

クラスを定義する際の基本的な構文は非常にシンプルですが、正しい理解が重要です。Pythonではclassキーワードを使い、クラス名の後にコロンを付けて定義を始めます。一般的なクラスの構文は次のようになります。

class クラス名:
    def __init__(self, 引数1, 引数2, ...):
        self.属性名1 = 引数1
        self.属性名2 = 引数2
    
    def メソッド名(self):
        実行する処理

具体的な例として、ユーザー情報を保持するクラスを作成してみましょう。

class User:
    def __init__(self, username, age):
        self.username = username
        self.age = age
    
    def greet(self):
        print(f"こんにちは、私は{self.username}です！")

# クラスインスタンスの作成
user1 = User("田中太郎", 25)
user1.greet()  # こんにちは、私は田中太郎です！

このコードでは、__init__メソッドがインスタンス生成時に呼び出され、属性usernameとageが初期化されています。また、selfはインスタンス自身を指し、クラスメソッド内でインスタンスの属性やメソッドにアクセスするために使います。

次に、クラスに条件付きメソッドを加えた例を示します。

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def calculate_area(self):
        return self.width * self.height

rect = Rectangle(5, 10)
print(f"長方形の面積: {rect.calculate_area()}")  # 長方形の面積: 50

このように、クラス定義では属性の初期化とインスタンスごとの動作を記述するメソッドを組み合わせることで、柔軟な機能を持つオブジェクトを作成できます。

クラスオブジェクト

クラスオブジェクトとは、クラスそのものがオブジェクトとして扱われる仕組みです。Pythonでは、クラス自体もtype型のインスタンスであり、メタクラスの概念に基づいて動作します。この特徴により、クラスを動的に生成したり、クラス属性を操作することが可能です。

通常、クラスオブジェクトはクラスを定義すると自動的に作成され、インスタンスを生成する際に利用されます。次の例は基本的なクラスオブジェクトの確認方法を示します。

class Example:
    pass

# クラスオブジェクトの確認
print(type(Example))  # <class 'type'>と表示される

Pythonではクラス自体がオブジェクトであるため、属性の追加やメソッドの動的な追加も可能です。

class DynamicClass:
    pass

# 動的に属性を追加
DynamicClass.new_attribute = "新しい属性"
print(DynamicClass.new_attribute)  # 新しい属性と表示される

また、type()を使って動的にクラスを作成することもできます。

# type()を使ったクラスの動的作成
DynamicTypeClass = type('DynamicTypeClass', (object,), {'attribute': '動的属性'})
print(DynamicTypeClass.attribute)  # 動的属性と表示される

クラスオブジェクトの概念を理解することで、柔軟なプログラム設計が可能となります。特にメタクラスを使った高度なプログラミングを行う際には欠かせない知識です。

インスタンスオブジェクト

インスタンスオブジェクトとは、クラスから生成された具体的なオブジェクトを指します。クラスは設計図のようなものであり、インスタンスオブジェクトはその設計図をもとに作成された実際のデータや動作を持つ個別の要素です。たとえば、「車」というクラスが設計図だとすれば、実際に製造された「トヨタのカローラ」や「ホンダのシビック」がインスタンスオブジェクトです。

インスタンスオブジェクトは、クラス内で定義された属性やメソッドを利用します。クラスの中に__init__()メソッドを定義すると、インスタンス生成時に初期化処理が自動的に実行され、各インスタンス固有の属性が設定されます。

以下は、インスタンスオブジェクトを作成し、それぞれ異なる属性を保持する例です。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"私は{self.name}です。年齢は{self.age}歳です。")

# インスタンスの作成
person1 = Person("田中太郎", 30)
person2 = Person("山田花子", 25)

person1.introduce()  # 私は田中太郎です。年齢は30歳です。
person2.introduce()  # 私は山田花子です。年齢は25歳です。

このように、異なるインスタンスオブジェクトがそれぞれ異なるデータを保持できる点がクラスの強力な特長です。

もう一つの例では、インスタンスごとに動作を変更するパターンを示します。

class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def make_sound(self):
        print(f"{self.name}は{self.sound}と鳴きます。")

# インスタンス生成
cat = Animal("猫", "ニャー")
dog = Animal("犬", "ワンワン")

cat.make_sound()  # 猫はニャーと鳴きます。
dog.make_sound()  # 犬はワンワンと鳴きます。

このように、インスタンスオブジェクトはクラスの情報を基に個別のデータを持ち、異なる動作を実現するために欠かせない概念です。

メソッドオブジェクト

メソッドオブジェクトとは、クラスやインスタンスから呼び出される関数であり、クラスの振る舞いを定義します。インスタンスメソッドは、self引数を受け取り、インスタンスの属性や他のメソッドにアクセスできます。クラスメソッドは、clsを第一引数に取り、クラス全体に関する操作を行います。

メソッドオブジェクトの基本的な特徴は、インスタンスメソッドがインスタンス固有のデータに依存する点です。以下はインスタンスメソッドの基本例です。

class Calculator:
    def __init__(self, value):
        self.value = value

    def add(self, amount):
        self.value += amount

calc = Calculator(10)
calc.add(5)
print(calc.value)  # 15と表示される

このコードでは、add()メソッドがインスタンスの属性valueを更新します。

次に、クラスメソッドの例を示します。

class Counter:
    count = 0

    @classmethod
    def increment(cls):
        cls.count += 1

# クラスメソッドを呼び出す
Counter.increment()
Counter.increment()
print(Counter.count)  # 2と表示される

この例では、@classmethodデコレーターが付いたincrement()メソッドがクラス属性countを操作します。インスタンスを生成せずにクラスレベルで動作させたい場合に便利です。

メソッドオブジェクトの正しい理解は、クラス設計の質を向上させ、より効率的なコードを実現するために重要です。

クラスとインスタンス変数

クラスとインスタンス変数は、オブジェクト指向プログラミングにおける重要な概念です。クラス変数はクラス全体で共有される変数で、すべてのインスタンスが同じ値を参照します。一方、インスタンス変数は特定のインスタンスに属し、それぞれ異なる値を持つことができます。

次の例では、クラス変数とインスタンス変数の違いを確認します。

class Employee:
    company_name = "TechCorp"  # クラス変数

    def __init__(self, name, role):
        self.name = name  # インスタンス変数
        self.role = role

# インスタンスを生成
emp1 = Employee("田中", "エンジニア")
emp2 = Employee("佐藤", "デザイナー")

print(emp1.company_name)  # TechCorp
print(emp2.company_name)  # TechCorp

このコードでは、company_nameはクラス変数であるため、すべてのインスタンスで同じ値が参照されます。

一方、次の例ではインスタンス変数の独立性を示します。

class Car:
    def __init__(self, brand, color):
        self.brand = brand  # インスタンス変数
        self.color = color

# インスタンス生成
car1 = Car("トヨタ", "赤")
car2 = Car("ホンダ", "青")

print(car1.color)  # 赤
print(car2.color)  # 青

このように、インスタンス変数は各インスタンスで異なる値を持つため、個別のデータを保持するために適しています。クラスとインスタンス変数の違いを理解することで、より効率的なクラス設計が可能になります。

Python 3 エンジニア認定基礎試験（9章）：クラス（後半）

いろいろな注意点

Pythonのクラスやオブジェクト指向プログラミングを使用する際、いくつか注意すべきポイントがあります。これらを事前に理解しておくことで、エラーを防ぎ効率的な開発が可能になります。

1. メソッド引数selfの記載忘れ

インスタンスメソッドを定義する際、最初の引数に必ずselfを記述する必要があります。これを忘れるとエラーになり、意図した動作が行われません。

class Sample:
    def greet():  # selfを忘れている
        print("こんにちは")

sample = Sample()
# TypeError: greet() takes 0 positional arguments but 1 was given
sample.greet()  

このエラーは、インスタンスが暗黙的に自身を引数として渡すため発生します。正しい書き方は以下の通りです。

class Sample:
    def greet(self):
        print("こんにちは")

sample = Sample()
sample.greet()  # 正常に動作する

2. クラス変数とインスタンス変数の混同

クラス変数はすべてのインスタンスで共有されるため、誤ってクラス変数をインスタンス固有のデータ管理に使うと意図しない挙動が起きます。

class Counter:
    count = 0  # クラス変数

    def increment(self):
        self.count += 1

counter1 = Counter()
counter2 = Counter()

counter1.increment()
print(counter2.count)  # 期待値は0だが、実際は1になる

この問題は、インスタンス変数を使うことで解消できます。

class Counter:
    def __init__(self):
        self.count = 0  # インスタンス変数

    def increment(self):
        self.count += 1

counter1 = Counter()
counter2 = Counter()

counter1.increment()
print(counter2.count)  # 正しく0と表示される

これらの注意点を理解することで、Pythonのクラス設計がより堅牢になります。

継承

継承とは、既存のクラス（親クラス）をもとに新しいクラス（子クラス）を作成する仕組みです。親クラスの属性やメソッドを子クラスで再利用できるため、コードの再利用性が向上します。これにより、冗長なコードを削減し、保守性の高いプログラムを作成できます。

基本的な継承の例

以下は、親クラスAnimalを子クラスDogが継承する例です。

class Animal:
    def sound(self):
        print("動物が音を出します")

class Dog(Animal):
    def sound(self):
        print("ワンワン")

dog = Dog()
dog.sound()  # ワンワン

このように、子クラスで親クラスのメソッドをオーバーライドすることで、独自の振る舞いを持たせることが可能です。

super()を使った親クラスメソッドの呼び出し

親クラスのメソッドを明示的に呼び出したい場合、super()を使います。

class Parent:
    def greet(self):
        print("こんにちは、親クラスです")

class Child(Parent):
    def greet(self):
        super().greet()
        print("そして子クラスです")

child = Child()
child.greet()

このコードでは、super().greet()により親クラスのメソッドが呼ばれ、その後に子クラス独自のメッセージが表示されます。

継承を正しく理解することで、オブジェクト指向プログラミングの強みを十分に活用できます。

多重継承

多重継承とは、複数の親クラスを子クラスが継承する仕組みです。Pythonでは多重継承が可能ですが、構造が複雑になるため注意が必要です。特に、メソッド解決順序（MRO：Method Resolution Order）が重要なポイントです。

基本的な多重継承の例

以下の例では、ClassCがClassAとClassBの両方を継承しています。

class ClassA:
    def show(self):
        print("ClassA")

class ClassB:
    def show(self):
        print("ClassB")

class ClassC(ClassA, ClassB):
    pass

c = ClassC()
c.show()  # ClassAと表示される

この場合、ClassCはClassAを優先してメソッドを解決します。これはMROに基づく動作です。

super()を使ったメソッド解決

多重継承時にsuper()を適切に使うと、複雑な継承関係でもスムーズなメソッド呼び出しが可能です。

class A:
    def process(self):
        print("Aの処理")

class B(A):
    def process(self):
        super().process()
        print("Bの処理")

class C(B):
    def process(self):
        super().process()
        print("Cの処理")

c = C()
c.process()

このコードでは、super()を使って親クラスの処理を順番に呼び出します。MROの順序に従い、A→B→Cの順に処理が行われます。

多重継承は強力ですが、設計が複雑になるため慎重な利用が求められます。MROやsuper()の仕組みを理解することで、より効率的なプログラム設計が可能となります。

プライベート変数

プライベート変数とは、クラスの外部から直接アクセスできないように隠蔽された変数のことです。Pythonでは厳密なアクセス制限はありませんが、命名規則によって「プライベート」として扱う方法があります。この概念はデータの保護やカプセル化を実現し、予期しないデータの変更を防ぐために重要です。

アンダースコアによるプライベート変数の定義

Pythonでは変数名の先頭にアンダースコア（_）を付けることで「プライベート変数」の目印とします。

class Sample:
    def __init__(self):
        self._private_var = "プライベート変数"

    def display_private_var(self):
        print(self._private_var)

sample = Sample()
sample.display_private_var()  # プライベート変数と表示
print(sample._private_var)  # 注意: アクセスは可能

このコードでは、変数_private_varにアンダースコアを付けていますが、アクセス自体は可能です。ただし、慣習的に「開発者は直接触れない」という暗黙のルールがあります。

ダブルアンダースコアによる名前マングリング

より強力なプライベート変数の隠蔽方法として、変数名の先頭にダブルアンダースコア（__）を付ける方法があります。この方法は「名前マングリング」と呼ばれ、クラスの外部から直接アクセスしにくくなります。

class Example:
    def __init__(self):
        self.__private_value = "隠れた値"

    def show_value(self):
        print(self.__private_value)

example = Example()
example.show_value()  # 隠れた値と表示

# 以下のコードはエラーになる
# print(example.__private_value)  # AttributeError

クラス外部から直接アクセスしようとするとエラーになります。このように名前マングリングを利用することで、変数の保護がより強固になります。適切にプライベート変数を使うことで、堅牢でメンテナンス性の高いコードを作成できます。

残りのはしばし

「残りのはしばし」という表現は、Pythonのクラスやオブジェクト指向プログラミングにおける細かい注意点や仕様を指します。これらの理解はプログラムの安定性を高め、予期しないバグの発生を防ぐために重要です。

属性の削除と動的属性の追加

Pythonではオブジェクトの属性を動的に追加したり、削除することができます。

class Example:
    pass

example = Example()
example.new_attr = "動的に追加された属性"
print(example.new_attr)  # 動的に追加された属性

このように任意の属性を簡単に追加できますが、過度に使用するとコードが読みにくくなり、保守性が低下する可能性があります。動的な属性操作は慎重に扱うべきです。

delによる属性の削除

属性を削除する場合はdelを使います。

class Sample:
    def __init__(self):
        self.value = "削除可能な属性"

sample = Sample()
print(sample.value)  # 削除可能な属性

del sample.value
# 次の行はエラー: AttributeError
# print(sample.value)

このように、属性が不要になった場合は削除することでメモリ効率が向上します。ただし、削除後のアクセスはエラーとなるため注意が必要です。

ダンダーメソッドの利用

Pythonには特殊な名前を持つ「ダンダーメソッド」が存在します。たとえば、__str__()を実装することで、オブジェクトを文字列として出力する際の挙動をカスタマイズできます。

class CustomObject:
    def __str__(self):
        return "カスタムオブジェクトです"

obj = CustomObject()
print(obj)  # カスタムオブジェクトです

これらの技術を理解し適切に活用することで、より高度なプログラム設計が可能になります。

イテレータ (iterator)

イテレータとは、要素を順番に取り出すためのオブジェクトです。Pythonではforループのような反復処理で自動的にイテレータが利用されます。イテレータを理解することで、効率的なデータ操作が可能になります。

イテレータの基本構造

イテレータは、__iter__()メソッドと__next__()メソッドを実装したオブジェクトです。

class SimpleIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        result = self.data[self.index]
        self.index += 1
        return result

# イテレータの利用
data = [1, 2, 3]
iterator = SimpleIterator(data)
for value in iterator:
    print(value)

この例では、SimpleIteratorクラスがイテレータの役割を果たし、リスト要素を順に出力します。

iter()とnext()の直接利用

組み込み関数iter()とnext()を利用してイテレータを直接操作することも可能です。

numbers = [10, 20, 30]
iterator = iter(numbers)

print(next(iterator))  # 10
print(next(iterator))  # 20
print(next(iterator))  # 30

# これ以上要素がない場合はStopIteration例外が発生

イテレータは大量のデータ処理時に特に有効です。メモリ効率が良いため、ジェネレータとともに使うとより効率的なデータ処理が可能です。イテレータの仕組みを深く理解することで、Pythonでのプログラム作成がより高度なものになります。

ジェネレータ (generator)

ジェネレータとは、大量のデータを効率よく処理するためのPythonの特殊な関数です。通常の関数ではすべての処理が一度に実行されるのに対し、ジェネレータは必要なタイミングで値を順番に返す仕組みを持っています。これにより、メモリ使用量を抑えながらデータを処理できます。

ジェネレータ関数はyieldキーワードを用いることで定義されます。yieldを使うと、関数は値を返す際に一時停止し、その後再開できます。

基本的なジェネレータの例

以下は単純なジェネレータ関数の例です。

def simple_generator():
    yield 1
    yield 2
    yield 3

for value in simple_generator():
    print(value)

このコードでは、ジェネレータ関数simple_generator()が順番に値を返します。通常の関数とは異なり、returnで終わるのではなく、途中でyieldで値を返しつつ関数が一時停止します。

無限シーケンスのジェネレータ

ジェネレータは無限に続くシーケンスを生成する際にも便利です。

def infinite_counter(start=0):
    while True:
        yield start
        start += 1

counter = infinite_counter(5)
print(next(counter))  # 5
print(next(counter))  # 6
print(next(counter))  # 7

このような場合、リストで全ての値を保持するのは不可能です。しかし、ジェネレータを使うことでメモリ効率の良いシステムを構築できます。大規模なデータ処理を効率よく行う際に、ジェネレータは非常に有用です。

ジェネレータ式

ジェネレータ式は、リスト内包表記に似た構文を使って簡単にジェネレータを作成する方法です。通常のジェネレータ関数に比べてシンプルな記述が可能です。リスト内包表記がメモリに全ての要素を保持するのに対し、ジェネレータ式は一度に一つずつ要素を生成するため、メモリ効率が優れています。

ジェネレータ式の基本例

以下は数値の二乗を生成するジェネレータ式の例です。

squares = (x ** 2 for x in range(5))

for value in squares:
    print(value)

このコードでは、ジェネレータ式(x ** 2 for x in range(5))が順次数値の二乗を生成します。通常のリスト内包表記[x ** 2 for x in range(5)]と異なり、すべての要素を保持せずに必要なときだけ値を返します。

sum関数でのジェネレータ式利用

ジェネレータ式は組み込み関数とも相性が良いため、効率的なデータ処理が可能です。

result = sum(x for x in range(10) if x % 2 == 0)
print(result)  # 偶数の合計: 20

この例では、ジェネレータ式(x for x in range(10) if x % 2 == 0)を使い、偶数の合計を効率よく計算しています。ジェネレータ式は記述が簡潔なだけでなく、処理速度やメモリ使用量の面でも効率的です。

ジェネレータ式は特に大量のデータを扱う際に便利で、パフォーマンスを向上させるための強力なツールとなります。

Python 3 エンジニア認定基礎試験（9章）の要点まとめ