サンプルコードで理解するPython入門講座（前編）

# はじめに
このエントリはPythonを手っ取り早く利用できるためのもので

* 詳しい説明は抜きだ！
* とにかく最初は「使えた！」と思えることが大切である
* 理論はあとからちゃんと調べればよい

という考えで書いています。

後編は以下です。

https://qiita.com/bashaway/items/11b829e7d2f161156f21


## 前提条件
プログラム的な用語そのものの解説はありません。

なにかしらのプログラム言語/シェル/スクリプトの基本的な用語や、コンピュータの基礎知識があるものとして記載しています。なので「変数とはデータを一時的に保管しておくための箱であり～～」とか「コンピュータの五大要素とは～～」などの解説はありません。

そこまで書くモチベがありませんでした。すいません。


また「プログラムは文と式から構成されており～～」「オブジェクトは、クラスから生成したインスタンスという実体の～～」などプログラム概論みたいな解説や、Pythonの言語仕様や用語定義にも触れません。

ここは私自身が他人に教えられるほど、正確な知識がないためです。ごめんなさい。



## ちゃんとした資料

ゼロから体系的に学びたいのであれば、このエントリは適切ではないかもしれません。

その場合には、世の中にたくさん良いドキュメントがありますので、そちらをおススメします。

https://www.python.jp/train/index.html

https://docs.python.org/ja/3/tutorial/

https://utokyo-ipp.github.io/

https://repository.kulib.kyoto-u.ac.jp/dspace/handle/2433/265459



## プログラムとは

**[ちゃんとした資料](https://repository.kulib.kyoto-u.ac.jp/dspace/bitstream/2433/265459/1/Version2021_10_08_01.pdf)** から引用すると以下のような記載でした。

> Python によらず広くプログラミング言語を学習する際には以下のような事項がプログラムを構成する基礎的な概念になります．
> * 算術，文字列，論理（真偽）の演算
> * 変数，変数への代入，変数の値の評価（代入されている値を使うこと）
> * 条件判断によるプログラムの実行の切り替え（分岐）
> * プログラムの特定箇所の繰り返し実行
> * 定型動作の記述と呼び出し（関数の定義と呼び出し）
> * 複合的なデータの取り扱い
> * 入出力（端末，GUI，ファイル，ネットワーク）

このエントリでは、これらが「そもそもどういうものであるか？」はごく簡単にしか触れていません。「それがPythonではどういうルールになっているか？どう記述すれば動作するのか？」からをメインに記載しています。


# Hello, Python!

まずはpythonに触れてみましょう。
シェル上で`python`と入力して実行すると、pythonの対話式シェルが起動します。
Windows+GitBashな環境の場合 `winpty python` とする必要があります。
（エイリアスとして設定しておいてもOKです）
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/334782/2a25ea9a-2db9-2340-66de-24c3179d9e9a.png)
`>>>`はプロンプトのことで、ここにPythonの処理文を記載していくことで、逐次処理させることができます。

## 単純な出力

画面に文字列を出力するために`print`文を使います。`print`文は、与えた引数を出力する関数です。
例として、`Hello, Python!`という文字列を出力してみましょう。

この場合プロンプト（`>>>`）に続けて `print('Hello, Python!')`と入力します。
```shell
$ python
Python 3.10.11 (tags/v3.10.11:7d4cc5a, Apr  5 2023, 00:38:17) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello, Python!')
Hello, Python!
>>> quit()
```

対話式シェルを終了する場合は`quit()`です。`()`まで記載しないと終了されません。


## 変数と代入

先ほどは`print`文に直接出力させる文字列を引数として渡していましたが、ここに変数を利用することができます。
こうすることで、`print`文を利用したまったく同じ記述で、異なる出力内容とすることができます。

```shell
$ python
Python 3.10.11 (tags/v3.10.11:7d4cc5a, Apr  5 2023, 00:38:17) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> message='Hello, Python!'
>>> print(message)
Hello, Python!
>>> message='Hello, World!'
>>> print(message)
Hello, World!
>>> quit()
```

最初は`message`変数に`Hello, Python!`という文字列を代入して`print`文を発行しています。
その次に`message`変数の値を書き変えてから同じ`print`文を発行していますので、出力内容が変わっています。

他の言語と同様に、様々な情報を変数に代入しておき、後続の処理で参照して利用することができます。

## 練習問題（対話式シェルの利用）

<details><summary>対話式シェルによる実行で、変数への代入を利用して「Hello」という文字列を表示する</summary>

