初心者のための「Python」入門

「Python」は1991年に開発・公開された30年以上も利用され続けているプログラム言語です。

特に2015年前後からは「人工知能・ビッグデータ」の分野で利用者数が増え、世界的に人気があるプログラム言語になりました。

海外のランキングでは１位になっていることもあり、現在が人気のピークであるとも言えます。

一方、日本では「IT人材」が不足しているため、「Python」を利用して「AIプログラムの開発」ができる人や「ビッグデータ分析」ができる人が不足しています。

そのため「ＩＴエンジニア」として就職・転職をしたい方にも人気の言語となっています。

「Python」の実行環境

「Python」を利用するためには「Pythonの実行環境」を用意する必要があります。

「Python」の実行環境にはさまざまなものがあり、目的や用途によって選択していくことが大切です。

公式サイト

「Python」の公式サイトから「Python」の処理系をダウンロードして、インストールする方法です。

公式サイトは、

→「python.org」

になります。

「download」のメニューから「Python」の処理系に関するプログラムをダウンロードすることができます。

「インストーラープログラム」がダウンロードされるため、「インストーラー」を実行して「Python」をインストールします。

Anaconda

「Anaconda」は「Pythonの実行結果」をGUIで確認することができ、特に「データ分析・統計解析」など「データサイエンス」分野で広く活用されているソフトウェアです。

「機械学習」などの「人工知能プログラム」の開発なども行うことができ、「数値計算」関連のライブラリのインストール等も容易に行うことができます。

→「ANACONDA」

Google Colab

「Google Colab」は、「Google」のクラウドサーバーで「Python」を実行することができるプラットフォームです。

「Python」を実行できる環境がセットアップされているため、すぐに「Pythonプログラム」を書いて実行することができます。

→「Google Colab」

「無料版」と高性能なクラウドサーバーを選択できる「有料版」があります。

Docker

「Docker」は、コンピュータ内に「仮想環境」を構築できるソフトウェアです。

現在利用している端末内に「Python専用の仮想環境」を構築し、「Python」を実行することができます。

しかし、「Dockerの仕組みや操作方法」の学習が必要なため「Python」を実行する環境を構築するハードルは高いと言えます。

それでは、ここから「Pythonの構文」について見ていきたいと思います。

エントリーポイント
インデントの役割
変数
データ型
演算子
リスト
タプル
辞書
分岐
繰り返し
関数
クラス
継承
抽象クラス・抽象メソッド
ダンダー・特殊・マジックメソッド
例外処理
ファイルの入出力
標準ライブラリ
非同期処理
ビッグデータ解析・統計解析・機械学習

エントリーポイント

Pythonのエントリポイントは、スクリプトやプログラムの実行が開始される場所です。

下記のように「if __name__ == "__main__" ブロック」を使用して定義されます。

def main():
    print("Hello, World!")
					
if __name__ == "__main__":
    main()

「if name == "main"」の役割

の条件文は、スクリプトが直接実行された場合にのみ、ブロック内のコードを実行することを保証します。

モジュールとしてインポートされた場合、このブロック内のコードは実行されません。

「name」変数

Pythonプログラムが実行されると、「__name__」は「__main__」になります。

ファイルがモジュールとしてインポートされると、__name__ はモジュール名になります。

main() 関数

実行する「Pythonプログラム」を記述します。

インデントの役割

Pythonではインデントが非常に重要な役割を果たします。

インデントはコードの構造を示すために使用され、特定のコードブロックが他のコードブロックの内側にあることを意味しています。

下記に、「Pythonのインデントの役割」について説明します。

コードブロックの定義

インデントはコードブロック（例えば、関数、ループ、条件分岐など）を定義するために使用されます。

同じレベルのインデントを持つ行は同じブロック内に属します。

例えば、「greet関数」を定義する場合は、

def greet(name):
  print("Hello, {name}!")
  return name

のように「関数の処理内容」はインデントを付加します。

「print文」と「return文」は「greet関数」の一部のため、インデントによってそのことが示されています。

インデントの重要性

インデントを正しく使うことで、コードが視覚的に整理され、読みやすくなります。

正しいインデントはエラーを防ぎ、プログラムの正常な実行を確保します。

インデントが適切でないと、Pythonは「構文エラー」を発生させます。

間違ったインデントの事例も見てみましょう。

if x > 0:
print("hogehoge")

「if」と「print」の位置が揃っていて、間違ったインデントになっています。

この場合、Pythonは「IndentationError」を発生します。

繰り返しになりますが、インデントはPythonの構文において非常に重要です。

コードブロックの開始と終了を示し、プログラムの構造を明確にします。

正しいインデントはコードの可読性を高め、エラーを防ぐのに役立ちます。

Pythonプログラミングを行う際には、インデントの使用方法をしっかりと理解し、プログラミングを行うことが大切です。

変数

変数は、データを保存するための名前付きの場所のことで、プログラム内でデータを一時的に保存し、後で再利用するために使用します。

命名規則

変数の「命名」には下記のようなルールがあります。

「文字」「数字」「アンダースコア(_)」を使用することができますが、変数名を数字で始めることはできません。

「大文字」と「小文字」は区別されます（例：Numberとnumberは異なる変数です）

「Pythonの予約語（キーワード）」は使用できません（例：def、classなど）。

変数の宣言と代入

Pythonでの変数の宣言と代入は下記のように行います。

num = 10       # 整数型
pi = 3.14      # 浮動小数点数型
name = "Taro"  # 文字列型
is_show = True # ブール型

「Python」では、変数を宣言する際にデータ型を明示する必要はありません。

代入する値によって自動的にデータ型が決まります。

動的型付け

「Python」は「動的型付け」のプログラム言語ですので、変数に「異なるデータ型」のデータを再代入することができます。

例えば、

num = 10       # 整数型
num = "じゅう" # 文字列型

のように記述することも可能です。

一括代入

変数の宣言を代入を「ワンライナー」で行うこともできます。

height, weight, age = 167, 67, 38

のように記述すると、下記のように出力されます。

print(height) # 出力値：167
print(weight) # 出力値：67
print(age) # 出力値：38

スコープ

Pythonの変数には２つの「スコープ（有効範囲）」があります。

関数内で変数を宣言するとその変数は「ローカルスコープ」になります。

ローカルスコープの変数は「関数内」でのみ利用することができます。

例えば、

def sample_func():
  num = 1
  print(num) # 関数内なのでOK
					  
print(num) # 関数外なのでNG

のようになります。

このプログラムを実行すると関数外で実行している「print文」がエラーになり「NameError: name 'num' is not defined.」が発生します。

関数の「外」で変数を定義した場合はその変数は「グローバルスコープ」になります。

例えば、

g_num = 10 # グローバルスコープの変数を定義

