今回のテーマは、ジェネレータと yield 文 です。やや高度なテーマなのですが、前回のラムダ式と同様に、試験の出題範囲を示したシラバスにあるものなので、しっかりとマスターしておきましょう。

• 
  （7）関数の定義
  
  利用者の定義による関数を用いて構造化されたプログラムを作成する。
  修得項目

  def 文，return 文，ジェネレータ，yield 文，ラムダ式，再帰呼出し，デコレータなど

出典基本情報技術者試験シラバス Ver.7.2 より

ジェネレータとは？

Python では、以下のように、 for 文の in の後にリストやタプルなどのイテラブル（複数の要素を反復して取り出せるオブジェクト）を置くと、要素が 1 つずつ取り出されます。

この記事で示すプログラムは、 Python の対話モードで実行しています。説明の都合で、プログラムの行末にコメントを付けていますが、実際にプログラムを動作させるときには、これらのコメントは不要です。

>>> animals = ['dog', 'cat', 'mouse']	# リストを作成する
>>> for a in animals:			        # for文で要素を1つずつ取り出す
...     print(a)			            # 要素を表示する
...					                    # ［Enter］キーだけを押す
dog					                    # 実行結果が表示される
cat
mouse

>>> numbers = (111, 222, 333)	# タプルを作成する
>>> for n in numbers:			# for文で要素を1つずつ取り出す
...     print(n)			    # 要素を表示する
...					            # ［Enter］キーだけを押す
111					            # 実行結果が表示される
222
333

リストやタプルは、あらかじめ Python に組込まれているものですが、それらと同様の機能を持つオブジェクトを独自に作成することができ、これをジェネレータと呼びます。

ジェネレータ（ generator ）は、「生成装置」という意味です。ジェネレータは、複数の要素を反復して取り出せるオブジェクトです。リストやタプルと同様に、 for 文の in の後にジェネレータを置くことができます。

ジェネレータ関数と yield 文

ジェネレータは、ジェネレータ関数によって作成されます。これは、言葉で説明するより、具体例を示した方が早いでしょう。

以下は、 'dog' 、 'cat' 、 'mouse' という文字列を順番に返す animal_generator というジェネレータ関数の定義です。

通常の関数では、戻り値を return 文で返しますが、ジェネレータ関数では、 yield 文で返します。 yield は、「生産する」という意味です。 3 つ並んだ yield 文は、要素を反復して取り出すときに、上から順に実行されます。

>>> def animal_generator():	# ジェネレータ関数の定義
...     yield 'dog'		    # 1つ目の要素を返す
...     yield 'cat'		    # 2つ目の要素を返す
...     yield 'mouse'	    # 3つ目の要素を返す
...				            # ［Enter］キーだけを押す

戻り値 = ジェネレータ関数() という構文でジェネレータ関数を呼び出すと、戻り値としてジェネレータが得られます。

以下では、

animal = animal_generator()

の部分で、 animal_generator 関数が返したジェネレータを、 animal に格納しています。この animal を for 文の in の後に置くと、要素を 1 つずつ得ることができます。

>>> animal = animal_generator()	# ジェネレータオブジェクトを得る
>>> for a in animal:            # for文で要素を1つずつ取り出す
...     print(a)		        # 要素を表示する
...				                # ［Enter］キーだけを押す
dog				                # 実行結果が表示される
cat
mouse

以下のように、ジェネレータ関数を for 文の in の後に置くこともできます。

>>> for a in animal_generator():	# ジェネレータ関数をfor文のinの後に置く
...     print(a)	                # 要素を表示する
...					                # ［Enter］キーだけを押す
dog					                # 実行結果が表示される
cat
mouse

Python の組み込み関数である list 関数の引数にジェネレータ関数の呼び出しを置くと、ジェネレータが返す要素をリストに変換することもできます。

>>> animals = list(animal_generator())	# ジェネレータの要素をリストに変換する
>>> animals				                # リストの内容を表示する
['dog', 'cat', 'mouse']		            # 実行結果が表示される

繰り返し処理の中で yield 文を使う

プログラム（すぐ後で例を示します）を見ると不思議な感じがするかもしれませんが、ジェネレータ関数に繰り返し処理を記述して、その中で yield 文を使うこともできます。

この場合には、繰り返し処理がまとめて実行されるのではなく、ジェネレータ関数が返したジェネレータから要素が 1 つずつ取り出されるときに、繰り返し処理の中にある yield 文が 1 回ずつ呼び出されます。

以下は、 Python の組み込み関数である range 関数と同様の機能を持つ、 range_generator(start, stop, step) というジェネレータ関数の定義です。

start から stop 未満まで step 間隔の値を返します。 while 文の繰り返し処理の中に yield 文があることに注目してください。この yield 文は、ジェネレータから要素が 1 つずつ取り出されるときに、 1 回ずつ呼び出されます。

>>> def range_generator(start, stop, step):	# ジェネレータ関数の定義
...     n = start
...     while n < stop:
...         yield n				            # ここに注目！
...         n += step
...						                    # ［Enter］キーだけを押す

以下は、 for 文の in の後に、 range_generator(0, 10, 1) を置き、ジェネレータから取り出した要素を表示するプログラムです。 0 から 10 未満まで 1 間隔の値が順番に得られています。

for i in range_generator(0, 10, 1):	# ジェネレータ関数をfor文のinの後に置く
...     print(i)			        # 要素を表示する
...					                # ［Enter］キーだけを押す
0					                # 実行結果が表示される
1
2
3
4
5
6
7
8
9

ジェネレータが役立つ場面（その 1 ）

ジェネレータは、要素が要求される場面でその都度データを産出する（ yield する）ので、メモリを多く消費しないという利点があります。

たとえば、学生時代の数学の教科書に掲載されていた 1 ～ 100 の平方表（ 1 ～ 100 を 2 乗した値の一覧表）を返す関数を作成するとしましょう。以下のように、 1 ～ 100 の平方表のリストを返す関数（ジェネレータ関数ではない通常の関数）として作成すると、リストの大きさ分のメモリを消費します。

>>> def square_func():			    # 平方表のリストを返す関数の定義
...     sq_list = []			    # 空のリストを作成する
...     n = 1
...     while n <= 100:
...         sq_list.append(n ** 2)	# リストに要素を追加する
...         n += 1
...     return sq_list			    # 要素数100個のリストを返す
...					                # ［Enter］キーだけを押す

>>> for data in square_func():	# 要素を1つずつ取り出す
...     print(data)			    # 要素を表示する
...					            # ［Enter］キーだけを押す
1					            # 実行結果が表示される
4
9
16
25
#　中　略
9604
9801
10000