```
$ python
Python 3.10.11 (tags/v3.10.11:7d4cc5a, Apr  5 2023, 00:38:17) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> msg='Hello'
>>> print(msg)
Hello
>>> quit()

$
```

</details>


# スクリプトファイルによる実行

前のセクションでは `python` を実行したことで対話式シェルが立ち上がり、print文の発行や、変数への代入を実施しました。
これらをファイルに書き起こすことで、同じ処理を何度でも繰り返すことができるようになります。
このファイルのことを、スクリプトファイルやソースコードと呼びます。

前のセクションで実行した処理は以下のようにファイルに書き出すことができます。
テキストエディタなどで `hello.py`という名称でファイルとして保存してください。
なお、各処理の行頭に `#`があるとコメントとなり、その行は実行されません。

```:hello.py
# この行はコメントなので実行されません
message='Hello, Python!'
print(message)

# この行もコメントなので実行されません
message='Hello, World!'
print(message)
```

`python`コマンドに保存したソースコードのファイル名を渡すことで、pythonプログラムとして実行することができます。

```:hello.pyの実行結果
$ python hello.py
Hello, Python!
Hello, World!
```

また、Linuxなどではpythonのパスを先頭に記載（`shebang`と呼ばれます）して、以下のように記載することもできます。

```:hello_ex.py
#!/usr/bin/python

message='Hello, Python!'
print(message)

message='Hello, World!'
print(message)
```

この場合は、ファイルに実行権限を付与させることで実行できるようになります。

```
$ chmod u+x hello.py
$ ./hello_ex.py
Hello, Python!
Hello, World!
```

このエントリでは、GitBashを利用することも想定し、前者のshebangなしのファイル形式で進めていきます。

フレームワークや（Flaskなど）、CGIスクリプト（FastCGIなど）には触れません。

## 練習問題（スクリプトファイルの実行）

<details><summary>スクリプトファイルによる実行で、変数への代入を利用して「Hello」という文字列を表示する</summary>

```:コード
msg='Hello'
print(msg)
```

```:実行結果
$ python sample.py
Hello

$
```

</details>


# データ型

情報を代入した変数（および情報そのもの）は、その情報の種類に応じて、データ型を持ちます。
データ型はクラスとして表現されますが、一般的に「データ型」「型」と呼んでいて大丈夫です。

## データ型（単一の情報）

よく使われるデータ型として、以下のようなものがあります。（これ以外にもあります）

|型|type|使い方|
|:--:|:--:|:--:|
|文字列|str|文字列を取り扱う|
|整数|int|整数を取り扱う|
|論理型/真偽値|bool|真（True）か偽（False）を取り扱う|


### 文字列

文字列型は文字列を表現するもの。
文字列はシングルクオーテーションもしくはダブルクォーテーションで囲みます。
シングルクオーテーションとダブルクォーテーションで違いはありません。

```python:コード
# 文字列を直接printする
print('Hello')

# 変数に文字列を代入してからprintする
moji = 'Hello'
print(moji)
```

```shell-session:実行結果
Hello
Hello
```

`class 'str'`として認識されます。`type`はデータ型を返す関数です。

```python:コード
# 文字列は文字列型として認識されます
print(type('Hello'))

# 文字列を代入した変数は文字列型として認識されます
moji = 'Hello'
print(type(moji))
```

```shell-session:実行結果
<class 'str'>
<class 'str'>
```

シングルクォーテーションで囲んだ文字列には、文字列としてダブルクォーテーションを使うことができます。
シングルクォーテーションで囲んだ文字列に、文字列としてシングルクォーテーションを使う場合は、エスケープが必要です。

```python:コード
moji = 'say "Hello"'
print(moji)

moji = 'say \'Hello\''
print(moji)
```

```shell-session:実行結果
say "Hello"
say 'Hello'
```

ダブルクォーテーションで囲んだ文字列には、文字列としてシングルクォーテーションを使うことができます。
ダブルクォーテーションで囲んだ文字列に、文字列としてダブルクォーテーションを使う場合は、エスケープが必要です。

```python:コード
moji = "say 'Hello'"
print(moji)

moji = "say \"Hello\""
print(moji)
```

```shell-session:実行結果
say 'Hello'
say "Hello"
```

エスケープは特殊文字を表現するために利用されます。
よく使うエスケープとして、改行`\n`、バックスラッシュ`\\`があります。

```python:コード
print("Hello\\Python")
print("Hello\nPython")
```

```shell-session:実行結果
Hello\Python
Hello
Python
```

文字列同士を連結するには`+`を使います。

