---
# System prepended metadata

title: Class of Python in Just before the test
tags: [Class, ' Python']

---

---
title: Class of Python in Just before the test
tags: Class, Python
---

# テスト直前授業
## 1 Hello Python!
1. 対話型インタープリタを起動して以下を入力後、エンターをクリック
```python=
>>> print('Hello Python!')
```
:::info
- 注意点
    1. 文字列の出力に使用するのは「print」関数
    2. Pythonは他の言語と違いインデントが意味を持つ
:::

## 2. 入力を受け取って表示する
```python=
>>> str = input()
aaa
>>> print(str)
aaa
>>>
```
:::info
- 注意点
    1. 入力を受け取るのは「input」関数
:::

## 3. 数値演算
```python=
>>> # 宣言
>>> testInt1 = 2
>>> testInt2 = 4
>>> testInt3 = 7
>>> # 四則演算
>>> testInt1 + testInt2
6
>>> testInt2 - testInt1
2
>>> testInt1 * testInt2
8
>>> testInt2 / testInt1 # 答えがfloat型になることに注意
2.0
>>> 
>>> # 整数の除算(小数点以下切捨て)
>>> testInt2 // testInt1
2
>>> # 剰余
>>> testInt3 % testInt2
3
>>> # 指数
>>> testInt1 ** testInt2
16
```

