Pythonの基礎基本を30分ですべて終わらせる

# Python(Django)でWebアプリ作成までの道#1

今回は、webアプリケーション作成をするために
参考書で勉強したことなどをまとめて行こうと思います。
初歩的なところも、復習も兼ねて読みつつ自分なりにまとめて記事にしていくので
更新頻度が多少遅くなりますが、是非見ていってアドバイスもらえると嬉しいです。

# Pythonの基礎を学ぶ
今回は、PythonのWebアプリケーションフレームワークであるDjangoを使うので
Pythonから学んで行こうと思います。(理解してるよって人も復讐も兼ねて見てみてね)
今更、Python勉強するなやって人も居ますかも知れませんが後輩たちや自分の基礎の復讐も兼ねて作ります。

## Pythonの魅力
Pythonは他の言語に比べて文法がシンプル！
Python「**;**」などで区切りはしませんが、インデントが非常に重要になって来ます。
また、「**:**」ごとにインデントを設定することで階層が見やすくなっています。
インデントを大切にしていることで文法に従って書くことで、自然と読みやすいコードになります。

```python
start = 'yes'
if start == 'yes':
    print('Hello World!')
```

##今回の実行環境
Pythonの勉強をしている人たちであれば、ローカルで作業するのも容易ですが。
初めて触る方や、ローカルでの開発環境づくりで勉強もやめてしまう人も多いと思います。
なので、今回の軽くPythonを振り返る会では、Google Colaboratoryを使用する事をお勧めします。
内容的には、ローカルでも実行可能です。
[Google Colaratory](https://colab.research.google.com/notebooks/intro.ipynb?hl=ja)

##Pythonの基礎基本
ここから、Pythonに関する説明、復習をまとめて行こうと思います。
主に、計算、変数、型、演算子、文法、モジュールなどです。
**print**を使って基本的に表示をしていきます。

###四則演算(足算、引き算、掛け算、割り算)
まずは、基礎基本の四則演算からです。
最も使う物でもあるのでしっかり覚えておいてください。
また、計算を行う順番などは数学と同じです。

```python
--- 足算 ---
>> print(1 + 1) #実行コード
-- 2 #出力結果

#「”」で囲むと文字列になります
>> print("1 + 1")
-- 1 + 1

#型の違う物同士は足算できません
>> print("文字" + 2)
-- TypeError: can only concatenate str (not "int") to str

#int()を使うことで文字列を数値にできます。
>> print(12 + int("17"))
-- 29

--- 引き算 ---
>> print(3 - 1)
-- 2

--- 掛け算 ---
>> print(4 * 5)
-- 20

--- 割り算 ---
>> print(12 / 4)
-- 3

>> print(5 / 3)
-- 1.6666666666666667

#商の値だけを計算
>> print(5 // 3)
-- 1 

#余りの値だけを計算
>> print(5 % 3)
-- 2
```

### 変数について
計算を行う過程で同じ数字や文字列が出て来ます。
その過程で、毎度書いているとコードが複雑になってくるのでこう言うときに、変数を使います。
変数は簡単に言うとデータを格納して置く箱です。
あらかじめデータを用意しといて何度でも使うことができます。

~~ **変数の書式** ~~
変数名 = 代入する値

注意点なのですが、「**=**」は、右の値を左に代入と意味になっています。
また、同じ変数に代入(=)をすると前者に入力した値は消えて後者の値のみ残ります。

```python
#例1
>> name = "miryuu"
>> print(name)
-- miryuu

#例2
>> tax = 1.1
>> pan = 500
>> print(pan * tax)
-- 550.0

#round関数を使うと少数を丸め込めます　
>> tax = 0.5 
>> pen = 3.5
>> print(round(pen * tax))
-- 2

#user名を変数として利用
>> user = "miryuu"
>> print("こんばんわ。" + user + "さん")
-- こんばんわ。miryuuさん

#同じ変数に代入
>> name = "miryuu"
>> name = "ruru"
>> print(name)
-- ruru

#変数の値を足し合わせて保存(累算代入演算子)
>> total = 0
>> tax = 1.1
>> pen = 500
>> note = 350 

>> total = pen * tax #(total = 550)
>> total += note * tax #(total = 1485)
>> print(total)
-- 1485
```
備考：少数の丸め込みに使ったround()関数　動きだけだと四捨五入に見えるが実は違う
> 端数が0.5より小さいなら切り捨て、端数が0.5より大きいならは切り上げ、端数がちょうど0.5なら切り捨てと切り上げのうち結果が偶数となる方へ丸める。
[出典:端数処理 wikipedia](https://ja.wikipedia.org/wiki/%E7%AB%AF%E6%95%B0%E5%87%A6%E7%90%86#%E5%81%B6%E6%95%B0%E3%81%B8%E3%81%AE%E4%B8%B8%E3%82%81%EF%BC%88round_to_even%EF%BC%89)


### リスト、辞書、タプルについて
変数以外にもリスト、辞書、タプルなどのデータを格納する手段があります。

<dl>
  <dt>リスト</dt>
  <dd>複数のオブジェクトや、string型(文字列)やint型(数値)などの様々な要素を持つことができます。</dd>
  <dd>簡単なイメージで言うと、変数を並べておいた様な箱です。</dd>
  <dt>タプル</dt>
  <dd>タプルはリスト同様に変数を並べた様な箱です。しかし、タプルでは要素の「追加、編集、削除」ができません。</dd>
  <dd>容量もリストより比較的に小さいですが、計算速度は比較的に早いです
  <dt>辞書</dt>
  <dd>辞書は、keyとvalueがペアになって構成されています。</dd>
</dl>
>[追記] [タプルの有効的な使い方](https://www.lifewithpython.com/2017/12/python-tuple-list-difference.html)

**[リストの書式](#リスト)**

**[要素0,要素1,要素2]**

最初を「**[**」で囲って終わりを「**]**」で囲います。
要素と要素の間には「**,**」を使います


**[タプルの書式](#タプル)**

**(要素0,要素1,要素2)**
**要素0,要素1,要素2**
**要素0,**

最初を「**(**」で囲って終わりを「**)**」で囲います。
また、「**(**」,「**)**」は省略が可能です。
その代わりに要素と要素の間に挟む「**,**」はタプルでは非常に大事です。

**[辞書の書式](#辞書)**

**{ key0 : value0 , key1 : value1 , ...}**

最初を「**{**」で囲って終わりを「**}**」で囲います。
keyとvalueは「**:**」を使って1セットに組み合わせます。
要素と要素の間には「**,**」を使います

####リスト
```python
#リストについて
>> print(["生き物",4,"23","まめ"])
-- ['生き物', 4, '23', 'まめ']

#変数への代入と要素の取得(リスト(配列)を格納した値の後ろに[]をつける。)
>> name = ["ヘッドホン","マウス","キーボード"]
>> print(name[0]) #最初の値から0,1,2..と順に並んでます
-- ヘッドホン
>> print(name[2])
-- キーボード

#リストに要素を追加
>> name = ["ヘッドホン","マウス","キーボード"]
>> name.append("マイク")
>> print(name)
-- ['ヘッドホン','マウス','キーボード','マイク']

#リストの要素を指定して削除(pop)
>> name = ["ヘッドホン","マウス","キーボード","マイク"]
>> print(name.pop(0)) #popを使うと消した値を取得できる
-- ヘッドホン
>> print(name)
-- ['マウス','キーボード','マイク']

#リストの要素を指定して削除(del)
>> name = ["ヘッドホン","マウス","キーボード","マイク"]
>> del name[0] #こちらは消した値の取得は行いません。
>> print(name)
-- ['マウス','キーボード','マイク']

#リストの指定したインデックスの値を更新
>> name = ["ヘッドホン","マウス","キーボード","マイク"]
>> name[0] = "イヤホン"
>> print(name) 
-- ['イヤホン','マウス','キーボード','マイク']
```
####タプル 

```python
#基本的変数への代入
>> name = ("ヘッドホン","マウス","キーボード","マイク")
>> print(name)
-- ('ヘッドホン','マウス','キーボード','マイク')

#タプルの要素を取得
>> name = ("ヘッドホン","マウス","キーボード","マイク")
>> print(name[1])
-- マウス

#括弧を省いたタプルの書式
>> n = 1, 2
>> print(type(n)) #type() オブジェクトの型の取得と確認に使えます
-- <class tuple>
>> n = 1,
>> print(type(n))
-- <class tuple>
```

####辞書
```python
#基本的変数への代入
>> name = {"ヘッドホン" : 1500, "マウス" : 600, "キーボード" : 2400}
>> print(name["ヘッドホン"])
-- 1500

#valueにリストを追加
>> name = {"miryuu" : ["男性", "175cm"], "shiba" : ["男性", "175cm"]}
>> print(name["miryuu"])
-- ['男性', '175cm']

#リストと辞書を組み合わせ
>> name = [ #行を変えて見やすくすることが可能　最初と最後の括弧を忘れない様に
->     {"名前" : "miryuu", "性別" : "男性", "身長" : "175cm"}
->     {"名前" : "shiba", "性別" : "男性", "身長" : "176cm"}]
>> print(name[1]["身長"])
-- 176cm
```

### 比較演算子、論理演算子

比較演算子は、主に二つの数式を比較し結果にTrueまたはFalseを返す。

| 記号 |　働き(条件を満たすときTrue)　|
|:-:|:-:|
| == | 左右が同じ |
| != | 左右が異なる |
| < | 左の値が右の値未満である |
| <= | 左の値が右の値以下である |
| > | 左の値が右の値より大きい |
| >= | 左の値は右の値以上である |

理論演算子は、比較演算子と組み合わせて使うことでより複雑な判定を行うことができる。

| 記号 | 意味 |　意訳 |
|:-:|:-:|:-:|
| and | 論理積（かつ）| 両方ともの条件を満たす時 |
| not | 否定(ではない) | 対象のものを含まない、またはそれではない |
| or | 理論和(または) | どちらかが成立する時 |

```python
#比較演算子、論理演算子の活用例
# (==)基本動作
>> test = 70
>> print(test == 70)
-- True
# (<), (and) 基本動作
>> min = 60
>> math = 75
>> history = 45
>> print(min < math and min < history)
-- False

#(<=), (and) 基本動作
>> min 60
>> math = 75
>> science = 60
>> print(min <= math and min <= science)
-- True

#(<), (or) 基本動作
>> min = 45
>> math = 30
>> japanese = 50
>>print( min < math or min < japanese)
-- True

```

##Pythonの文法
Pythonを書く上で基本になり、これがないとプログラミングが始まらないよ！
って言うところに進んでいきたいと思います。内容としては、
条件分岐、繰り返し、例外処理、関数について、クラスについてなどなど

###条件分岐

条件分岐の定番**if文**、「もし〜したら、〜する」というパターン指定するプログラム。

####**ifの書式**

急に難しくなった様に見えますが、ひとつひとつは簡単です。

1. **if** の条件式がTrueだった場合、処理0のみ実行します
1. **if** の条件式がFlaseだった場合、処理0は実行されず。**elif**の条件式がTrueだった場合、処理1のみ実行します。
1. **if** の処理がFalseだった場合、処理0は実行されず。 **elif**の条件式がFalseだった場合、処理1は実行されず。**else**の処理2のみ実行します。

ひとつひとつの処理を順に、しっかりと読み取って行くことが大切です。

```
#ifの書式
if 条件式:
    処理0
elif 条件式:
    処理1
else:
    処理2
```

下は、テストの平均を数学のテストの点数が超えたかを条件式にしたものです。
条件式は、もっと複雑にすることも可能ですが、抜け穴などが内容にしっかり条件をカバーすることが大切です。

```python
#ifの活用例
>> average = 60
>> math = 75
>> if average =< math:
->     print("数学が平均点を超えた")
-> elif average == math:
->     print("平均点と同じだった")
-> else:
->     print("平均点以下だった")
-- 数学が平均点を超えた

>> average = 60
>> math = 45
>> if average =< math:
->     print("数学が平均点を超えた")
-> elif average == math:
->     print("平均点と同じだった")
-> else:
->     print("平均点以下だった")
-- 平均点以下だった
```

###繰り返し

いつも頼ってばかりの繰り返しです。
繰り返しには、**while文**と**for文**があります。

| 繰り返し | 条件と動き |
|:-:|:-:|
| while | 条件式が満たされている間繰り返し処理を実行する |
| for | リスト等から要素を取り出し終わるまで繰り返し処理を実行する |

####**whileの書式**

```python
#whileの書式
while 条件式: #条件式がTrueの時処理が実行される
    処理
```

####**forの書式**

for文を初めて見る人に難しいと思うので説明を追加します。
1. リスト等の中身を変数に代入します。
2. リストの中身がなくなるまで繰り返し処理が実行されます

```python
#forの書式
for 変数 in リスト等: 
    処理
```

whileとforの利用例を見てみましょう
for文の例で**range関数**と**enumerate関数**を説明してます。
使える機会も多いので覚えると便利です。

```python
#whileの活用例
>> num = 0
>> while num < 3: #numが３未満の間繰り返されます
->     print(num)
->     num += 1
-- 0
-- 1
-- 2

#forの活用例
>> for name in ["ヘッドホン","マウス","キーボード"]: #要素が3個なので三回繰り返されます。
->     print(name)
-- ヘッドホン
-- マウス
-- キーボード

#range関数
>> for i in range(3): #今回の場合、与えた数字分0から数値を代入してくれます
->     print(i)
-- 0
-- 1
-- 2

#emurate関数 簡単な表現だと何周目かわかりやすい
>> for index, v in enumerate(["ヘッドホン","マウス","キーボード"]): #インデックスと中の値を返す
->     print(index, v) #print(index, v)はprint(index + " " + v)と同じ役割をします。
-- 0 ヘッドホン
-- 1 マウス
-- 2 キーボード
```

###breakとcontinue

whileは、条件を満たしている間は、永遠に処理が終わりません。無限ループという状態です。
それを強制的に終わらせるのが、**break**です。
また、**continue**を使うことで次のループまで処理をスキップします。

```python
#breakの使い方
>>while True:
->    s = str(input("y/n")) #input関数を使うと入力フォームが出て来ます。リアルタイム値を入力
->    if s == "y": #yを入力した際の条件分岐
->        print("yes")
->        break
->    elif s == "n": #nを入力した際の条件分岐
->        print("no")
->        break
->    else: #y,n以外の入力があった際の条件分岐
->        print("正しく入力してください")

#continue
>> for i in range(3):
->     if i == 0:
->         print(i)
->     elif i == 1: #printの前にcontinueがあるので条件が成立されてもprintは動きません
->         continue
->         print(i)
->     else:
->         print("elseだよ)
-- 0
-- elseだよ
```

###例外処理
どの様な開発でもバグやエラーは付き物ですが、バグやエラーを想定することで、
エラーのたびに落ちてしまう事を防ぎより良い改善をすることができます。
そのために使うのが、**try**,**except**です。

####**try,exceptの書式**

```python
#try,exceptの書式
>> try:
->      正常な場合の処理
-> except:
->      エラーが出たときの処理

>> try:
->     正常な場合の処理
-> except Exception as e:
->     print(e.args) #プリントでエラーの内容を表示
```

書き方にはたくさんあるのですが、その中での一例を紹介します。
また、エラーをファイルとして書き出すことや、多くのエラーが発生してしまった場合は、
**ブレイクポイント(import pdb; pdb.set_trace())**を使うことで、その時点での変数の中身を
確認したり、関数を打ち込んで返り値を確認したりすることができる。

```python
#try,exceptの活用例
>> try:
->     print(5 + "5") #数値(int) + 文字列(string)なのでエラーになる
-> except:
->     print("error")
-- error

>> x = {0 : "0だよ", 1 : "1だよ", 3 : "3だよ", 5 : "5だよ"}
>> for n in range(5):
->     try:
->         print(x[n])
->     except Exception as e:
->         print("error", e.args)
-- 0だよ
-- 1だよ
-- error (2,)
-- 3だよ
-- error (4,)

#tracebackモジュール　traceback.format_exc()を使うと、エラーの詳細がわかる
>> import traceback
>>x = {0 : "0だよ", 1 : "1だよ", 3 : "3だよ", 5 : "5だよ"}
>> for n in range(5):
->     try:
->         print(x[n])
->     except:
->         print(tracebacl.format_exc())
-- 0だよ
-- 1だよ
-- error内容 #KeyError: 2(省略)
-- 3だよ
-- error内容 #KeyError: 4(省略)
```

###関数について
関数を使うことで、プログラムのまとまりを何回でも呼び出すことができる。
何度も同じプログラムを書く必要性がなくなります。

####**関数の書式**

```python
>> def 関数名(引数,引数...):
->     処理
->     return 返り値

#最小関数
>> def 関数名():
->     処理
```

上の様に、任意の関数名を決め、与えたい量の引数を与えて処理を行うことができます。
また、中で行った処理の結果を返すことができます。
関数において、引数と返り値はなくても動きます。

```python
#活用例
>> def print_user(user):
->     print(user + "さん。")
>> print_user('miryuu') #関数呼び出し
-- miryuuさん。 #出力結果
>> print_user('shiba')
-- shibaさん。

>> def cal_tax(money):
->     tax = 1.1
->     return money * tax
>> tax_money = cal_tax(100)
>> print(tax_money)
-- 110
```

###クラスについて
クラスは、変数や関数を組み合わせた設計図の様なものです。
クラスには重要な用語として、インスタンス化とインスタンスがあります。

| クラス | インスタンス化 | インスタンス |
|:-:|:-:|:-:|
| 設計図 | 設計図で作成 | 設計図で作成した物 |

こんなイメージを持ってもらえたらいいと思います。
クラスには、書式と言う書式がないので、実際の例から説明していきます。

```python
>> class user:
->     def __init__(self, name, age): #インスタンス化の時実行される。
->         self.name = name
->         self.age = age
->         print("インスタンス化されたよ")
->
->     def check(self):
->         print(self.name,str(self.age)) #str()数値を文字列にしています。
>>
>> miryuu = user("miryuu", 20) #クラスを変数に代入する事をインスタンス化、できた変数をインスタンスとしている
-- インスタンス化されたよ
>> print(miryuu.name)
-- miryuu
>> miryuu.check()
-- miryuu 20
```

コード内にも書きましたがこちらにも詳しく説明を加えます。
**class 変数名**を作り中に関数を作っています。
**__init__**を使って宣言された関数はインスタンス化したときに実行されます。
**self**はインスタンス自身を示しており、インスタンス変数やクラス内の関数を使用する際に用います。
（ここ結構わかりにくいかも）要するに、インスタンスごとにselfの中身は別物だよと言う事

###クラスの継承
クラスに追加機能を加えたりする際に使えます。
最初に、全てに適応するクラスを作った後に細かに分けるときなどに使えます。

人クラス（最小）→ 日本人クラス → 武蔵野大学学生クラス

| クラス | 変数 | 
|:-:|:-:|
| 人クラス(最小) | 名前、年齢 |  
| 日本人クラス | 名前、年齢、国籍 |  
| 某大学生クラス | 名前、年齢、国籍、学籍番号 |   

この様な感じに、クラスが深くなって行く中で名前や年齢など上から引き継げるものを引き継ぎのがクラスの継承です。
もちろん、変数だけでなく関数も引き継がれます。

```python
>> class human:
->     def __init__(self, name, age):
->         self.name = name
->         self.age = age
->         print("インスタンス化されたよ")
->
->     def check(self):
->         print(self.name,str(self.age)) #str()数値を文字列にしています。
>>
>> class jp_human(human):
->     def __init__(self, name, age):
->         super().__init__(name, age) #super関数、継承元のinit関数も動かす時に使用
->         self.country = "japanese"
->
->     def jp_check(self):
->         if self.country == "japanese":
->             print(self.name,"is",self.country)
>>
>> miryuu = jp_human("miryuu",20)
>> miryuu.jp_check()
-- miryuu is japanese
```

最初うまく理解できないと言う人も多いかも知れませんが実際にコードを動かしてみる事をお勧めします。
これまでに、大体大まかなpythonの説明は終わりました。
ここにパッケージやモジュールやライブラリーを入れる事でやれる事がかなり増えますが、今回はそこに触れません。
実際に、何かしらのコードを実際に作ってみると理解力が上がると思います。

私からおすすめの問題をいくつか下に用意するので、もしよかったらやってみてください。

##pythonおすすめ問題！(By miryuu)

### 数学の公式の実装！
ここでは、数学としていますが自分が機能をよく理解しているものを実装する事で、
pythonではどの様に書けばいいのかわかる様になります。
もし、実際の数学の公式等の機能を使いたいならライブラリーを使った方が絶対にいいです。
なるべく特定の条件の時でなく、どの様な値を入れても動く様に作ってみてください。

おすすめの公式や計算の実装(簡単な順)
1. シグマの実装(指定した範囲の合計)
2. ユークリッド距離の計算(２点間の距離) *ヒント:ルートはmath.sqrt()関数を使うといいです。
3. インテグラル（積分法の実装）

最近自分が実装して楽しんでいたのは、機械学習のパッケージを使わずに機械学習のアルゴリズムを実装でした。

##参考文献
今回お世話になっている本です。もっと詳しい事が下の中に書いてあるのでもしよかったら見てみてください。
Pythonのことだけを学びたいなら他の本の方がいいと思いますが、実際にwebアプリ作りたいならこれがおすすめ
[プロフェッショナルWebプログラミング Django](https://www.amazon.co.jp/%E3%83%97%E3%83%AD%E3%83%95%E3%82%A7%E3%83%83%E3%82%B7%E3%83%A7%E3%83%8A%E3%83%ABWeb%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0-Django-%E7%94%B0%E4%B8%AD-%E6%BD%A4/dp/4295201065/ref=sr_1_3_sspa?__mk_ja_JP=%E3%82%AB%E3%82%BF%E3%82%AB%E3%83%8A&dchild=1&keywords=django&qid=1622078799&sr=8-3-spons&psc=1&spLa=ZW5jcnlwdGVkUXVhbGlmaWVyPUEyUkNGS1NXNlZTUjhKJmVuY3J5cHRlZElkPUEwNjYzMzEwMzFBNzhFQkg1TDlEJmVuY3J5cHRlZEFkSWQ9QTJaTlFPVlVGMElUWDMmd2lkZ2V0TmFtZT1zcF9hdGYmYWN0aW9uPWNsaWNrUmVkaXJlY3QmZG9Ob3RMb2dDbGljaz10cnVl)