```python:コード
moji = "Hello, " + "Python"
print(moji)

moji = moji + "!!"
print(moji)

# moji  = moji + 文字列 という表記は
# moji += 文字列 と表記することもできる（他の演算子も同様）
moji += "??"
print(moji)
```

```shell-session:実行結果
Hello, Python
Hello, Python!!
Hello, Python!!??
```


### 整数

整数型は整数を表現するもの。
整数は数字をそのまま使います。

```python:コード
# 整数を直接printする
print(25)

# 変数に整数を代入してからprintする
seisuu = 99
print(seisuu)
```

```shell-session:実行結果
25
99
```

`class 'int'`として認識されます。

```python:コード
# 整数は整数型として認識されます
print(type(25))

# 整数を代入した変数は整数型として認識されます
seisuu = 99
print(type(seisuu))
```

```shell-session:実行結果
<class 'int'>
<class 'int'>
```

整数型は四則演算、剰余、べき乗の計算が利用できます。
`/`で除算すると、戻りは浮動小数点（=float）という型になります。整数同士の除算も浮動小数点で戻ります。
`//`で除算すると、戻りは整数で小数点以下が切り捨てられます。


```python:コード
a = 7
b = 3

# 加算
print(a+b)

# 減算
print(a-b)

# 乗算
print(a*b)

# 除算
print(a/b)

# 剰余
print(a%b)

# 除算（小数点以下切り捨て）
print(a//b)

# べき乗
print(a**b)
```

```shell-session:実行結果
10
4
21
2.3333333333333335
1
2
343
```

整数は2/8/16進数での表記も可能です。


```python:コード
int_bin = 0b11000000
int_oct = 0o250
int_dec = 10
int_hex = 0xfe

print(int_bin)
print(int_oct)
print(int_dec)
print(int_hex)
```

```shell-session:実行結果
192
168
10
254
```

なお、数のデータ型としては小数点を取り扱う`float`や`decimal`がありますが、ここでは扱いません。


### 論理型/真偽値

論理型/真偽値は真もしくは偽を表現するもの。
真は`True`、偽は`False`で、それぞれ先頭文字は大文字です。
これ以外の値はありません。

```python:コード
# 論理型を直接printする
print(True)

# 変数に論理型を代入してからprintする
ronri = False
print(ronri)
```

```shell-session:実行結果
True
False
```

`class 'bool'`として認識されます。

```python:コード
# True/Falseは整数型として認識されます
print(type(True))

# True/Falseを代入した変数は論理型として認識されます
ronri = False
print(type(ronri))
```

```shell-session:実行結果
<class 'bool'>
<class 'bool'>
```

論理型は論理演算を利用して処理することができます。

```python:コード
# 論理積はand
print(True and True)
print(True and False)
print(False and False)
print()

# 論理和はor
print(True or True)
print(True or False)
print(False or False)
print()

# 否定はnot
print(not True)
print(not False)
```

```shell-session:実行結果
True
False
False

True
True
False

False
True
```


### 型変換

それぞれのデータ型は変換することが可能な場合があります。

|書式|使い方|
|:--:|:--:|
|`str()`|文字列に変換する|
|`int()`|整数に変換する|
|`bool()`|論理型に変換する|

数値を文字列型に変換して、識別子や文字列の一部として利用する場合があります。

```python:コード
mon = 4
day = 25
moji = str(mon+1) + '月' + str(day) + '日'
print(moji)
```

```shell-session:実行結果
5月25日
```

文字列や数値を論理型に変換して、条件判断に利用する場合があります。

```python:コード
# 空文字列はFlaseと判定されます
moji = "MOJI"
moji_empty = ""
print(bool(moji))
print(bool(moji_empty))

# 整数０はFalseと判定されます
seisuu = 10
seisuu_zero = 0
print(bool(seisuu))
print(bool(seisuu_zero))
```

```shell-session:実行結果
True
False
True
False
```

変換できない場合にはエラーになります。

```python:コード
moji = 'sample'
print(moji)

# なんらかの文字が含まれるので True
print(bool(moji))

# 変換できないものはエラーになる
print(int(moji))
```

```shell-session:実行結果
sample
True
Traceback (most recent call last):
  File "C:\Users\basha\tmp\python\sample.py", line 8, in <module>
    print(int(moji))
ValueError: invalid literal for int() with base 10: 'sample'
```

### 練習問題（単一の情報）

<details><summary><b>文字列：</b> 以下の実行結果を表示させるためのコードのmsg1とmsg2はどのように記載すればよいか？</summary>