同じ目的の関数を、以下のようにジェネレータ関数として作成すれば、要素が要求される場面でその都度データを算出するので、メモリを多く消費しません。

>>> def square_generator():		# ジェネレータ関数の定義
...     n = 1
...     while n <= 100:
...         yield n ** 2		# 平方の値を算出する
...         n += 1
...					            # ［Enter］キーだけを押す

>>> for data in square_generator():	# 要素を1つずつ取り出す
...     print(data)			        # 要素を表示する
...					                # ［Enter］キーだけを押す
1					                # 実行結果が表示される
4
9
16
25
#　中　略
9604
9801
10000

ジェネレータが役立つ場面（その 2 ）

ジェネレータ関数は、現在の状態を保持できる関数だといえます。したがって、直前に算出したデータの値を、次に算出するデータの演算で使う、ということができます。これは、通常の関数には、できないことです。通常の関数は、呼び出されるたびに、まっさらな状態で処理を行うからです。

以下は、 1 から 100 までの階乗を算出するジェネレータ関数 fact_generator の定義です。直前に算出したデータの値を変数 prev に格納しているので、変数 n の階乗を prev * n という演算で求めることができます。

>>> def fact_generator():		# ジェネレータ関数の定義
...     prev = 1			    # 直前の値の初期値
...     n = 1				    # 現在の値の初期値
...     while n <= 10:
...         fact = prev * n		# nの階乗を演算する
...         yield fact			# nの階乗を算出する
...         prev = fact			# 直前に産出した値を記憶する
...         n += 1
...					            # ［Enter］キーだけを押す

>>> for data in fact_generator():	# 要素を1つずつ取り出す
...     print(data)			        # 要素を表示する
...					                # ［Enter］キーだけを押す
1					                # 実行結果が表示される
2
6
24
120
720
5040
40320
362880
3628800

いかがでしたか。ジェネレータと yield 文の機能を、しっかりとマスターできたでしょう。

なお、リストやタプルからの要素の取り出しは、ジェネレータではなく、同様の機能をクラスで定義したイテレータで実現されています。イテレータの作り方に関するキーワードは、基本情報技術者試験のシラバスに示されていなので、この連載では取り上げませんが、興味がある人は、ぜひ調べてみてください。

それでは、またお会いしましょう！

The post 基本情報ではじめる Python (7) generator と yield 文 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

今回のテーマは、ラムダ式です。かなり高度なテーマですが、試験の出題範囲を示したシラバスにあるものなので、しっかりとマスターしておきましょう。

• 
  （7）関数の定義
  
  利用者の定義による関数を用いて構造化されたプログラムを作成する。
  修得項目

  def 文，return 文，ジェネレータ，yield 文，ラムダ式，再帰呼出し，デコレータなど

出典基本情報技術者試験シラバス Ver.7.1 より

ラムダ式とは？

ラムダ式は、ラムダ計算をベースにしています。ラムダ計算は、コンピュータの動作を関数で抽象化するものであり、関数を λ（ラムダ） という文字を使って表すことから、その名前が付けられました。ラムダ計算には、様々なトピックがありますが、 Python のラムダ式は、それらの中の一部分だけを使っています。

あらかじめ結論を言ってしまうと、 Python のラムダ式は、無名関数です。

無名関数は、名前のない関数です。 Python では、関数を定義するときに、一般的に def 文を使いますが、もう 1 つ別の方法としてラムダ式があるのです。ラムダ式によって無名関数が作られるのです。

例を示しましょう。
以下は、
底辺 × 高さ ÷ 2
という計算で、三角形の面積を求める関数を def 文で定義したものです。

def triangle_area(bottom, height):
    return bottom * height / 2

この関数には、
triangle_area という名前があり、
bottom （底辺）と height （高さ）という引数があり、
bottom * height / 2 という計算式があり、
return 文で 計算結果を戻り値として返します。

同じ機能の関数をラムダ式で作ると、以下のようになります。ラムダ式は、

lambda 引数 : 計算式

という構文で記述します。

lambda bottom, height : bottom * height / 2

先頭の lambda というキーワードが、ラムダ式をあることを示しています。

引数が複数ある場合は、カンマで区切ります。引数が計算式で使われ、その計算結果が戻り値として返されます（ return 文は、使いません）。

ラムダ式には、関数の名前に相当するものがありません。だから、無名関数なのです。

ラムダ式の呼び出し方

名前がある triangle_area 関数は、

triangle_area(10, 20)

という構文で呼び出します。

以下は、 Python の対話モードで、 triangle_area 関数を定義して呼び出した例です。説明の都合で、プログラムの行末にコメントを付けていますが、実際にプログラムを動作させるときには、これらのコメントは不要です。

>>> def triangle_area(bottom, height):  # def文で関数を定義する
...     return bottom * height / 2
...
>>> triangle_area(10, 20)  # 関数を呼び出す
100.0

それでは、名前がないラムダ式は、どのように呼び出せばよいのでしょう？ いくつかの方法があります。

1 つは、ラムダ式全体をカッコで囲んで、その後にカッコで囲んで引数を指定するという方法です。以下に例を示します。

>>> (lambda bottom, height : bottom * height / 2)(10, 20)  # ラムダ式を呼び出す
100.0

もう 1 つは、ラムダ式を変数に代入して、その変数を関数の名前として、通常の関数と同様に呼び出すという方法です。

以下に例を示します。ここでは、ラムダ式に a という名前を付けています。

>>> a = lambda bottom, height : bottom * height / 2  # ラムダ式を変数aに代入する
>>> a(10, 20)  # 変数aを関数名として通常の関数と同様に呼び出す
100.0

ラムダ式の実用的な使い方と高階関数

先ほど、ラムダ式を呼び出す方法を 2 つ示しましたが、どちらもラムダ式の実用的な使い方ではありません。

Python におけるラムダ式の実用的な使い方は、高階関数（ higher order function ）の引数にすることです。高階関数とは、引数に関数を指定する関数のことです。

Python には、あらかじめ様々な高階関数が用意されています。

たとえば、 Python の組み込み関数（ import 文でインポートせずに、すぐに使える関数）の filter 関数は、

filter(関数, イテラブル)

という構文の高階関数です。

filter 関数は、 2 つの目の引数で指定されたイテラブル（リストやタプルなど）から要素を順番に取り出し、それを 1 つ目の引数で指定された関数に渡して True が返されたものだけを抽出します。

例として、 filter 関数を使って、

してみましょう。