def sample_func():
  print(g_num) # 関数内もOK
						
print(g_num)　# 関数外もOK

のようにプログラムを作成すると、２つの「print文」はどちらも正常に実行することができます。

このように関数の外で定義した変数は「グローバルスコープ」となり、関数の中でも外でも利用することができます。

データ型

Pythonで利用できる「データ型」についてご説明していきたいと思います。

整数型（int）

整数型は「小数点を含まない」数値です。

例えば、

num = 10
num = 0
num = -5

のように記述します。

Python2では扱える整数の範囲によって「int型」と「long型」が存在していました。

Python3では「long型」が廃止され、「int型」のみとなり、「int型」で扱える数値の範囲の上限が無くなりました。

そのためPython3では「int型」で「無限の整数」を扱うことができますが「扱える数値の範囲」は「物理メモリ容量」などの制約を受けます。

浮動小数点型(float)

浮動小数点型は「小数点を含む」数値です。

扱える数値の最大値は、

print(sys.float_info)

で出力することができます。

出力例：
sys.float_info(
	max=1.7976931348623157e+308,    # 浮動小数点数が表現できる最大の値
	max_exp=1024,                   # 浮動小数点数の指数部で表現できる最大の値
	max_10_exp=308,                 # 浮動小数点数で表現できる最大の10進指数
	min=2.2250738585072014e-308,    # 浮動小数点数が表現できる最小の正の非ゼロ値
	min_exp=-1021,                  # 浮動小数点数の指数部で表現できる最小の値
	min_10_exp=-307,                # 浮動小数点数で表現できる最小の10進指数
	dig=15,                         # 浮動小数点数で正確に表現できる10進の有効桁数
	mant_dig=53,                    # 浮動小数点数の仮数部（マンティッサ部）における有効ビット数
	epsilon=2.220446049250313e-16,  # 1.0と1.0より大きい最小の浮動小数点数
	radix=2,                        # 浮動小数点数の基数（通常は2）
	rounds=1                        # 浮動小数点数の丸め方法
)

複素数型（complex）

複素数型は「複素数」を扱えるデータ型です。

複素数は、「実部」と「虚部」を持ち、「数学」や「工学」などの分野で広く利用されています。

複素数は「 a + bj 」の形式で表されます。

ここで、「a」は実部（real part）、「b」は虚部（imaginary part）、「j」は虚数単位です。

例えば、「5 + 4j」は実部が「5」、虚部が「4」の複素数です。

プログラムでは、

c1 = 5 + 4j

のように複素数を作成することができます。

文字列型(string)

文字列型は「文字のつながり」を扱えるデータ型です。

「シングルクォート（'）」もしくは「ダブルクォート（"）」で文字を囲みます。

例えば、

str1 = 'Hello'

のように作成します。

文字列型の「最大文字数」の制限はありませんが、端末の物理メモリ容量などの制約を受けます。

bool型

「bool型」は「真（True）」または「偽（False）」を表します。

is_active = True
is_admin = False

None型

「None型」は、特別な値「None」を持ち、「値が存在しないこと」を示します。

score = None

演算子

「演算子」は、変数や値に対して様々な操作を行うための記号やキーワードです。

演算子には、

算術演算子
比較演算子
論理演算子
ビット演算子
代入演算子
特殊演算子

があります。

算術演算子

算術演算子は「数値の計算」を行います。

加算演算子

「 + 」は加算を行うための演算子です。

print(2 + 5) # 出力結果：7

減算演算子

「 - 」は減算を行うための演算子です。

print(8 - 3) # 出力結果：5

乗算演算子

「 * 」は乗算を行うための演算子です。

print(2 * 5) # 出力結果：10

除算演算子

「 / 」は除算を行うための演算子です。

print(8 / 2) # 出力結果：4

剰余演算子

「 % 」は剰余を行うための演算子です。

print(4 % 2) # 出力結果：0

べき乗演算子

「 ** 」はべき乗を行うための演算子です。

print(8 ** 2) # 出力結果：64

整数除算演算子

「 // 」は整数除算を行うための演算子です。