```:コード
# 回答例
msg1 = '"A sample text"'
msg2 = '"The \'sample\' text"'
print(msg1 + ' and ' + msg2)

# 別解例
msg1 = "\"A sample text\""
msg2 = "\"The 'sample' text\""
print(msg1 + ' and ' + msg2)
```

</details>

```:実行結果
"A sample text" and "The 'sample' text"
```

```:コード
msg1 = ～～～～～
msg2 = ～～～～～
print(msg1 + ' and ' + msg2)
```

<details><summary><b>整数：</b>整数「100」を「3」で割ったときの商と余りをそれぞれ変数に格納して表示させる。答えと余りの変数を利用して「100」に戻す計算をした結果を表示する</summary>

```
num = 100
div = 3
ans = num//div
rem = num%div

print('ans='+str(ans))
print('rem='+str(rem))
print(ans*div+rem)
```

</details>

```:実行結果
ans=33
rem=1
100
```

```:コード
num = 100
div = 3
ans = ～～～～～
rem = ～～～～～

print('ans='～～～～～)
print('rem='～～～～～)
print(～～～～～)
```

## データ型（複数の情報：コンテナ）

Pythonで取り扱う型/変数を複数まとめて、ひとつの型/変数として取り扱うことができます。
まとめた型/変数を、さらにまとめて、一つの変数として取り扱うこともできます。

よく使われるデータ型として、以下のようなものがあります。（これ以外にもあります）

|型|type|用途|要素の変更|使い方|
|:--:|:--:|:--:|:--:|:--:|
|リスト|list|複数要素をひとまとまりとして取り扱う|〇|`[要素,要素,...]`|
|タプル|tuple|複数要素をひとまとまりとして取り扱う|×|`(要素,要素,...)`|
|辞書|dict|複数要素をキーと値で取り扱う|〇|`{キー:値,キー:値,...}`|
|セット|set|複数要素を順序なしで取り扱う|×|`{要素,要素,...}`|


### リスト

リストは複数の要素をひとつのまとまりとして取り扱います。
要素には異なる型を含めることができます。

```python:コード
list_a = [1, 2, 3, 4, 5]
print(type(list_a))
print(list_a)

# 先頭からの添え字で特定要素にアクセス
print(list_a[0])

# 末尾からは-1からの添え字で特定要素にアクセス
print(list_a[-1])

# [開始:終了]で範囲選択が可能（終了省略で最後まで、開始省略で最初から）
# 開始はその添え字番号を含む。終了はその添え字番号未満（＝その添え字番号は含まない）。
print(list_a[2:4])
print(list_a[2:])
print(list_a[:4])
```

```shell-session:実行結果
<class 'list'>
[1, 2, 3, 4, 5]
1
5
[3, 4]
[3, 4, 5]
[1, 2, 3, 4]
```

リストは複数行にわたって要素を記載してもよく、最後の要素はカンマ（,）はあってもなくてもよい。
また、リスト同士は `+` で連結することができる。

```python:コード
list_a = [
'str01',
'str02',
'str03',
]

list_b = [
11,
12,
13
]

# リスト同士は＋で連結可能
list_c = list_a + list_b
print(list_c)
```

```shell-session:実行結果
['str01', 'str02', 'str03', 11, 12, 13]
```

リストに要素を追加する場合は `append`や`insert` を利用する。

```python:コード
list_a = [
'str01',
'str02',
'str03',
]

# appendでリスト末尾に要素を追加
list_a.append('strings')
print(list_a)

# insertでリストの任意の場所に要素を追加
list_a.insert(2,'strxx')
print(list_a)
```

```shell-session:実行結果
['str01', 'str02', 'str03', 'strings']
['str01', 'str02', 'strxx', 'str03', 'strings']
```

リストから要素を削除する場合は `pop`や`del` を利用する。

```python:コード
list_a = [
'str01',
'str02',
'str03',
'str04',
'str05',
]

# popで指定添え字の要素を削除
print(list_a.pop(0))
print(list_a)

# delで指定の要素を削除
del list_a[1:3]
print(list_a)
```

```shell-session:実行結果
str01
['str02', 'str03', 'str04', 'str05']
['str02', 'str05']
```


複数リストをまとめて、ひとつのリストにすることもできます。
この場合、特定要素を参照するには、[リスト自体の添え字][リスト内の添え字]でアクセスします。

```python:コード
list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_multi = [list_a, list_b]
print(list_multi)

# 0番目のリストの2番目の要素に整数100を代入する
list_multi[0][2] = 100
print(list_multi)
```

```shell-session:実行結果
[[1, 2, 3], [4, 5, 6]]
[[1, 2, 100], [4, 5, 6]]
```