filter 関数の 1 つ目の引数に指定する関数は、引数の値が 3 以上ならTrueを返す、という機能にします。この関数を、 def 文を使って three_or_greater という名前で定義すると、以下のようになります。

def three_or_greater(data):
    return data >= 3

filter 関数を、 1 つ目の引数に three_or_greater 関数を指定し、 2 つ目の引数に、 [1, 2, 3, 4, 5] というリストを指定して実行すると、以下のように 3 以上の[3, 4, 5] が抽出されます。

>>> def three_or_greater(data):  # def文で関数を定義する
...     return data >= 3
...
>>> list(filter(three_or_greater, [1, 2, 3, 4, 5]))  # 引数に関数を指定する
[3, 4, 5]

filter 関数は、戻り値として filter オブジェクトを返すので、ここでは、それを list 関数でリストに変換しています。リストに変換しないと、要素の値を画面に表示できないからです。

さて、ここからがポイントです。

filter 関数の 1 つ目の引数に指定しているのは、引数の値が 3 以上なら True を返す、という単純な機能の関数です。 filter 関数を使うために、わざわざ three_or_greater 関数という定義するのは面倒でしょう。

もしも、

filter(>= 3, [1, 2, 3, 4, 5])

のように、 filte r関数の引数に >= 3 という条件が指定できたら便利です。

ただし、 Python の構文では、関数の引数に条件だけを指定することができません。どうしましょう？ そうです！ こういう場面で、ラムダ式が役立つのです。

filter 関数の引数に、 >= 3 という条件は指定できませんが、

lambda data : data >= 3

というラムダ式なら指定できます。これが、ラムダ式の実用的な使い方です。以下に、例を示します。

>>> list(filter(lambda data : data >= 3, [1, 2, 3, 4, 5]))  # 引数にラムダ式を指定する
[3, 4, 5]

いかがでしたか。 Python のラムダ式の意味と使い方を、しっかりとマスターできたでしょう。

この連載では、今後も、基本情報技術者試験を Python で受けるための知識を取り上げて行きます。

それでは、またお会いしましょう！

The post 基本情報ではじめる Python (6) ラムダ式 って何？ どんな用途で使うの？ first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

今回のテーマは、 Python によるオブジェクト指向の基礎です。オブジェクト指向は、情報処理推進機構が公開している Python のサンプル問題でも取り上げられている重要なテーマなので、しっかりとマスターしてください。

オブジェクト指向とは？

オブジェクト指向は、プログラムの部品化に関する指向です。 Python では、プログラムの部品化に 2 つの指向が使えます。プロセス指向とオブジェクト指向です。

プロセス指向では、関数を部品にします。
オブジェクト指向では、クラスを部品にします。

どちらの指向を使うのかは、プログラマの好みの問題ですが、一般的に言うと、小規模なプログラムには、プロセス指向が適していて、大規模なプログラムには、オブジェクト指向が適しています。

関数は、単独の機能を持った小さな部品です。関数は、外部から引数として渡されたデータを使って処理を行います。
クラスは、複数の機能を持った大きな部品です。クラスは、内部に保持しているデータを使って処理を行います。

たとえば、半径の値から、円周の長さと円の面積を求める部品を作るとしましょう。

プロセス指向

外部から引数として渡された半径の値から円周の長さを求める circle_perimeter 関数と、面積を求める circle_area 関数を、別々に作ることになります

オブジェクト指向

内部に半径の値を保持し、その値を使って円周の長さを求める perimeter メソッド ^※ と、円の面積を求める area メソッドを持つ、 Circle クラスを作ることになります

^※ メソッド（ method = 「やり方」）とは、クラスが持つ処理のこと

以下は、オブジェクト指向の図示技法としてよく使われる UML （ Unified Modeling Language ）のクラス図を使って、 Circle クラスを示したものです。

クラス図では、四角形を 3 段階に区切り、上段にクラス名（ここでは Circle ）、中段にクラスが内部に保持するデータ（ここでは radius ）、下段にクラスが持つメソッド（ここでは perimeter() と area() ）を記述します。メソッドは、メソッドあることがわかりやすいように、メソッド名の後に () を付けます。オブジェクト指向では、個々のメソッドではなく、クラス全体が 1 つの部品です。

クラスを定義する方法

先ほど UML のクラス図で示した Circle クラスを、 Python のプログラムで表してみましょう。

以下は、 Circle クラスを定義です。このプログラムを Circle.py というファイル名で作成しましょう。

# Circleクラスの定義
class Circle:
    # 初期化メソッドの定義
    def __init__(self, radius):
        self.radius = radius

    # 円周の長さを求めるメソッド
    def perimeter(self):
        return self.radius * 2 * 3.14

    # 円の面積を求めるメソッド
    def area(self):
        return self.radius * self.radius * 3.14

クラスは、

class クラス名:

という構文で定義します。

クラスのブロックの中に

def メソッド名(self, その他の引数, ・・・)

という構文で、メソッドを定義します。

メソッドを定義する構文は、関数を定義する構文と同様ですが、第 1 引数を self にする約束になっています。この self は「自分」という意味であり、そのクラスのインスタンス（インスタンスについてはあとで説明します）の識別情報が自動的に格納されます。それによって、メソッドの処理の中では、

self.変数名

という構文で、クラスのインスタンスが持つデータを読み書きできます。このデータをインスタンス変数と呼びます。

perimeter メソッドは、

self.radius * 2 * 3.14

という計算で得られる円周の長さを返します。

area メソッドは、

self.radius * self.radius * 3.14

という計算で得られる円の面積を返します。

self.radius は、「自分が保持しているインスタンス変数 radius 」という意味です。それでは、インスタンス変数 radius の実体は、どこにあるのでしょう？

それは、 __init__ メソッドの処理内容を見ればわかります。

特殊メソッド __init__ の役割

先ほど UML のクラス図で示した Circle クラスには、ありませんでしたが、 Python でクラスを定義するときには、 __init__ メソッドを記述します。 init は、 initialize （初期化）という意味です。

メソッド名の前後に、アンダースコア（ _ ）が 2 つずつあるのは、特定の場面で自動的に呼び出される特殊メソッドであることを意味しています。 __init__ メソッドは、クラスのインスタンスが生成された直後に、自動的に呼び出される特殊メソッドです。

__init__ メソッドの処理として、何を行うのかは、プログラムの目的次第ですが、多くの場合に、インスタンス変数を作成します。

self.radius = radius

の部分で、インスタンス変数 radius を作成し、それに radius という値を設定しています。