print(10 // 2) # 出力結果：5

比較演算子

「比較演算子」は「2つの値」を比較し、「真（True）」または「偽（False）」を返します。

等しい

「 == 」は「2つの値」が「等しい」かを判定する演算子です。

print( 10 == 5 ) # 出力結果：False

等しくない

「 != 」は「2つの値」が「等しくない」かを判定する演算子です。

print( 10 != 5 ) # 出力結果：True

大きい

「 > 」演算子の「左辺の値」が「右辺の値」より「大きい」かを判定する演算子です。

print( 10 > 5 ) # 出力結果：True

小さい

「 < 」演算子の「左辺の値」が「右辺の値」より「小さい」かを判定する演算子です。

print( 10 < 5 ) # 出力結果：False

大きいかまたは等しい

「 >= 」演算子の「左辺の値」が「右辺の値」より「大きい」かまたは「等しい」かを判定する演算子です。

print( 10 >= 5 ) # 出力結果：True

小さいかまたは等しい

「 <= 」演算子の「左辺の値」が「右辺の値」より「小さい」かまたは「等しい」かを判定する演算子です。

print( 10 <= 5 ) # 出力結果：False

論理演算子

「変数・式の評価結果」の「bool値」によって全体の「bool値」を返します。

and

「変数・式の評価結果」がすべて「true」の場合に「and」の結果が「true」となります。

print(true and true) # 出力結果：true

or

「変数・式の評価結果」のどれか１つが「true」の場合に「or」の結果が「true」となります。

print(false or true) # 出力結果：true

not

「真」を偽に、「偽」を真に反転

print(!true) # 出力結果：false

ビット演算子

ビットを操作するための演算子が「ビット演算子」です。

&（AND）

ビットの「AND演算」を行います。

b1 = 10 # 出力結果：binary: 1010
b2 = 3  # binary: 0011
print( b1 & b2) # 出力：2 binary: 0010

| (OR)

ビットの「OR演算」を行います。

b1 = 5 # 出力結果：binary: 0101
b2 = 3  # binary: 0011
print( b1 | b2) # 出力：7 binary: 0111

^(XOR)

ビットの「XOR演算(排他的論理和)」を行います。

b1 = 12 # 出力結果：binary: 1100
b2 = 3  # binary: 0011
print( b1 ^ b2) # 出力結果：15 binary: 1111

<<

ビットの「左シフト」を行います。

b1 = 10 # binary: 1010
print( b1 << 2) # 出力結果：40 binary: 101000

>>

ビットの「右シフト」を行います。

b1 = 10 # binary: 1010
print( b1 >> 2) # 出力結果：2 binary: 0010

代入演算子（複合代入演算子）

代入演算子は変数に値を代入します。

複合代入演算子は算術演算子と組み合わせて使用できます。

+=

「左辺の変数」に「右辺」を加算してから代入します。

total = 10
total += 10
print(total) # 出力結果：20

-=

「左辺の変数」に「右辺」を減算してから代入します。

total = 30
total -= 15
print(total) # 出力結果：15

*=

「左辺の変数」に「右辺」を乗算してから代入します。

otal = 2
total *= 5
print(total) # 出力結果：10

/=

「左辺の変数」に「右辺」を除算してから代入します。

total = 100
total /= 20
print(total) # 出力結果：5.0

%=

「左辺の変数」に「右辺」を除算した余りを計算してから代入します。

total = 10
total %= 3 
print(total) # 出力結果：1

**=

「左辺の変数」に「右辺」をべき乗した値を代入します。

total = 2
total **= 8 
print(total) # 出力結果：256

//=

「左辺の変数」に「右辺」を整数除乗した値を代入します。

total = 10
total //= 3 
print(total) # 出力結果：3

特殊演算子

あるデータ群の中に「ある値」があるかを調べる演算子です。

in

リストの中にあるデータがあれば「True」を返し、そうでなければ「False」を返します。

num_list = [1, 2, 3, 4, 5]
print(2 in data_list) # 出力結果：True

not in

リストの中にあるデータがあれば「False」を返し、そうでなければ「True」を返します。

num_list = [1, 2, 3, 4, 5]
print(10 not in num_list) # 出力結果：True

アイデンティティ演算子

あるオブジェクトが「同一」かあるいは「同一でない」かを判定する演算子です。

is

あるオブジェクトが同一の場合は「True」そうでない場合は「False」を返します。

data = 5
data_2 = data
print(data is data_2) # 出力結果：True

is not

あるオブジェクトが同一の場合は「False」そうでない場合は「True」を返します。

data = 5
data_2 = 10
print(data is not data_2) # 出力結果：True

リスト（list）

「複数の値」を保存できる仕組みが「リスト」です。

下記のように作成します。

results = [15, 27, 38, 42, 57]

上記の値は全て「整数型」ですが、他のデータ型の値と保存することもできます。

results = ['a', 27, 38, 'b', 57]

データの取得には「インデックス」を指定します。

インデックスは、

インデックス→ 0    1   2   3    4
  results = ['a', 27, 38, 'b', 57]

のように左端から０番を開始番号として付加されています。

results[3]

を指定すると「b」が取得できます。

append

リストに要素を追加する時は下記のように「append」を利用します。

num = [1, 2, 3]
num.append(4)
print(num) # 出力結果：[1, 2, 3, 4]

extend

リスト同士を結合するには下記のように「extend」を利用します。

num1 = [1, 2, 3]
num2 = [4, 5, 6]
num1.extend(num2)
print(num1)  # 出力結果：[1, 2, 3, 4, 5, 6]

insert

リストの指定した位置に要素を追加する場合は、下記のように「insert」を利用します。

num = [1, 2, 4]
num.insert(2, 3)
print(num)  # 出力例：[1, 2, 3, 4]

この例では「insert(2,3)」となっていますので、「2番目」の要素の後ろに「3」を追加します。

「インデックス」ではなく「左から2番目」という意味なので注意が必要です。

remove

リストの要素を削除する場合は下記のように「remove」を利用します。

alphabets = ['a', 'b','c','d','e']
alphabets.remove('d')
print(alphabets) # 出力例：['a', 'b', 'c', 'e']

pop

要素を削除して削除した要素を取得する場合は下記のように「pop」を利用します。

alphabets = ['a', 'b','c','d','e']
removed_alphabets = alphabets.pop(1)  # インデックス1の要素を削除
print(removed_alphabets)  # 出力例:e
print(alphabets)  # 出力例:['a', 'b', 'c', 'd']

popに「引数」を指定しない場合は下記のように「最後の要素」を削除します。

clear

リストの要素をすべて削除するには下記のように「clear」を利用します。

alphabets = ['a', 'b','c','d','e']
alphabets.clear()  
print(alphabets)  # 出力例:[]

index

リスト内の「要素の位置」を調べるためには下記のように「index」を利用します。

cities = ['fukuoka', 'osaka','nagoya','tokyo','sapporo']
index = cities.index('tokyo')  
print(index)  # 出力例（最初の要素のインデックス番号）:3

count

あるデータがリスト内に何個含まれているかを調べるために、下記のように「count」を利用します。

cities = ['fukuoka', 'osaka','nagoya','tokyo','sapporo','tokyo','osaka', 'tokyo', 'fukuoka', 'tokyo']
print(cities.count('tokyo'))  # 出力例:4

sort

リストの要素を並び替えるためには下記のように「sort」を利用します。

cities = ['fukuoka', 'osaka','nagoya','tokyo','sapporo']
cities.sort()
print(cities)  # 出力例（昇順）:['fukuoka', 'nagoya', 'osaka', 'sapporo', 'tokyo']

「降順」で並び替える場合は下記のように「sort」の引数に「reverse=True」を追記します。

cities = ['fukuoka', 'osaka','nagoya','tokyo','sapporo']
cities.sort(reverse=True)
print(cities)  # 出力例（降順）:['tokyo', 'sapporo', 'osaka', 'nagoya', 'fukuoka']

reverse

リスト内のデータを「逆順」にするためには下記のように「reverse」を利用します。

cities = ['fukuoka', 'osaka','nagoya','tokyo','sapporo']
cities.reverse()
print(cities)  # 出力例（降順）:['sapporo', 'tokyo', 'nagoya', 'osaka', 'fukuoka']

copy

リストをコピーする場合は下記のように「copy」を利用します。

cities = ['fukuoka', 'osaka','nagoya','tokyo','sapporo']
cities2 = cities.copy()
cities2.append('okinawa')
print(cities)  # 出力例:['sapporo', 'tokyo', 'nagoya', 'osaka', 'fukuoka']
print(cities2)  # 出力例:['sapporo', 'tokyo', 'nagoya', 'osaka', 'fukuoka', 'okinawa']

タプル

「タプル（tuple）」は、リストと同様に複数の要素を順序付けて格納するためのデータ型ですが、リストとは異なり、タプルは「変更不可（イミュータブル）」です。

タプルは、要素の変更が不要である場合や、データの不変性が必要な場合に有用です。

タプルの作成

タプルは「括弧 () 」を使って作成します。

要素はカンマ「 , 」で区切ります。

original_tuple = (18, 25, 37, 'hello')

要素へのアクセス

インデックスを使ってタプルの要素にアクセスします。

インデックスは0から始まります。

print(original_tuple[0])  # 1番目の要素を取得
print(original_tuple[2])  # 3番目の要素を取得

タプルのスライス

「スライス」は、シーケンス（リスト、タプル、文字列など）の一部を取得するための機能です。

スライスを使うことで、特定の範囲の要素を簡単に取得できます。

書式は、

タプル名[start:stop:step]

のようになり、

start: スライスの開始インデックス（含む）
stop: スライスの終了インデックス（含まない）
step: スライスのステップ（間隔）

を表します。

この「スライス」を使ってタプルの一部を取得することもできます。

# タプルのスライス
original_tuple = (1, 2, 3, 'a', 'b', 'c')
print(original_tuple[1:3])  # 出力例：(2, 3)
print(original_tuple[:3])   # 出力例：(1, 2, 3)
print(original_tuple[3:])   # 出力例：('a', 'b', 'c')

タプルの変更

タプルはイミュータブルなので、一度作成するとその要素を変更できません。

ただし、タプル内のリストなどのミュータブルな要素は変更できます。

original_tuple = (15, 22, 37, [48, 51, 67])
						
# タプル内のリストの要素は変更可能
original_tuple[3][0] = 22
print(original_tuple)  # (15, 22, 37, [22, 51, 67])

タプルの結合と繰り返し

「+」演算子でタプルを結合します。

そして、「*」演算子でタプルを繰り返します。

# タプルの結合
tuple1 = (17, 23, 31)
tuple2 = ('a', 'b', 'c')
tuple3_combined = tuple1 + tuple2
print(tuple3_combined)  # (17, 23, 31, 'a', 'b', 'c')
  
# タプルの繰り返し
tuple4_repeated = tuple1 * 3
print(tuple4_repeated)  # (17, 23, 31, 17, 23, 31, 17, 23, 31)

アンパック

タプルの要素を個別の変数に割り当てます。

original_tuple = (18, 28, 35)
a, b, c = original_tuple
print(a)  # 18
print(b)  # 28
print(c)  # 35

ネストされたタプル

タプルの中にタプルを含めることができます。

tuple_nest = (12, 23, (37, 45, 53), (64, 75))
print(tuple_nest)        # (12, 23, (37, 45, 53), (64, 75))
print(tuple_nest[2])     # (37, 45, 53)
print(tuple_nest[2][1])  # 45

タプルのメソッド

count

タプルの中にある「指定した値」の個数を得ることができます。

original_tuple = (1, 2, 2, 3, 4, 2, 2, 1, 2)
print(original_tuple.count(2))  # 5

index

「指定した値：の最初の出現位置を得ることができます。

original_tuple = (1, 2, 2, 3, 4, 2, 2, 1, 2)
print(original_tuple.index(3))  # 3

タプルを利用する具体的なメリット

タプルを利用することで得られるメリットについて解説していきます。

イミュータビリティ（不変性）

タプルは一度作成すると変更できないため、データの整合性を保つのに適しています。

誤ってデータを変更してしまうリスクがありません。

多値返却

関数が複数の値を返す場合に、タプルを使って1つのオブジェクトとして返すことができます。

意図の明確化

タプルを使うことで、データが変更されるべきではないことを明示的に示すことができます。

これはコードの可読性を高め、意図を明確にするのに役立ちます。

辞書

「辞書（dictionary）」は、「キー」と「値」のペアを格納することができます。

「辞書」は変更可能であり、「キー」と「値」のペアを「追加、削除、更新」することができます。

辞書の作成

辞書は下記のように作成します。

# 「空」の辞書を作成
empty_dict = {}

# キーと値のペアを含む辞書を作成
human = {
    "name": "Taro",
    "age": 32,
    "city": "Tokyo"
}

取得

辞書で作成したデータは、下記のように取得することができます。

print(human["name"])  # 出力結果："Taro"
print(human["age"])   # 出力結果：32

「get」を利用して取得することもできます。

print(human.get('name'))
print(human.get('age'))

変更

辞書で作成したデータは、下記のように変更することができます。

human = {
    "name": "Taro",
    "age": 32,
    "city": "Tokyo"
}
					
print(human['city']) # 出力結果： Tokyo
human['city'] = 'Osaka'
print(human['city']) # 出力結果：Osaka

削除

「del」または「pop」を利用して下記のようにデータを削除します。

del

  human = {
    "name": "Taro",
    "age": 32,
    "city": "Tokyo"
}
					
print(human) # 出力結果： {'name': 'Taro', 'age': 32, 'city': 'Tokyo'}
del human['city']
print(human) # 出力結果：{'name': 'Taro', 'age': 32}

pop

human = {
  "name": "Taro",
  "age": 32,
  "city": "Tokyo"
}

print(human) # 出力結果： {'name': 'Taro', 'age': 32, 'city': 'Tokyo'}
age = human.pop("age")
print(age)   # 出力結果： 32
print(human) # 出力結果： {'name': 'Taro', 'city': 'Tokyo'}

メソッド

辞書には便利なメソッドが多数あります。

clear

辞書内の全ての要素を削除します。

human = {"name": "Taro", "age": 25}
human.clear()
print(human)  # 出力: {}

copy

辞書のコピーを返します。

human = {"name": "Taro", "age": 25} 
new_human = human.copy() 
print(new_human) # 出力: {'name': 'Alice', 'age': 25}

fromkeys

指定されたキーのイテラブルと値から新しい辞書を作成します。

keys = ["name", "age", "city"] 
new_dict = dict.fromkeys(keys, "unknown") 
print(new_dict) # 出力: {'name': 'unknown', 'age': 'unknown', 'city': 'unknown'}

items

辞書のすべてのキーと値のペアを返します。

human = {"name": "Taro", "age": 35} 
print(human.items()) # 出力: dict_items([('name', 'Taro'), ('age', 35)])

keys

辞書のすべてのキーを返します。

human = {"name": "Jiro", "age": 32} 
print(human.keys()) # 出力: dict_keys(['name', 'age'])

popitem

最後に追加されたキーと値のペアを削除して返します。

human = {"name": "Masa", "age": 42} 
item = human.popitem() 
print(item) # 出力: ('age', 42)
print(human) # 出力: {'name': 'Masa'}

setdefault

指定されたキーの値を返します。

キーが存在しない場合は、キーとデフォルト値を辞書に追加します。

human = {"name": "Taro"} 
age = human.setdefault("age", 31) 
print(age) # 出力: 31
print(human) # 出力: {'name': 'Taro', 'age': 31}

分岐

Pythonには様々な分岐処理の作り方があります。

if

「if」は、「elif」「else」を組み合わせて「分岐処理」を作ることができます。

if 条件1:
  # 条件1が真の場合に実行されるコード
elif 条件2:
  # 条件1が偽で、条件2が真の場合に実行されるコード
else:
  # 条件1も条件2も偽の場合に実行されるコード

例えば、

num = 76
if num > 100:
  print("high")
elif num > 50:
  print("middle")
else:
  print("low")

のように作成します。

if num > 100:
print("high")

のように「if」のみの時もあります。

または、

if num > 100:
  print("high")
else:
  print("low")

のように「if・else」のみの時もあります。

if文のネスト

「if文の内側」に「if文」を入れることができます。

例えば、

score_1 = 10
score_2 = 20
						
if score_1 > 5:
  if score_2 > 15:
    print("score_1は5より大きく、score_2は15より大きい")
  else:
    print("score_1は5より大きく、score_2は15以下です")
else:
  print("score_1は5以下です")

複合条件

「if文」では「論理演算子」を利用してより複雑な条件を指定することも可能です。

例えば、

temp = 25
hdt = 70
						
if temp > 20 and hdt > 60:
  print("暑くて湿度が高い")
elif temp > 20 and hdt <= 60:
  print("暑くて湿度は低い")
else:
  print("判定できません")

三項演算子

シンプルな条件の場合は「三項演算子」を利用することで、より簡潔にプログラムを記述することができます。

三項演算子は、単一の行で簡単な条件付き代入を行うために使用されます。

書式は、

条件成立時の値 if 条件 else 条件未成立時の値

のようになります。

例えば、

score_1 = 5
score_2 = 10
result = "score1がscore_2より大きい" if score_1 >score_2 else "score_1がscore2以下"
print(result) # 出力結果：score_1がscore2以下

match

Python Version 3.10からは「match」が使えるようになりました。

書式は

match 値
  case 値1:
    処理１
  case 値2:
    処理２
  case 値3:
    処理３
  case _:
    値にマッチしない時の処理

のように記述します。

例えば、

color = 2
match color:
  case 1:
    print("Blue")
  case 2:
    print("Pink")
  case 3:
    print("Brown")
  case _:
    print("White")

のようになります。

辞書を利用した分岐

「辞書」を利用して処理の分岐を行うことができます。

例えば、

def taskA():
  return "taskA"
					  
def taskB():
  return "taskB"
					  
tasks = {
  "a": taskA(),
  "b": taskB()
}
					  
def main():
  print(tasks["a"]) # 出力結果: taskA
  print(tasks["b"]) # 出力結果: taskBs

のように、辞書に「関数名」を格納して処理を分岐させることができます。

関数については後に解説していきます。

繰り返し

「繰り返し処理」の仕組みや作り方について解説していきます。

for文

「for文」の書式は下記のようになります。

for 変数 in 繰り返す対象のデータ:
  # 繰り返し処理

例えば、

areas = ["Fukuoka", "Osaka", "Tokyo"]
for area in areas:
  print(area)

のようにプログラムを作成すると、

Fukuoka
Osaka
Tokyo

のように出力されます。

繰り返し回数を指定したい場合は、

for i in range(3):
  print(i)

のように作成すると、

0
1
2

のように出力されます。

while文

「while文」の書式は下記のようになります。

while 条件:
 # 繰り返し処理

例えば、

num = 0
while num < 5:
  print(num)
  num += 1

のようになり、

のように出力されます。

break文

「break文」は繰り返し処理を途中で抜けたい場合に利用します。

例えば、

areas = ["Fukuoka", "Osaka", "Tokyo", "Aomori", "Hokkaido"]
for area in areas:
  print(area)
  if area == "Osaka":
    break

「area」変数の値が「Osaka」の場合に「break文」が実行され、繰り返し処理を抜けます。

このプログラムの実行結果は、

Fukuoka
Osaka

のようになります。

continue文

「continue文」はその回の繰り返し処理をスキップします。

areas = ["Fukuoka", "Osaka", "Tokyo", "Aomori", "Hokkaido"]
for area in areas:
  if area == "Osaka":
    continue
  else :
    print(area)

このプログラムの実行結果は、

Fukuoka
Tokyo
Aomori
Hokkaido

のようになり、「area」変数の値が「Osaka」の場合に「continue文」が実行され、繰り返し処理をスキップします。

関数

「関数」は「処理のまとまり」を定義し、「関数名」から実行できる機能です。

関数を定義するには、

def 関数名(引数1, 引数2, ...):
  関数内の処理
  return 戻り値

のように記述します。

例えば、

# 関数の定義（作成）
def hello(name):
  return f"Hello, {name}!"
					
# 関数の実行（呼び出し）
print(hello("Taro"))  # 出力結果: Hello, Taro!

のように作成します。

「関数」は定義するだけでは実行されないため、「実行（呼び出し）」を行うプログラムを書くことが必要です。

関数を実行するには

関数名（引数）

のように記述します。

引数

関数には任意の数の引数を渡すことができます。

また、デフォルト値を持つ引数や、可変長引数も使用できます。

例えば、

# 関数の定義（作成）
def hello(name="unknown"):
  return f"Hello, {name}!"
					
# 関数の実行
print(hello())  # 出力結果: Hello, unknown!

のように「引数」にデフォルト値を代入します。

可変長引数

引数の個数を変化させることができる「可変長引数」は下記のように記述します。

def calcurate_sum(*args):
  return sum(args)
										  
print(calcurate_sum(17, 23, 35))  # 出力: 75

可変長引数のデータ型は関数内部では「タプル型」になっています。

下記のように「辞書型」として受け取ることもできます。

def print_info(**kvargs):
  for key, value in kvargs.items():
    print(f"{key}: {value}")
					
print_info(name="Taro", age=38)  # 出力: name: Taro, age: 38

戻り値（返り値）

関数は「return文」を使って値を返すことができます。

「return文」を使わない場合、関数は「None」を返します。

例えば、

def add(num1, num2):
  return num1 + num2
					
result = add(23, 34)
print(result)  # 出力: 57

ラムダ関数（匿名関数・無名関数）

「ラムダ関数」は「名前の無い関数」の１つで短くシンプルな関数を一行で定義するために使われます。

「ラムダ関数」を定義するには、

lambda 引数1, 引数2, ... : 式

のように記述します。

「lambda」の後に「引数リスト」を続け、その後にコロン（:）を置きます。

コロンの後に、関数の本体となる式を記述します。

例えば、

total = lambda x, y: x + y
print(total(20,15)) # 出力結果：35

のように利用します。

「ラムダ関数」を利用して「リスト内のデータ」を一括で変更することもできます。

例えば、

scores = [10, 25, 33, 47, 51]
score_double = list(map(lambda score: score * 2, scores))
print(score_double)  # 出力結果: [20, 50, 66, 94, 102]

のように記述することができます。

他にも「リストデータのフィルタリング」で利用することもできます。

例えば、

scores = [10, 25, 33, 47, 51]
result = list(filter(lambda score: score > 30, scores))
print(result)  # 出力: [33, 47, 51]

のようになります。

クラス

クラスはオブジェクト指向プログラミングの基本的な構成要素で、クラスを使うと、関連するデータ（属性）とその「データ」に対する「操作（メソッド）」をまとめることができます。

クラスは、下記の書式で定義します。

class クラス名:
  # コンストラクタ
  def __init__(self, 引数1, 引数2, ...):
    self.属性1 = 引数1
    self.属性2 = 引数2
    ...
    
  def メソッド名(self, 引数1, 引数2, ...):
    # メソッドの処理

のように作成します。

「属性」はコンストラクタの中で定義しないとエラーが発生します。

例えば、

class Car:
  def __init__(self, name):
    self.name = name
    self.speed = 0;
    
  def forward(self):
    self.speed += 10;
    print(f"current speed={self.speed}")
    
  def getNName(self):
    return self.name

のようにクラスを作成することができます。

インスタンスメソッドは「第一引数」に「self」が必要です。

「インスタンス」を作成するには、

car = Car('sedan')
name = car.getName()
print(name) # 出力結果： sedan

のように記述します。

コンストラクタ

「コンストラクタ」はクラスのインスタンスを作成した際に自動実行されるメソッドです。

先ほど作成したクラスでは、

def __init__(self, name):
  self.name = name
  self.speed = 0;

の部分がコンストラクタです。

インスタンスを作成する際に、

car = Car('sedan')

の部分で、コンストラクタの引数に「sedan」の文字列がありましたが、この文字列がコンストラクタの「name」に代入されます。

クラスメソッド

Pythonのクラスでは「クラスメソッド」や「クラス属性」を定義することができます。

class クラス名:
  クラス属性名 = 初期値

  @classmethod
  def クラスメソッド名（cls, 引数1, 引数2 ...）:
    # 処理の内容

のように記述し、「クラスメソッド・クラス属性」を作成します。

例えば、

class Car:
  number = 0 # クラス属性名
						
  @classmethod # クラスメソッド
  def incNum(cls):
    cls.number += 1

のように作成します。

クラス名.クラス属性名
クラス名.クラスメソッド名

と記述すると、「クラスメソッド・クラス属性」を利用することができます。

例えば、

print(Car.num) # 出力結果： 0
Car.incNum()
print(Car.num) # 出力結果： 1

のように利用します。

継承

「継承」はクラス間に「親子関係」を作ることができる機能です。

Pythonでは下記のように記述することで、「クラスの継承関係」を作ることができます。

class クラス名（親クラス名）:
  # コンストラクタの中で属性を定義
  # メソッドを定義

例えば、

class Car:
  def __init__(self, name):
    self.name = name
    self.speed = 0;
	  
  def forward(self):
    self.speed += 10;
    print(f"current speed={self.speed}")
  
  def getName(self):
    return self.name

class Truck(Car):
  def __init__(self, name, payload):
    self.name = name
    self.speed = 0;
    self.payload = payload

  def getPayload(self):
    return self.payload

のように定義すると、

truck = Truck("truck",10)
print(truck.getPayload()) # 出力結果： 10

のように実行することができます。

Pythonでは「多重継承」を行うことができます。

class クラス名（親クラス名1, 親クラス名2）:
  # コンストラクタの中で属性を定義
  # メソッドを定義

抽象クラス・抽象メソッド

Pythonでは「抽象クラス」を定義することができます。

抽象クラス内には「抽象メソッド」を定義することができます。

from abc import ABC, abstractmethod
						
class Shop(ABC): # ABCを継承
  @abstractmethod #抽象メソッドを定義
  def sell(self):
    pass

「抽象クラス」を作成するには、「ABC」のインポートが必要なことと「抽象メソッド」を定義するには「abstractmethod」が必要なため、

from abc import ABC, abstractmethod

の部分でインポートしています。

抽象クラスは「ABC」を継承することで定義することができます。

抽象メソッドは「@abstractmethod」を記述し、その下に「抽象メソッド定義」を記述しますが、メソッド内には「何もしない」ことを表す「pass」を記述しています。

具体的な抽象メソッドの処理の内容は「抽象クラス」を継承したクラス内で定義をします。

例えば、

class CarShop(Shop):
  def sell(self):
    print("車を売る")

のように定義します。

抽象クラスからはインスタンスが作成できないため、抽象クラスを継承したクラスからインスタンスを生成します。

例えば、

carShop = CarShop()
carShop.sell() # 出力結果: 車を売る

のようにインスタンスを生成してメソッドを実行します。

ダンダー・特殊・マジックメソッド

Pythonには「ダンダーメソッド」と呼ばれるメソッドがあります。

「ダンダー」とは「double underscore」の略で、

__メソッド名__

のようにメソッド名の前後に「ダンダー（double underscore）」が付加されているのが特徴です。

これまでにも「__init__」のコンストラクタがありました。

全部で２０～３０ほどありますが、その一部を紹介したいと思います。

__del__: オブジェクトが削除される時に実行される「デストラクタ」。
__str__: 「str()」や「 print()」の呼び出す時の文字列を定義。
__add__: 「+」演算子の動作を定義。
__sub__: 「-」演算子の動作を定義。
__mul__: 「*」演算子の動作を定義。
__mul__: 「/」演算子の動作を定義。
__mod__: 「%」演算子の動作を定義。

他にもたくさんのダンダーメソッドがありますので、ご興味があればご自身で調べてみてください。

例外処理

例外処理は、コードの実行中に発生するエラーを処理し、プログラムのクラッシュを防ぐための重要な機能です。

ここでは、エラーハンドリングの基本とカスタム例外の作成について詳しく説明します。

例外処理の書き方

「try-except」を使用すると、コードの特定の部分を実行し、エラーが発生した場合にエラーを「捕捉」することができます。

try:
  total = 10 /0
except ZeroDivisionError:
  print('ZeroDivisionError')

「0」で割ると「ZeroDivisionError」が発生します。

「except」で「ZeroDivisionError」を指定しているため、「print文」が実行され「ZeroDivisionError」が出力されます。

「エラーの内容」を調べたい時は「エラーオブジェクト」を取得することができました。

try:
  total = 10 /0
except ZeroDivisionError as e:
  print(e)

try:
  total = 10 /0
except ZeroDivisionError as e:
  print(e) # 出力結果： division by zero

のように「except」に「as」を追加し、「変数名」を記述するとその変数にエラーの内容が格納されます。(※Python3での記述)

複数のエラーの補足

複数のエラーを補足したい場合は、下記のように記述します。

try:
  total = 10 /0
except ZeroDivisionError as e:
  print(e)
except TypeError as e:
  print(e)

のように「except」を追加していきます。

「ZeroDivisionError」と「TypeError」で同じエラー処理を行いたい場合は、

try:
  total = 10 /0
except ( ZeroDivisionError,TypeError ) as e:
  print(e)

のように記述することもできます。

全てのエラーを補足

全てのエラーを補足したい場合は、

try:
  total = 10 /0
except Exception as e:
  print(e)

のように記述すると、例外が発生すると例外の内容が出力されます。

エラーが発生しなかった時の処理

「else」を記述すると「エラーが発生しなかった時」に特定の処理を行うことができます。

例えば、

try:
  total = 10 / 2
except Exception as e:
  print(e)
else:
  print("no error") # 出力結果： no error

のように記述します。

最後に必ず実行したい処理

エラーの有無を問わず「try」の処理が終わった際に必ず処理を実行したい場合は「finally」を利用します。

例えば、

try:
  total = 10 / 2
except Exception as e:
  print(e)
finally:
  print("executed") # 出力結果： executed

のように記述します。

独自例外の作成

オリジナルの例外を作ることもできます。

独自例外を作成することで、特定の状況に対する独自のエラーを定義できます。

カスタム例外は、Pythonの組み込みExceptionクラスを継承して作成します。

例えば、

class MyCustomError(Exception):
  def __init__(self, message):
    self.message = message
    super().__init__(self.message)

例外を発生させるには「raise」キーワードを使用します。

例えば、

num = 0
if num == 0:
  raise MyCustomError("occur error")

のように記述します。

ファイルの入出力

Pythonのファイルを開くには「モード」を指定する必要があります。

モードには下記のようなものがあります。

モード：r: 読み取り専用モード。ファイルが存在しない場合、エラーが発生します。
モード：w: 書き込み専用モード。ファイルが存在しない場合、新しいファイルが作成されます。
モード：a: 追記モード。ファイルが存在しない場合、新しいファイルが作成されます。ファイルが存在する場合、内容の末尾に追記されます。
モード：b: バイナリモード。このモードは他のモード（'rb'、'wb'、'ab'など）と組み合わせて使います。

ファイルを開くには「open関数」を利用します。

file = open("ファイル名", モード)

のように記述し、「戻り値」には「ファイルへアクセスするための情報」が入ります。

テキストファイルの読み込み

「テキストファイル」を読み込むには下記のように記述します。

with open('sample.txt', 'r') as file:
  content = file.read()
  print(content)

「file.read()」で１行ずつ「テキストファイル」の内容を読み込みます。

そして、「print」で出力しています。

テキストファイルへの書き込み

ファイルにデータを書き込むには「wモード」でファイルを開き、「write（１行書き込み）」または「writeLines（複数行書き込み）」を利用します。

例えば、1行データを書き込むには、

with open('sample.txt', 'w') as file:
  file.write('Hello, World!')

のように記述します。

複数行書き込むには、

lines = ['First\n', 'Second\n', 'Third\n']
with open('sample.txt', 'w') as file:
  file.writelines(lines)

のように記述します。

file = open('example.txt', 'r')
# ファイル操作
file.close()

のように記述することもできます。

「with」を利用すると「close」は自動で実行されます。

標準ライブラリ

Pythonでは便利なライブラリがあらかじめ用意されています。

Pythonの標準ライブラリは、Pythonに組み込まれているモジュールやパッケージの集合で、追加のインストールを必要とせずに利用できます。

以下に、代表的な標準ライブラリのモジュールについて詳しく説明します。

sys

Pythonインタープリタとの対話を可能にします。

コマンドライン引数、実行時の環境、終了コードなどを操作できます。

例えば、

import sys
print(sys.argv)

のように記述すると、「コマンドライン引数」を取得できます。

os

オペレーティングシステムとのインターフェースを提供します。

ファイルやディレクトリの操作、環境変数の取得・設定などが可能です。

例えば、

import os
print(os.getcwd())

のように記述すると「カレントディレクトリ」のパスを出力することができます。

datetime

日付と時刻を操作するためのモジュールです。

日時の取得、操作、フォーマットなどができます。

例えば、

from datetime import datetime
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))

