[Python]基本文法を個人的にまとめた。

Pythonについて、理解を深めるためにまとめる。
随時更新していく。

参考文献
☆国本大悟/須藤秋良『スッキリわかるPython入門』

##流れ
#####①ソースコードの作成
ソースファイルの拡張子は`「.py」`

#####②実行
・`Pythonインタプリタ`（：ソフトウェア）によって
　ソースコードを`マシン語`（：コンピュータが理解できる言葉）に変換する
・文法上誤りがあれば`SyntaxError（構文エラー）`が表示される
・`例外（Exception）`（：実行時のエラー）時は実行が中止になる

##式
#####【算術演算子】
`/`：割り算（答えは`小数`）
`//`：割り算の商（答えは整数）
`**`：べき乗
`*`：文字列の反復（`文字列 * 数値`もしくは`数値 * 文字列`）

[優先順位]
高：`**`
中：`*`、`/`、`%`
低：`+`、`-`

    print(1 + 1 * 7)   --8
    print((1 + 1) * 7) --14、丸かっこで優先度を上げることが可能

#####【エスケープシーケンス】
文字列リテラルの使用時に用いられる特殊記号

`\n`：改行
`\\`：バックスラッシュ
`\'`：シングルクォーテーション
`\"`：ダブルクォーテーション
    
    print('おはよう\n諸君\\')
    print('\"と\'')

##変数
    変数名 = 値  #変数の代入
    変数名      #変数の参照

    print('半径7の円直径は')
    ans = 7 * 2   --代入
    print(ans)    --参照
    print('円周は')
    print(ans * 3.14)

    name, age = 'John', 33 --アンパック代入（：複数の変数をまとめて定義する方法）

#####【予約語】
    import keyword
    print(keyword.kwlist)
・`識別子`（：名前に使う文字や数字の並び）として利用不可の単語
・上記コードで確認できる
・中身を固定したい時は、`大文字`で名付けることが多い
   
#####【複合代入演算子】
    age += 1      --「age = age + 1」と同じ
    price *= 1.1  --「price = price * 1.1」と同じ

#####【input関数】
    変数名 = input(文字列)

    name = input('名前教えて!')
    print('ようこそ！' + name)

キーボードからの入力を変数へ代入する
データ型は`str`型


##データ型
[主な一覧]
`int`：整数
`flaot`：小数
`str`：文字列
`bool`：真偽値

[変換]
`int関数`：小数以下は切り捨て、文字列はエラーになる
`float関数`：文字列はエラーになる
`str関数`
`bool関数`

・演算は`文字列`もしくは`数値`同士のみ連結が可能
・Pythonは`暗黙の型変換`（：自動的に型変換が行われる仕組み）`がない`ため、
　`明示的な型変換`を行わなければならない

#####【type関数】
変数はデータ型を持たない（＝`どのデータ型の値でも代入が可能`）
➡︎どのデータ型が格納されているかを調べる

    type(変数名)
    int(変数名)
    float(変数名)
    str(変数名)
    bool(変数名)

    x = 3.14
    y = int(x)      --int関数
    print(y) 
    print(type(y))  --type関数
    z = str(x)　　　 --str関数
    print(z)
    print(type(z))
    print(z * 2)

#####【format関数】
文字列に値を埋め込むことができる
{}＝`プレースホルダー`

    '{}を含む文字列'.format(値1,値2・・・)　

    name = '神'
    age = 77
    print('我が名は{}、年は{}である').format(name,age) --{}が値を埋め込む場所

#####【f-string関数】
Python3.6から導入された機能
プレースホルダー内に変数名(式もOK)を`直接指定`することが可能

    print(f'我が名は{name}、年は{age}である')

##コレクション（もしくはコンテナ）
関連するデータをグループ化して`1つの変数`として扱う仕組み

####❶【リスト（もしくは配列）】
[使用目的]
`順序性`を持つ複数データを`1つ`にまとめる

    変数名 = [要素1, 要素2・・・]    　#定義
    リスト[添え字]                　#参照
    リスト[変更値添え字] = 変更後値 　#変更

    members = ['さとう', 'たなか', 'すずき'] 
    members[0] = 'こばやし'     --「さとう」が「こばやし」に変更される
    print(members) 
    print(members[0])

#####【sum関数】
・リスト要素の`合計値`を計算する
・`文字列`が格納されているリストには`使えない`
・`タプル`、`セット`にも使える

    sum(リスト)

    scores = [70, 80, 90]
    total = sum(scores)
    print('合計は{}点です。'.format(total))