左辺も右辺も radius なので、混乱するかもしれませんが、 self が付いている self.radius がインスタンス変数であり、 self が付いていない radius は外部から引数として __init__ メソッドに渡された半径の値です。 Python は、変数を宣言せずに使う言語なので、この self.radius = radius によって、インスタンス変数 radius が作成されます。

インスタンスを生成して使う方法

クラスは、オブジェクトを定義したものです。クラスは、その機能が必要になった時点で、メモリにロードして使います。メモリにロードされたクラスが オブジェクト であり、クラスの インスタンス（ instance = 「実例」）とも呼ばれます。

クラスを定義したプログラムは、ハードディスク上にあります。このプログラムをメモリにロードしたものが、クラスのインスタンスです。 1 つのクラスから、複数のインスタンスを生成することもできます。生成とは、メモリにロードすることです。

たとえば、以下の例は、 Circle クラスのインスタンスを 2 つ生成して、それぞれに c1 および c2 という名前を付けたときの、ハードディスクとメモリのイメージです。

Python のプログラムで、 Circle クラスのインスタンスを生成して使ってみましょう。

以下は、 Circle クラスのインスタンスを 2 つ生成して、それぞれの機能を使うプログラムを、 Python の対話モードで実行したところです。説明の都合で、行末にコメントを付けていますが、実際に実行するときには、コメントは不要です。

>>> from Circle import Circle	# Circleをインポートする
>>> c1 = Circle(10)		# 半径 10 のインスタンス c1 を生成する
>>> c2 = Circle(100)	# 半径 100 のインスタンス c2 を生成する
>>> c1.perimeter()		# c1の円周を求める
62.800000000000004
>>> c2.perimeter()		# c2の円周を求める
628.0
>>> c1.area()			# c1の面積を求める
314.0
>>> c2.area()			# c2の面積を求める
31400.0

クラスのインスタンスは、 インスタンス名 = クラス名(引数) という構文で生成します。

c1 = Circle(10)

によって Circle クラスのインスタンス c1 が生成され、引数 radius に 10 という値が渡されて __init__ メソッドが自動的に呼び出されます。

クラスの定義では、メソッドの第 1 引数に self がありますが、メソッドを呼び出すときには、 self を指定しません。 self は、自動的に付加されるようになっているからです。

同様に、

c2 = Circle(100)

によって Circle クラスのインスタンス c2 が生成され、引数 radius に 100 という値が渡されて __init__ メソッドが自動的に呼び出されます。

それぞれの半径の値を内部に保持したインスタンス c1 と c2 が生成されました。これ以降では、 インスタンス名.メソッド名() という構文で、メソッドを呼び出して使います。

c1.perimeter() と c1.area() で、 c1 の円周と面積が求められます。
c2.perimeter() と c2.area() で、 c2 の円周と面積が求められます。

perimeter メソッドと area メソッドを呼び出すときに、引数に半径の値を指定していないことに注目してください。これは、どちらのメソッドも、内部に保持している半径の値を使って処理を行っているからです。

いかがでしたか。 Python によるオブジェクト指向の基礎を、しっかりとマスターできたでしょう。

この連載では、今後も、基本情報技術者試験を Python で受けるための知識を取り上げて行きます。

それでは、またお会いしましょう！

The post 基本情報ではじめる Python (5) オブジェクト指向 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

今回のテーマは、 分岐と繰り返しの構文 です。これらは、多くの場合に、試験問題のプログラム（他人が作ったプログラム）を読み取るときの重要なポイントになるので、しっかりとマスターしてください。

分岐と繰り返しの基本構文

プログラムの流れには、

• 「順次」
• 「分岐」
• 「繰り返し」

の 3 つがあります。

順次を表現するのに、特別な構文は必要ありません。複数行の処理を記述すれば、上から下に流れる順次になります。

それに対して、分岐と繰り返しを表現するには、それらを表すための構文を使います。分岐は、 if ～ else 文であり、繰り返しは、 while 文および for 文です。

図 1 ～図 3 に、それぞれの基本構文を示します。「基本」と断っているのは、これらの構文には、いくつかのバリエーションがあるからです。図 3 の for 文の基本構文の中にあるイテラブルとは、要素を取り出せるオブジェクトのことで、リスト、タプル、文字列、辞書、集合、 range 関数などがあります。

if 条件:
    # 条件が True のときに実行する処理
else:
    # 条件が False のときに実行する処理

while 条件:
    # 条件が True である限り繰り返される処理

for 変数 in イテラブル
    # イテラブルから取り出した要素を使った処理

どの構文でも、ブロックを使っています。ブロックとは、処理のまとまりを示すものです。

Python では、インデント（プログラムの先頭にスペースを入れて字下げすること）でブロックを表します。ブロックには、複数の処理を記述することもできます。たとえば、図 4 は、処理 1, 処理 2, 処理 3 をブロックとした while 文の例です。条件が True である限り、このブロックの中にある 3 つの処理が繰り返されます。

while 条件：
    # 処理1
    # 処理2
    # 処理3

if ～ else 文による分岐

それでは、バリエーションも含めて、それぞれの構文を使ったサンプルプログラムを、お見せしましょう。ここでは、 Python の実行モードでプログラムを実行します。たとえば、 sample1.py というファイル名のプログラムは、端末（ Windows ではコマンドプロンプト）で、

python sample1.py

と入力して「 Enter 」キーを押すことで実行します。

リスト 1 は、 if ～ else 文の基本構文のサンプルプログラムです。

キー入力した年齢が 20 未満なら「未成年です。」、そうでないなら「成人です。」と表示します。プログラミング言語で使われるキーワードの意味は、英語の意味と同じです。 if は「もしも」という意味で、 else は「そうではないなら」という意味です。

英語を日本語に訳すように、プログラムを読んでみましょう。そうすれば、すんなりと意味を読み取れるはずです。

age = int(input("年齢->"))
if age < 20:
    print("未成年です。")
else:
    print("成人です。")

リスト 1 の実行結果の例を図 5 に示します。

C:¥test>python sample1.py
年齢->18
未成年です。
C:¥test>python sample1.py
年齢->25
成人です。

if ～ else 文のバリエーション（ if ブロックだけ）

リスト 2 は、 if ～ else 文のバリエーションです。

if ブロックだけがあり、 else ブロックがありません。このプログラムは、キー入力した年齢が 20 未満なら、「未成年です。」と表示します。そうではないなら、何も表示しません。

age = int(input("年齢->"))
if age < 20:
    print("未成年です。")

リスト 2 の実行結果の例を図 6 に示します。

C:¥test>python sample2.py
年齢->18
未成年です。
C:¥test>python sample2.py
年齢->25

if ～ else 文のバリエーション（ elif ブロックがある）