のように記述すると「Python実行時の日時」を出力することができます。

json

JSONデータの読み書きをサポートします。

Pythonのデータ構造をJSON形式に変換したり、その逆変換を行うことができます。

例えば、

import json
data = {'name': 'Taro', 'age': 38}
json_str = json.dumps(data)  # PythonオブジェクトをJSON文字列に変換
data_back = json.loads(json_str)  # JSON文字列をPythonオブジェクトに変換

のように「dumps」と「loads」によって「Pythonオブジェクト」と「JSON文字列」を相互に変換することができます。

csv

CSVファイルの読み書きを行うためのモジュールです。

例えば、

import csv

with open('data.csv', mode='r', newline='') as file:
  reader = csv.reader(file)
  for row in reader:
    print(row)

のように記述すると、「CSVファイル」の内容を読み取り出力することができます。

import csv

with open('output.csv', mode='w', newline='') as file:
  writer = csv.writer(file)
  writer.writerow(['Rina', 32])
  writer.writerow(['Akihito', 23])

のように記述すると、「CSVファイル」へデータを書き込むことができます。

math

数学関数を提供するモジュールです。

三角関数、対数、累乗などの関数があります。

例えば、

import math
print(math.sqrt(16))  # 平方根
print(math.pi)        # 円周率

のように記述すると「平方根」や「円周率」を求めることができます。