## 4. 文字列操作
### 4.1. シングルクオートとダブルクオート
```python=
>>> # 以下のstr1とstr2は同様の結果となる
>>> str1 = 'test'
>>> str2 = "test"
>>> str1
'test'
>>> str2
'test'
```
### 4.2. トリプルクォート
> 対話型インタープリタが行う自動エコーの場合、改行は改行コード(\n)となって表示されるが、print()の出力では改行される
```python=+
>>> str3 = '''this is test.
... String triple quote test!!!'''
>>> print(str3)
this is test.
String triple quote test!!!
```
### 4.3. *によるくり返し
```python=+
>>> loopStr = 'na ' * 4
>>> loopStr
'na na na na '
```
### 4.4. []による文字の抽出
```python=+
>>> letters = 'abcdefghijklmnopqrstuvwxyz'
>>> letters[0]
'a'
>>> letters[1]
'b'
>>> letters[-1]
'z'
>>> # 文字列はイミュータブル(書き換えできない)なので、以下はできない
>>> letters[1] = 'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>>
>>> # 文字列を書き換える場合はreplaceやスライス(後述)の組み合わせを使用する
>>> letters.replace('a','A')
'Abcdefghijklmnopqrstuvwxyz'
```
### 4.5. スライス
```python=+
>>> # [ start:end:step ] によるスライス
... # ・[:] 先頭から末尾までのシーケンス全体を抽出する
... # ・[start:] startオフセットから末尾までのシーケンスを抽出する
... # ・[:end] 先頭からend-1オフセットまでのシーケンス全体を抽出する
... # ・[start:end] startオフセットからend-1オフセットまでのシーケンス全体を抽出する
... # ・[start:end:step] step文字ごとにstartオフセットからend-1オフセットまでのシーケンス全体を抽出する
>>>
>>> letters[:]
'abcdefghijklmnopqrstuvwxyz'
>>> letters[20:]
'uvwxyz'
>>> letters[12:15]
'mno'
>>> letters[-3:]
'xyz'
>>> letters[18:-3]
'stuvw'
>>> # 先頭から末尾まで7文字毎に文字を取り出す
>>> letters[::7]
'ahov'
>>> letters[4:20:3]
'ehknqt'
>>> # 以下の二つは結果が同じ
>>> letters[-1::-1]
'zyxwvutsrqponmlkjihgfedcba'
>>> letters[::-1]
'zyxwvutsrqponmlkjihgfedcba'
>>> # スライスは間違ったオフセットにも寛容(OutOfIndexにならない)
>>> letters[-50::]
'abcdefghijklmnopqrstuvwxyz'
>>> letters[-50::-50]
''
>>> letters[:71]
'abcdefghijklmnopqrstuvwxyz'
```
### 4.6. splitによる分割とjoinによる結合
```python=+
>>> todos = 'get gloves,get mask,give cat vitamins,call ambulance'
>>> splittodo = todos.split(',')
>>> splittodo
['get gloves', 'get mask', 'give cat vitamins', 'call ambulance']
>>> # セパレータを指定しないと空白文字(改行、スペース、タブ)のシーケンスを使う
>>> todos.split()
['get', 'gloves,get', 'mask,give', 'cat', 'vitamins,call', 'ambulance']
>>> jointodo = ','.join(splittodo)
>>> jointodo
'get gloves,get mask,give cat vitamins,call ambulance'
>>>
```
### 4.7. replaceによる変換
```python=+
>>> alphabet = 'abcdefghijklmn'
>>> alphabet.replace('a', 'AAA')
'AAAbcdefghijklmn'
```
> その他、多彩な文字列操作が行えるが、ここでは紹介を控える
> 興味がある人は標準ドキュメント(http://bit.ly/py-docs-strings)を参照してください。


## 5. リスト・タプル・辞書型・集合
### 5.1. リスト
> 1. 要素の順番を管理できるため、順序と内容が変わるオブジェクトの操作に向いている
> 1. ミュータブルであるため、内容を直接書き換えることができる。要素の追加・削除・書き換えが可能
> 1. 要素はいくつ重複してもよい
> 1. 配列とは違いどんなオブジェクトでも格納できる
#### 5.1.1. リスト作成
```python=
>>> empty_list = []
>>> empty_list_func = list()
>>> weekday = ['Sunday', 'Monday', 'Tuesday']
>>> int_list = [1, 2, 3, 4, 5, -1, 10]
>>> empty_list
[]
>>> empty_list_func
[]
>>> weekday
['Sunday', 'Monday', 'Tuesday']
>>> int_list
[1, 2, 3, 4, 5, -1, 10]
```
#### 5.1.2. 要素の取り出し(内包する要素を超えるとIndexErrorが発生する)
```python=+
>>> # インデックス指定の取り出し
>>> weekday[0]
'Sunday'
>>> weekday[-1]
'Tuesday'

>>> # 最大値・最小値の取り出し
>>> min(int_list)
-1
>>> max(int_list)
10
```

### 5.2. タプル
> 1. タプルは消費スペースが小さい
> 1. タプルはイミュータブル(書き換え不可)のため、要素を誤って書き換える危険がない
> 1. タプルは辞書のキーとして使用できる
> 1. 名前付きタプルは、オブジェクトの単純な代用品として使える
> 1. 関数の引数はタプルとして渡される

#### 5.2.1. タプル作成
```python=+
>>> # 空のタプル
>>> tuple = ()
>>> tuple
()
>>> # 1つ以上の要素を持つタプルはカンマで区切る(要素が1つの場合も末尾にカンマをつけて作る)
>>> tuple = 'test',
>>> multi_tuple = 'a','b','c' # 複数要素の場合の末尾のカンマは省略可能
>>> tuple
('test',)
>>> multi_tuple
('a', 'b', 'c')
```

### 5.3. 辞書
> 1. 要素の順序が管理されていないので、要素を選択するときにオフセットは使用しない
> 1. 値を「Key:Value」形式で持つため、Key(一意である)で値を取得する
> 1. Keyは文字列の場合が多いが、Pythonのイミュータブル型なら何でもよい

#### 5.3.1. 辞書作成
> Json形式を思い出してもらえると嬉しい
```python=
>>> empty_dict = {}
>>> empty_dict
{}
>>> dict = {'a':'aaa','b':'bbb','c':'ccc'}
>>> dict
{'a': 'aaa', 'b': 'bbb', 'c': 'ccc'}
```
#### 5.3.2. keysによるすべてのキーの取得
```python=+
>>> loldict.keys()
dict_keys(['a', 'b', 'c', 'd'])
```
#### 5.3.3. valuesによるすべての値の取得
```python=+
>>> loldict.values()
dict_values(['A', 'B', 'C', 'D'])
```
#### 5.3.4. itemsによるすべてのキー/バリューペアの取得
```python=+
>>> loldict.items()
dict_items([('a', 'A'), ('b', 'B'), ('c', 'C'), ('d', 'D')])
```

#### 5.4. 集合
> 1. 一意の値のみを持つオブジェクト

---

## 6. 処理構造
### 6.1. if elif else
```python=
>>> def test(intA): # 「def」は関数の宣言
...   if intA == 0:
...     print('0!')
...   elif intA == 1:
...     print('1!')
...   else:
...     print('No!')
...
>>> test(0)
0!
>>> test(1)
1!
>>> test(2)
No!
>>>
```
### 6.2. 比較演算子
| 演算子 | 説明 |
| -------- | -------- |
| == | 等しい |
| != | 等しくない |
| <  | より小さい |
| <= | 以下 |
| >  | より大きい |
| >= | 以上 |
| in ... | 要素になっている |
### 6.3. Trueとは何か？
| FalseとみなされるPythonの値 | 説明 |
| -------- | -------- |
| False | BooleanのFalse |
| None | Null |
| 0 | 整数の0 |
| 0.0 | floatの0 |
| '' | 空文字列 |
| [] | 空リスト |
| () | 空タプル |
| {} | 空辞書 |
| set() | 空集合 |
> 上記を使用して、Falseだけではなく空データ構造かどうかをチェックできる
```python=
>>> some_list = []
>>> if some_list:
...   print("There's something in here")
... else:
...   print('empty!')
...
empty!
```
## 7. ループ
### 7.1. WhileとFor
```python=
>>> count = 1
>>> while count <= 5:
...   print(count)
...   count += 1
...
1
2
3
4
5
>>> numbers = 1,2,3,4,5
>>> position = 0
>>> while position < len(numbers):
...   print(numbers[position])
...   position += 1
1
2
3
4
5
>>>
>>> # forで書き直し
>>> for number in numbers:
...   print(number)
...
1
2
3
4
5
```
#### 7.1.1. breakによるループ中止
```python=
>>> while True: # 無限ループ
...   # コンソールでのインプットを受け取る
...   inputdata = input('type q to quit:')
...   if inputdata == 'q':
...     break
...   print(inputdata.capitalize())
...
type q to quit:a # <-[a]を入力した
A
type q to quit:b # <-[b]を入力した
B
type q to quit:q # <-[q]を入力したことでループが終了
```
#### 7.1.2. continueによる次のイテレーションの開始
```python=
>>> while True: # 無限ループ
...   # コンソールでのインプットを受け取る
...   value = input('type q to quit: ')
...   if value == 'q': # 終了する
...     break
...   if value == 'a': # 次のイテレーションへ移動
...     continue
...   print(value.capitalize())
...
type q to quit: a # <-[a]を入力したのでコンティニュー
type q to quit: b # <-[b]を入力した
B
type q to quit: test # <-[test]を入力した
TEST
type q to quit: q # <-[q]を入力したことでループが終了
```
#### 7.1.3. rangeによる数値シーケンスの作成
あらかじめリストやタプルなどの大きなデータ構造体を作ってそこに値を格納しなくても、指定した範囲の数値ストリームを返すことができる。range(start, end, step)というスライスと似た形式で使用し、startを省略すると0が先頭になる。endは必須引数。
```python=
>>> # 0~2までのプリント
>>> for tmp in range(0,3):
...   print(tmp)
...
0
1
2
>>>
>>> # 0~2までのリスト作成
>>> list(range(0, 3))
[0, 1, 2]
```
## 8. 関数
### 8.1. 関数宣言
```python=
>>> def test(intA):
...   if intA == 0:
...     print('0!')
...   elif intA == 1:
...     print('1!')
...   else:
...     print('No!')
...
>>> test(0)
0!
>>> test(1)
1!
>>> test(2)
No!
>>>
```
* 「def」で定義する
* 「()」内に引数を指定する
* 戻り値はreturnで指定するだけで宣言に加えない
#### 8.1.1. 位置引数
> 先頭から順に対応する位置の仮引数にコピーされる
> 他言語と同様な一般的な引数の指定方法
```python=+
>>> test(0)
0!
```
#### 8.1.2. キーワード引数
> 仮引数に名前を指定して実引数を指定する方法で、関数定義と引数の順序が異なっていても構わない。
> 関数を呼び出す側の指定の仕方による。
> 位置引数とキーワード引数の両方を使って関数を呼び出すことが可能だが、先に一引数を指定しなければならない。
```python=+
>>> test(intA=0)
0!
```
#### 8.1.3. デフォルト引数の指定
> 仮引数にはデフォルト値を指定することができる。呼び出し元が対応する実引数を渡してこなかったときに使用される。
:::danger
デフォルト引数が計算されるのは、**関数が実行された時ではなく、定義されたとき**なので、リストや辞書型などのミュータブル(変更可能)なデータ型をデフォルト引数として使ってしまうと、**前回の呼び出しでセットされた値が残ってしまい**、想定とは違う動きになってしまうので注意が必要 :fire:
:::
```python=+
>>> def test2(intA, intB=10):
...   if intA == 0:
...     print('0!')
...   elif intA == 1:
...     print('1!')
...   else:
...     print('No!')
...   if intB == 10:
...     print('Default')
...
>>> test2(10)
No!
Default
>>> test2(1,2)
1!
```
#### 8.1.4. *による位置引数のタプル化
> 仮引数の一部として*を使うと、可変個の位置引数をタプルにまとめてその仮引数にセットすることができる。
```python=+
>>> def print_args(*args):
...   print('tuple:', args)
...
>>> print_args(1,2,'a','arg','oh!!')
tuple: (1, 2, 'a', 'arg', 'oh!!')
```
#### 8.1.5. \**によるキーワード引数の辞書化
> 二つのアスタリスクを使えば、キーワード引数を1個の辞書にまとめることができる。引数の名前は辞書のキー、引数の値は辞書の値になる。
```python=+
>>> def print_kwargs(**kwargs):
...   print('keyword args:', kwargs)
...
>>> print_kwargs(wine='merlot', entree='mutton', dessert='macaroon')
keyword args: {'wine': 'merlot', 'entree': 'mutton', 'dessert': 'macaroon'}
```

## 9. map・filter・lambda関数
### 9.1. lambda関数
> 無名関数(defで宣言せず、変数などに直接代入して使用するもの)
```python=+
# 引数xを2倍するLambda関数
>>> x2 = lambda x : x * 2
>>> x2(4)
8
```
### 9.2. map
> リストのすべての要素に対して同様の処理を適用するもの
```python=+
>>> strnums = ['1', '2', '3', '4', '5']
>>> strnums
['1', '2', '3', '4', '5']
>>> nums = list(map(int, strnums)) # 文字列の数値リストを整数型に変換する
>>> nums
[1, 2, 3, 4, 5]
>>> list(map(lambda x : x * 2, nums)) # 整数型にしたリストの値を2倍にする
[2, 4, 6, 8, 10]
```
### 9.3. filter
> リストから任意の値のみ取り出すもの
```python=+
>>> nums = [1,2,3,4,5,6,7,8,9,10]
>>> nums
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# リストから偶数の物だけ取り出す
>>> list(filter(lambda x : (x % 2) == 0, nums))
[2, 4, 6, 8, 10]
```