リスト 3 も、 if ～ else 文のバリエーションです。

if ブロックと else ブロックの間に、 elif ブロックがあります。 elif は、else if の略で「そうではなくて、もしも」という意味です。 if ブロックの条件が True でないなら、 elif ブロックの条件がチェックされます。

このプログラムは、キー入力した年齢が 20 未満なら「未成年です。」、そうではなくて 65 未満なら「成人です。」、そうではないなら「高齢者です。」と表示します。

age = int(input("年齢->"))
if age < 20:
    print("未成年です。")
elif age < 65:
    print("成人です。")
else:
    print("高齢者です。")

リスト 3 の実行結果の例を図 7 に示します。

C:¥test>python sample3.py
年齢->18
未成年です。
C:¥test>python sample3.py
年齢->25
成人です。
C:¥test>python sample3.py
年齢->72
高齢者です。

while 文による繰り返し

リスト 4 は、 while 文の基本構文のサンプルプログラムです。

while は、「～である限り」という意味です。所持金を意味する money の初期値を 10000 として、 money > 0 という条件で、買い物した金額のキー入力と money の更新を繰り返します。

このプログラムの内容は、「所持金がある限り、買い物を繰り返す」というものです。

money = 10000
while money > 0:
    price = int(input("買い物した金額->"))
    money -= price
print("買い物は終了です。")

リスト 4 の実行結果の例を図 8 に示します。

C:¥test>python sample4.py
買い物した金額->5000
買い物した金額->3000
買い物した金額->2000
買い物は終了です。

for 文による繰り返し

Python のプログラムでは、イテラブルから要素を繰り返し取り出す、という場面がよくあります。この場合には、 while 文ではなく、 for 文を使います。

リスト 5 は、 for 文の基本構文のサンプルプログラムです。

a = [11, 22, 33, 44, 55]

というリスト（リストは、イテラブルの一種です）から要素を繰り返し取り出して、それぞれを画面に表示します。

a = [11, 22, 33, 44, 55]
for x in a:
    print(x)

リスト 5 の実行結果の例を図 9 に示します。

C:¥test>python sample5.py
11
22
33
44
55

range 関数を使った for 文

擬似言語には、繰り返し回数をカウントする変数を使った

■ 変数：初期値, 条件, 増分

という構文があります。たとえば、

■ i：0, i < 10, 1 

なら、変数 i の値を 0 から 10 未満まで 1 つずつ増やしながら繰り返しが行われます。

これと同様のことを Python で記述すると、リスト 6 のようになります。

range(0, 10, 1)

は、 0 から 10 未満まで 1 つずつ増える値を返します。ここでは、その値を変数 i に代入し、画面に表示しています。

for i in range(0, 10, 1):
    print(i)

リスト 6 の実行結果の例を図 10 に示します。

C:¥test>python sample6.py
0
1
2
3
4
5
6
7
8
9

break 文と continue 文

繰り返しを行う while 文または for 文のブロックの中で、 break 文を実行すると、繰り返しが中断され、 continue 文を実行すると、それ以降の処理がスキップされます（繰り返しは継続される）。 break は、「中断する」という意味で、 continue は、「継続する」という意味です。

リスト 7 は、 for 文のブロックの中で break 文と continue 文を使ったサンプルプログラムです。 range(0, 10, 1) で得た 0 ～ 10 未満の値を変数 i に代入し、画面に表示しています。

その際に、
i の値が 3 のときは、 continue 文が実行されるので、それ以降にある処理がスキップされます（ 3 は表示されません）。
i の値が 7 のときは、 break 文が実行され、その時点で繰り返しが中断します（ 7 以降の値は表示されません）。

for i in range(0, 10, 1):
    if i == 3:
        continue
    if i == 7:
        break
    print(i)

リスト 7 の実行結果の例を図 11 に示します。

C:¥test>python sample7.py
0
1
2
4
5
6

while 文と for 文のバリエーション（ else ブロックがある）

繰り返しを行う while 文と for 文のバリエーションとして、どちらにも else ブロックを追加できます。この else ブロックの処理は、 break 文で繰り返しが中断されなかったときに実行されます。

else は、「そうでなければ」という意味なので、この else は、「繰り返しが中断されなかったら」と覚えるとよいでしょう。

リスト 8 は、 for 文に else ブロックを追加したサンプルプログラムです。

繰り返し表示される「中断しますか？」に対して、「 y 」を入力すると繰り返しが中断されるので、 else ブロックの処理が実行されません。最後まで「 y 」を入力しなければ、繰り返しが中断されないので、 else ブロックの処理（「中断されませんでした。」と表示する処理）が実行されます。

for i in range(0, 10, 1):
    print(i)
    s = input("中断しますか？")
    if s == "y":
        break
else:
    print("中断されませんでした。")

リスト 8 の実行結果の例を図 12 に示します。

C:¥test>python sample8.py
0
中断しますか？n
1
中断しますか？n
2
中断しますか？n
3
中断しますか？y
C:¥test>python sample8.py
0
中断しますか？n
1
中断しますか？n
2
中断しますか？n
3
中断しますか？n
4
中断しますか？n
5
中断しますか？n
6
中断しますか？n
7
中断しますか？n
8
中断しますか？n
9
中断しますか？n
中断されませんでした。

いかがでしたか。 Python の分岐と繰り返しの構文を、しっかりとマスターできたでしょう。

この連載では、今後も、基本情報技術者試験を Python で受けるための知識を取り上げて行きます。

それでは、またお会いしましょう！

The post 基本情報ではじめる Python (4) if ～ else と while / for first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

今回のテーマは、関数の引数の形式です。擬似言語の関数の引数には、 1 つの形式しかありませんが、 Python には、様々な形式があります。それぞれの特徴を、しっかりとマスターしてください。

擬似言語と同様の「位置引数」

以下は、引数の位置と設定された値を表示する my_func 関数の定義です。

1 つ目の引数が arg1 で、 2 つ目の引数が arg2 です。この記事では、関数の定義と、それを呼び出すプログラムを、 Python の対話モードで示します。

プログラムの説明としてコメントを付けている部分がありますが、実際にプログラムを動かすときには、コメントを付ける必要はありません。これ以降で示すプログラムでも、関数の名前は my_func であり、処理内容は引数の値を表示するだけです。どれも、様々な形式の引数を知るためのサンプルプログラムです。

>>> def my_func(arg1, arg2):
...     print(f'1つ目の引数の値 = {arg1}')
...     print(f'2つ目の引数の値 = {arg2}')
...

以下は、 my_func 関数を呼び出すプログラムです。