statistics

基本的な統計関数を提供します。

平均値、中央値、標準偏差などを計算できます。

例えば、

import statistics
data = [1, 2, 3, 4, 5]
print(statistics.mean(data))  # 平均
print(statistics.median(data))  # 中央値

のように記述すると「平均値」や「中央値」を求めることができます。

urllib

URLを扱うためのモジュールです。

データの取得、パラメータのエンコード、URLの解析などができます。

例えば、

from urllib import request
response = request.urlopen('https://www.pgls-kl.com/')
html = response.read().decode('utf-8')
print(html)

のように記述すると、指定したURLの「HTMLコード」を出力することができます。

非同期処理

Pythonの「非同期処理」は、I/O操作やその他の時間のかかる処理を効率的に扱うための方法です。

特に、ネットワーク通信、ファイルI/O、データベースアクセスなど、待機時間が発生する操作に対して有効です。

Pythonでは、非同期処理を実現するために「asyncioモジュール」をインポートする必要があります。

例えば、プログラムを、

import asyncio

async def task1():
  print('Task 1 started')
  await asyncio.sleep(2)
  print('Task 1 completed')
		
async def task2():
  print('Task 2 started')
  await asyncio.sleep(1)
  print('Task 2 completed')
				
async def main():
  await asyncio.gather(task1(), task2())
						