### タプル
タプルはリストとほぼ同じ使い方ですが、要素の変更ができません。

```python:コード
tuple_a = (1, 2, 3)
tuple_b = (4, 5, 6)

# tuple_multiとしてタプルをまとめる
tuple_multi = (tuple_a, tuple_b)
print(type(tuple_multi))
print(tuple_multi)

# 要素の変更はできないので、ここでエラーが発生する
tuple_multi[0][2] = 100
```

```shell-session:実行結果
<class 'tuple'>
((1, 2, 3), (4, 5, 6))
Traceback (most recent call last):
  File "C:\Users\basha\tmp\python\test.py", line 8, in <module>
    tuple_multi[0][2] = 100
TypeError: 'tuple' object does not support item assignment
```


### 辞書

リストは複数の要素をひとつのまとまりとして取り扱う際に、特定要素にアクセスするために添え字を利用していました。
辞書型では、添え字の代わりに、キーを利用して、要素にアクセスします。
ここでも、各要素として異なる型を含めることができます。

```python:コード
dict_a = {'key1': 1, 'key2': 'moji', 'key3': False}
print(type(dict_a))
print(dict_a)

# キーを指定することで特定要素にアクセス
print(dict_a['key1'])

# キーは辞書型のメソッド（get）を利用してもよい
print(dict_a.get('key2'))
```

```shell-session:実行結果
<class 'dict'>
{'key1': 1, 'key2': 'moji', 'key3': False}
1
moji
```

辞書は複数行にわたって要素を記載してもよく、最後の要素はカンマ（,）はあってもなくてもよい。

また、辞書同士は `|` で連結することができるが、同じキーを含む値は、連結「する」方の値で上書きされる。

```python:コード
dict_a = {
'key11': 1,
'key12': 'moji',
'key13': False,
}

dict_b = {
'key21': 33,
'key22': 'string',
'key23': True,
'key12': 'new moji'
}

# 辞書同士は｜で連結可能
print(dict_a | dict_b)
```

```shell-session:実行結果
{'key11': 1, 'key12': 'new moji', 'key13': False, 'key21': 33, 'key22': 'string', 'key23': True}
```

辞書に要素を追加する場合は追加するキーと値のセットを代入すればよい。

```python:コード
dict_a = {
'key11': 1,
'key12': 'moji',
'key13': False,
}

# キーと値のセットを代入する
dict_a['key21'] = 'NewValue'
print(dict_a)

# キーがすでに存在するものであった場合、値が上書きされる
dict_a['key12'] = 123456
print(dict_a)
```

```shell-session:実行結果
{'key11': 1, 'key12': 'moji', 'key13': False, 'key21': 'NewValue'}
{'key11': 1, 'key12': 123456, 'key13': False, 'key21': 'NewValue'}
```

辞書から要素を削除する場合は `pop` や `del` を利用する。

```python:コード
dict_a = {
'key11': 'val1',
'key12': 'val2',
'key13': 'val3',
'key14': 'val4',
'key15': 'val5',
}

# popで指定キーの要素を削除
print(dict_a.pop('key11'))
print(dict_a)

# delで指定の要素を削除
del dict_a['key15']
print(dict_a)

```

```shell-session:実行結果
val1
{'key12': 'val2', 'key13': 'val3', 'key14': 'val4', 'key15': 'val5'}
{'key12': 'val2', 'key13': 'val3', 'key14': 'val4'}
```



### セット

セットは複数の要素をひとつのまとまりとして取り扱います。
要素には異なる型を含めることができます。
リストと異なる点として、重複した値を含めることはできず、添え字によるアクセスもできません。

```python:コード
set_a = {1, 2, 3, 4, 5}
print(type(set_a))
print(set_a)
```

```shell-session:実行結果
<class 'set'>
{1, 2, 3, 4, 5}
```

セットは複数行にわたって要素を記載してもよく、最後の要素はカンマ（,）はあってもなくてもよい。

また、セット同士は論理演算が可能である。


```python:コード
set_a = {
'str01',
'str02',
12
}

set_b = {
11,
12,
'str01'
}

# セット同士は論理演算が可能
print(set_a | set_b)
print(set_a & set_b)
print(set_a ^ set_b)
```

```shell-session:実行結果
{'str02', 'str01', 11, 12}
{12, 'str01'}
{'str02', 11}
```

### 練習問題（複数の情報：コンテナ）

<details><summary><b>リスト：</b>以下の実行結果となるようなコードを作成する</summary>