>>> my_func(123, 456)
1つ目の引数の値 = 123
2つ目の引数の値 = 456

1 つ目の引数の値に 123 を設定しているので、それが 1 つ目の引数の arg1 に渡されます。
2 つ目の引数の値に 456 を設定しているので、それが 2 つ目の引数の arg2 に渡されます。

このように、関数の定義における引数の位置と、関数を呼び出すときの引数の位置を対応させる形式を「位置引数」と呼びます。

擬似言語の関数の引数の形式には、位置引数しかありません。

Python には、位置引数の他にも、

• キーワード引数
• デフォルト引数
• 可変長引数
• 可変長キーワード引数

という形式があります。これ以降では、それぞれを順番に説明します。

位置に関係なく引数を設定できる「キーワード引数」

Python では、関数を呼び出すときに

引数名 = 値

と記述することができ、この形式を「キーワード引数」と呼びます。キーワード引数を使うと、関数の定義における引数の位置とは無関係に、それぞれの引数に値を設定できます。

以下は、引数名と設定された値を表示する関数の定義です。

>>> def my_func(arg1, arg2):
...     print(f'arg1の値 = {arg1}')
...     print(f'arg2の値 = {arg2}')
...

以下は、 my_func 関数を呼び出すプログラムです。

>>> my_func(arg1=123, arg2=456)  # arg1、arg2の順に引数を設定する
arg1の値 = 123
arg2の値 = 456
>>> my_func(arg2=456, arg1=123)  # arg2、arg1の順に引数を設定する
arg1の値 = 123
arg2の値 = 456

my_func(arg1=123, arg2=456)と呼び出しても、 my_func(arg2=456, arg1=123)と呼び出しても、 arg1 には 123 が渡され、 arg2 には 456 が渡されます。引数が、位置ではなく引数名で識別されるからです。

引数の設定を省略できる「デフォルト引数」

関数の定義で、

引数名=デフォルト値

と記述すると、引数が設定されなかったときにデフォルト値が使われます。この形式を「デフォルト引数」と呼びます。

以下は、 arg1 のデフォルト値を 123 、 arg2 のデフォルト値を 456 とした my_func 関数の定義です。

>>> def my_func(arg1=123, arg2=456):
...     print(f'arg1の値 = {arg1}')
...     print(f'arg2の値 = {arg2}')
...

以下は、 my_func 関数を呼び出すプログラムです。

>>> my_func()  # 引数を設定せずに呼び出す
arg1の値 = 123
arg2の値 = 456
>>> my_func(arg1=999)  # arg1だけを設定して呼び出す
arg1の値 = 999
arg2の値 = 456
>>> my_func(arg2=999)  # arg2だけを設定して呼び出す
arg1の値 = 123
arg2の値 = 999

引数を設定せずに my_func() と呼び出すと、 arg1 がデフォルト値の 123 になり、 arg2 がデフォルト値の 456 になります。
arg1 だけを設定して my_func(arg1=999)と呼び出すと、 arg1 は 999 になり、 arg2 がデフォルト値の 456 になります。
arg2 だけを設定して my_func(arg2=999)と呼び出すと、 arg1 はデフォルト値の 123 になり、 arg2 が 999 になります。

任意の数の引数を渡せる「可変長引数」

関数の定義で、引数に *（アスタリスク 1 個）を付けると、任意の数の引数を渡せる「可変長引数」になります。

可変長引数は、関数を呼び出す側で設定された複数の引数が、 1 つのタプルとして関数に渡されることで実現されます。

以下は、可変長引数に設定された値を表示する my_func 関数の定義です。 *args の部分が、可変長引数です。この args にタプルが渡されるので、 for 文で要素を 1 つずつ取り出して表示しています。

>>> def my_func(*args):
...     for n in args:
...         print(n)

以下は、 my_func 関数を呼び出すプログラムです。

1 個の引数で my_func(123) と呼び出すことも、
2 個の引数で my_func(123, 456) と呼び出すことも、
3 個の引数で my_func(123, 456, 789) と呼び出すこともできます。

>>> my_func(123)  # 1個の引数で呼び出す
123
>>> my_func(123, 456)  # 2個の引数で呼び出す
123
456
>>> my_func(123, 456, 789)  # 3個の引数で呼び出す
123
456
789

任意の数のキーワード引数を渡せる「可変長キーワード引数」

関数の定義で、引数に **（アスタリスク 2 個）を付けると、任意の数のキーワード引数を渡せる「可変長キーワード引数」になります。

可変長引数は、関数を呼び出す側で設定された複数のキーワード引数が、 1 つの辞書として関数に渡されることで実現されます。キーワード引数の引数名が辞書のキーになり、引数の値が辞書のバリューになります。

以下は、可変長キーワード引数に設定された引数名と値を表示する my_func 関数の定義です。**kwargsの部分が、可変長キーワード引数です。この kwargs に辞書が渡されるので、 for 文で要素を 1 つずつ取り出してキー（引数名）とバリュー（値）表示しています。

>>> def my_func(**kwargs):
...     for k in kwargs.keys():
...         print(f'{k}の値 = {kwargs[k]}')

以下は、 my_func 関数を呼び出すプログラムです。

1 個のキーワード引数で my_func(arg1=123) と呼び出すことも、
2 個のキーワード引数で my_func(arg1=123, arg2=456) と呼び出すことも、
3 個のキーワード引数で my_func(arg1=123, arg2=456, arg3=789) と呼び出すこともできます。

>>> my_func(arg1=123)  # 1個のキーワード引数で呼び出す
arg1の値 = 123
>>> my_func(arg1=123, arg2=456)  # 2個のキーワード引数で呼び出す
arg1の値 = 123
arg2の値 = 456
>>> my_func(arg1=123, arg2=456, arg3=789)  # 3個のキーワード引数で呼び出す
arg1の値 = 123
arg2の値 = 456
arg3の値 = 789

様々な形式の引数を混在させることもできる

これまでに説明した様々な形式の引数は、 1 つの関数で、混在させて使うこともできます。

たとえば、 Python の組み込み関数である print 関数の引数は、以下の形式になっています。

print(*object, sep=' ', end='\n', file=sys.stdout, flush=False)

先頭にある object が可変長引数で、その他の sep, end, file, flush は、デフォルト引数です。可変長引数とデフォルト引数が混在しています。