asyncio.run(main())

のように作成すると、実行結果は、

Task 1 started
Task 2 started
Task 2 completed
Task 1 completed

のようになります。

非同期実行する関数の前に「async」キーワードを追加するとその関数は「非同期処理」の対象となります。

非同期関数内で非同期関数の関数の呼び出し時に「await」キーワードを追加することで、その関数は非同期で処理が実行されます。

asyncio.run

非同期プログラムの実行するための関数です。

引数には「非同期実行する処理（関数）」を渡します。

asyncio.sleep

この関数は「指定した時間」だけプログラムの実行を一時停止しますが、処理は非同期で実行されます。

ビッグデータ解析・統計解析・機械学習

「Python」は、「ビッグデータ解析・統計解析・機械学習」の分野でよく利用されているプログラム言語です。

内容自体には深く触れませんが、どのようなソフトウェア・ライブラリなどがあるのかをご紹介していきたいと思います。

ビッグデータ解析

「ビッグデータ解析」とは、非常に大規模で多様なデータセット（ビッグデータ）を収集、処理、解析して、有用な情報や洞察を得るプロセスを指します。

ビッグデータは、従来のデータベース管理ツールやデータ処理アプリケーションでは扱いきれない量、速度、種類のデータを含むため、特別な技術とツールが必要です。