```python:コード
list_a = ['a', 'b', 'c', 'd']
print(list_a)

list_b = list_a[2:4]
print(list_b)

list_b.append('x')
print(list_b)

list_b.insert(0,'X')
print(list_b)

print(list_a+list_b)
print([list_a,list_b])
```

</details>

```shell-session:実行結果
['a', 'b', 'c', 'd']
['c', 'd']
['c', 'd', 'x']
['X', 'c', 'd', 'x']
['a', 'b', 'c', 'd', 'X', 'c', 'd', 'x']
[['a', 'b', 'c', 'd'], ['X', 'c', 'd', 'x']]
```

```python:コード
list_a = ～～～～～
print(list_a)

list_b = list_a[～～～～～]
print(list_b)

list_b.append(～～～～～)
print(list_b)

list_b.insert(～～～～～)
print(list_b)

print(～～～～～)
print(～～～～～)
```


<details><summary><b>辞書：</b>以下の実行結果となるようなコードを作成する</summary>

```
dict_a = { 'key1': 'val1', 'key2': 'val2', 'key3': 'val3' }
print(dict_a)

dict_a.pop('key1')
print(dict_a)

dict_a['key4'] = 'val4'
print(dict_a)

dict_a['key2'] = 'NewValue'
print(dict_a)
```

</details>

```shell-session:実行結果
{'key1': 'val1', 'key2': 'val2', 'key3': 'val3'}
{'key2': 'val2', 'key3': 'val3'}
{'key2': 'val2', 'key3': 'val3', 'key4': 'val4'}
{'key2': 'NewValue', 'key3': 'val3', 'key4': 'val4'}
```


```python:コード
dict_a = ～～～～～
print(dict_a)

dict_a.pop(～～～～～)
print(dict_a)

dict_a[～～～～～] = ～～～～～
print(dict_a)

dict_a[～～～～～] = 'NewValue'
print(dict_a)
```

# 制御文

プログラムは制御文を複数記載することで処理を行います。

|書式|使い方|
|:--:|:--:|
|順次処理|記載されている処理内容を順番に実行していく|
|分岐処理|与えられた条件によって次に実行する処理内容を変える|
|反復処理|記載されている処理内容を繰り返し実行する|

## 順次

記載された順に処理を実行していくこと。特に難しく考える必要はない。

```python:コード
print('最初に実行される処理')
moji = '次に実行される処理'
print(moji)
```

```shell-session:実行結果
最初に実行される処理
次に実行される処理
```


## 分岐

`if` を利用して条件に応じた処理に分岐させる。条件に利用できるのは真偽値として取り扱えるもの。

条件文の最後にはコロン`:`をつける必要があり、その条件に合致した場合の処理は**インデント**したブロックとしておく必要がある。

このドキュメントのインデントは、比較的利用されることが多い「スペース４つ」を採用する。

```python:コード
if True:
    print('Trueは常に真である')
    print('よって、この処理は常に実行される')

print('ここはifによる分岐の影響を受けない')

if False:
    print('Falseは常に偽である')
    print('よって、この処理は常に実行されない')
```

```shell-session:実行結果
Trueは常に真である
よって、この処理は常に実行される
ここはifによる分岐の影響を受けない
```

真偽値として取り扱えるものであれば、どのようなデータ型でも問題ありません。前述の論理型で出てきた`bool()`による型変換を強制的に実施してしまう、と考えてよいです。

```python:コード
# 文字列がなにかあれば True
moji = 'Hello'
if moji:
  print('str: '+moji)

# 整数の０は False
seisuu = 0
if seisuu:
  print('int:'+seisuu)
```

```shell-session:実行結果
str: Hello
```

### 評価式

実際には、変数を直接評価するのではなく、比較演算子を利用した評価式で条件分岐させることが多いです。

|比較演算子|True(=真)になる条件|
|:--:|:--:|
|`a==b`|aとbが等しい場合|
|`a!=b`|aとbが等しくない場合|
|`a<b`|aがbより小さい場合|
|`a<=b`|aがb以下の場合|
|`a>b`|aがbより大きい場合|
|`a>=b`|aがb以上の場合|

`is` というオブジェクトが同一であるか？という比較演算子もありますが、これは論理値（`True` `False`）や`None`との比較に利用します。（ここでは触れません）

```python:コード
seisuu = 10
if 10 == seisuu:
    print('整数(seisuu)は10です')
```

```shell-session:実行結果
整数(seisuu)は10です
```

ただし、通常比較対象としないようなものでも、成立してしまうものがあるので、意図した比較をさせるように記載する必要があります。

例えば、以下のように文字列同士の大小比較もできてしまいますので、注意が必要です。