#####【len関数】
・リスト要素の`平均値`を計算する
・`ディクショナリ`、`タプル`、`セット`にも使える

    len(リスト)

    scores = [70, 80, 90]
    avg = total / len(scores)
    print('平均は{}点です。'.format(avg))

#####【append関数】
リスト要素を末尾に`追加`する

    リスト.append(追加値)

    members.append('Charotte')

#####【remove関数】
リスト要素から指定値を`削除`する

    リスト.remove(削除値)

    members.remove('Charotte')

#####【スライス文】
リスト要素の`範囲指定`ができる
`A:`➡︎添え字A以上の要素
`:B`➡︎添え字B未満の要素
`:`➡︎すべての要素
`-A`➡︎リスト末尾から数える（数え初めは`「1」`）

    リスト変数[A:B]　 #添え字A以上B未満の要素を参照
    リスト変数[-A]   #参照（負の数指定）

    scores = [70, 80, 90, 100]
    print(scores[0:2])  --70,80
    print(scores[1:])   --80,90,100
    print(scores[:3])   --70,80,90
    print(scores[:])    --70,80,90,100
    print(scores[-3])   --80

####❷【ディクショナリ（もしくはマップ）】
[使用目的]
複数データに`キー`を付けて管理する
➡︎Python3.7から順序性が機能追加

--
データ型の指定なし
キーの重複も可能（非推奨）
キーは大/小文字の区別を行う

    変数名 = {キー1:値1, キー2：値2・・・}  #定義
    ディクショナリ名[キー名]              #参照
    ディクショナリ名[追加キー名] = 追加値   #追加
    ディクショナリ名[変更キー名] = 変更後値　#変更

    scores = {'Japanese Language':70, 'Mathmatics':80, 'Science':90, 'Social Studies':100} 
    scores['English'] = 88
    scores['Science'] = 98
    print(scores['Social Studies']) 

#####【del文】
ディクショナリ要素を`削除`する

    del ディクショナリ名[削除するキー名]

    del scores['Mathmatics']

######【valuesメソッド】
ディクショナリ要素の`合計値`を計算する

    ディクショナリ名.values()

    total = sum(scores.values())
    print(total)

####❸【タプル】
リストと似た特徴を持つ（`ただし要素の追加、変更、削除ができない`）
リストとともに`シーケンス`と総称される

[使用目的]
`書き換える可能性のない`複数データを1つにまとめる

    変数名 = (値1, 値2・・・)

    points = (1, 2, 3) 
    print(points)

    members = ('James',)  --要素数1つのみのタプル(値の後ろにカンマをつける)
    print(type(members))

####❹【セット（もしくは集合）】
同じくリストと似た特徴を持つ(ただし`重複不可`、`添え字&キーなし`、`順序性なし`)

[使用目的]
`種類`をデータとして管理する

    変数名 = {値1, 値2・・・}

    numbers = {10, 20, 30, 30}
    print(numbers)

#####【add関数】
セットではappend関数の代わりに用いる
またセットには要素に`末尾がない`ため、ただ単に加わるだけになる

    セット.add(追加値)

    scores.add(100);

####相互変換
`list関数`：リストに変換する　　※`list（）`の場合、空コレクションが作成される
`tuple関数`：タプルに変換する
`set関数`：セットに変換する

    scores = {'Japanese Language':70, 'Mathmatics':80, 'Science':90, 'Social Studies':100}
    members = ['John', 'Mike', 'Jack']
    print(tuple(members))              --membersをタプルに変換
    print(list(scores))                --scoresをリストに変換
    print(set(scores.values()))        --scoresをセットに変換

    dict(zip(キーのリスト, 値のリスト))       #ディクショナリに変換する

####ネスト
    a_scores = {'Japanese Language':70, 'Mathmatics':80, 'Science':90, 'Social Studies':100}
    b_scores = {'Japanese Language':100, 'Mathmatics':90, 'Science':80, 'Social Studies':70}
    member_scores = {
      'A' = a_scores,
      'B' = b_scores,
    }
    --
    member_likes = {
      'C': {'ねこ', 'いちご'},
      'D': {'いぬ', 'みかん'}
    }
    print(member_likes)        --全員のlikesを表示
    print(member_likes['C'])   --Cのlikesを表示
    --
    x = [1, 2, 3]
    y = [11, 22, 33]
    z = [a, b]                --aを0番目、bを1番目とする二次元リスト（：リスト内に別リストを組み込んだ構造）
    print(z)                  --z全体を参照
    print(z[0])               --zのリストxを参照
    print(z[1][2])            --zのリストyを参照