ビッグデータは一般的に次の3つの特徴を持っています。

Volume（量）: データの量が非常に大きい。例えば、ソーシャルメディアの投稿、センサーデータ、ログファイル、動画など。
Velocity（速度）: データが非常に高速に生成される。リアルタイムまたはほぼリアルタイムで処理が必要な場合も多い。
Variety（多様性）: データの形式や種類が多様。構造化データ（データベースのテーブルなど）、半構造化データ（JSONやXMLファイルなど）、非構造化データ（テキスト、画像、音声など）を含む。

ビッグデータ解析の目的は、以下のような有用な洞察を得ることです。

パターンの発見: 大量のデータからトレンドやパターンを見つける。例えば、顧客行動の傾向や機械の故障パターン。
意思決定の支援: データに基づいた意思決定を行う。例えば、マーケティング戦略の最適化や業務プロセスの改善。
予測分析: 過去のデータを基に将来の出来事や行動を予測する。例えば、需要予測やリスク評価。

Pythonが利用できる「ビッグデータ解析」の仕組みとして下記のようなものがあります。

Pandas: データ操作と解析のためのライブラリ。データフレームの操作が簡単に行え、データのクリーニング、フィルタリング、集計、変換などが可能。
Dask: 大規模なデータを効率的に処理するための並列計算ライブラリ。Pandasと似たインターフェースを持ち、分散環境での処理をサポート。
Apache Spark: 大規模データ処理のためのフレームワーク。PySparkというPython APIを提供し、分散データ処理が可能。