• 引数 object には、画面に表示するオブジェクトを任意の数だけ設定します
• 引数 sep には、画面に表示するオブジェクトを区切る文字列を設定します。デフォルト値は、半角スペース 1 個です
• 引数 end には、すべてのオブジェクトを表示した後の末尾で表示する文字列を設定します。デフォルト値は、改行文字（ \n ）です
• 引数 file には、出力先のファイルを設定します。デフォルト値は、標準出力（ Windows ならコマンドプロンプトの画面）を意味する sys.stdout です
• 引数 flush には、出力をバッファリング（すぐに出力せずに貯めておくこと）するかどうかを True または False で設定します。デフォルト値は、 False です

以下は、 print 関数を呼び出すプログラムです。

>>> print(123, 456, 789)  # 引数objectだけを設定する
123 456 789
>>> print(123, 456, 789, sep=',', end='')  # 引数sepとendも設定する
123,456,789>>>

引数 object だけを設定すると、オブジェクト（ここでは、 3 つの整数）が半角スペース 1 個で区切られて、画面に直ちに表示され、最後に改行されます。
引数 sep にカンマ（ ',' ）を設定し、引数 end に空文字列（ '' ）を設定すると、オブジェクトがカンマで区切られて表示され、最後に改行されません。

いかがでしたか。 Python の関数の引数に、様々な形式があることがわかったでしょう。

この連載では、今後も、基本情報技術者試験を Python で受けるための知識を取り上げて行きます。

それでは、またお会いしましょう！

The post 基本情報ではじめる Python (3) 引数 ～ Python の関数の引数には様々な形式がある first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.

今回のテーマは、要素を持つデータ型（配列）であるリスト、タプル、文字列、集合、辞書の特徴です。

とても幅広いテーマなので、まずは、この記事で、概要をつかんでください。

配列の操作が苦手な人に朗報です！

基本情報技術者試験の午後試験の「データ構造およびアルゴリズム」には、配列の操作に関する問題がよく出ます。

たとえば、以下は、実際の試験問題に示されたプログラムの一部を抜粋して改変したものです。このプログラムは、要素数 num 個の配列 data を二分割して、前半部の要素を配列 data1 に格納し、後半部の要素を配列 data2 に格納します。

/* 配列を二分割する擬似言語のプログラム */
・num1 ← num ÷ 2
・num2 ← num - num1
■ i：0, i < num1, 1
｜・data1[i] ← data[i]
■
■ i：0, i < num2, 1
｜・data2[i] ← data[num1 ＋ i]
■

これを見て「そうそう、こういうのが苦手なんです！」という人が多いでしょう。

そんな人に朗報です。 Python の問題には、このように配列をコツコツと操作するプログラムは、ほとんど出ないはずです。なぜなら、 Python の配列は、単なるデータの並びではなく、複数のデータと、データに対する様々な機能をまとめたオブジェクトだからです。

Python の配列を使うと、先ほどの擬似言語と同様の処理を、以下のように短く簡単に記述できます。

# 配列を二分割するPythonのプログラム
mid = num // 2		# 真ん中の要素の添字を得る
data1 = data[:mid]	# 真ん中より前の要素をdata1に格納する
data2 = data[mid:]	# 真ん中以降の要素をdata2に格納する

擬似言語のプログラムでは、変数 i をループカウンタとして繰り返し処理を行っていましたが、 Python のプログラムには、それがありません。 Python の配列には、指定した位置で要素を切り分ける「スライス」という機能があるからです（スライスの構文に関しては、後で説明します）。

要素を持つデータ型とは？

先ほど「 Python の配列」と言いましたが、実際には、 Python には、擬似言語の配列と同じものはありません。

擬似言語の配列に相当するオブジェクトとして、

• リスト
• タプル
• 文字列
• 辞書
• 集合

があり、これらを
「要素を持つデータ型（これは基本情報技術者試験のシラバスに示された呼び名です）」
や
「イテラブル（ iterable = 繰り返し可能）」
と総称します。

シーケンスとコレクション

要素を持つデータ型は、要素に順序がある「シーケンス」と、順序がない「コレクション」に分類されます。順序があるとは、個々の要素を添字で指定できる、ということです。

リスト、タプル、文字列は、シーケンスです。
辞書と集合は、コレクションです。

後で具体例を示しますが、辞書は、添字ではなく、キーで要素を指定します。キーとなる言葉で辞書を引くようなイメージです。
集合は、個々の要素ではなく、データの集まり、つまり集合を取り扱います。

このように、辞書と集合は、「個々の要素を添字で指定できない」というよりは、「個々の要素を添字で指定するような用途では使わない」のです。

ミュータブルとイミュータブル

要素を持つデータ型は、要素の値を変更できる「ミュータブル」と、変更できない「イミュータブル」にも分類できます。

リスト、辞書、集合は、ミュータブルです。
文字列とタプルは、イミュータブルです。

ミュータブルとイミュータブルの区別は、あまり気にする必要はありません。なぜなら、試験問題には、イミュータブルな要素の値を変更するような、構文的に間違ったプログラムが出ることはないからです。

Python のオブジェクトは、クラスとして定義されています。

リスト、タプル、文字列、辞書、集合は、それぞれ list クラス、 tuple クラス、 str クラス、 dict クラス、 set クラスとして定義されています。今回は、取り上げませんが、それぞれのクラスには、様々な機能が用意されています。

リスト、タプル、文字列の表記方法

リストは、要素をカンマで区切って並べて、全体を [ と ] で囲みます。
タプルは、要素をカンマで区切って並べて、全体を ( と ) で囲みます。
文字列は、文字の並びの全体を ' と ' または " と " で囲みます。

以下に例を示します。

>>> a = [1, 2, 3, 4, 5]		# リストa
>>> b = (6, 7, 8, 9, 10)	# タプルb
>>> c = "hello"			# 文字列c

左辺の変数に、右辺のリスト、タプル、文字列を代入していますが、これは、代入というよりは、右辺のリスト、タプル、文字列に名前を付けている、と考えてください。

ここでは、 Python の対話モードでプログラムを実行しています。プログラムの後にあるコメントは、説明の都合で付けたものです（これは、これ以降で示すプログラムでも同様です）。

リスト、タプル、文字列に共通した機能 1（添字による要素の指定）

シーケンス（順序があり、個々の要素を添字で指定できる）であるリスト、タプル、文字列には、共通した機能がいくつかあります。主な機能を紹介しましょう。

シーケンスの個々の要素は、

 名前[添字] 

という構文で指定できます。

添字は、先頭から順に 0, 1, 2 ・・・です。マイナスの添字を使うこともでき、この場合には、末尾から順に　-1, -2, -3 です。タプル全体は ( と ) で囲み、文字列全体は ‘ と ‘ または ” と ” で囲みますが、どのシーケンスでも、個々の要素は、添字を [ と ] で囲みます。