####集合演算

[集合演算子]
`|演算子`：和集合
`-演算子`：差集合
`&演算子`：積集合
`^演算子`：対象差

    G = {1, 2, 3, 4}
    H = {2, 3, 4, 5}
    print(G | H)    --1,2,3,4,5
    print(G - H)    --1
    print(G & H)    --2,3,4
    print(G ^ H)    --1,5

`セット`のみの機能
ある2つのセットの`共通点`、`違い`を探し出す
    
    セット1 & セット2

    member_likes = {
      'E': {'野球', '肉'},
      'F': {'魚', '野球'}
    }
    common_likes = member_likes['E'] & member_likes['F']   
    print(common_likes)          

##条件分岐
`制御構造`：`文`（：1行毎の実行単位）の実行順を管理するプログラム構成
`構造化定理`：制御構造である`順次`、`分岐`、`繰り返し`の組み合わせによってプログラムが成り立つ

    name = 'よしこ'; print('私の名前は{}ではありません。'.format(name))　--行末にセミコロンを加えることで1行に複数文を記述することができる

#####【if-else文】
    if 条件式：　     --コロン忘れに注意
        ifブロック
    else:　　　　　　--コロン忘れに注意
        elseブロック

    name = input('名前を教えて>>')
    print('{}さん、よろしくね。'.format(name))
    food = input('{}さんの好きな食べ物は？>>'.format(name))
    if food == 'ケーキ':            　　　　　　　　　　　　
        print('美味しいですよね！')
    else:　　　　　　　　　　　　　　　　　　　　　　　　　　 
        print('{}もいいですね。'.format(food))

#####【pass】
    if 条件式:
        処理内容
    else:
        pass　　　　　--Pythonでは空ブロック不可のため、「pass」によって空ブロックを許可できる

#####【in演算子】
    if 'ケーキ' in food:　　　　　--foodにあるどの「ケーキ」も含める
    --
    scores = [70, 80, 90, 100]
    if 100 in scores:   　　　　--scoresに「100」があるか調べる
    --
    --
    キー名 in ディクショナリ名

    scores = {'Japanese Language':70, 'Mathmatics':80, 'Science':90, 'Social Studies':100}
    key = input('追加する科目名を入力してください。')
    if key in scores:         --scoresにkeyがあるか調べる

#####【論理演算子】
`and`：かつ
`or`：または
`not`：でなければ

    if score >= 70 and score <= 100:　　　　--70以上かつ100以下
    if 70 <= score <= 100:　　　　          --この書き方も可能（ただPython以外では不可）
    
    if score < 70 or score > 100:          --70未満または100より大きい
    if not (score < 70 and score > 100):   --70未満かつ100より上でなければ
    if not 'ケーキ' in food:                 --foodに「ケーキ」が含まれていなければ

    not(day in [28, 30, 31])　--変数dayの値が28、30、31でなければ

#####【if-elif文】
    if 条件式1：　     
        ifブロック
    elif 条件式2：
        elifブロック
    （else:　　　　　    #省略可能　
        elseブロック）

    score = int(input('点数を入力してください'))
    if score < 0 or score > 100:
        print('入力が間違っています。正確に入力し直してください')
    elif score >= 70:
        print('合格です。おめでとうございます。')
    else:
        print('不合格です。追試を受けてもらいます。')

#####【ネスト】
    print('質問にyesもしくはnoで回答してください。')
    money = input('所持金はありますか。')
    if money == 'yes':
        tight_eat = input('がっつり食べたいですか。')
        light_eat = input('軽く食べたいですか。')

        if tight_eat == 'yes':
            print('ラーメンはいかがですか。')
        elif light_eat == 'yes':
            print('サンドイッチはいかがですか。')
    else:
        print('家で食べましょう。')

#####【三項条件演算子】
    値1 if 条件式 else 値2

    div = '偶数' if number % 2 == 0 else '奇数'
    print('{}月です。'.format(div))

