Python初心者のための基礎入門

# はじめに
プログラミングをこれから始める方、Pythonをこれから始める方に向けて簡単に学習をできるように記事を作ってみました。
この記事1つで、基礎的なPythonの記載方法を学べるようにしているので長い記事となっています。
目次から学習したいところをクリックして、対象の場所まで飛んで学習してみてください。

また、誤りのある点や感想などありましたら是非コメントの方よろしくお願いいたします！
Qiitaへの投稿も初めてのためアドバイスの方もよろしくお願いいたします！

# 目次
**[1.Pythonとは](#pythonとは)**
**[2.環境構築](#環境構築)**
**・[2-1Pythonのインストール](#2-1pythonのインストール)**
**・[2-2環境変数の設定](#2-2環境変数の設定)**
**・[2-3VisualStudioCodeのインストール](#2-3visualstudiocodeのインストール)**
**・[2-4拡張機能の追加](#2-4拡張機能の追加)**
**[3.Pythonファイルの作り方](#pythonファイルの作り方)**
**[4.出力方法と実行方法](#出力方法と実行方法)**
**[5.変数](#変数)**
**[6.演算子](#演算子)**
**・[6-1代数演算子](#6-1代数演算子)**
**・[6-2代入演算子](#6-2代入演算子)**
**・[6-3比較演算子](#6-3比較演算子)**
**・[6-4論理演算子](#6-4論理演算子)**
**・[6-5文字列演算子](#6-5文字列演算子)**
**・[6-6複合代入演算子](#6-6複合代入演算子)**
**[7.コメント](#コメント)**
**[8.データ構造](#データ構造)**
**・[8-1リスト](#8-1リスト)**
**・[8-2リストのメソッド](#8-2リストのメソッド)**
**・[8-3タプル](#8-3タプル)**
**・[8-4タプルのメソッド](#8-4タプルのメソッド)**
**・[8-5辞書](#8-5辞書)**
**・[8-6辞書のメソッド](#8-6辞書のメソッド)**
**・[8-7集合](#8-7集合)**
**・[8-8集合のメソッド](#8-8集合のメソッド)**
**[9.制御フロー](#制御フロー)**
**・[9-1条件分岐](#9-1条件分岐)**
**・[9-2繰り返し処理](#9-2繰り返し処理)**
**・[9-3制御フローの中断とスキップ](#9-3制御フローの中断とスキップ)**
**[10.関数](#関数)**
**・[10-1組み込み関数](#10-1組み込み関数)**
**・[10-2関数の定義](#10-2関数の定義)**
**[11.モジュール](#モジュール)**
**・[11-1標準ライブラリ](#11-1標準ライブラリ)**
**・[11-2自作のモジュール](#11-2自作のモジュール)**
**・[11-3パッケージ](#11-3パッケージ)**
**[12.クラス](#クラス)**
**・[12-1コンストラクタとデストラクタ](#12-1コンストラクタとデストラクタ)**
**・[12-2クラスの引数](#12-2クラスの引数)**
**・[12-3継承](#12-3継承)**
**・[12-4オーバーライド](#12-4オーバーライド)**
**・[12-5抽象クラス](#12-5抽象クラス)**

# Pythonとは
Pythonとは、1991年にグイド・ヴァンロッサム氏が開発したプログラミング言語です。
Webアプリケーション開発やデータ分析などさまざまな分野に使える **<font color="blue">汎用性の高い言語</font>** として人気が高いです。
身近なサービスだと、YouTubeやInstagramなどでも使用されています。
他にもPythonには以下のようなメリット・デメリットが挙げられます。

|メリット|内容|
|---|---|
|**初心者でも<br>学習がしやすい**　|他のプログラミング言語と比較して、短い文でコーディングができるため初心でも勉強しやすい|
|**様々な場面で<br>使用できる**|PythonはWebアプリケーション開発やデータ分析、画像・音声認識等様々な場面で活用できます。|
|**ライブラリが<br>充実している**|Pythonは複数のモジュールを1つにまとめた **<font color="red">ライブラリ</font>** というものが充実しています。<br>例えば、高速な計算処理が可能なNumpyやデータの可視化を可能にするMatplotlibなどがあり、開発を効率的に進めることが可能になります。|

|デメリット|内容|
|---|---|
|**実行速度が遅い**|Pythonは1行ずつ読み込み都度実行する **<font color="red">インタプリタ言語</font>** です。<br>そのため、実行時に多くの処理が必要になり、実行速度が遅くなります。|
|**型のエラーが<br>起こりやすい**|Pythonは他の言語とは異なり、型の指定をせずに記載することができます。<br>プログラムで使用する型の変数や値は実行する際に決まるため、型に対してエラーが起こりやすくなります。|

# 環境構築
Pythonを自分のPCで使用できるように環境構築を行っていきます。
※この記事では以下の環境で環境構築を実施しています。
|種類|環境|
|---|---|
|OS|Windows 11 Pro|
|Python|Python 3.12|

### 2-1pythonのインストール
PythonをインストールするためにAnacondaのインストールから行います。
**<font color=red>Anaconda</font>** はPythonの開発に必要なライブラリをまとめたものです。
簡単にインストールができ、機械学習などに必要なライブラリも揃っているためおすすめです。

**～手順1～**
以下のリンクにアクセスします。

https://www.anaconda.com/download

**～手順2～**
Email Address：」の部分に自分のメールアドレスを入力し、「Submit >」ボタンを押下します。

**～手順3～**
自分の使用している端末のOSとシステムに合わせてインストールを行います。
 私の環境では、Windows11 Proを用いているため、Windowsの「64-Bit Graphical Installer (912.3M)」のリンクをクリックします。

※端末の情報は、Windowsの検索欄にて「システム」と検索し、表示することができます。

**～手順4～**
Anaconda3-2024.06-1-Windows-x86_64.exe」ファイルがPCのダウンロードフォルダに入るため、exeファイルをダブルクリックします。

**～手順5～**
Anacondaのインストール用のポップアップが開いたら、基本的に「Next」、「I Agree」、「Install」を押していき、進めていきます。

以下の画面が表示された際は、Anacondaを入れるフォルダを「Browse」から選択し、「Next」を押下します。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/44bd4eb0-208b-0787-8ae6-1cf166d34bc3.png)
**<font color=blue>※こちらの参照先のパスは後程使用するため、コピーしてメモなどに残しておくことをお勧めします。</font>**

**～手順6～**
「FInish」を押下して、インストールが完了したら完了です。

### 2-2環境変数の設定
次にPythonを使用できるように環境変数の設定を行っていきます。

**～手順1～**
windowsの検索欄にて「システム環境変数」と入力し、「システム環境変数の編集」を開きます。

**～手順2～**
「システムのプロパティ」が開いたら、右下の「環境変数」を開きます。

**～手順3～**
以下の画面が表示されたら、「システム環境変数(S)」の「Path」を選択し、「編集」を押下します。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/a4a58afc-509a-3be0-4e1e-fc851a49b763.png)

**1.Pythonのインストールの手順5** で参照したフォルダに「python.exe」ファイルが入っていることを確認します。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/8ad53b79-1415-16da-420d-5b819c616748.png)

**～手順4～**
手順3が確認出来たら、環境変数の編集へ戻り、「新規」を押下後手順3のパスをコピー＆ペーストし、「OK」を押下します。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/c9d43802-eb00-33de-a67f-15c5eaf9b7dd.png)

**～手順5～**
windowsの検索欄にて「cmd」と、コマンドプロンプトを開きます。
コマンドプロンプトにて「Python」と入力し、Pythonがインストールされていることを確認します。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/3d6c0d91-9aae-17ac-8c8a-667b31c53f65.png)

上記でPythonが使用できることを確認できました。

### 2-3visualstudiocodeのインストール
ここでは、プログラムを記載するためのエディタをインストールしてきます。
今回はVisualStudioCodeを使用していきます。

**～手順1～**
以下のリンクにアクセスし、自分のOSにあったものをインストールしていきます。

https://code.visualstudio.com/download

**～手順2～**
「VSCodeUserSetup-x64-1.94.0.exe」ファイルがPCのダウンロードフォルダに入るため、exeファイルをダブルクリックします。

**～手順3～**
VisualStudioCodeのインストールのポップアップが表示されたら「同意する」を選択し、「次へ」を押下してインストールを進めていきます。

以下の画面が表示されたら、インストールするフォルダを「参照」から選択し、「次へ」を押下します。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/82dac4f5-e59a-fb0c-756d-53f105045560.png)

「次へ」で進めていき、以下の画面が表示されたら、今回はデスクトップ上にアイコンを追加するを選択することをお勧めします。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/40613562-9f11-c762-8a40-f08e0c785f23.png)

「次へ」で進めていき、「インストール」を押下して、インストール出来たら完了です。

### 2-4拡張機能の追加
ここではVisualStudioCodeに拡張機能の追加を行い、VisualStudioでPythonを使えるようにしていきます。
(画面の色合いなどが初期と異なります。申し訳ございません)

**～手順1～**
Vscodeの左下のサイドバーにて「拡張機能」を選択もしくは(ctrl + )
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/59a35be6-afbe-e179-7413-293ba3e651da.png)

**～手順2～**
検索欄で、「Python」と検索し、「インストール」を押下し、下記のような画面になれば完了です。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/af0e8cd6-c02b-0aa2-383d-0b216c56ca1e.png)

上記と同じ手順で **「Japanese Language Pack for Visual Studio Code」** もインストールしてみてください。
**「Japanese Language Pack for Visual Studio Code」** をインストールすることで、VScodeを日本語にできます。

# Pythonファイルの作り方
**～手順1～**
デスクトップなどにフォルダを作成
今回は「Python」というフォルダを作成します。

**～手順2～**
VScodeにて手順1で作成したフォルダを開いていきます。

VScodeでフォルダ開くには画像のように「ファイル」→「フォルダを開く」で開くことができます。
 ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/864f4e86-181e-8c26-fb3b-dd6e9d37aa0b.png)

**～手順3～**
フォルダを開けたらエクスプローラーの部分で右クリックし、「新しいファイル」を選択し、「hello.py」と名前を付けEnterを押してください。

上記の手順でPythonファイルを作成することができます。
ファイル名に.pyという拡張子をつけることで、Pythonファイルを作成することができます。

# 出力方法と実行方法
[Pythonファイルの作り方](#pythonファイルの作り方)で作成したファイルを使って、Pythonで「Hello World!」と **<font color=red>ターミナル</font>**(コンピュータのコマンドを直接入力して操作するためのインターフェース)へ出力させてみます。

Pythonで出力をするには、以下のように書きます。

**<font color=green>Print(出力したい内容)</font>**

実際にコードを記載すると以下のようになっています。
```
print('Hello World!')
```
表示したい文字列は、'(シングルクォート)で囲んでprint()に入れることで、表示することができます。

では、こちらのコードを実行してみます。

1.対象のファイルで右クリック
2.「Python」の実行を選択
3.「ターミナルでPythonファイルを実行する」を選択
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/321816ae-d7b7-82fb-6c91-07db624dd75a.png)
4.ターミナルが立ち上がり、実行される。

上記の手順で実行します。
実行結果は以下のようになり、Hello World!が出力されていることがわかります。

::: note info
Hello World!
:::

※今後は黒の背景がコード、緑の背景が実行結果としていきます。

また、Pythonのルール上<font color=blue>
**文字列が短い場合：'(シングルクォート)**<br>**文字列が長い場合："(ダブルクォーテーション)**
</font>で囲むことが一般とされています。

先ほどは文字列の表示をしましたが、値の場合は'や"で囲む必要がありません。
```py
print(100)
```
::: note info
100
:::

# 変数
**<font color=red>変数</font>** とは値や文字列を格納することができる箱みたいなものです。

**～変数の記載方法～**
例えば10をxという変数にいれ、xに入っているか確認してみます。
```py
x = 10

print(x)
```
::: note info
10
:::
文字列の場合も同様です。
Tanakaをnameという変数に入れたいと思います。
```py
name = 'Tanaka'

print(name)
```
::: note info
Tanaka
:::

**～変数のデータ型～**
変数にはデータの種類や性質があり、**<font color=red>データ型</font>** といいます。
Pythonでは変数のデータ型の宣言が必要ありません。なぜかというと、Pythonは実行した際に変数の型が決まるためです。

変数が知りたいときのために、確認する方法があります。
記載方法は以下になります。
**<font color=green>type(変数名)</font>**
実際にコードに書いてみます。
```py
x = 10
name = 'Tanaka'

print(type(x))
print(type(name))
```
::: note info
\<class 'int'>
\<class 'str'>
:::
実行結果を見ると、値100を入れた変数xはint(整数)で、文字列Tanakaを入れた変数nameはstr(文字列)と返ってきています。

Pythonの変数の型は主に以下のものがあります。

|型名|意味|
|---|---|
|int|整数|
|float|浮動小数点|
|str|文字列|
|bool|真偽値|
|list|リスト・配列|
|tuple|タプル|
|dict|辞書|
|set|集合|

Pythonはコードを記載する際にデータ型が見えないため、データ型の違いでエラーとなるケースがあるためコードの記載方法を間違えていないか注意しましょう。

# 演算子
2つ以上の変数や値を組み合わせて計算や制御を行うことを **<font color=red>演算</font>** といいます。プログラミングでは変数や値を **<font color=red>演算子</font>** という記号で囲むことで演算を行うことができます。
### 6-1代数演算子
**<font color=red>代数演算子</font>** は、数値の演算をする際に使用する演算子です。
代数演算子は以下のものがあります。

|演算子|意味|記載方法|
|---|---|---|
|+|足し算|a + b|
|-|引き算|a - b|
|*|掛け算|a * b|
|/|割り算|a / b|
|%|剰余|a % b|
|**|累乗|a ** b|

上記の演算子を用いて、コードを記載してみます。
**足し算**
```py
addition = 1 + 2
print(addition)
```
::: note info
3

:::
**引き算**
```py
subtraction = 2 - 1
print(subtraction)
```
::: note info
1
:::
**掛け算**
```py
multiplication = 2 * 3
print(multiplication)
```
::: note info
6
:::
**割り算**
```py
division = 4 / 2
print(division)
```
::: note info
2.0
:::
**剰余**
```py
remainder = 5 % 2
print(remainder)
```
::: note info
1
:::
**累乗**
```py
exponentiation = 2 ** 3
print(exponentiation)
```
::: note info
8
:::

### 6-2代入演算子
代入演算子はa = bのように=を使用し、左に右の値を代入する演算子です。
実際にコード見ると以下のようになります。
```py
a = 10
b = a

print(a)
```
::: note info
10
:::

### 6-3比較演算子
**<font color=red>比較演算子</font>** は、2つの値を比較するときに使用する演算子です。
比較演算子の結果は正しい場合は「True」、正しくない場合は「False」と表示されます。
比較演算子をまとめると以下のものがあります。

|演算子|記載方法|意味|
|---|---|---|
|==|a == b|aとbは等しい|
|!=|a != b|aとbは等しくない|
|<|a < b|aはbより小さい|
|>|a > b|aはbより大きい|
|<=|a <= b|aはb以下|
|>=|a >= b|aはb以上|
|in|a in b|aにbが含まれる|
|not in|a not in b|aにbが含まれない|

上記の演算子を用いて、コードを記載してみます。
**==、!=**
```py
a = 10
b = 10
c = 20
print(a == b)
print(a != b)
```
::: note info
True
False
:::
**<、>、<=、>=**
```py
a = 10
c = 20
print(a < c)
print(a > c)
print(a <= c)
print(a >= c)
```
::: note info
True
False
True
False
:::
**in、not in**
```py
d = [1,2,3,4,5]
e = 1

print(e in d)
print(e not in d)
```
::: note info
True
False
:::
上記コードにて[]を使用しています。[]に入れているものを **<font color = red>リスト</font>** をといいます。
リストは複数の値を格納できるデータ型です。
上記のコードでいうと、1,2,3,4,5が入っているリストdの中に変数eに入れている1が入っているか確認するという意味になります。
リストについては **[8-1リスト](#8-1リスト)** にて詳しく説明します。

### 6-4論理演算子
<font color=green>**論理演算子**</font> は、真偽値(True or False)に対して演算を行うことができる演算子です。

|演算子|記載方法|意味|
|---|---|---|
|and|a and b|aかつb（aとbが真の場合に真）|
|or|a or b|aまたはb(aかbのどちらかが真の場合に真)|

**and**
```py
a = 10
b = 50

print((a < 25 ) and (b > 25))
print((a < 5 ) and (b > 25))
```
::: note info
True
False
:::
**or**
```py
a = 10
b = 50

print((a < 25 ) or (b > 100))
print((a < 5 ) or (b > 100))
```
::: note info
True
False
:::

### 6-5文字列演算子
**<font color=green>文字列演算子</font>** は、文字列を連結したり、繰り返すための演算子です。
文字列演算子をまとめると以下のものがあります。

|演算子|記載方法|意味|
|---|---|---|
|+|文字列 + 文字列|文字列を連結|
|*|文字列 * 値|文字列を繰り返す|

上記の表を基にコードを記載してみます。

**文字列を連結**
```py
family = 'Tanaka'
name = 'Taro'

print(family + name)
```
::: note info
TanakaTaro
:::
**文字列を繰り返す**
```py
print('Hello' * 3)
```
::: note info
HelloHelloHello
:::
文字列演算子を使用していると、改行したい、文字列と値を繋げたいと思うことがあると思います。
その時の記載方法についても説明します。

**～文字列を改行したい場合～** 
改行をしたい場合は改行をしたい位置で **<font color=green>「\n」</font>** を入れることで改行をすることが可能になります。
```py
print('お疲れ様です。\n' + '田中です。')
```
::: note info
お疲れ様です。
田中です。
:::

**～文字列と値を繋げたい場合～**
文字列と値を繋げて出力しようと思い、文字列演算子を使って出力しようとしてみます。
```py
print(100 + '円です')
```
:::note alert
TypeError: unsupported operand type(s) for +: 'int' and 'str'
:::

上記のように「整数型（int）と文字列（str）を + することはできません」とエラーが出てしまいます。
これはルール上、int型とstr型など別の型が混在している場合に、出力できないようになっているためです。
これを解決するには以下の方法で記載します。
**<font color = green>str(値) + 文字列</font>**
実際にコードを記載すると以下のようになります。
```py
print(str(100) + '円です')
```

### 6-6複合代入演算子
**<font color = red>複合代入演算子</font>** とはaに1を足してaに代入したい際に普通に「a = a + 1」と書かずに代入演算子を用いて簡単に書くことができる演算子です。
複合演算子をまとめると以下のものがあります。

|演算子|記載方法|意味|
|---|---|---|
|+=|a += 値|aに値を足してaに代入|
|-=|a -= 値|aから値を引いてaに代入|
|*=|a += 値|aに値をかけてaに代入|
|/=|a /= 値|aから値を割ってaに代入|

コードにすると以下のようになります。
```py
a = 100
a += 1
print('a += 1の結果')
print(a)

b = 100
b -= 1
print('b -= 1の結果')
print(b)

c = 4
c *= 2
print('c *= 2の結果')
print(c)

d = 4
d /= 2
print('d /= 2の結果')
print(d)
```
::: note info
a += 1の結果
101
b -= 1の結果
99
c *= 2の結果
8
d /= 2の結果
2.0
:::

他の言語(CやJavaなど)では、インクリメント演算子(++)、デクリメント演算子(--)が使用されますが、Pythonでは明示的でシンプルな記載方法が推奨されており、演算子の挙動に一貫性を持たせるためにインクリメント演算子(++)、デクリメント演算子(--)は使用されていません。

# コメント
コードを書いている際にソース上にコメントを残したいと考える場合があると思います。
ソース上にコメントを残すには以下のような方法でコメントを残します。
**①短いコメントの場合**
1文などでコメントを残す場合は **<font color = green>#</font>** を用いることでコメントを残すことが一般です。
```py
# コメント
```
**②複数行コメントの場合**
複数行のコメントを残す場合は<font color = green>"(ダブルクォーテーション)3つ</font>で上下を囲むことでコメントを残すことができます。
```py
"""
コメント
コメント
コメント
"""
```
# データ構造
**<font color=red>データ構造</font>** とは複数の値をひとまとまりとして使う方法です。
データ構造には、「リスト、タプル、セット、ディクショナリ」があります。
これらについてここではまとめていきます。

### 8-1リスト
**<font color=red>リスト</font>** は複数の値をまとめるデータ型です。
リストなどでよく使用する言葉に「要素」と「インデックス」というものがあります。
**<font color=red>要素</font>** とは、リストに格納されている値を指し、**<font color=red>インデックス</font>** とは各要素に振られている番号で左から順に0,1,2,...と番号が振られています。

では、リストの記載方法についてみていきます。
リストは **<font color=green>[要素1,要素2,要素3,....]</font>** と記載することで表すことができます。
実際にコードにしてみると以下のようになります。
```py
name_list = ['Yamda','Tanka','Suzuki']

print(name_list)
```
::: note info
['Yamda', 'Tanka', 'Suzuki']
:::
上記のリストから特定の値を指定して出力するには以下のように記載します。
**<font color = green>リスト名[インデックスの値]</font>**
実際にコードを記載すると以下のようになります。
```py
name_list = ['Yamda','Tanka','Suzuki']

print(name_list[0])
```
::: note info
Yamda
:::
**～後ろから指定したい場合～**
後ろからインデックスの値を指定する際は、後ろから **<font color=green>-1</font>** とすることで指定することが可能です。

```py
number_list = [1,2,3,4,5,6,7,8,9,10]

print(number_list[-1])
```
::: note info
10
:::
**～スライス(範囲指定)したい場合～**
**<font color=red>スライス</font>** (範囲指定)する際は **<font color=green>リスト名[開始位置：終了位置-1]</font>** と記載することで可能になります。
```py
number_list = [1,2,3,4,5,6,7,8,9,10]

print(number_list[0:5])
```
::: note info
[1, 2, 3, 4, 5]
:::
Pythonでは、**<font color=red>半開区間</font>** という方式が使用されています。
これは、開始位置は含むが終了位置は含まないという仕様です。
この方式を用いることで、計算の簡潔さと一貫性を保つことができるようになります。
例えば、以下のように開始位置をstart、終了位置をendとした場合、end - startスライスしたでリストの長さを確認することができます。
```py
start = 2
end = 5

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

print(list[start:end])
print('リストの長さ' + str(5 -2))
```
::: note info
[3, 4, 5]
リストの長さ3
:::

**～2つ目ごとに飛ばしたい場合～**
```py
number_list = [1,2,3,4,5,6,7,8,9,10]

print(number_list[::2])
```
::: note info
[1, 3, 5, 7, 9]
:::
**～リストの値を置き換えたい場合～**
リストの値を置き換えたい場合は、リストを指定して、別の値や文字列を代入することで、置き換えることができます。
```py
name_list = ['Yamda','Tanka','Suzuki']

print('置き換え前')
print(name_list)

name_list[0] = 'Yoshida'
print('置き換え後')
print(name_list)
```
::: note info
置き換え前
['Yamda', 'Tanka', 'Suzuki']
置き換え後
['Yoshida', 'Tanka', 'Suzuki']
:::
**～複数のリストを合わせたい場合～**
複数のリストを合わせたい場合は+で繋げることで、合わせることができます。
```py
class_list_A = ['Yamada','Yoshida']
class_list_B = ['Tanaka','Takada']

combined_class_list = class_list_A + class_list_B

print(combined_class_list)
```
::: note info
['Yamada', 'Yoshida', 'Tanaka', 'Takada']
:::

### 8-2リストのメソッド
Pythonには **<font color=red>メソッド</font>** というデータ型ごとに用意された機能があります。
ここではリストで使用できるメソッドを紹介していきます。
リストで使用できるメソッドは以下のものがあります。

|メソッド名|使用用途|記載方法|
|---|---|---|
|append|リストに要素を追加する|リスト.append(要素)|
|clear|リストからすべての要素を取り除く|リスト.clear()|
|copy|リストのコピーを返す|リスト.copy()|
|count|指定した要素の数を返す|リスト.count(要素)|
|extend|リストに **<font color=red>イテラブル</font>** (リスト、<br>タプル、セット、辞書など)を結合する|リスト.extend(イテラブル)|
|index|指定した要素の場所を返す|リスト.index(要素)|
|insert|指定した位置に要素を挿入する|リスト.insert(挿入する場所,挿入する要素)|
|pop|リストから指定した要素を取り出す|リスト.pop(要素)|
|remove|リストから指定した値を削除する|リスト.remove(要素)|
|reverse|リスト内の要素の順番を逆にする|リスト.revers()|
|sort|リストの要素を昇順または降順にする|昇順：リスト.sort()<br>降順：<br>リスト.sort(reverse=True)|

上記の一部を使ってみます。
**append**
```py
list = [1,2,3,4,5]

list.append(6)

print(list)
```
::: note info
[1, 2, 3, 4, 5, 6]
:::
**clear**
```py
list = [1,2,3,4,5]

list.clear()

print(list)
```
::: note info
[]
:::
**copy**
```py
listA = [1,2,3,4,5]

listB = listA.copy()

print(listB)
```
::: note info
[1, 2, 3, 4, 5]
:::
copyメソッドのメリットとしては、コピー前のリストとコピー後のリストで別のものとして扱えるということです。
copyメソッドを使用せずに「=」で別の変数に代入しても問題ないのではと思えますが、実際にその方法を行い、代入した変数のリストの中を変えてみると代入前のリストも中身が変わってしまいます。
実際にコードで確認してみます。
```py
listA = [1,2,3,4,5]
listB = listA

listB[0] = 10

print(listA)
print(listB)
```
::: note info
[10, 2, 3, 4, 5]
[10, 2, 3, 4, 5]
:::
上記のように代入前のリストの0番目の値も10に代わってします。
これはPythonの仕様上、=で複製してしまうと値ではなく参照自体をコピーしてしまうためこのような状態になってしまいます。これを **<font color=red>浅いコピー</font>** といいます。
浅いコピーにならないためには、新しいリストを作成して、コピーしたい要素をコピーする必要があります。これを **<font color=red>深いコピー</font>** といいます。
コードにすると以下のようになります。
```py
listA = [1,2,3,4,5]
listB = listA.copy()

listB[0] = 10

print(listA)
print(listB)
```
::: note info
[1, 2, 3, 4, 5]
[10, 2, 3, 4, 5]
:::

### 8-3タプル
**<font color=red>タプル</font>** はリストと同様に複数の値をまとめるデータ型です。
タプルの特徴としては、**<font color=blue>要素の追加、要素の削除ができない</font>** ことです。

タプルの記載方法についてみていきます。
タプルは **<font color=green>(要素1,要素2,要素3,....)</font>** と記載することで表すことができます。
実際にコードにしてみると以下のようになります。
```py
tuple = (1,2,3,4,5)

print(tuple)
```
::: note info
(1, 2, 3, 4, 5)
:::
また、タプルは()で囲まずに記載することも可能です。
```py
tuple = 1,2,3,4,5

print(tuple)
```
::: note info
(1, 2, 3, 4, 5)
:::
**～要素の指定～**
タプルもリストと同様に要素のインデックスを指定することで、出力などを行うことができます。
```py
tuple = (1,2,3,4,5)

print(tuple[0])
print(tuple[0:2])
```
::: note info
1
(1, 2)
:::
**～タプルに要素を追加したい場合～**
タプルは要素の追加を行えないと紹介しましたが、タプル同士を合わせることで、タプルに要素を追加することができます。
```py
tuple1 = (1,2,3,4,5)
tuple2 = (6,7,8,9,10)

tuple_coalescence = tuple1 + tuple2

print(tuple_coalescence)
```
::: note info
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
:::
### 8-4タプルのメソッド
タプルは変更・追加・削除ができないため、あまりメソッドが用意されていません。
タプルで使用できるメソッドは以下のものがあります。
|メソッド名|使用用途|記載方法|
|---|---|---|
|index|指定した要素の場所を返す|タプル.index(要素)|
|count|指定した要素の数を返す|タプル.count(要素)|

上記を使ってみます。
**index**
```py
tuple = ('A','B','C','D','E','F','G')

tuple1 = tuple.index('D')

print(tuple1)
```
::: note info
3
:::
**count**
```py
tuple = ('A','B','C','A','B','A','A')

tuple2 = tuple.count('A')

print(tuple2)
```
::: note info
4
:::
### 8-5辞書
**<font color=red>辞書(ディクショナリ)</font>** はリストやタプル同様に複数の値をまとめるデータ型です。
ディクショナリは、リストやタプルと異なり、**<font color=red>キー</font>** と **<font color=red>バリュー（値）</font>** のペアを格納するデータ構造となっており、キー＝バリュー(値)という意味を持っています。
記載方法としては以下のようになっています。
**<font color=green>{キー1:バリュー1,キー2:バリュー2,キー3:バリュー3,...}</font>** 
実際にコードにすると以下のようになります。
```py
dictionary = {'key1':1,'key2':2,'key3':3,'key4':4}

print(dictionary)
```
::: note info
{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4}
:::
**～要素の指定～**
辞書型の指定方法は、**<font color=green>ディクショナリ名[キー名]</font>** とすることで、出力することができます。
```py
dictionary = {'key1':1,'key2':2,'key3':3,'key4':4}

print(dictionary['key1'])
```
::: note info
1
:::
**～要素の変更～**
辞書型もリスト同様に要素の変更をすることが可能です。
```py
dictionary = {'key1':1,'key2':2,'key3':3,'key4':4}

dictionary['key1'] = 10

print(dictionary)
```
::: note info
{'key1': 10, 'key2': 2, 'key3': 3, 'key4': 4}
:::
### 8-6辞書のメソッド
辞書型で使用できるメソッドは以下のものがあります。
|メソッド名|使用用途|記載方法|
|---|---|---|
|keys|辞書のキーのリストを返す|ディクショナリ.keys()|
|values|辞書の値のリストを返す|ディクショナリ.values()|
|items|辞書のキーと値のペアをタプルで含む<br>リストで返す|ディクショナリ.items()|
|get|指定したキーに対応する値を取得する|ディクショナリ.get(キー)|
|pop|指定したキーと対応する値を削除し、<br>その値を返す|ディクショナリ.pop(キー)|
|popitem|辞書から指定したキーとバリューのペアを<br>削除し、そのペアを返す。|ディクショナリ.pop(キー)|
|clear|辞書のすべての要素を削除する|ディクショナリ.clear()|
|update|指定したキーがあれば追加、なければ<br>値を上書きする|ディクショナリ.update(キー)|
|copy|辞書の深いコピーを作成する|ディクショナリ.copy()|
|fromkeys|初期化された辞書（値が全て同一の辞書）<br>を作成する|ディクショナリ<br>.fromkeys(キー,バリュー)|
|setdefault|指定したキーがある場合はその値を返す。ない場合は新しいキーとデフォルト値を追加する。|ディクショナリ.setdefault(キー,バリュー)|

**keys**
```py
dictionary = {'a': 1, 'b': 2, 'c': 3}

print(dictionary.keys())
```
::: note info
dict_keys(['a', 'b', 'c'])
:::
**values**
```py
dictionary = {'a': 1, 'b': 2, 'c': 3}

print(dictionary.values())
```
::: note info
dict_values([1, 2, 3])
:::
**pop**
```py
dictionary = {'a': 1, 'b': 2, 'c': 3, 'd':4, 'e':5}

print(dictionary.pop('c'))

print(dictionary)
```
::: note info
3
{'a': 1, 'b': 2, 'd': 4, 'e': 5}
:::
**fromkeys**
```py
keys = ['a', 'b', 'c']
default_value = 0

dictionary = dict.fromkeys(keys, default_value)

print(dictionary)
```
::: note info
{'a': 0, 'b': 0, 'c': 0}
:::
**setdefault**
```py
dictionary = {'a': 1, 'b': 2}
value = dictionary.setdefault('c', 3)

print(value)  
print(dictionary)
```
::: note info
{'a': 0, 'b': 0, 'c': 0}
:::
### 8-7集合
**<font color=red>集合型(set型)</font>** はリストやタプル、辞書型同様に複数の値をまとめるデータ型です。特に集合を扱うための型になります。
集合型は以下のように記載します。
**<font color=green>{要素1,要素2,要素3,...}</font>**
```py
set = {1,2,3,4,5}

print(set)
```
::: note info
{1, 2, 3, 4, 5}
:::
**～要素の取り除き～**
集合型では、例えば集合Aから集合Bを取り除くことができます。
実際にコードで確認してみます。
```py
setA = {1,2,3,4,5,6,7,8,9,10}
setB = {5,6,7}

remove_set = setA - setB

print(remove_set)
```
::: note info
{1, 2, 3, 4, 8, 9, 10}
:::
上記のように集合Aから集合Bの{5,6,7}が取り除かれることを確認できました。

### 8-8集合のメソッド
集合のメソッドには以下のものがあります。

|メソッド名|使用用途|記載方法|
|---|---|---|
|add|集合に値を追加する|集合.add(要素)|
|discard|指定した要素が存在するなら削除<br>指定した要素が無ければエラーとなる|集合.discard(要素)|
|remove|指定した要素が存在するなら削除<br>指定した要素が無い場合もエラーとならない|集合.remove(要素)|
|clear|すべての要素を削除する|集合.clear()|
|len|集合内の要素の数を数える|集合.len()|
|union|和集合(2つの集合を集めた集合)|集合1.union((集合2))|
|difference|差集合<br>(片方の集合から片方の集合と共通する値を削除した集合)|集合1.difference((集合2))|
|intersection|積集合(2つの集合の共通部分を表す集合)|集合1.intersection(集合2)|
|symmetric_difference|対称差集合(2つの集合の共通しない部分を合わせた集合)|(集合1).symmetric_difference((集合2))|

上記のメソッドをいくつか使ってみます。
**add**
```py
even = {1,2,3,4}

even.add(5)

print(even)
```
::: note info
{1, 2, 3, 4, 5}
:::
**discard**
```py
set = {1,2,3,4}

set.discard(3)

print(set)
```
::: note info
{1, 2, 4}
:::
**clear**
```py
set = {1,2,3,4,5}

set.clear()

print(set)
```
::: note info
set()
:::

**～和集合、差集合、積集合、対象差集合～**
和集合、差集合、積集合、対象差集合はメソッドを使用せず、演算子を用いて表すこともできます。
```py
setA = {1,2,3,4,5}
setB = {6,7,8,9,10}
setC = {2,4}

# 和集合
union = setA | setB
print('setAとsetBの和集合')
print(union)

# 差集合
difference = setA - setC
print('setAとsetBの差集合')
print(difference)

# 積集合
intersection = setA & setC
print('setAとsetBの積集合')
print(intersection)

# 対称差集合
symmetric_difference = setA ^ setC
print('setAとsetBの対称差集合')
print(symmetric_difference)
```
::: note info
setAとsetBの和集合
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
setAとsetBの差集合
{1, 3, 5}
setAとsetBの積集合
{2, 4}
setAとsetBの対称差集合
{1, 3, 5}
:::

# 制御フロー
ここでは制御フローのツールについて触れていきます。

### 9-1条件分岐
**～if文～**
プログラムで特定の条件が満たされた際に実行する処理を実行したい場合に **<font color = red>条件分岐(if文)</font>** という構文を用います。
条件分岐(if文)の記載方法は以下になります。
<font color = green>**if 条件:<br>条件を満たした際の処理**</font>
コードにすると以下のようになります。
```py
# xが5以上ならTrueと出力する条件
x = 10

if x > 5:
    print('True')
```
::: note info
True
:::
上記のようにPythonでは条件の後に条件を満たした際の処理を書く際は、**<font color=blue>半角スペースを4つ入れる</font>** ことが一般的です。

**～else文～**
上記のif文に対して、条件が満たない場合は **<font color = red>else文</font>** を用います。
else文は以下のように記載します。
<font color = green>**if 条件:<br>条件を満たした際の処理<br>else:<br>条件を満たさなかった際の処理**</font>
コードにすると以下のようになります。
```py
""""
xが10以上なら「10以上」と出力し、
10より小さければ「10より小さい」と出力する。
"""
x = 5

if x >= 10:
    print('10以上')
else:
    print('10より小さい')

```
::: note info
10より小さい
:::
**～elif文～**
別の条件を満たすか確認するためには **<font color = red>elif文</font>** を使用します。
elif文は以下のように記載します。
<font color = green>**if 条件:<br>条件Aを満たした際の処理<br>elif:<br>条件Bを満たした際の処理**</font>
コードにすると以下のようになります。
```py
""""
xが10より大きいなら「10よりと大きい」と出力し、
xが0なら「xは0」と出力し、
上記以外なら「それ以外」と出力する。
"""
x = 0

if x > 10:
    print('10よりと大きい')
elif x == 0:
    print('xは0')
else:
    print('10より小さい')
```
::: note info
xは0
:::
**～if文の中にif文～**
if文の中にはif文を書くこともできます。
```py
"""
aが5よりも大きく、15よりも小さければ、「aは5よりも大きく、15より小さい」と出力する
"""
a = 10

if a > 5:
    if a < 15:
        print('aは5よりも大きく、15より小さい')
```
::: note info
aは5より大きく、15より小さい
:::
他の言語だとif文は{}で囲んで記載しますが、Pythonの場合は、**<font color = red>インデント</font>** といわれる、行の開始位置を合わせることでif文などを認識します。
そのため、**<font color = blue>インデントをきれいに合わせること</font>** を注意して書きましょう。

### 9-2繰り返し処理
プログラムで同じ処理を繰り返すには **<font color = red>繰り返し処理(while文、for文)</font>** を利用します。
while文とfor文はそれぞれ以下の際に使用します。
**while文：繰り返し回数が決まっていない際に使用**
**for文 ：繰り返し回数が決まっている際に使用**


**～while文～**
while文を利用する繰り返し処理は以下のように記載します。
<font color = green>**while 条件:<br>条件を満たした際の処理<br>**</font>
コードにすると以下のようになります。
```py
"""
countの値が5になるまで、現在のcountの値を表示する
"""
count = 0

while count < 5:
    print('現在の回数：' + str(count))
    count += 1 # countの値を増やす処理
```
::: note info
現在の回数：0
現在の回数：1
現在の回数：2
現在の回数：3
現在の回数：4
:::

**～for文～**
for文を利用する繰り返し処理は以下のように記載します。
<font color = green>**for 変数 in シーケンス(リスト、文字列、タプルなど):<br>条件を満たした際の処理<br>**</font>
コードにすると以下のようになります。
```py
"""
ネームリストの中身を1つずつ表示する
"""

name_list = ['Tanaka','Yamada','Ogawa','Yoshida']

for name in name_list:
    print(name)
```
::: note info
Tanaka
Yamada
Ogawa
Yoshida
:::

### 9-3制御フローの中断とスキップ
制御フローの中断をするには **<font color = red>break文</font>** 、スキップをするには **<font color = red>continue文</font>** を使用します。
**～break文～**
break文は条件を満たした際の処理を記載するところで **<font color = green>break</font>** を記載することで利用することができます。
実際にコードにすると以下のようになります。
```py
"""
countの値が10になるまで現在の回数を出力する。
もし、countの値が5ならば中断する。
"""
count = 0

while count < 10:
    if count == 5:
        break
    
    print('現在の回数：' + str(count))
    count += 1 
```
::: note info
現在の回数：0
現在の回数：1
現在の回数：2
現在の回数：3
現在の回数：4
:::
**～continue文～**
continue文は条件を満たした際の処理を記載するところで **<font color = green>continue</font>** を記載することで利用することができます。
実際にコードにすると以下のようになります。
```py
"""
alphabet_listの中身を一つずつ表示する。
alphabet_listの中身が「B」の場合はスキップする
"""
alpabet_list = ['A','B','C','A','B','D',]

for alphabet in alphabet_list:
    if alphabet == 'B':
        continue
    print(alphabet)
```
::: note info
A
C
A
D
:::
# 関数
**<font color=red>関数</font>** とは処理をまとめたもののことを言います。

### 10-1組み込み関数
Pythonには自分で用意しなくても元から用意されている **<font color=red>組み込み関数</font>** というものがあります。

Pythonの組み込み関数は70種類ほどあるためここではまとめませんが、以下のサイトにてまとめられているので以下を参考にしてみてください。

https://docs.python.org/ja/3/library/functions.html

上記のサイトを参考にいくつか組み込み関数を使用してみます。
**～input～**
input関数を用いることで、ユーザが入力したデータを文字列として返すことができます。
```py
print('数字を入力してください')

number = input()

print(number + 'が入力されました。')
```
::: note info
数字を入力してください
:::
100を入力

::: note info
100が入力されました。
:::
input関数は入力されたデータを文字列として返すため、**<font color=blue>数字として扱いたい場合はint()でint型に変換する</font>** 必要があります。

**～range～**
range関数を用いることで、指定した開始数から終了数までの連続した値を持つことができます。
```py
"""
5からスタートし、10までの数値を表示
"""
count = range(5,10)

for i in count:
    print(i)
```
::: note info
5
6
7
8
9
:::

### 10-2関数の定義
関数は組み込み関数だけではなく、自分で作ることもでき、関数を作成することで再利用することができるようになります。
そのため、同じ処理をする場合などに関数を用いることで、コードを省略可することができます。

関数を定義するには以下のように記載します。
**<font color=green>def 関数名():<br>処理</font>**
また、関数を呼び出すには以下のように記載します。
**<font color=green>関数名()</font>**

実際にコードを書いてみます。
```py
# 関数の定義
def say_hello():
    print('hello')
    print('こんにちは')

# 関数の呼び出し
say_hello()
```
::: note info
hello
こんにちは
:::

**～戻り値を返す場合～**
**<font color=red>戻り値</font>** とは、関数などを呼び出した際に返す値のことです。
戻り値を使用することで、関数を呼び出した際にデータを返すことができます。

実際にコードを書いてみます。
```py
"""
縦10、横5の四角形の面積を計算する関数area
"""
length = 10
width = 5

def area():
    result = length * width
    return result

area_result = area()
print(area_result)
```
::: note info
50
:::
**～引数を使用する場合～**
上記の面積を計算するコードでは、縦と横の値は固定となっています。
縦と横の値を呼び出す場所によって変えたいという場合は、引数を使用します。
**<font color=red>引数</font>** とは関数に渡す値のことです。

引数を用いて関数を定義する際は、以下のように記載します。
関数を定義するには以下のように記載します。
**<font color=green>def 関数名(引数):<br>処理</font>**

実際に四角形の面積を計算するarea関数に引数を入れて、呼び出すものによって値が変わるように書いてみます。
```py
"""
四角形の面積を計算するarea関数
"""
# 引数にlengthとwidthを設定
def area(length,width):
    result = length * width
    return result

# lengthに20、widthに5が入るように設定
area1 = area(20,5)
print('縦20横5の四角形の面積')
print(area1)

# lengthに15、widthに8が入るように設定
area2 = area(15,8)
print('縦15横8の四角形の面積')
print(area2)
```
::: note info
縦20横5の四角形の面積
100
縦15横8の四角形の面積
120
:::
上記のように引数を用いることで、関数を呼び出すごとに値を変えることができます。

# モジュール
**<font color=red>モジュール</font>** とは様々な関数を1つのファイルにまとめたものです。
Pythonファイル自体がモジュールに当たります。

モジュールは、コードの先頭で以下のように記載することで使用可能になります。
**<font color=green>import モジュール名</font>**

### 11-1標準ライブラリ
Pythonの **<font color=red>標準ライブラリ</font>** とは、Pythonに元から用意されているモジュールのことです。
Pythonには豊富なライブラリが揃っているため、便利です。
Pythonの標準ライブラリは豊富なため、以下のサイトを参照してみてください。

https://docs.python.org/ja/3.14/library/index.html

今回は、上記サイトにて紹介されているmathモジュールのsqrt関数を利用してみます。
mathモジュールのsqrt関数は、平方根の計算が可能になる関数です。
モジュールの中の関数を呼び出す際には以下のように記載します。
**<font color=green>import モジュール名<br>モジュール名.関数名(引数)</font>**
```py
# mathモジュールをインストール
import math

# mathモジュールのsqrt関数を呼び出し
root = math.sqrt(25)

print('25の平方根')
print(root)
```
::: note info
25の平方根
5.0
:::
### 11-2自作のモジュール
自作モジュールも標準ライブラリと同様に呼び出すことが可能です。
実際に、計算を実施するための関数を入れたcaluculation.pyファイルと呼び出して実行するためのcall.pyファイルを作成して、実行すると以下のように自作モジュールを使用したコードを作成することができます。
```caluculation.py
# 関数モジュール
# num1とnum2の足し算をするための関数addition_function
def addition_function(num1,num2):
    addition = num1 + num2
    print(str(num1) + 'と' + str(num2) + 'の結果')
    return addition
```
```call.py
# 実行用のPythonファイル
import calculation

num1 = 100
num2 = 50

add = calculation.addition_function(num1,num2)
print(add)
```
::: note info
100と50の結果
150
:::

**～from を使ったインポート～**
自作モジュールはfromを用いたインポートも可能です。
fromを用いることで特定の関数をインポートすることが可能になります。
fromを用いた記載方法としては以下になります。
**<font color=green>from モジュール名 import 関数名</font>**
実際にコードにすると以下になります。
```modules.py
# 関数モジュール

# num1とnum2の足し算をするための関数addition_function
def addition_function(num1,num2):
    addition = num1 + num2
    print(str(num1) + '+' + str(num2) + 'の結果')
    return addition
```
```main.py
# addition_functionを呼び出し実行するファイル
from modules import addition_function

num1 = 100
num2 = 50

add = addition_function(num1,num2)
print(add)
```
::: note info
100+50の結果
150
:::
**～import as を使ったインポート～**
モジュール名・関数名が長い場合や名前が重なる場合などは、import asを用いることで、モジュール名・関数名の名前に別名を付けることができます。
記載方法としては以下になります。
**<font color=green>import モジュール名 as 付けたい別名</font>**
実際にコードにすると以下のようになります。
```modules.py
# 関数モジュール

# num1とnum2の足し算をするための関数addition_function
def addition_function(num1,num2):
    addition = num1 + num2
    print(str(num1) + '+' + str(num2) + 'の結果')
    return addition
```
```main.py
# addition_functionを呼び出し実行するファイル
import modules as m

num1 = 100
num2 = 50

add = m.addition_function(num1,num2)
print(add)
```
::: note info
100+50の結果
150
:::
### 11-3パッケージ
**<font color=red>パッケージ</font>** とは複数のモジュールをまとめたものです。
モジュールをパッケージにするには使用する **<font color=green>モジュールが入ったディレクトリにて、\__init__.pyファイルを作成</font>** することでパッケージにすることができます。

実際に、パッケージを作成して実行してみます。
**～ファイル構造～**
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3901198/03265c2f-b9a7-cc47-4d65-cfff8a270c8e.png)

**～手順1～**
modulesディレクトリを作成し、その中に「addition.py」と「subtraction.py」を作成。
「addition.py」と「subtraction.py」のソースは以下としました。
```addition.py
# num1とnum2を足し算する関数
def addition_function(num1,num2):
    addition = num1 + num2
    print(str(num1) + '+' + str(num2) + 'は')
    return addition
```
```subtraction.py
# num1とnum2を引き算する関数
def subtraction_function(num1,num2):
    subtraction = num1 - num2
    print(str(num1) + '-' + str(num2) + 'は')
    return subtraction
```
**～手順2～**
手順1を行ったmodulesディレクトリの中に「\__init__.py」を作成し、modulesディレクトリをパッケージにする。
**<font color=blue>「\__init__.py」は空で問題ない</font>**
```__init__.py

```
**～手順3～**
modulesパッケージを呼び出し、実行する「main.py」を作成。
```main.py
from modules import addition
from modules import subtraction

num1 = 100
num2 = 50

add = addition.addition_function(num1,num2)
print(add)

sub = subtraction.subtraction_function(num1,num2)
print(sub)
```
**～手順4～**
実行結果

::: note info
100+50は
150
100-50は
50
:::
# クラス
**<font color=red>クラス</font>** とはデータと処理をまとめたものです。
Pythoではデータのことを **<font color=red>アトリビュート</font>** といい、処理のことを **<font color=red>メソッド</font>** といいます。
また、クラスを実体化したものを **<font color=red>インスタンス</font>** といい、クラスを実際に使えるように名前を付けること **<font color=red>インスタンス化する</font>** を言います。

記載方法としては以下になります。
<font color=green>
**class クラス名**
**&emsp;&emsp;def メソッド名(self)**
**&emsp;&emsp;&emsp;&emsp;処理**
&emsp;
**インスタンス名 = クラス名()**
&emsp;
**インスタンス名.メソッド名()**
</font>
Pythonではクラスを使用する際は、メソッドに引数を入れる必要があります。
中身は何でもよいですが、 **<font color=green>self</font>** を入れることが一般とされています。

コードにすると以下のようになります。
```greeting.py
class Greeting():             #クラス名をつける
    def morining(self):       #メソッド名をつける
        print("Good morinig") #実行したい処理

    def nigth(self):          #メソッド名をつける
        print("Good night")   #実行したい処理

greeting = Greeting()         #インスタンス名をつける

greeting.morining()           #呼び出す
greeting.nigth()              #呼び出す
```
::: note info
Good morinig
Good night
:::

### 12-1コンストラクタとデストラクタ

**～コンストラクタと初期化～**
**<font color=red>コンストラクタ</font>** とは、インスタンス化した際に最初に呼ばれるメソッドです。
コンストラクタにて **<font color=green>\__init__</font>** というコンストラクタを作ると、初期化(クラスを呼び出した際に最初に呼び出し)をすることができます。
実際にコードを書くと以下のようになります。
```py
class Initialization():
    # コンストラクタ
    def __init__(self):
        print("コンストラクタ")

    # helloメソッド
    def hello(self):
        print("helloメソッド")

"""
initialization.__init__()のようにしなくても最初に呼び出してくれる。
"""
initialization = Initialization()
```
::: note info
コンストラクタ
:::
上記のコードのように、コンストラクタの部分はinitialization.\__init__()としなくてもクラスを呼んだだけで呼び出してくれます。逆にコンストラクタではない、helloメソッドはinitialization.hello()としないと、呼び出してくれないことが分かります。

**～デストラクタ～**
コンストラクタに対して、最後に呼び出したいメソッドを<font color=red>**デストラクタ**</font>といいます。
デストラクタは、 **<font color=green>\__del__</font>** と記載することで表すことができます。
実際にコードを書いてみます。
```py
class Initialization():
    # コンストラクタ
    def __init__(self):
        print("コンストラクタ")

    # helloメソッド
    def hello(self):
        print("helloメソッド")

    #デストラクタ
    def __del__(self):
        print("デストラクタ")

initialization = Initialization()
```
::: note info
コンストラクタ
デストラクタ
:::
上記のように、デストラクタもコンストラクタ同様にinitialization.\__del__()としなくてもクラスを呼んだだけで最後に呼び出してくれます。

### 12-2クラスの引数

**～引数を使用する場合(関数)～**
引数を関数に入れて呼び出す場合は以下のように実施します。
```calculation.py
class Calculation():
    def addition(self,num1,num2):
        add = num1 + num2
        print(str(num1) + '+' + str(num2) + '=' )
        print(add)

    def subtraction(self,num1,num2):
        sub = num1 - num2
        print(str(num1) + '-' + str(num2) + '=' )
        print(sub)


num = Calculation()
num.addition(100,50)
num.subtraction(100,50)
```
::: note info
100+50=
150
100-50=
50
:::

**～引数を使用する場合(インスタンス)～**
引数をインスタンスに持たせて呼び出したい際は以下のように記載します。
<font color=green>
**class クラス名**
**&emsp;&emsp;def メソッド名(self,値)**
**&emsp;&emsp;&emsp;&emsp;print(self.値 = 値)**
**&emsp;&emsp;&emsp;&emsp;print(self.値)**
&emsp;
**インスタンス名 = クラス名(値)**
&emsp;
**インスタンス名.メソッド名()**
</font>
実際にコードを書いてみます。
```py
class Person():
    def __init__(self,name):
        self.name = name
        print('私は' + self.name + 'です。')

person = Person('田中')
```
::: note info
私は田中です。
:::

### 12-3継承
**<font color=red>継承</font>** とは、新しいクラスを作る際に、既存のクラスからメソッドや変数を受け継ぐことです。
クラスの継承では受け継がれるクラスと受け継ぐクラスがあり、それぞれ以下のように名前がついています。
**<font color=red>親クラス(スーパークラス)</font>**　：　受け継がれるクラス
**<font color=red>子クラス(サブクラス)</font>**　　　：　受け継ぐクラス

書き方としては以下になります。
<font color=green>
**class 親クラス名():**
**&emsp;&emsp;&emsp;&emsp;処理A**
&emsp;
**class 子クラス名(親クラス名):**
**&emsp;&emsp;&emsp;&emsp;処理B**
&emsp;
**インスタンス名 = 子クラス名()**
&emsp;
**インスタンス名.メソッド名()**
</font>
実際にコードを書いてみます。
```py
class FullName():
    def __init__(self):
        print("田中")

class Child(FullName):
    def name(self):
        print('太郎')

fullname = Child()
fullname.name()
```
::: note info
田中
太郎
:::
上記のように子クラスを呼びましたが、親クラスのコンストラクタも呼び出していることが分かります。
また、コンストラクタではなく、親のメソッドを呼び出したい際は、**<font color=green>**インスタンス名.親メソッド名()**</font>** とすることで呼び出し可能となります。
実際に書いてみます。
```py
class Parent():
    def family(self):
        print("田中")

class Child(Parent):
    def name(self):
        print('太郎')

fullname = Child()
fullname.family()
fullname.name()
```
::: note info
田中
太郎
:::
**～親クラスと子クラスのコンストラクタ～**
親クラスと子クラスにコンストラクタがあった際はどうなるのか確認してみます。
```py
class Parent():
    def __init__(self):
        print("田中")

class Child(Parent):
    def __init__(self):
        print('太郎')

fullname = Child()
```
::: note info
太郎
:::
上記のように子クラスのコンストラクタのみ出力されました。
Pythonでは **<font color=blue>子クラスと親クラスでコンストラクタが定義されており、子クラスのインスタンス化をした場合は、子クラスのコンストラクタを呼び出す</font>** ようになっています。

**子クラスで親クラスのコンストラクタも呼び出したい** という場合があると思います。
その際は子クラスのメソッド内に以下のように記載します。
```py
class Parent():
    def __init__(self):
        print("田中")

class Child(Parent):
    def __init__(self):
        super().__init__()  # 親クラスのコンストラクタを呼び出す
        print('太郎')

fullname = Child()
```
::: note info
田中
太郎
:::
上記のように呼び出したい子クラスのメソッド内で、**<font color=green>super().\__init__()</font>** とすることで子クラスでも親クラスのコンストラクタを呼び出すことが可能になります。

### 12-4オーバーライド
**<font color=red>オーバーライド</font>** とは、親クラスで定義されたメソッドを子クラスで再定義することです。
オーバーライドを使用することで、クラスの特定の動作を変更したり拡張することができるようになります。
以下のように記載します。
<font color=green>
**class 親クラス名():**
**&emsp;&emsp;&emsp;&emsp;def メソッド名(self):**
**&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;処理**
&emsp;
**class 子クラス名(親クラス名):**
**&emsp;&emsp;&emsp;&emsp;def 親メソッド名(self):**
**&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;処理**
&emsp;
**インスタンス名 = 子クラス名()**
&emsp;
**インスタンス名.メソッド名()**
</font>

```py
class Animal:
    def speak(self):
        print("Animal speak")

class Cat(Animal):
    def speak(self):  # 親クラスのメソッドをオーバーライド
        print("にゃー")

# インスタンスを作成
animal = Animal()
cat = Cat()

# メソッドを呼び出す
animal.speak()    
cat.speak() 
```
::: note info
Animal speak
にゃー
:::

### 12-5抽象クラス
**<font color=red>抽象クラス</font>** とは、他のクラスが共通して持つべきメソッドやデータの状態を定義するためのテンプレートのことです。
抽象クラスは<font color=blue>**直接インスタンス化できない**</font> という特徴を持ちます。

Pythonの抽象クラスは **<font color=red>abcモジュール</font>** を用いて定義します。
また、**<font color=red>`@abstractmethodデコレーター`</font>** をメソッドの前に記載し、抽象メソッドを定義することができます。
以下のように記載します。
<font color=green>
**class 抽象クラス名():**
**&emsp;&emsp;&emsp;&emsp;`@abstractmethod`**
**&emsp;&emsp;&emsp;&emsp;def メソッド名(self):**
**&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;処理**

</font>

```py
from abc import ABC, abstractmethod

# 抽象クラスの定義
class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

# Dogクラスの定義
class Dog(Animal):
    def speak(self):
        return 'ワン'

# Catクラスの定義
class Cat(Animal):
    def speak(self):
        return 'ニャー'

# インスタンスを作成
dog = Dog()
cat = Cat()

# メソッドを呼び出し
print(dog.speak())
print(cat.speak()) 
```
::: note info
ワン
ニャー
:::
上記のように抽象クラスを作成(Animal)し、その中にabstractmethodデコレーターを使ってメソッド(speak)を定義します。他のクラス(Dog、Cat)はこの抽象クラスを継承し、それぞれメソッド(speak)を実装します。

# さいごに
長い記事をお読みいただき、ありがとうございます。
初めての記事で読みづらいとこもあったと思います。
修正点などありましたら是非コメントよろしくお願いいたします。

次回からはPythonの応用編の記事を投稿できたらと考えているので、次回もよろしくお願いいたします。

# 参考・参照文献
・現役シリコンバレーエンジニアが教えるPython 3 入門 + 応用 +アメリカのシリコンバレー流コードスタイル

https://www.udemy.com/course/python-beginner

・Python入門｜初心者が知識ゼロから始められる実践記事まとめ

https://www.sejuku.net/blog/147190

・【Python】リスト（list）で使用できるメソッド一覧

https://office54.net/python/basic/list-method

・【Python独学】タプルで使えるメソッド

https://tech.pjin.jp/blog/2020/12/29/python_7_4/

・Pythonの基本⑤【dict型のメソッド】

https://qiita.com/jay_42tokyo/items/aba295d33aaa716dcecf

・【Python初心者】集合とは何か｜基本からメソッドまでを分かりやすく解説

https://creive.me/archives/32496/

・組み込み関数

https://docs.python.org/ja/3/library/functions.html

・標準ライブラリ

https://docs.python.org/ja/3.14/library/index.html

・【Python】Python言語入門⑥～関数・モジュール・import～

https://sakigake-robo.com/python-5/

・Pythonのパッケージとは。パッケージの基本と使い方

https://dot-blog.jp/news/python-package/