```python:コード
if 'abc' > 'ABC':
    print('文字abcは文字ABCより大きい')
```

```shell-session:実行結果
文字abcは文字ABCより大きい
```

### 文字列の評価式

文字列の場合は`in`を利用すると、「含まれる」かどうかを判定することができます。

```python:コード
moji = 'abcdefg'
if 'cde' in moji:
    print('mojiにはcdeが含まれています')
```

```shell-session:実行結果
mojiにはcdeが含まれています
```


### 複数情報（コンテナ）の評価式

リストや辞書を利用した条件式は仕組みが複雑なので、簡単なものだけ取り上げます。

リスト内に特定文字列が含まれているかどうかは`in`で評価できます。（タプル、セットでも同様に評価できます）

```python:コード
list_moji = ['python', 'perl', 'php']
if 'perl' in list_moji:
    print('list_mojiにはperlが含まれています')
```

```shell-session:実行結果
list_mojiにはperlが含まれています
```

辞書はキーと値のセットで、単純に`in`で評価した場合は「キーが含まれているか？」の比較になります。値だけを配列にする`values()`を利用することで、値だけを取り出した状態の一時的なリストと「値が含まれているか？」の比較することができます。

```python:コード
dict_moji = {'key1': 'python', 'key2': 'perl', 'key3': 'php'}
if 'key3' in dict_moji:
    print('dict_mojiのキーにはkey3が含まれています')

if 'perl' in dict_moji.values():
    print('dict_mojiの値にはperlが含まれています')
```

```shell-session:実行結果
dict_mojiのキーにはkey3が含まれています
dict_mojiの値にはperlが含まれています
```


セットの場合は異なる順番であっても、要素が同一であれば`==`で同一性の評価が可能です。（リスト、タプルでは順番も評価対象なので、同一になりません）

```python:コード
set_moji = {'python', 'perl', 'php'}
set_lang = {'perl', 'php', 'python'}
if set_moji == set_lang:
    print('list_mojiとlist_langは同じです')
```

```shell-session:実行結果
list_mojiとlist_langは同じです
```


### else/elif

`else`を利用すると、条件に合致「しなかった」場合の処理もあわせて記載することができます。

```python:コード
moji = 'abc'
if moji == 'ABC':
    print('文字はABCです')
else:
    print('文字はABCではありません')
```

```shell-session:実行結果
文字はABCではありません
```

`elif`を、直前の条件に合致しなかった場合の、次の条件を記載することができます。

```python:コード
moji = 'abc'
if moji == 'ABC':
    print('文字はABCです')
elif moji == 'abc':
    print('文字はabcです')
else:
    print('文字はABCでもabcでもありません')
```

```shell-session:実行結果
文字はabcです
```


### and/or/not

複数の評価式を複合することもできます。

```python:コード
moji = 'abc'
if moji == 'ABC' or moji == 'abc':
    print('文字はABCかabcのどちらかです')
```

```shell-session:実行結果
文字はABCかabcのどちらかです
```

評価式に `not` をつけると、否定形となります。また、複数の評価式を複合する場合には、できるだけ`()`をつけて、可読性を上げるようにします。

```python:コード
moji = 'abcdefg'
if ('abc' in moji) and (not ('xyz' in moji)):
    print('mojiにはabcは含んでいますが、xyzは含まれていません')
```

```shell-session:実行結果
mojiにはabcは含んでいますが、xyzは含まれていません
```


## 反復

Pythonで利用できる反復処理は`for`と`while`があります。`for`は、リストを参照しながら個々の要素に対して処理をする場合によく使われます。

ここでは`for`のみ解説します。

基本的な書式は以下のようなものです。条件文と同じように、forで反復する処理の部分はインデントしたブロックとして表記しておきます。

```python:forの書式
for [処理内で参照する変数名] in [リスト]:
    処理１
    処理２
    ...
```

３つの整数型を持つリストの各要素を表示するには以下のように記述することができます。


```python:コード
values = [10, 20, 30]
for value in values:
    print('value: '+str(value))
```

```shell-session:実行結果
value: 10
value: 20
value: 30
```

固定回数として「n回繰り返す」としたい場合は`range`関数を利用します。

```python:コード
for iter in range(3):
    print(str(iter)+'回目の表示処理')
```

```shell-session:実行結果
0回目の表示処理
1回目の表示処理
2回目の表示処理
```

`range`関数は引数で与えらられた数値を持つrangeオブジェクトを生成する関数ですが、forで固定的に利用するだけの場合は「添え字＝値」を持つリストと思っていて大丈夫です。