##繰り返し
####①【while文】
[使い分け]
繰り返し回数の`目処が立たない`場合

    while 条件式：
        whileブロック

    count = 0
    while count < 3:
        count += 1
        print('ひつじが{}匹'.format(count))
    print('おやすみ')

    ----
    count = 0
    student_num = int(input('生徒数を入力'))
    score_list = list()　#空リストの作成
    while count < student_num:
        count += 1
        score = input('{}人目の点数を入力'.format(count))
        score_list.append(score)　#入力された値を得点リストに追加
    print(score_list)
    total = sum(score_list)
    print('平均点は{}。'.format(total / student_num))
    
    ----
    カウンタ変数 = 0
    while カウンタ変数 < len(リスト):
        リスト[カウンタ変数]を用いた処理
        count += 1

    scores = [55, 77, 33, 99]
    count = 0
    while count < len(scores):　 #リスト要素を繰り返し条件に指定
        if scores[count] >= 60:　＊1 リストの添え字にカウンタ変数を指定
            print('合格です。おめでとうございます。')
        else:
            print('不合格です。追試を受けてもらいます。'）
        count += 1

`カウンタ変数`（もしくは`ループ変数`）➡︎繰り返す毎に値が変化する変数（ここで言うcount）
＊1　繰り返す度に自動的に変化して、リスト要素すべての参照が可能

#####【無限ループ】
    count = 0
    while count < 3:
        print('ひつじが{}匹'.format(count))
    print('おやすみ')

変数countを更新する記述（`count += 1`）がないため、繰り返しが終わらない

#####【フラグ】
    is_awake = True
    count = 0
    while is_awake == True:
        count += 1
        print('ひつじが{}匹'.format(count))
        key = input('寝そうですか。（yes/no）')
        if key == 'yes':
    	     is_awake = False
    print('おやすみ')

真偽値で状態を表す情報
フラグ名は`is_xxx`

####②【for文】
[使い分け]
繰り返し回数の`目処が立つ`場合

    for 変数 in リスト：
        forブロック

    scores = [55, 77, 33, 99]
    for data in scores:　
        if data >= 60:
            print('合格です。おめでとうございます。')
        else:
            print('不合格です。追試を受けてもらいます。'）


`自動的に`繰り返しが行われるため、繰り返し条件やカウンタ変数の記述が`不要`

#####【range関数】
    range(n)　#n回繰り返される（0以上n未満）

    for num in range(3):　--0,1,2
    print('ヨーソロー')

###【break文】
繰り返しの`強制終了`

    ages = [5, 7, 9, 12, 16, 18, 20, 24, 27, 30]
    num = 5　--抽出数
    samples = list()
    for data in ages:
        if 20 <= data >= 30:
            samples.append(data)
            if len(samples) == num:
                break
    print(samples)

###【continue文】

繰り返しの`スキップ`（特定の繰り返しを飛ばして、他の繰り返しに移行する）

    ages = [5, 7, 'ないしょ', 12, 16, 18, 20, 24, 27, 30]
    samples = list()
    for data in ages:
    if not isinstance(data, int):　 --数値でないデータをスキップ
        continue
        if 20 <= data >= 30:　      --条件に合致しないデータをスキップ
            continue
    samples.append(data)
    print(samples)

#####【isinstance関数】
データがデータ型と`一致`するか判定
データ型にはint、str、bool等が使用できる 

    isinstance(データ, データ型)

    isinstance("apple", str)    #True
    isinstance("apple", int)    #False
    isinstance("apple", object) #True

##関数
`部品化`：1つのプログラムを複数に分割すること

[メリット]
①可読性の向上（：プログラム全体の処理を把握しやすくなる）
②保守性の向上（：修正範囲を限定できる）
③作業効率の向上

`名前の衝突`：デフォルトで存在する関数名と同名を用いた場合、以前の関数は呼び出せなくなる
`ローカル変数の独立性`：定義された変数は、その関数内で`しか`使用できない
➡︎関数内で定義された変数                 

#####【def文】
    def 関数名（）：  #定義
        処理      --関数ブロック
    関数名（）       #呼び出し

    def hello():
        print('おはよう！')
    hello()

#####【引数】
    def hello(name):　#仮引数
        print('おはよう！{}ちゃん'.format(name))
    hello('よしこ')　　　#実引数
    hello('ヨハネ')　　　#実引数
    
    ----
    def 関数名（引数1, 引数2・・・）：  
        処理      
    関数名（引数1, 引数2・・・）       

    def profile(name, age, hobby):
        print('彼女は{}。'.format(name))
        print('{}歳。'.format(age))
        print('{}を弾くのが好き。'.format(hobby))
    profile('まき', 16, 'ピアノ')  --記述順に呼び出される

    ----
    def 関数名（仮引数名＝デフォルト値）:　
        処理
        return 戻り値

    def eat(breakfast, lunch, dinner='納豆'):
        print('朝は{}を食べました。'.format(breakfast))
        print('昼は{}を食べました。'.format(lunch))
        print('夜は{}を食べました。'.format(dinner))
    eat('ヨーグルト', 'そば')　--この場合dinnerの実引数は省略できる

    ----
    def eat(breakfast='バナナ', lunch, dinner): *1

    ----
    関数名（仮引数名1=実引数1, 仮引数名2=実引数2・・・）　#【キーワード指定】
                                                                                        
    def eat(breakfast, lunch='サンドイッチ', dinner='納豆'):  
        print('朝は{}を食べました。'.format(breakfast))
        print('昼は{}を食べました。'.format(lunch))
        print('夜は{}を食べました。'.format(dinner))
    --dinnerが「納豆」ではない場合（下記はすべて同じ意味）--
    eat(breakfast='お茶漬け', dinner='オムライス')　＊2　 
    eat(dinner='オムライス', breakfast='お茶漬け')  *2   
    eat('お茶漬け', dinner='オムライス')            *3

    ----
    def 関数名（仮引数名1, 仮引数名2・・・, *仮引数名）

    def eat(breakfast, lunch, dinner, *snack):  
        print('朝は{}を食べました。'.format(breakfast))
        print('昼は{}を食べました。'.format(lunch))
        print('夜は{}を食べました。'.format(dinner))
        for s in snack 
            print('おやつに{}を食べました。'.format(s))  
    eat('お茶漬け', 'オムライス', 'ハンバーグ', 'チョコ', 'アイスクリーム')　--snackに「チョコ」「アイスクリーム」が渡される

    ----
    def eat(**kwargs):
        for key in kwargs
            print('{}に{}を食べました。'.format(key, kwarge[key]))
    eat(朝ごはん='おにぎり', 昼ごはん='ドーナツ', 夜ごはん='うなぎ’)　--丸かっこ内がディクショナリとしてkwargsに渡される

    --グローバル変数--
    name = 'まき'
    def hello():
        print(name + 'ちゃん、おはよう')　--このnameはローカル変数ではない
    hello()

    --global文--
    global 変数名

    name = 'まき'
    def change_name():
        global name　--nameがグローバル変数であることを宣言
        name = 'えり' --nameへ代入
    def hello():
        print(name + 'ちゃん、おはよう')
    change_name()
    hello()

`デフォルト引数`：特定値が指定された仮引数
　　　　　　　　呼び出し時に実引数が指定されていない場合、そのままデフォルト値が表示される
　　　　　　　　指定後はすべての仮引数にデフォルト値の設定をしなければならない

＊1　デフォルト引数より`後ろ`には通常の仮引数は`定義できない`

`キーワード指定`
＊2　記述順に関わらず、指定の仮引数に渡される
＊3　キーワード指定のない実引数（ここで言うお茶漬け）は前から順の仮引数に渡される

`可変長変数`：固定値でなく`任意値`の仮引数
　　　　　　　`末尾`の仮引数にしか設定できない
　　　　　　　`*`：タプルとして受け取る
　　　　　　　`**`：ディクショナリとして受け取る

`グローバル変数`：すべての関数から参照して、データの利用ができる変数
　　　　　　　　　同名のローカル変数がある場合、ローカル変数が優先
　　　　　　　　　`global文`：1つの変数を複数関数で使用可能にする
　　　　　　　　　　　　　　　グローバル変数であることを明示的に宣言
[デメリット]
開発者の混乱やミスに繋がる恐れがあるため、チーム開発や中規模以上開発での使用は好ましくない

#####【戻り値】
    def 関数名（引数1, 引数2・・・）
        処理
        return 戻り値　#return文（戻り値は１つのみ）
    戻り値を受け取る変数名 = 関数名(引数1, 引数2・・・)

    def plus(x, y):
        answer = x * y　　--4行目answerとはまったくの別物
        return answer
    answer = plus(2, 7)　#関数呼び出し演算子
                         --plusの呼び出し後、「14」に化けて「answer=14」の代入文になる
    print('掛けると{}'.format(answer))

    ----
    def plus_and_minus(a, b)
        return a + b, a - b　　*1 タプルの丸かっこ省略
    next, prev = plus_and_minus(3, 8)　#タプルの戻り値にアンパック代入をしている

`関数呼び出し演算子`：呼び出し時に記述する（）
　　　　　　　　　　 呼び出し完了後に戻り値に化ける

＊1　`関数の戻り値`に用いる場合、省略が推奨（原則は非推奨）

##オブジェクト
あるデータとそのデータに関する処理を行う関数がひとかたまりになっているもの
Pythonではあらゆる値がオブジェクトに属する

[分類]
`可変`：中身の値や属性が書き換えられる　＊ほとんどが可変
`不変`：中身の値や属性が書き換えられない
　　　　➡︎`int`、`str`、`bool`、`tuple`

    names = list()　--リスト
    print('変更前のlistのidentity値: {}'.format(id(names))　--4421528648
    names.append('ほのか')
    print('変更後のlistのidentity値: {}'.format(id(names))　--4421528648

    name = `ことり`　--文字列
    print('変更前のstrのidentity値: {}'.format(id(name))　--4420992840
    name = 'ちゅんちゅん' + name
    print('変更後のstrのidentity値: {}'.format(id(name))　--4539526984

不変オブジェクトを書き換えた場合、別オブジェクトとして`生まれ変わる`
そして元のオブジェクトは`捨てられ`、最終的にはガベージコレクションによって自動的に`消滅`する

###【メソッド】
オブジェクトに所属する関数
➡︎オブジェクトが従える関数は`データ型`によって決まる
    
    --呼び出し--
    オブジェクト.メソッド名（引数）

    num = 10
    num.bit_length()

    names = ['だいや']
    names.append('るびぃ')

#####【str型】
`capitalize()`：頭文字のみ大文字
`lower()`：すべて小文字
`upper()`：すべて大文字
`title()`：各単語の頭文字を大文字
`strip()`：前後の空白を消す
`split(▲)`：▲で区切り、各要素をリストで返す
`replace(●,✖️)`：●を✖️に置き換えた結果を返す
`count(■)`：■が登場する回数を返す

    userinfo = input('名前と血液型を入力>>')
    [name, blood] = userinfo.split(',')
    blood = blood.upper().strip()
    print('{}さんは{}型です。'.format(name,blood))

###【クラス】
オブジェクトを作るための設計図

[生成方法]
①リテラルを用いる
`int`クラス：数字（小数点を含まない）
`float`クラス：数字（小数点を含む）
`str`クラス：文字（''や""で囲まれた）
`list`クラス：文字（［］で囲まれた）
`dict`クラス：文字（｛〜：〜｝で囲まれた）
`set`クラス：文字（｛〜｝で囲まれた）


②クラス名と同名の関数を呼び出す

    変数名 = クラス名（）

    int_value1 = 0          --intオブジェクト(中身0)を生成
    int_value2 = int()      
    int_value3 = int(7)     --intオブジェクト（中身7）を生成
    list_value1 = []        --空のlistオブジェクトを生成
    list_value1 = list()    
    list_value1 = list(('りん', 'はなよ'))　--2要素を持つlistオブジェクトを生成

###【identity】
`すべて`のオブジェクトに`自動的に`割り当てられる`管理番号`

`等価判定`：オブジェクトの`内容`が等しいか
`等値判定`：オブジェクトの`identity値`が等しい（＝同一のオブジェクト）か

    scores1 = [78, 85, 100]
    scores2 = [78, 85, 100]
    print('scores1のidentity: {}'.format(id(scores1)))　=>#scores1のidentity: 4311149512
    print('scores2のidentity: {}'.format(id(scores2)))　=>#scores2のidentity: 4310302536

    if scores1 == scores2:　--等価判定
        print('scores1とscores2は同じ内容です。')
    else:
        print('scores1とscores2は異なる内容です。')

    if id(scores1) == id(scores2):　--等値判定
        print('scores1とscores2は同じ存在です。')
    else:
        print('scores1とscores2は異なる存在です。')

変数にはオブジェクトではなく、`identity値`（：オブジェクトを指し示す数値=`参照`）が格納されている

    scores1 = [78, 85, 100]
    scores2 = [78, 85, 100]
    print('scores1の先頭要素は{}'.format(scores1[0]))　
    print('scores2の先頭要素は{}'.format(scores2[0]))　

    print('変数scores2を変数scores1に代入する。')
    scores1 = scores2　--scores1のidentity値をscores2にコピーしているに過ぎない
                     　--これによりscores1とscores2は同一オブジェクトを指し示すことになる
                     　--よって1つのオブジェクトに複数の変数でアクセスが行える

    print('scores1の先頭要素を60に書き換える。')
    scores1[0] = 60

    print('60を代入したscores1の先頭要素は{}'.format(scores1[0]))　
    print('60を代入していないscores2の先頭要素は{}'.format(scores2[0]))　

###【防御的コピー】
変数の`複製`を行い、破壊のリスクを避けるテクニック
`copyメソッド`や`スライス文`での記述がよく見られる

    def add_suffix(names):　--渡される名前に「ちゃん」を付ける
    for i in range(len(names)):
        names[i] = names[i] + 'ちゃん'
    return names

    before_names = ['ちか', 'よう', 'りこ']
    --リストの複製--   
    ①copied_names = before_names.copy()　--copyメソッド--
    ②copied_names = before_names[:]　　　 --スライス文--
    ③import copy　　　　　　　　　　　　　　　--copyモジュール--
      copied_names = copy.copy(before_names)　
    ④copied_names = list()　　　　　　　　　--list関数--

    for n in before_names:
        copied_names.append(n)　
    --ここまで--
    after_names = add_suffix(copied_names)　-複製リストをafter_namesに渡す
    print('ちゃん付後:' + after_names[0])
    print('ちゃん付前:' + before_names[0])

##モジュール
開発効率を図ることができる便利な部品
さまざまな変数や関数を提供してくれる1つのファイル

`ライブラリ`：複数のモジュールがまとまったもの
　　　　　　必要なモジュールを取り込み、適した関数を呼び出すだけでよい
　　　　　　import文は先頭にまとめて記述することが推奨

#####【標準ライブラリ】
Python公式が用意したモジュール

`mathモジュール`：数学計算に関する処理
`randomモジュール`：乱数に関する処理
`datetimeモジュール`：日時に関する処理
`emailモジュール`：電子メールに関する処理
`csvモジュール`：CSVファイルに関する処理
`jsonモジュール`：JSONファイルに関する処理
`osモジュール`：OS操作に関する処理

    ⭐︎import モジュール名　　　　　　　#import文
                                 モジュールの取り込み
    モジュール名.変数名             #モジュール内変数の参照
    モジュール名.関数名(引数, ・・・)　　#モジュール内関数の呼び出し

    import math　　　　　　　　　　　　　　　　　　--mathモジュールの取り込み
    print('円周率は{}です。'.format(math.pi))　　--変数piの参照　
    print('小数点以下切り捨てをしたら{}です。'.format(math.floor(math.pi)))　--floor関数の呼び出し
    print('小数点以下切り上げをしたら{}です。'.format(math.ceil(math.pi)))   --ceil関数の呼び出し

    *pi、floor、ceilはmathモジュールが提供する変数や関数

    ----
    import モジュール名 as 別名

    import math as m　　　　　　　　　　　　　　　　　　--mathモジュールを「m」として取り込む
    print('円周率は{}です。'.format(m.pi))　　
    print('小数点以下切り捨てをしたら{}です。'.format(m.floor(m.pi)))　
    print('小数点以下切り上げをしたら{}です。'.format(m.ceil(m.pi)))

    ----
    ⭐︎from モジュール名　import 変数名もしくは関数名

    from math import pi                --mathモジュールから変数piを取り込む
    from math import floor　　　　　　　　--mathモジュールからfloor関数を取り込む　　　
    print('円周率は{}です。'.format(pi))　　
    print('小数点以下切り捨てをしたら{}です。'.format(floor(pi)))

    ----
    from モジュール名　import 変数名もしくは関数名 as 別名

    from math import pi as ensyuritsu              
    from math import floor as kirisute　　　　　　　　　　
    print('円周率は{}です。'.format(ensyuritsu))　　
    print('小数点以下切り捨てをしたら{}です。'.format(kirisute(ensyuritsu)))

`ワイルドカードインポート`：＊記号を使ったモジュールの特殊な取り込み方法　　※ただし`非推奨`
　　　　　　　　　　　　指定モジュールの変数、関数すべてを取り込む
    
    from モジュール名　import *　

    from math import *　　
    print('円周率は{}です。'.format(pi))　　
    print('小数点以下切り捨てをしたら{}です。'.format(floor(pi)))
    print('小数点以下切り上げをしたら{}です。'.format(ceil(pi)))

#####【外部ライブラリ】
組織や個人によって作られたモジュール
利用場面は限定的だが、より高度な処理を容易に行うことができる

[代表的なもの]
`matplotlibモジュール`：データ可視化
`Pandasモジュール`：データ解析
`Numpyモジュール`：ベクトル・行列計算
`SciPyモジュール`：科学技術計算
`SymPyモジュール`：代数計算
`scikit-learnモジュール`：機械学習
`TensorFlowモジュール`：深層学習
`Pygameモジュール`：グラフィックス、音声
`dateutilモジュール`：日時
`simplejsonモジュール`：JSONファイル
`pyYAMLモジュール`：YAMLファイル
`requestsモジュール`：Webアクセス

[インストール]

    pip install モジュール名

[例]

    --matplotlibパッケージ--
    import matplotlib.pyplot as plt　--matplotlibパッケージのpuplotモジュールをpltとして取り込む
    weight = [45.0, 48.2, 54.5, 57.6, 64.5, 69.2]
    plt.plot(weight)　--取り込んだpltのplot関数を呼び出す

    --requestsパッケージ--
    import requests
    response = requests.get('https://python.org/downloads/')
    text = response.text
    print(text)

####【組み込み関数】
いつでも自由に呼び出せる関数

[入出力]
`print関数`：引数を標準出力（：ディスプレイ）に出力する
`input関数`：標準入力（：キーボード）から1行読み込んだ結果を返す

[データ型]
`type関数`：引数の`データ型`を返す
`int関数`：引数を`整数値`で返す
`float関数`：引数を`小数値`で返す
`str関数`：引数を`文字列`で返す

[コレクション]
`list関数`：引数を`リスト`で返す
`dict関数`：引数を`ディクショナリ`で返す
`tuple関数`：引数を`タプル`で返す
`len関数`：引数の`要素数`を返す
`sum関数`：引数の`合計値`を返す
`max関数`：引数の`最大値`を返す
`min関数`：引数の`最小値`を返す

[計算]
`abs関数`：引数の`絶対値`を返す
`round関数`：引数を`四捨五入値`で返す

[ファイル]
`open関数`：引数指定の`ファイル`を開く

    ❶open(ファイル名, モード)
    ❷ファイルオブジェクト.write(書き込む内容)
    ❸ファイルオブジェクト.close()

    text = input('何を記録しますか。>>')
    file = open('diary.txt', 'a')　--ファイルを開く
                                     戻り値としてファイルオブジェクトが返される
    file.write(text + '\n')　　　　 --ファイルに書き込む
    file.close()　　　　　　　　　　　--ファイルを閉じる

`モード`:開いたファイルの操作指示
　　　　`r`：`読み込み`　＊指定ファイルが存在しない場合はエラー
　　　　`w`：`書き込み`　＊指定ファイルが存在しない場合は新規作成
　　　　`a`：`追記`　　 ＊指定ファイルが存在しない場合は新規作成

`with文`：ファイルを自動で閉じてくれる

    with open(ファイル名, モード) as 変数名:
         ファイルオブジェクト.write(書き込む内容)

    text = input('今日起こった出来事を教えてね。>>')
    with open('diary.txt', 'a') as file:　--戻り値としてのファイルオブジェクトが変数に代入される
         file.write(text + '\n')　　　　　 --withブロック終了時に自動でファイルを閉じる処理が行われる

`ストリーム`：キーボード、ディスプレイ、ファイルでのデータのやり取りで生じるデータの流れ
　　　　　　大規模システムでは外部資源（データベースやネットワーク）と繋がることも多い
　　　　　　データの開きっぱなしは、パソコンに負荷を掛けるため、開き終わった後は閉じた方が望ましい

####【パッケージ】
いくつかのモジュールがまとまったもの

    ①import パッケージ名.モジュール名 (as 別名）　#取り込み
      パッケージ名.モジュール名.変数名　　　　　　　#変数参照
      パッケージ名.モジュール名.変数名（引数, ・・・）  #関数呼び出し

      import http.client
      conn = http.client.HTTPConnection('www.python.org')

    ----
    ②from パッケージ名 import モジュール名 (as 別名）　#取り込み
     モジュール名.変数名　　　　　　　                #変数参照
     モジュール名.変数名（引数, ・・・）                  #関数呼び出し

     import http.client
     conn = client.HTTPConnection('www.python.org')

    ----
    ③from パッケージ名.モジュール名 import 変数名もしくは関数名 (as 別名） 　#取り込み
     変数名　　　　　　　                                           #変数参照
     変数名（引数, ・・・）                                             #関数呼び出し

     from http.client import HTTPConnection
     conn = HTTPConnection('www.python.org')