統計解析

「統計解析」とは、データを収集、整理、分析し、そこから有意な情報を導き出すための一連の方法論や技術を指します。

統計解析は、データの傾向やパターンを把握し、過去のデータを基に将来の出来事や行動を予測するために使用されます。

統計解析の主な目的には以下のようなものがあります。

データの要約: データをわかりやすく整理し、その中心的傾向や分散を把握する。平均値や中央値、標準偏差などの記述統計を用いる。
関係の発見: 異なる変数間の関係性を明らかにする。相関分析や回帰分析を使用して、変数間の関連性や因果関係を調べる。
推測と予測: サンプルデータを基に、母集団全体について推測を行う。仮説検定や信頼区間を用いて統計的推測を行う。また、過去のデータを基に将来の出来事や行動を予測する。
データの比較: 複数のグループ間での差異を検証する。例えば、異なる治療法の効果を比較するためのt検定や分散分析（ANOVA）を使用する。

Pythonが利用できる「統計解析」の仕組みとして下記のようなものがあります。

SciPy: 科学計算と技術計算のためのライブラリ。多くの統計関数や最適化手法、信号処理機能を提供。数値積分、最適化、信号処理、統計分布などが豊富。
Statsmodels: 統計モデリングのためのライブラリ。回帰分析、分散分析、時系列分析などが可能。
Seaborn: Matplotlibをベースにしたデータ可視化ライブラリ。統計的グラフを簡単に作成できる。

機械学習

「機械学習」とは、コンピュータがデータを解析し、そのデータからパターンやルールを学習して、予測や分類などのタスクを自動的に行う技術です。

機械学習は人工知能（AI）の一分野であり、特にデータ駆動型のアルゴリズムを使用してコンピュータが学習する能力を持たせることに重点を置いています。

「機械学習の種類」には下記のようなものがあります。

教師あり学習（Supervised Learning）: 入力データとそれに対応する出力ラベルがペアになったデータを使用してモデルを学習する。線形回帰、ロジスティック回帰、サポートベクターマシン（SVM）、k近傍法（k-NN）、決定木、ランダムフォレスト、ニューラルネットワークなどがある。
教師なし学習（Unsupervised Learning）: 出力ラベルがないデータを使用して、データの構造やパターンを学習する。k-meansクラスタリング、主成分分析（PCA）、自己組織化マップ（SOM）、t-SNEなどがある。
強化学習（Reinforcement Learning）: エージェントが環境と相互作用し、報酬を最大化するために行動を学習する。Q学習、深層強化学習（DQN、DDPG）、政策勾配法などがある。

Pythonが利用できる「機械学習」の仕組みとして下記のようなものがあります。

Scikit-learn: 多くの機械学習アルゴリズムを簡単に利用できるライブラリ。教育目的やプロトタイピングに適している。
TensorFlow: Googleが開発したディープラーニングライブラリ。大規模なニューラルネットワークの構築と訓練が可能。
PyTorch: 不正取引の検出、機器の故障予測など。
Keras: 高水準のニューラルネットワークAPI。TensorFlowやTheano、CNTKの上に構築されており、使いやすさが特徴。

HOMEへ

初心者のための「Python」入門

「Python」の実行環境

公式サイト

Anaconda

Google Colab

Docker

目次

エントリーポイント

「if __name__ == "__main__"」の役割

「__name__」変数

main() 関数

インデントの役割

コードブロックの定義

インデントの重要性

変数

命名規則

変数の宣言と代入

動的型付け

一括代入

スコープ

データ型

整数型（int）

浮動小数点型(float)

複素数型（complex）

文字列型(string)

bool型

None型

演算子

算術演算子

加算演算子

減算演算子

乗算演算子

除算演算子

剰余演算子

べき乗演算子

整数除算演算子

比較演算子

等しい

等しくない

大きい

小さい

大きいかまたは等しい

小さいかまたは等しい

論理演算子

and

or

not

ビット演算子

&（AND）

| (OR)

^(XOR)

<<

>>

代入演算子（複合代入演算子）

+=

-=

*=

/=

%=

**=

//=

特殊演算子

in

not in

アイデンティティ演算子

is

is not

リスト（list）

append

extend

insert

remove

pop

clear

index

count

sort

reverse

copy

タプル

「if name == "main"」の役割

「name」変数