以下に例を示します。

>>> a[0]	# リストaの先頭の要素を読み出す
1		# 要素の値は1である
>>> b[0]	# タプルbの先頭の要素を読み出す
6		# 要素の値は6である
>>> c[0]	# 文字列cの先頭の要素を読み出す
'h'		# 先頭の要素は 'h' である
>>> a[-1]	# リストaの末尾の要素を読み出す
5		# 要素の値は5である
>>> b[-1]	# タプルbの末尾の要素を読み出す
10		# 末尾の要素は10である
>>> c[-1]	# 文字列cの末尾の要素を読み出す
'o'		# 末尾の要素は 'o' である

リスト、タプル、文字列に共通した機能 2（スライス）

シーケンスの要素は、

 名前[開始位置:終了位置:ステップ] 

という構文で、部分的に切り出せます。この機能を「スライス（ slice = 断片）」と呼びます。

スライスによって、開始位置～終了位置未満の範囲の要素が、ステップごとに切り出されます。

開始位置を省略すると、先頭の要素から切り出されます。終了位置を省略すると末尾の要素まで切り出されます。ステップを省略すると、 1 個ごとに切り出されます。

以下に例を示します。

>>> a[2:4:1]	# リストaのa[2]からa[4]未満の要素を1個ごとに切り出す
[3, 4]		# a[2]からa[3]の要素が切り出される
>>> b[2:4:1]	# タプルbのb[2]からb[4]未満の要素を1個ごとに切り出す
(8, 9)		# b[2]からb[3]の要素が切り出される
>>> c[2:4:1]	# 文字列cのc[2]からc[4]未満の要素を1個ごとに切り出す
'll'

スライスは、難しく感じるかもしれませんが、個々の要素を指定する 名前[添字] という構文の拡張バージョンだと思えばわかりやすいでしょう。

リスト、タプル、文字列に共通した機能 3（ + 演算子と * 演算子）

 シーケンス1 + シーケンス2 

という構文で、 2 つのシーケンスを連結できます。

 シーケンス * 数値 

という構文で、シーケンスを数値の回数だけ繰り返して連結できます。

以下に例を示します。

>>> a + a			  # リストaとリストaを + 演算する
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]	  # リストaとリストaが連結される
>>> b + b			  # タプルbとタプルbを + 演算する
(6, 7, 8, 9, 10, 6, 7, 8, 9, 10)  # タプルbとタプルbが連結される
>>> c + c			  # 文字列cと文字列cを + 演算する
'hellohello'			  # 文字列cと文字列cが連結される
>>> a * 3			  # リストaと3を * 演算する
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]  # リストaが3回連結される
>>> b * 3			  # タプルbと3を * 演算する
(6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9, 10)  # タプルbが3回連結される
>>> c * 3			  # 文字列cと3を * 演算する
'hellohellohello'		  # 文字列cが3回連結される

辞書の表記方法と機能（キーによる要素の指定）

辞書は、

キー:バリュー

という形式の要素をカンマで区切って並べて、全体を { と } で囲みます。

以下は、英語をキー（鍵 key ）、それに対応した日本語をバリュー（値 value ）とした辞書の例です。

>>> d = {"apple":"リンゴ", "orange":"ミカン", "grape":"ブドウ"}  # 辞書d

辞書には、辞書ならではの機能があります。

それは、シーケンスの個々の要素を

 名前[キー] 

という構文で指定することです。 [ と ] の中にあるのが、添字ではなくキーであることに注目してください。このキーの指定によって、対応するバリューが得られます。

以下に例を示します。

>>> d["apple"]		# "apple" というキーに対応するバリューを得る
'リンゴ'		# "リンゴ" である
>>> d["orange"]		# "orange" というキーに対応するバリューを得る
'ミカン'		# "ミカン" である
>>> d["grape"]		# "grape" というキーに対応するバリューを得る
'ブドウ'		# "ブドウ" である

集合の表記方法と機能（集合演算）

集合は、要素をカンマで区切って並べて、全体を { と } で囲みます。{ と } で囲むことは、辞書と同じですが、要素がキー:バリュー という形式ではないので、集合と辞書を区別できます。

以下は、集合の例です。

>>> e = {1, 2, 3, 4}	# 集合e
>>> f = {3, 4, 5, 6}	# 集合f

集合には、集合ならではの機能があります。それは、集合どうしで「交わり（積集合）」や「結び（和集合）」などの集合演算ができることです。

交わりは、& 演算子で求められ、結びは | 演算子で求められます。集合どうしの演算結果は、集合になります。このように、個々の要素ではなく、要素の集まりを取り扱うから、集合なのです。

以下に例を示します。

>>> e & f		# 集合eと集合fの交わりを求める
{3, 4}			# {3, 4} という集合が得られる
>>> e | f		# 集合eと集合fの結びを求める
{1, 2, 3, 4, 5, 6}	# {1, 2, 3, 4, 5, 6} という集合が得られる

要素があるデータ型の使い分け

要素があるデータ型が5種類もあるので、どのように使い分けたらよいか、混乱してしまうかもしれません。

「基本的にリストを使い、その他は、それぞれの独自の機能が活かせる場面で使う」と考えてください。

シーケンスで（順序があり、個々の要素を添字で指定できる）、ミュータブルである（要素の値を書き換えられる）リストは、擬似言語の配列に近いものです。したがって、特に理由がないなら、リストを使えばよいのです。

要素の値を変更することがないなら、イミュータブルの（要素の値を書き換えられない）タプルを使うとよいでしょう。
文字の並びを取り扱う場合は、当然ですが、文字列を使います。
添字ではなく、キーで要素を指定するなら、辞書を使います。
個々の要素ではなく、全体をまとめて取り扱うなら、集合を使います。

要素があるデータ型の使い分け

・特に理由がない

arrow_forward　リストを使う

・要素の値を変更しない

arrow_forward　タプルを使う

・文字の並びを取り扱う

arrow_forward　文字列を使う

・キーで要素を指定する

arrow_forward　辞書を使う

・要素をまとめて取り扱う

arrow_forward　集合を使う

いかがでしたか。要素を持つデータ型の種類と特徴がわかったでしょう。

この連載では、今後も、基本情報技術者試験を Python で受けるための知識を取り上げて行きます。

それでは、またお会いしましょう！

The post 基本情報ではじめる Python (2) 配列 ～ リスト、タプル、文字列、集合、辞書の特徴 first appeared on 基本情報技術者試験 受験ナビ｜科目A・科目B対策から過去問解説まで 250本以上の記事を掲載.