最初に例示したものは、リストの各要素の値を表示するだけでしたが、あわせて添え字をインデックスとして利用したい場合は`enumerate`関数を利用します。

```python:コード
values = [10, 20, 30]
for index,value in enumerate(values):
    print(str(index)+'回目の処理 value: '+str(value))
```

```shell-session:実行結果
0回目の処理 value: 10
1回目の処理 value: 20
2回目の処理 value: 30
```

繰り返しに使うデータを辞書型にする場合、「キーのみ」「値のみ」「キーと値」を繰り返しの要素とすることができます。


```python:コード
dict_moji = {'key1': 'python', 'key2': 'perl', 'key3': 'php'}

# キーのみ利用する場合は keys() を利用
for k in dict_moji.keys():
    print(k)

# 値のみ利用する場合は values() を利用
for v in dict_moji.values():
    print(v)

# キーと値を利用する場合は items() を利用
for k,v in dict_moji.items():
    print(k+': '+v)

```

```shell-session:実行結果
key1
key2
key3
python
perl
php
key1: python
key2: perl
key3: php
```


繰り返しに使うデータがリストや辞書型のネストとなっている場合は、繰り返し処理の中で繰り返し処理をすることができる。

```python:コード
list_a = [1, 2, 3]
list_b = [4, 5, 6]
list_multi = [list_a, list_b]
print(list_multi)
print()

for outer in list_multi:
    print('外側の繰り返し処理')
    print(outer)
    for inner in outer:
        print('内側の繰り返し処理:'+str(inner))
    print()
```

```shell-session:実行結果
[[1, 2, 3], [4, 5, 6]]

外側の繰り返し処理
[1, 2, 3]
内側の繰り返し処理:1
内側の繰り返し処理:2
内側の繰り返し処理:3

外側の繰り返し処理
[4, 5, 6]
内側の繰り返し処理:4
内側の繰り返し処理:5
内側の繰り返し処理:6
```


## 練習問題

<details><summary>以下の得点リストを与えられた場合に、80以上であれば「合格」、80未満であれば「不合格」、0~100の範囲にない数値であれば「不正」と出力するコードを作成する</summary>

```python:コード
list_point = [100, 0, 30, -10, 95, 200,-1]

for p in list_point:
    if (0 > p) or (p > 100):
        print(str(p)+':不正')
    elif p >= 80:
        print(str(p)+':合格')
    else:
        print(str(p)+':不合格')
```

</details>

```:得点リスト
list_point = [100, 0, 30, -10, 95, 200,-1]
```

```shell-session:実行結果
100:合格
0:不合格
30:不合格
-10:不正
95:合格
200:不正
-1:不正
```


<details><summary>４人のプレイヤーがトランプをそれぞれ４枚ずつ引いたときの合計得点を出力する。ただし、トランプの得点は絵札場合は以下の辞書データで与えられ、絵札でないカードはすべて１ポイントとなる。得点を集計するためのコード部分は人数が増えても大きく変更する必要がないように工夫すること。</summary>

```python:コード
dict_point = {'A': 5, 'J': 3, 'Q': 3, 'K': 4}
player_0 = ['A', '2', '5', 'J']
player_1 = ['Q', 'K', '8', '9']
player_2 = ['3', '9', '7', 'K']
player_3 = ['6', '4', '8', 'A']

# いったん全プレイヤーの引いたカードをplayersリストに保管しておく
players = [player_0, player_1, player_2, player_3]

# playersリストを順次処理していく
for index,player in enumerate(players):
    # ポイントは０から加算していく
    point = 0
    # 各プレイヤーごとに、引いたカードのリストを順次処理していく
    for card in player:
        # 引いたカードが得点表に存在していれば、その数値を加算する
        if card in dict_point:
            #print(str(index) + ':' + card + '=' + str(dict_point[card]))
            point += dict_point[card]
        # 引いたカードが得点表に存在していなければ、１ポイントを加算する
        else:
            #print(str(index) + ':' + card + '=' + str(1))
            point += 1

    # 各プレイヤーごとに、引いたカードのリストをすべて処理しおわった段階で、合計得点を表示する
    print('player_'+str(index)+':'+str(point))
```

</details>

```:得点表
dict_point = {'A': 5, 'J': 3, 'Q': 3, 'K': 4}
```

```:各プレイヤーが引いたカード
player_0 = ['A', '2', '5', 'J']
player_1 = ['Q', 'K', '8', '9']
player_2 = ['3', '9', '7', 'K']
player_3 = ['6', '4', '8', 'A']
```

```shell-session:実行結果
player_0:10
player_1:9
player_2:7
player_3:8
```