この記事はNuco Advent Calendar 2023の14日目の記事です。

目次

1.はじめに
2.VSCodeの拡張機能紹介
3.コーディングのポイント
4.よく使われる英単語一覧
5.エラーとの向き合い方
6.テストで動作確認
7.検索の極意
8.公式ドキュメントに慣れる
9.リファクタリングでさらに読みやすく
10.資料作成で気をつけること
11.Gitで管理
12.よく使うLinuxコマンド一覧
13.仕事の進め方
14.プログラム以外で意識するところ
15.初心者こそ読んで欲しい本
16.まとめ

1. はじめに

プログラミングは現代のデジタル社会において重要なスキルです。

AIがコードを書いてくれる時代ですが、それでも人の手によるプログラミングはいまだに必要です。それはAIが完璧なコードを書いてくれるわけではないからです。

この記事では、プログラミングの世界に新たに足を踏み入れた皆さんを全力でサポートします。

VSCodeの便利な拡張機能から始まり、コーディングの基本、エラーへの対処法、効率的な検索技術、重要なリファクタリングのコツ、仕事の進め方に至るまで、初心者が即戦力となるための知識を網羅的に提供します。

このガイドを通じてプログラミングの基本を固め、日々の開発作業に自信を持って臨めるようになることを目指します。

プログラミングの世界へ足を踏み入れる皆さん、この即戦力ガイドで一緒に学んでいきましょう。

1-1. 本記事のターゲット

この記事の対象となる人たちは以下を想定しています。

• プログラミングを学び始めの人
• 仕事でプログラミングに触れ始めた人
• 自分のコードに自信がない人
• 読みやすいコードを書きたい人
• 初心を忘れてしまった人

1-2. 本記事の前提

この記事ではインストール方法や環境の設定については説明をしません。

またサンプルコードはPythonで記述をします。

わかりやすさ重視のため、一部あえて細かい説明を省いている部分もございますが、何卒ご容赦ください。

1-3. 参考著書

この記事を書くにあたり、主に以下の著書を参考にさせていただきました。

• リーダブルコード
  

• きれいなPythonプログラミング
  

その他の記事も大いに参考にさせていただいております。各項目で、説明しきれないところはリンクを貼っておりますので、読み進めながらリンク先で詳細を確認してもらえたらと思います。

2. VSCodeの拡張機能紹介

2-1. VSCodeとは

まずVSCodeについて簡単に説明します。

VSCodeとは正式には「Visual Studio Code」と呼ばれる、ソースコードエディター（プログラムを書くためのソフトウェア）です。

ソースコードエディターはVSCodeの他にAtom、TeraPad、サクラエディタなどいくつか種類があり、これらはコードの自動整形やエラーやデバッグのサポートなど、プログラムを書く際のサポート機能を備えています。

VSCodeは任意で拡張機能を追加することが可能なソースコードエディターで、エンジニアに非常に人気があります。

2-2. おすすめ拡張機能 6選

開発状況で入れた方が良い拡張機能は異なってくるのですが、ここではどんな状況でも役に立つであろう拡張機能を6個紹介したいと思います。

• Japanese Language Pack for Visual Studio Code
  VSCodeはデフォルトで英語表記です。この拡張機能はVSCode内の表記を日本語にしてくれます。英語に慣れていない方は入れたほうが良いでしょう。

インストール前

インストール後

• vscode-icons
  この拡張機能はファイルやディレクトリのアイコンをわかりやすいように表示してくれます。視認性が高まるため開発スピードが爆上がりすること間違いなしです。

インストール前

インストール後

• Code Spell Checker
  英単語のタイプミスを教えてくれるとても優れた拡張機能です。寿司打でいくら高得点をただき出す猛者でもタイプミスは無くせないはず。そんな我々のミスを見逃さずに教えてくれます。

インストール前

インストール後

「天才」の英語「genius」のスペルミスを教えてくれていますね。

• indent-rainbow
  インデント（段落）を見やすいように色付けしてくれます。Pythonを利用しているならば入れたほうが良いでしょう。なぜならばPythonはインデントでコードを理解してくれる言語なので、この機能でインデントによるエラーを未然に防ぐことができるからです。

インストール前

インストール後

• Atom One Dark Theme
  VSCodeで表示される色を落ち着いた色にしてくれます。長時間画面と向き合うことを考えるとぜひ入れておきたい機能です。

インストール前

インストール後

• Trailing Spaces
  コードの終わりにある無駄なスペースを教えてくれます。余分なものが無い方がエラーを引き起こしにくいのですが、終わりのスペースほど見つけにくいものはありません。そんな無駄スペースを教えてくれます。

インストール前

インストール後

以上が私のオススメするVSCodeの拡張機能となります。これらがあると無いとでは作業効率が大きく異なってくるはずです。

なお機能紹介は Visual Studio Codeを使うなら絶対に入れておきたい拡張機能Top20【2022最新版】 を参照させていただいております。こちらの記事では今回紹介しきれなかった拡張機能についても書かれていますので、ぜひ読んで見てください。

【追記】
2023年最新版の記事が出ていましたので、こちらも合わせて確認してみてください。

3. コーディングのポイント

3-1. 読みやすいコードを意識しよう

皆さんが思う優れたコードとは何でしょうか？

プログラミングを学び始めたころの私は、短く処理内容が凝縮されたコードが優れていると考えていました。

特に競技プログラミングでは効率性を追求した短いコードが多く見られ、その印象が強かったのです。

しかし、実際の開発現場での経験を通じて 短いコードが優れたコードとは限らない ことを学びました。

エンジニアの業務では、コードを書く時間よりも読む時間の方が遥かに多くなります。特に、チームでのプロジェクトにおいては自分で書いたコードは自分だけのものではなく、他の開発者にも読まれることになります。

自分のコードが他の人にとって読みにくければ、プロジェクト全体の作業効率を下げることになりかねません。

場合によっては、数ヶ月後の自分自身でさえ書いたコードを理解するのに苦労することもあります。

また読みにくいコードが原因でエラーを引き起こしてしまう可能性も多いにあります。

いくらコードを短く書いたからといって、それが他の人にとって読みにくいならば上記のようなことが起きてしまい、結果としてそれは優れたコードとは言えなくなってしまいます。

優れたコードの前提は読みやすいことです。

読みやすいコードとは他の人々にとって理解しやすい、メンテナンスしやすい、そして拡張性があるコードを意味します。

これを達成するためには、変数名や関数名を明確にし、コードに適切なコメントを付けることが重要となってきます。また、複雑なロジックを避け、必要に応じてリファクタリングを行い、コードをシンプルで分かりやすい形に保つことが求められます。

プログラミングは単にコードを書く技術だけではなく、チームでの共同作業も含まれます。

読みやすいコードを書くことは、コミュニケーションの一形態であり、効果的なチームワークの基盤を築きます。

より良いコードを目指して、私たちは常に学び、成長していく必要があります。

3-2. 名前の付け方

先ほどは読みやすいコードとはどういうコードなのかお伝えしました。

読みやすいコードを書くための第一歩として名前の付け方があります。名前には変数名や関数名、クラス名などがあります。

プログラミング初心者の大多数は名前の重要さを軽んじているのでは無いでしょうか。実際は名前をつける段階が非常に重要で、はじめのうちはここのステップに力を入れるべきです。

では、名前が適切に付けられなかった場合に起こり得ることをいくつかあげてみましょう。

具体的にサンプルコードで具体的にみていきましょう。

calc(5, 3)


# 出力
8

上記はcalcという関数に5と3を与えたら8が出力された状況を表しています。

calcという関数名から何か計算していることが想像できますが、具体的な処理内容を理解できない関数名となっています。

このcalcの中身は以下のようになっています。

❌ NG

def calc(a, b):
    sum = a + b
    return sum

2つの引数を合計していますが、関数名から処理内容を把握することができていません。また、この関数にはもう一つ問題があります。

それは引数のa, bがどのような変数を受け取るのかわかりません。

これらの問題を2つまとめて解決して、適切な名前にしてみましょう。

⭕ GOOD

def add(first_integer, second_integer):
    total = first_integer + second_integer
    return total

関数名から合計を出す処理を行なっていることが把握しやすくなりました。

また引数も数値であることが明確になりました。この状態で関数呼び出し箇所を見てましょう。

num = add(5, 3)
print(num)

# 出力
8

関数名から、2つの引数を受け取って合計した数値を返していることが直感的にわかるようになっていませんか？

このように名前を見ただけで、どのような値が入っているのか、どのような処理が行われているのかがわかるようになれば可読性が高まります。

名前をつけるときは具体的な名前をつけるように心がけてください。

次に命名規則の一部を紹介します。

いざ名前をつけようとしてもルールが無ければ無秩序の名前がコード内に存在することになります。これを防ぐために、一定のルールがあります。

キャメルケース

キャメルケースは最初の単語を除く各単語の最初の文字を大文字にし、残りの文字は小文字で記述します。例えば、camelCaseVariableのようになります。このスタイルは多くのプログラミング言語で変数や関数名に用いられます。ラクダのコブのイメージですね。

camelCaseVariable = "thisIsCamelCase"

スネークケース

スネークケースは各単語をアンダースコア（_）で区切り、全ての文字を小文字で記述します。例えば、snake_case_variableのようになります。このスタイルはPythonなどで変数や関数名によく用いられます。これは蛇のイメージです。

snake_case_variable = "this_is_snake_case"

アッパースネークケース（コンスタントケース）

全ての文字を大文字で記述したスネークケースです。定数に用いられることからコンスタントケースとも呼ばれます。例えば、 SNAKE_CASE_VARIABLEのようになります。このスタイルはPythonなどで定数に用いられます。

SNAKE_CASE_VARIABLE = "THIS_IS_UPPER_SNAKE_CASE"

パスカルケース

パスカルケースは、各単語の最初の文字を大文字にし、残りの文字を小文字で記述します。例えば、PascalCaseVariableのようになります。このスタイルは多くの場合クラス名に用いられます。

PascalCaseVariable = "ThisIsPascalCase"

これらのルールに則って名前を決めるメリットはなんでしょうか。

それは名前から変数、関数、クラスなどのカテゴリーが瞬時にわかることです。名前の命名規則を徹底することで可読性を上げることに繋がります。

次は変数と関数の名前の付け方についてお伝えします。

結論をいうと 変数は名詞/名詞句、関数は動詞 を意識すると良いです。

理由は簡単で、変数は何かしらの数値や文字などのデータを入れる容器みたいなもので、処理（計算する、文字を出力する等）を行わないからです。

一方、関数は動作や振る舞い（計算する、文字を出力する等）をするからです。

それでは変数名の付け方をサンプルコードで見ていきましょう。

❌ NG

send_message = "You are genius."

これはsend_messageという変数名に文字列を格納しているだけで、何かしらの処理をしていません。

変数名が中身と一致していないため、このコードを見た人はsend_messageが「メッセージを送る」処理をする関数だと一瞬思ってしまうかもしれません。

それでは、変数名を修正してみます。

⭕ GOOD

message = "You are genius."

変数名を動詞から名詞にしました。

これにより、読む人はmessageに何かしらの文字列が格納されているということを推測することができるでしょう。

次は関数名について見てみましょう。

❌ NG

def fruits(fruits_name):
    print(fruits_name)

これは関数名がフルーツという名詞になっています。フルーツ自体はただの物体であり、何かしらの処理をする訳ではありません。

コードを読んだ人はfruitsの関数名を見た時に何かしらのフルーツの名前が入った変数だと誤解する可能性が高いです。

ここで関数の中身を見ると、引数のフルーツ名を受け取って出力していることがわかります。そこで、この関数名を動詞を用いて以下のように修正してみます。

⭕ GOOD

def print_fruits(fruits_name):
    print(fruits_name)

この関数名なら「フルーツの名前を出力する」と認識することができ、可読性が高くなります。

最後に英文法を意識した名前の付け方についてお伝えします。

名前をつける時、具体的な名前をつけようとすると複数の英単語を組み合わせることになります。

例えば「フィルターされたユーザー名」という変数名をつける時を考えてみましょう。

英文法に則るとfiltered_usernameとなりますね。

これを意識しないでfilter_usernameやfiltering_usernameなどとつけてしまうと、変数名から直感的に理解することが難しくなり可読性が低くなります。

3-3. 型とは？

型はプログラミングで非常に大切な概念です。プログラムを読むのはコンピュータですが、彼らは書かれたコード内容をそのまま理解することができません。

なのでコードを書く際にコンピュータに対して「これは整数、これは文字列」といった具合に教えてあげなければなりません。

この時の「数値、文字列」が型になります。型には他にも種類があるのですが、代表的なものについて後ほど紹介します。

それではなぜ型が大切なのか確認していきましょう。まずはサンプルコードを見てみましょう。

❌ NG

def add(number, text):
    return number + text

result = add(5, "apples")  # 5は整数(int)型、"apples"は文字列(str)型
print(result)


# エラーメッセージ
TypeError: unsupported operand type(s) for +: 'int' and 'str'

これは5が整数(int)型、applesが文字列(str)型であり、型が異なるもの同士を足そうとしてエラーになっています。

では同じ型同士は計算できるのか見てみましょう。

⭕ GOOD

def add(number_1, number_2):
    return number_1 + number_2

result = add(5, 10)  # 5,10ともに整数(int)型
print(result)


# 出力結果
15

これはnumber_1とnumber_2が同じ整数(int)型であるため足し算ができています。

もう一つ見てみましょう。

⭕ GOOD

def add(text_1, text_2):
    return text_1 + text_2

result = add("私は", "猫が好きです")  # "私は"と"猫が好きです"はどちらも文字列型
print(result)


# 出力結果
私は猫が好きです

これはtext_1とtext_2が同じ文字列型であるため足し算ができています。

もう一歩踏み込んでみましょう。次は関数の出力の型を意識できなかったパターンです。

❌ NG

def add(int_1, int_2):
    return int_1 + int_2

def print_num(int):
    print("This num is " + int)

num = add(5, 10)

print_num(num)


# 出力
TypeError: can only concatenate str (not "int") to str

これはaddが2つの整数を合計する関数で、print_numが「This num is {引数の数値}」を出力する関数です。

addに5と10を与え、その返り値を変数numに代入しています。そのnumをprint_numに渡しています。

その結果はTypeErrorになっています。これもprint_numで文字列型と整数型を足そうとしていることが原因です。

初めのうちは慣れないかもしれませんが、関数の返り値の型が何であるかを意識することで上記のようなエラーを防ぐことができます。

ちなみに上記のコードを修正すると以下のようになります。

⭕ GOOD

def add(int_1, int_2):
    return int_1 + int_2

def print_num(int):
    print(f"This num is {int}")

num = add(5, 10)

print_num(num)


# 出力
This num is 15

print_numの処理内容を修正しています。ここのfはフォーマット済み文字リテラルと言います。詳しくはこちらの記事を見てみてください。

変数に代入されているデータの型は何か、関数の引数および返り値の型は何かを常に意識してください。

続いては動的型付け言語における型についてお伝えします。

Python、Ruby、JavaScriptなどは動的型付け言語と呼ばれ、プログラムを書くときに型を明示しなくても実行時に勝手に型を理解してくれる言語になります。

以下のサンプルで確認してみましょう。

def add(int_1, int_2):
    return int_1 + int_2

num = add(5, 10)

print(num)
print(type(num))


# 出力
15
<class 'int'>

addで引数に5と10の整数を与え、その返り値と型を確認しています。（print(type(num))でnumの型を確認しています。）

numの型はint（整数）型ですね。

続いては引数を5.0と10.0にしてみましょう。

def add(int_1, int_2):
    return int_1 + int_2

num = add(5.0, 10.0)

print(num)
print(type(num))


# 出力
15.0
<class 'float'>

numが15.0のfloat（浮動小数点）型に変わっていますね。

このように型を勝手に理解してプログラムを実行してくれるのが動的型付け言語になります。

プログラムは基本的に変数や定数などに型を指定し、その型が格納されないとそもそも実行できないのですが、動的型付け言語は型を明示しなくても都合よく型を理解してくれます。

その結果エンジニアのコードを書くときの手間を省いてくれます。

それでも可読性を高めるためには型を明示した方が良いです。

それはコードを読む人がその変数や定数ががどのような型なのか把握できるからです。

先ほどの2つの関数のサンプルコードについて、型を明示して修正してみましょう。

def add(int_1: int, int_2: int) -> int:
    return int_1 + int_2

def print_num(int: int) -> str:
    print(f"This num is {int}")

num: int = add(5, 10)

print_num(num)


# 出力
This num is 15

まずaddから見てみましょう。

修正されている点としては引数部分に :intが追記されていますね。また、関数名の列の最後に-> int:も追加されていますね。

引数の追加した箇所は、引数の型がint（整数）型であると明示しています。また-> int:については、この関数の返り値の型がint（整数）型であると明示しています。

関数print_numと変数numについても同様に型を明示しています。

このメリットはコードを追わないでも型がわかることにあります。

プロジェクトのコードはお互いの関係が複雑になり、プロジェクト参加し始めたときのキャッチアップやエラーの原因特定の時は、ひたすらコードを追うことになります。

この時に型が明示されていないと、コードを追う量が一気に増えてしまいますが、型を明示しているとコードを追う量が少なくなります。

今回のサンプルコードでは型を明示することのメリットを中々感じられないですが、普段から型を明示する癖をつけましょう。

また動的型付け言語についてはこちらの記事に詳細が書かれていますので、気になった方は確認してみてください。

3-4. ミュータブルとイミュータブル

変数には数値や文字列、リストやタプルなどが代入されます。

同じ変数に違う値などを代入し内容を変更できる場合をミュータブルと言い、変更できない場合をイミュータブルと言います。

サンプルコードで確認してみましょう。まずは変更可能なミュータブルについてです。
　

# ミュータブル
⭕ GOOD

mutable_list = [1, 2, 3]
print("Original Mutable List:", mutable_list)
print(type(mutable_list))
print(mutable_list[0])

mutable_list[0] = 10  # インデックス0の数値「1」を「10」に変更
print("Modified Mutable List:", mutable_list)


# 出力
Original Mutable List: [1, 2, 3]
<class list>
1
Modified Mutable List: [10, 2, 3]

mutable_listに[1, 2, 3]のリストを代入しています。mutable_listのインデックス0の数値が1であることを確認し、その値を10に変更しています。

この時のmutable_listの型はlist型であることも確認できます。

次はイミュータブルのサンプルコードを見てみましょう。

# イミュータブル
❌ NG

immutable_tuple = (1, 2, 3)
print("Original Immutable Tuple:", immutable_tuple)
print(type(immutable_tuple))
print(immutable_tuple[0])

immutable_tuple[0] = 10  # インデックス0の数値「1」を「10」に変更
print("ModifiedImmutable Tuple:", immutable_tuple)


# 出力
File "/Users/qiita/sample.py", line 6, in <module>
    immutable_tuple[0] = 10  # インデックス0の数値「1」を「10」に変更
    ~~~~~~~~~~~~~~~^^^
TypeError: 'tuple' object does not support item assignment

処理内容は先ほどとほとんど同じです。異なる点はimutable_tupleの型がtuple型ということです。（ここではエラーとなり型の確認まではできおりませんが。）

エラー箇所はimmutable_tuple[0] = 10になります。immutable_tupleの内容を変更しようとしてエラーになったのです。

このように、内容の変更ができる場合はミュータブルといい、変更ができない場合はイミュータブルと言います。

なぜこのようにミュータブルとイミュータブルがあるのでしょうか。

先ほどのリストの例のように、ミュータブルなオブジェクトはデータの動的な操作を可能にし、プログラムが実行される間に内容を変更したり拡張したりすることができます。

これによりアルゴリズムやデータ処理が柔軟になります。

またミュータブルなオブジェクトはメモリ効率が良く、新しいオブジェクトを何度も作成する必要がないため、実行速度の向上にも寄与します。

しかしミュータブルなオブジェクトは、予期しない変更によるバグや、並行処理の際のデータ競合を引き起こすリスクがあります。

一方、イミュータブルなオブジェクトは、一度作成されるとその状態が変更されないことが特徴です。

イミュータブルなオブジェクトのこの特徴により、プログラムの安全性と予測可能性を高めることが可能になります。

またデータが変わらないため、予期しない変更や並列処理時の競合が発生しません。

しかし必要に応じて新しいオブジェクトの作成が必要になるため、メモリ使用量が増加する可能性があります。

このようにミュータブルとイミュータブルにはそれぞれメリット・デメリットが存在します。

これらはプログラミングにおける柔軟性、効率性、安全性、予測可能性などのバランスを取るためのものであり、特定のアプリケーションや要件に応じて適切なタイプが選択する必要があります。

3-5. 関数の内容はコンパクトに

次は関数の書き方についてです。

3-2.名前の付け方で、関数は処理や振る舞いを行うので、関数名をつけるときは動詞で考えると良いことをお伝えしました。

このとき、1つの関数が色々な振る舞いや処理を行なっていればどうなるでしょうか。

名前をつける時に具体的な名前をつけることができなくります。

その他のデメリットとして、エラーが起きた時や予期しない動作（エラーではないが期待通りの挙動ではない）を起こしたときに、原因特定が困難になってしまいます。

例えば以下のような関数があったとします。

# 多くの処理を持つ関数の例
❌ NG

def process_data(data: list) -> int:
    # 入力リストの要素を2倍
    processed_data = [x * 2 for x in data]
    
    # データ集計
    total = sum(processed_data)
    
    # データ表示
    print(f"Processed Data: {processed_data}")
    print(f"Total: {total}")
    
    # データ保存
    with open("output.txt", "w") as file:
        file.write(str(processed_data))
        
    return total

process_data([1, 2, 3, 4])


# 出力
Processed Data: [2, 4, 6, 8]
Total: 20

process_dataの中には「データ前処理」「データ集計」「データ表示」「データ保存」の処理があります。そして「データ集計」処理で行われた合計値（total）を返しています。

このように処理が複数あると、そもそもprocess_dataという関数名が適切でないことがわかります。

しかし、処理全てを反映した関数名、例えばprocessed_print_save_dataも明かにわかりにくですよね。

1つの関数に複数の処理を持たせると可読性が低くなります。

それでは修正した場合のサンプルコードを見てみましょう。

⭕ GOOD

# 入力リストの要素を2倍する関数
def two_times_data(data: list) -> list:
    return [x * 2 for x in data]

# データ集計を行う関数
def sum_data(data: list) -> int:
    return sum(data)

# データ表示を行う関数
def print_data(data: list, total: int) -> str:
    print(f"Processed Data: {data}")
    print(f"Total: {total}")

# データ保存を行う関数
def save_data(data: list, filename="output.txt"):
    with open(filename, "w") as file:
        file.write(str(data))

# 関数を組み合わせて全体のプロセスを実行
original_data = [1, 2, 3, 4]
processed_data = two_times_data(original_data)
total = sum_data(processed_data)
print_data(processed_data, total)
save_data(processed_data)


# 出力
Processed Data: [2, 4, 6, 8]
Total: 20

先ほどのprocess_dataに含まれていた4つの処理を4つの関数に分けています。

出力結果は同じですが、　関数の責任（関数が行う処理）がより明確になりました。また関数名も処理内容を反映したものになっています。

関数の数自体は増えていますが、可読性の向上とエラー特定も簡単になることから分割する方が良いです。

定義した関数の処理内容が多いなと感じたら、その関数の処理の「動詞」を考えてみてください。

サンプルコードでもわかるように、動詞にすることで関数の分割するポイントが見えてくるはずです。

3-6. 説明変数とは

説明変数とは式を表す変数のことです。

と言われてもよくわからないと思うので早速サンプルコードでみてみましょう。

❌ NG

if line.split(":")[0].strip() == "root":
    print("This is root")

処理内容は置いておいて、このコードを読んだ時if文を直感的に理解しにくくありませんか。

このサンプルコードにおける式はline.split(":")[0].strip() == "root"になります。

これを以下のように修正してみましょう。

⭕ GOOD

username = line.split(":")[0].strip()
if username == "root":
    print("This is root")

usenameという変数を宣言して、先ほどの式の左辺(line.split(":")[0].strip())を入れています。

その後、usernameを条件文で利用しています。

つまり変数を準備して、式を分割していることになります。

修正前のコードだと「何」が「root」ならば「This is root」が出力されるのかが、わかりにくいです。

しかし修正後だと「username」が「root」ならば「This is root」が出力されることが、すぐにわかるのではないでしょうか。

このように式を利用する場面において、そのままコードを書くとわかりにくい場合は、わかりやすい名前の変数を準備して式を代入することで可読性が高くなります。

3-7. 変数への書き込みは1度だけ

変数には何かしらのデータを代入しますが、同じ変数に他のデータを何度も代入することは避けましょう。

再代入を行うことでさまざまなデメリットが生じます。

まず、同じ変数に異なる値や異なる型のデータを繰り返し代入すると、コードの読み手がその変数の現在の値や、変数の意味を理解するのが難しくなります。

また変数の値が頻繁に変更されると、プログラムの特定の部分で期待される値が保持されなくなる可能性があり、これがバグの原因になることがあります。

他にも変数が頻繁に変更されると、デバッグ中にその変数の値がどの時点でどのように変化したかを追跡するのが難しくなったり、同じ変数が異なる箇所で使用されたことによりコードの修正や拡張が難しくなります。

それではサンプルコードで確認してみましょう

❌ NG

def process_data(data: list) -> int:
    result = sum(data)  # 合計を計算
    result = result / len(data)  # 平均を計算
    result = round(result, 2)    # 結果を丸める
    return result

average = process_data([1, 2, 3, 4, 5])
print("Average:", average)


# 出力
Average: 3.0

process_dataの中でresultに何度か値が代入され返されていますが、このresultには何の値が入っているのかわかりにくくなっています。(そもそもresult自体も具体的な変数名ではないですね）

次に修正したサンプルコードを見てみましょう。

⭕ GOOD

def process_data(data: list) -> int:
    total = sum(data)  # 合計を計算
    average = total / len(data)  # 平均を計算
    rounded_average = round(average, 2)  # 結果を丸める
    return rounded_average

average = process_data([1, 2, 3, 4, 5])
print("Average:", average)


# 出力
Average: 3.0

resultに何度も代入していた時よりも具体性が増しています。またこのようにすることで、関数の中身が複雑になっても同じ変数を利用することを避けられるので、バグを生み出す可能性を下げてくれます。

ただし処理によっては再代入を必要とするところも出てくると思うので極力、再代入をしないことを心がけてください。

次に参照透過性について少しお伝えします。参照透過性には以下2つのポイントがあります。

• 関数は同じ変数を引数として与えられれば同じ値を返す
• 変数の値は最初に定義した値と常に同じとする

後者については先述のとおりです。

前者についてをサンプルコードで見てみましょう。

❌ NG

total = 0

def add_to_total(value: int) -> int:
    global total
    total += value
    return total

result1 = add_to_total(5)
print("結果1:", result1)

result2 = add_to_total(5)
print("結果2:", result2)



# 出力
結果1: 5
結果2: 10

これは参照透過性を守れていないサンプルコードです。

参照透過性では、関数は同じ引数なら同じ出力結果を出すことがルールですが、上記のサンプルコードでは引数5を与えられたときに1回目と2回目で出力結果が異なっています。

出力結果が、1回目は5なのですが、2回目では10となっていますね。

これは関数の中でグローバル変数のtotalが呼ばれていること原因です。（グローバルについては後述）

totalの初期値は0で、1回目の関数で呼ばれ 0 + 5 = 5となり、5が代入され返されています。

2回目の関数で呼ばれたときはtotalに5が入った状態なので5 + 5 = 10となり、10が代入され返されています。

この結果から、関数の処理が関数の外にあるグローバル変数に依存していることがわかります。

このように、引数が同じなのに出力が異なると処理が複雑になってきた時にエラーやバクの原因となるだけでなく、その原因の特定が難しくなってしまいます。

関数の処理が外部の要素に依存しないようにすることが大切です。

それではサンプルコードを修正してみましょう。

⭕ GOOD

def add_values(value1: int, value2: int) -> int:
    return value1 + value2

result1 = add_values(5, 10)
print("結果1:", result1)

result2 = add_values(5, 10)
print("結果2:", result2)


# 出力
結果1: 15
結果2: 15

若干処理内容が変わっていますが、同じ引数を与えたときに同じ出力となることが確認できます。

このように参照透過性を守ることはプログラミングにおいて重要です。

3-8. if文を読みやすく

続いてはif文を読みやすくするポイントをお伝えしようと思います。

if文の条件文を考える時、自然な日本語で考えていませんか？

例えば「年齢が10歳以上なら」や「色が赤なら」といった具合です。

この日本語をそのままコードに落とし込めば、それだけでも可読性は上がります。サンプルコードで見てみましょう。

❌ NG

age = 10

if 10 <= age:
    print("age is over 10")


# 出力
age is over 10

この条件文は先ほどの「年齢が10歳以上なら」の語順に則っていませんよね。

読み手からすると不自然であり、理解に時間を要します。

これを修正すると以下のようになります。

⭕ GOOD

age = 10

if age >= 10:
    print("age is over 10")


# 出力
age is over 10

語順が文法に則っているためこちらの方が読みやすくなります。

それでは修正後のサンプルコードを少し変更してみます。

❌ NG

age = 10

if not age < 10:
    print("age is over 10")


# 出力
age is over 10

条件文が否定系になっています。出力自体はこれまでと同じなのですが否定系にすると読みにくくなっていませんか？

余程のことがない限りコードは普通肯定で書かれるので否定系が出てくるとコードの可読性が下がってしまいます。

可読性を落とさないためにも条件文で否定系を使用することは極力避けましょう。

続いては三項演算子についてです。まずは以下のサンプルコードを確認してみましょう。

age = 9

if age >= 10:
    print("age is over 10")
else:
    print("age is under 10")


# 出力
age is under 10

これでも直感的に意味はわかるのですが、少し冗長な気がします。これを1文にまとめることが可能なので、サンプルコードで見てみましょう。

age = 9

print("age is over 10") if age >= 10 else print("age is under 10")


# 出力
age is under 10

このように 条件が成立したとき if 条件 else 条件が成立しなかったときのように記載することを三項演算子と言います。

先ほどの elseブロックがある時よりも冗長性が無くなりスッキリしていますね。

このように三項演算子を用いることで可読性を上げることができます。

しかし、場合によっては三項演算子が読みにくくなることもあります。

サンプルコードで確認してみましょう。

❌ NG

a = 5
b = 10
c = 15

result = a * 2 if b > 5 else c if a < 10 else b

print("Result:", result)


# 出力
Result: 10

サンプルコードでは三項演算子を使っていますが、直感的に分かりにくいですよね。その結果、可読性を低くさせています。

この場合は無理に三項演算子を使わないで、elseブロックを使用した方が良いです。

以下修正したサンプルコードです。

⭕ GOOD

a = 5
b = 10
c = 15

if b > 5:
    result = a * 2
elif a < 10:
    result = c
else:
    result = b

print("Result:", result)


# 出力
Result: 10

先ほどの三項演算子を使った場合よりも、直感的にわかりやすくなっていませんか。

このように、コードを短くしても他の人が読みにくくなるくらいならば、少し冗長になっても読みやすい方が可読性が高くなります。

3-9. ネストは浅く

プログラムの内容が複雑になると、ネストが深くなってしまうことがあります。

しかし、ネストを深くすることは可読性の低下につながります。

ネストが深い場合のサンプルコードを見てみましょう。

❌ NG

def check_conditions(num_1: int, num_2: int, num_3: int):
    if num_1 > 0:
        if num_2 > 0:
            if num_3 > 0:
                print("All variables are positive")
            else:
                print("c is not positive")
        else:
            print("b is not positive")
    else:
        print("a is not positive")

check_conditions(1, 2, -3)


# 出力
c is not positive

サンプルコードではif文が3つ使用されています。このコードを読むとき「aが0より大きいならば」 → 「bが0より大きいならば」 → 「cが0より大きいならば」と条件文を追っていく必要があります。

これがさらにネストが深くなり、また条件文も複雑になると非常に読みにくくなることが考えられますね。

それではネストを深くしないように修正したサンプルコードを確認してみましょう。

⭕ GOOD

def check_conditions(num_1: int, num_2: int, num_3: int):
    if num_1 > 0 and num_2 > 0 and num_3 > 0:
        print("All variables are positive")
    elif num_1 <= 0:
        print("a is not positive")
    elif num_2 <= 0:
        print("b is not positive")
    else:
        print("c is not positive")

check_conditions(1, 2, -3)


# 出力
c is not positive

3つの条件文を組み合わせ、かつ条件文を追加することでネストが浅くなり、読みやすくなりました。

別のパターンも見てみましょう。

⭕ GOOD

def check_conditions(num_1: int, num_2: int, num_3: int):
    if num_1 <= 0:
        print("a is not positive")
        return
    if num_2 <= 0:
        print("b is not positive")
        return
    if num_3 <= 0:
        print("c is not positive")
        return

    print("All variables are positive")

check_conditions(1, 2, -3)


# 出力
c is not positive

こちらもネストが浅くなり読みやすくなっています。先ほどのパターンと違うところは、各if文にreturnが設定されている点です。

これは早期リターン（アーリーリターン）またはガード節といい、条件に当てはまったら関数を終えることができます。

早期リターンによって無駄な処理を走らせることがなくなる（条件に当てはまったif文のreturn以降の処理が走らない）ので、バグやエラーの発生を少なくさせることができます。

今回はif文を例にしましたが、他にもfor文などでもネストが深くなる場合があるので、その時は一度処理自体を見直すようにし、ネストが浅くなるようにしましょう。

3-10. スコープ（範囲）を意識する

プログラミングにおけるスコープとは、変数や関数などの名前（識別子）が有効である範囲のことを指します。

スコープがあることでプログラムの異なる部分（ブロック等）で名前の衝突を避けることができるので、重要な役割となっています。

ここではグローバルスコープとローカルスコープについてお伝えします。

グローバルスコープとは、プログラム全体にわたる範囲（スコープ）のことを指します。

グローバルスコープで宣言された値や変数（グローバル変数という）や関数はどこからでもアクセス可能になりますが、グローバル変数を多用すると、プログラムの理解や保守が難しくなる可能性があります。

ローカルスコープとは、関数やブロック内など特定の範囲（スコープ）のことを指します。

ローカルスコープで宣言された値や変数は、その関数やブロック内でのみ有効です。これにより、同じ名前の変数が他の場所で使われていても、それらが衝突することなく独立して機能します。

それではサンプルコードで確認してみましょう。

global_variable = "グローバル" # グローバル変数

def print_scope() -> str:
    local_variable = "ローカル" # ローカル変数

    print("関数内：", local_variable)
    print("関数内：", global_variable)

print_scope()


# 出力
関数内： ローカル
関数内： グローバル

サンプルコードでglobal_variableがグルーバル変数になります。これは特定の範囲内で宣言されていないグローバル変数になります。

一方local_variableは関数print_scopeで宣言されたローカル変数になります。

サンプルコードではグローバル変数をprint_scopeのローカルスコープでも呼び出すことが可能ということが確認できます。

次のサンプルコードでグローバル変数とローカル変数の違いを確認してみましょう。

⭕ GOOD
# グローバル変数を出力

global_variable = "グローバル" # グローバル変数

def print_scope() -> str:
    local_variable = "ローカル" # ローカル変数

    print("関数内：", local_variable)
    print("関数内：", global_variable)

print(global_variable)


# 出力
グローバル

❌ NG
# ローカル変数を出力

global_variable = "グローバル" # グローバル変数

def print_scope() -> str:
    local_variable = "ローカル" # ローカル変数

    print("関数内：", local_variable)
    print("関数内：", global_variable)

print(local_variable)


# 出力
NameError: name 'local_variable' is not defined. Did you mean: 'global_variable'?

上記より、グローバル変数の出力は問題ないのですが、ローカル変数の出力ではエラーが発生していますね。

先ほどお伝えしたようにローカル変数は宣言された関数やブロックのみで有効となります。

エラーが起きたサンプルコードではlocal_variableは関数print_scope内で宣言されたローカル変数です。

このローカル変数を関数外(スコープ外)から呼ぼうとして（print(local_variable)の箇所）エラーが起きてしまったのです。

このようにグローバルスコープとローカルスコープで宣言された変数の扱われかれ方が異なりますが、これらがあることのメリットは何でしょうか。

グローバルスコープで値や変数を宣言することのメリットは、先ほどのサンプルコードで確認できたように、どこからでも呼ぶことが可能になることです。

アプリケーション全体で利用する値や変数をグローバルスコープで宣言すれば、スコープの違いによるエラーが防ぐことができるでしょう。

また頻繁に利用する値や変数をグローバルスコープで宣言することで一箇所にまとめることになり、再利用されることになるのでメモリの効率化へとつながります。

次に、ローカルスコープについてです。

ローカルスコープで値や変数を宣言することのメリットは、変数名の衝突を防ぐことが挙げられます。ローカルスコープで宣言された値や変数は、そのスコープでしか有効でないため、他のスコープ（関数など）で同じ変数名があってもお互いに干渉することがありません。

これについてサンプルコードで確認しましょう。

def print_student_name() -> str:
    name = "Tom" 

    print("student name:", name) 


def print_teacher_name() -> str:
    name = "Alex" 

    print("teacher name:", name) 


print_student_name()
print_teacher_name()


# 出力
student name: Tom
teacher name: Alex

print_student_nameとprint_teacher_nameそれぞれの関数内でnameというローカル変数が宣言されていますね。

これらの変数にはTomとAlexが代入されているのですが、関数を実行した時にお互いの名前を保持しています。

これが先ほどお伝えした、ローカル変数はお互いに干渉しないということです。

それではグローバル変数とローカル変数は干渉するのかも合わせて確認しましょう。

name = "Alex"

def print_student_name() -> str:
    name = "Tom" 

    print("student name:", name) 

print_student_name()


# 出力
student name: Tom

nameがグローバル変数とローカル変数として存在していますね。

グローバル変数でAlexを代入したのち、ローカル変数でTomを再代入した結果、最終的には出力がTomになっています。

このようにグローバルスコープとローカルスコープを意識しないと、エラーやバグの原因となってしまうので、注意する必要があります。

グローバルスコープとローカルスコープで何の値や変数を宣言すべきなのか、コードを書く時にはよく考えるようにしましょう。

3-11. 不要なコードは削除する

プログラミングでよく目にするコメントアウトなどがされている不要なコードですが、これが残っていることで様々なデメリットをもたらしてしまいます。

まずは可読性の低下です。サンプルコードで確認してみましょう。

❌ NG

def add(numbers: list) -> int:
    total = 0
    for number in numbers:
        total += number
    unused_variable = 10
    return total

sample_list = [1, 2, 3]
num = add(sample_list)
print(num)


# 出力
6

この関数はnumbersというリストを受け取り、リストの中の数値を合計して返しています。

ただ、unused_variable = 10 というコードは処理の中で何もしていません。このような不要なコードがあると、何のために設定されているのか読む人が無駄に時間を要してしまう可能性があります。

この不要コードを削除したら以下のようになります。

⭕ GOOD

def add(numbers: list) -> int:
    total = 0
    for number in numbers:
        total += number
    return total

sample_list = [1, 2, 3]
num = add(sample_list)
print(num)


# 出力
6

不要コードがなくなったことで処理内容がわかりやすくなりました。

このように可読性を下げる不要コードはどんどん削除していきましょう。

続いてのデメリットは保守性の低下です。先ほどの内容と被ってしまうのですが、コードのリファクタリング（後述）において、不要なコードがあることで修正の妨げとなります。

他にも使われていないコードがあると、その分メモリを消費するのでパフォーマンスの低下にも繋がります。

最後にバグの原因にもなります。不要コードといえど、何かしらのタイミングで他の部分と干渉してしまう可能性があります。

こういったデメリットがあるので不要コードは消すようにしましょう。

何かのタイミングでまた使うかもしれないと思うかもしれませんが、不要コードはその後使われることはほぼ無いので心配する必要はありません。

3-12. 重複コードは避ける

同じような内容の重複コードがあれば、それを排除（1つにまとめるなど）で対応しましょう。

重複コードがあることのデメリットは先ほどの不要なコードは削除するであげたものと同様になりますが、1点だけさらに追加されます。

それは機能拡張がしにくくなるです。同じようなコードを書いていると、その箇所の修正があった場合、他の同様のコードも合わせて修正しなければならなくなります。

1、2箇所であれば問題ないのですが、重複コードが全体に及んでいる場合は修正に非常に時間がかかることになります。

また修正の漏れがあった場合、そこがエラーの原因にもなります。

それではサンプルコードで確認していきましょう。

❌ NG

def print_student_details(name: str, age: int, grade: int) -> str:
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"Grade: {grade}")

def print_teacher_details(name: str, age: int, subject: str) -> str:
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"Subject: {subject}")

print_student_details("Tom", 15, 3)


# 出力
Name: Tom
Age: 15
Grade: 3

print_teacher_details("Alexander", 30, "Science")


# 出力
Name: Alexander
Age: 30
Subject: Science

1つずつ関数の中身を見てみましょう。

print_student_detailsは生徒の名前、年齢、学年を出力します。

print_teacher_detailsは先生の名前、年齢、教科を出力します。

2つを見比べると名前と年齢を出力する箇所が重複していることがわかります。

同じような内容なのに関数が2つに分かれているのも冗長に感じられるのではないでしょうか。

この冗長なコードを以下のように修正してみます。

⭕ GOOD

def print_details(name: str, age: int, third_label, third_attribute) -> str:
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"{third_label}: {third_attribute}")

print_details("Tom", 15, "Grade", 3)


# 出力
Name: Tom
Age: 15
Grade: 3


print_details("Alexander", 30, "Subject", "Science")


# 出力
Name: Alexander
Age: 30
Subject: Science

まず2つあった関数が1つにまとまりました。そして重複コードも無くなっています。

ここでprint_detailsについて少しみてみましょう。

引数にthird_labelとthird_attributeが新しく追加されています。

修正前のコードと比較するとthird_labelには Grade またはSubjectの文字列が入り、' third_attribute ` には学年数か教科が入ることがわかると思います。

修正後は引数が増えてしまっていますが、print_details呼び出す時の引数の渡し方も異なってしまいますが、全体としてスッキリしたと思われます。

このように重複したコードがある場合は、それを1つにまとめるようにしていきましょう。

3-13. 言葉で説明できるコードを書く

あなたは自分で書いたコードを他の人に説明できるでしょうか。

アルバート・アインシュタインは以下の言葉を残しています

おばあちゃんがわかるように説明できなければ、本当に理解したとは言えない。

何度も言いますが、どんなに複雑なコードでもそれを理解してもらえなければほとんど意味がありません。

ましてや、自分で書いたコード自体も言葉で説明できないのならばそれは理解に苦しむコードと言われるでしょう。

説明できるためには処理内容を簡単なレベルに落としこむことが解決策につながるはずです。

これは文章でも同じです。以下の日本語を見てみましょう。

昨日、私が大学で研究している分野に関連する重要な講義があったのですが、その講義についての詳細な内容を友人に説明しようと思ったところ、その講義で取り扱われた複数の理論とそれらがどのように互いに関連しているのか、さらにそれらの理論が現代の社会においてどのように応用され得るのかという点について、私自身も完全には理解していない部分が多々あることに気づき、その講義の内容を再度じっくりと振り返りながら、それに関連する文献や研究報告を調べたり、さらには専門的な知識を持つ教授にもいくつか質問を投げかけてみたりするなど、多角的にその理解を深めるための努力をした結果、ある程度その内容を理解することができたものの、それを友人に簡潔に説明するということが思いの外難しく、結局長々と話してしまい、友人にはその複雑な内容を的確に伝えることができなかったという経験を昨日のうちにしてしまったのでした。

もはや何がなんだかわかりません。文章の内容自体が複雑なことに加え、1つの文章に詰め込みすぎです。

この文章をわかりやすくしてみましょう。

昨日、大学の講義で研究分野に関する重要な話がありました。しかし、その複雑な内容を友人に説明しようとしたとき、自分も完全には理解していないことに気づきました。そこで、その話題についてもっと勉強しました。文献を読んだり、教授に質問したりして、内容を理解する努力をしました。最終的にはある程度理解できましたが、それを友人に簡潔に伝えるのは難しかったです。

こちらの方が圧倒的にわかりやすく本質を逃していません。

この文章ならおばあちゃんに伝えても理解されるはずです。

これはコードでも同じです。

あなたが書いたコードを他の人に説明できるのか立ち止まってみてみましょう。

もしもできないようならば複雑な処理を行なっていないか、もっと簡単なロジックに落とし込めないかを疑うべきです。

3-14. コメントの容量用法は適切に

コメントをメモ代わりとして残そうとする人がいます。

一見、他の人がコード読んだ時のサポートとなるから良いように見えますが、実際のところはそうではありません。

適切なコメントが読み手をサポートしてくれるのであり、それ以外は逆に可読性を落としてしまいます。

コメントがあると読み手はそこを読むために時間を割きます。またコメントがある分、画面を占領してしまうことになります。

コメント自体はコードに影響を与えることはないのですが、コメントを残す場合は先程のデメリットを上回る価値が必要となります。

それでは不適切なコメントとはなんでしょうか。

関数や変数に対するコメントはハッキリ言ってほとんどが意味がないでしょう。

そもそも、そのような箇所にコメントを残すということは関数名や変数名が適切につけられていない可能性があります。

またコードを読めば処理内容がわかるため、これもコメントにする必要がありません。

サンプルコードで確認しましょう。

❌ NG

# この関数は引数を受け取り合計値を返します。
def calculate(int_1: int, int_2: int) -> int:
    return int_1 + int_2

num = calculate(5, 10)
print(num)


# 出力
15

これは関数名の付け方が不適切です。また処理内容もコードを見ればわかります。

関数名が適切ならばコメントをする必要がありません。

サンプルコードを修正してみましょう。

⭕ GOOD

def add(int_1: int, int_2: int) -> int:
    return int_1 + int_2

num = add(5, 10)
print(num)


# 出力
15

関数名が具体的になったことでコメントの必要が無くなりました。

次の不適切なコメントについてですが、曖昧な言葉を使っているコメントも良くありません。

代名詞（あれ、それ、これ等）などがコメントにあると読み手はさらにその代名詞を読み解かなくてはなりません。

曖昧な言葉を使うことを避け、簡潔（複数行にならない）で具体的な言葉でコメントを残すようにしましょう。

次はコメントを残した方が良いパターンを考えてみます。

コメントを残した方が良い例として、定数に対するコメントや、コードから読み取れない処理実行時に対するコメントがあります。

まず定数のコメントのサンプルコートで見てみましょう。

⭕ GOOD

# ブックマークの上限は現実的に1000が妥当
max_bookmark_num = 1000

この場合max_bookmark_numに1000の値を設定しているが、なぜ1000なのか読み手はコメントがなければ、その意図が読み取れません。

しかしコメントにあるように「現実的に1000が上限ですよ」とコメントを残しておくと、その定数の背景がわかり、読み手もコードに対する理解が深まります。

次にコードから読み取れない処理に対するコメントです。

⭕ GOOD

# 関数を実行すると完了までに1時間程度要する
def archive_documents(documents: list, genres: list):
    categorized_documents = {}
    for document in documents:
        for genre in genres:
            categorized_documents[genre] = document
    return categorized_documents

この場合、コードを読んだだけではわからない実際の処理の内容をコメントとして残しています。

サンプルコードではarchive_documentで二重for文が使われていますが、実際にこの関数が動いたときにどのくらい処理に時間がかかるかまではわからないです。

この処理にかかる時間を、関数前にコメントで残しておくと読み手は実際にコードが走ったときに「なんでこんなに時間がかかるんだろう」と疑問に思わなくなります。

このように、コードの背景がわからない箇所や、実際の処理に関するコメントは有効となることがあります。

コメントに対して、そのコメントが具体的に何を意味するのかを明示するコメントも存在します。

例えばTODOコメントです。TODOコメントは、その箇所で行わないといけない内容を記載するものです。

サンプルコードで確認しましょう。

def calculate_statistics(data):
    # TODO: この関数の処理を実装する
    pass

この場合は、calculate_statisticsの具体的な処理がまだ実装されていないので、TODOコメントで将来的に実装する旨をコメントで残しています。

このTODOのようなコメントはアノテーションコメントといい、特定の意図や注意点をマークするために使われるコメントになります。

以下に代表的なアノテーションコメントを紹介します。

このようなアノテーションコメントを利用することで、読み手にとってどのような意味があるのが簡潔に伝えることができます。

3-15. コードフォーマットで綺麗に

フォーマットを意識することも大切です。

フォーマットが汚いとコードが読みにくくなるので可読性が低下します。

またバグやエラーの発見が難しくなったり、メンテナンスが困難になったりします。

フォーマットの方法には明確なルールというものがないのですが、一般的に多くの人が見やすいフォーマットというものがあります。

早速サンプルコードで確認してみましょう。

❌ NG

def calculate_area(length,width):return length*width # 計算を一行で行っている
def printArea(area):print('Area:',area) # スペースの不足
length,width=10,5# 変数宣言が不明瞭
area=calculate_area(width,length) # 宣言された変数と引数の順番が一致していない
if area>0:printArea(area)
else:print("Invalid dimensions") # if文が読みにくい


# 出力
Area: 50

一目見ただけでも嫌悪感を抱くレベルのフォーマットです。サンプルコードの問題点を以下に示します。

• 関数が1行でまとめられている
• 改行がされていない（ブロックに分けられていない）
• シングルクォーテーション(')とダブルクォーテーション(")の混同
• 変数宣言が不明瞭
• 変数宣言と引数の順番が一致していない
• 適切なスペースがない
• if文が読みにくい

このサンプルコードだけでも、指摘するポイントがたくさんあります。

フォーマットが揃っていないと読み手にとって上記が負担になってしまいます。

それではサンプルコードを修正してみましょう。

⭕ GOOD

def calculate_area(length, width):
    return length * width

def print_area(area):
    print("Area:", area)

length = 10
width = 5

area = calculate_area(length, width)

if area > 0:
    print_area(area)
else:
    print("Invalid dimensions")


# 出力
Area: 50

修正前と比べて非常に読みやすくなっています。

適切な改行やスペースを入れる、ブロックに分けるなどのフォーマットは読み手の負担を一気に減らしてくれます。

この他にもフォーマットに関するポイントはいくつかあるのですが、フォーマットは言語によっても異なる点があります。

この記事はPythonでコードを記載しているので、その他のPythonのフォーマットに関するスタイルガイドを確認してみてください。

3-16. マジックナンバーを避ける

まずは以下のコードを見てください。

expiration = time.time() + 604800

expirationは期限という意味です。

time.time()で現在時刻を取得するのはわかりますが、604800は何を意味しているのでしょうか。

このコードを書いた本人ならば数値の意味がわかるかもしれませんが、他の人がコードを読んだ時は理解できないと思います。

実は604800は１週間の秒数を表しています。(60秒 * 60分 * 24時間 * 7日 = 604800秒)

つまり先ほどのコードは、「期限は現在時刻から1週間後」を表しています。

しかしながら、これを直感的に理解できる人はほとんどいないと思います。

このようにソースコードに直接記載された、本人しかわからない数値のことを マジックナンバー といいます。

マジックナンバーがあることでコードの可読性を下げてしまいます。

マジックナンバーを使わないで上記コードを書く場合は定数を使います。定数は大文字で表記された、内容が変更されない変数のことを言います。

先程のコードを定数を使って書き換えてみます。

SECOND_PER_MINUTE = 60
MINUTE_PER_HOUR = 60 * SECOND_PER_MINUTE
HOUR_PER_DAY = 24 * MINUTE_PER_HOUR
SECONDS_PER _WEEK = 7 * HOUR_PER_DAY

expiration = time.time() + SECONDS_PER_WEEK

いかがでしょうか。

行数こそ増えてしまったものの、expirationが何を意味しているか定数（SECONDS_PER_WEEK）から理解しやすくなったと思います。

このように、コードの中でマジックナンバーが出てきたら定数を設けてみましょう。

3-17. オブジェクト指向プログラミング

プログラミングにおいてオブジェクト指向は非常に重要な考え方（概念）です。

これは何かの決まったルールや規則ではなく、プログラミングを効率よくするための考え方です。

オブジェクト指向については詳しい記事や本がたくさんありますので、ここでは詳細をお伝えすることはしません。

オブジェクト指向の基本的な考え方の部分を紹介したいと思います。

そもそも「オブジェクト」って何？って思う方がいらっしゃると思うので、オブジェクトについてお伝えします。

オブジェクトとは直訳すると「物体」という意味ですが、文脈（環境や状況）によってその意味は異なります。

wikipediaによると以下のような説明となっています。

コンピュータ科学の分野において、オブジェクト（英語: object）は、変数、データ構造、関数、メソッドなど、識別子によって参照されるメモリ上の値を意味することがある。

オブジェクト指向プログラミングのパラダイムでは、オブジェクトは変数、関数、データ構造を組み合わせたものを意味することがある。特に、クラスベースのオブジェクト指向プログラミングのパラダイムでは、特に、クラスのインスタンスを指す。

今回は、オブジェクト指向でのオブジェクトということなので後者の意味、

特に、クラスベースのオブジェクト指向プログラミングのパラダイムでは、特に、クラスのインスタンスを指す。

の意味になります。

そうなると、次に疑問に思うのは「クラス」と「インスタンス」とは何か、ということですね。

よく言われるのが、クラスは設計書、インスタンスはクラス（設計書）から作られる具体的な物体（オブジェクト）ということです。

上記を図にすると以下のようになります。

（こちらの記事より引用させていただいております。）

この図は個人をオブジェクトとしており、個人を定義するための人というカテゴリの設計書（雛形、テンプレート）をクラスとしています。

もう少し具体的にみていきましょう。

例えばゲームを開発しているとしましょう。このゲームの中で登場する生物が「ヒト」「犬」だったとします。

もちろん、それぞれの生物にはさらに個体に細分化されたキャラクターがいます。

ヒトならば「タケシ」や「ヒトミ」といった個人、犬ならば「ポチ」や「ロドリゲス」といった個体です。

ヒトのキャラクターを表すためには「名前」「性別」「年齢」「職業」「年収」「趣味」などがあると思います。

一方、犬のキャラクターを表すためには「名前」「性別」「年齢」「犬種」「好きなエサ」などが考えられます。

これらに具体的なデータ（名前ならタケシ、性別なら男等）を定義してキャラクターになりますね。

次にキャラクターのとる動作（振る舞い）についてみていきましょう。

キャラクターの取れる動作は生物ごとに決まっています。

ヒトなら「挨拶をする」や「告白する」、犬なら「鳴く」のような振る舞いをとります。

よって、タケシやヒトミは「挨拶をする」「告白する」振る舞いを持っており、ポチやロドリゲスは「鳴く」振る舞いを持っています。

このように、キャラクターを決定するための「名前」や「性別」の変数をメンバ変数といい、具体的な値のことを属性と言います。

またキャラクターの「挨拶をする」「鳴く」のような振る舞いのことを操作といいます。

そして属性や操作によってそれぞれのキャラクターが確定していきます。

それでは、それぞれのキャラクターのメンバ変数（名前や性別など）の属性（タケシや男など）と操作（挨拶するなど）を具体的に決定してみましょう。

（ヒト）
名前 : タケシ
性別 : 男
年齢 : 47
職業 : 経営者
年収 : 2,000万円
趣味 : バードウォッチング
挨拶をする
告白をする

名前 : ヒトミ
性別 : 女
年齢 : 38
職業 : 看護師
年収 : 600万円
趣味 : 料理
挨拶をする
告白をする

（犬）
名前 : ポチ
性別 : オス
年齢 : 5
犬種 : 芝犬
好きな餌 : 骨
鳴く

名前 : ロドリゲス
性別 : メス
年齢 : 3
犬種 : パグ
好きな餌 : チュール
鳴く

このように、メンバ変数に属性を設定し、それぞれに「挨拶する」や「鳴く」などの操作（振る舞い）を持たせることで個人・個体が決定しました。

この例でいうとメンバ変数や操作（振る舞い）をまとめているのがクラスであり、クラスから作られたキャラクターがインスタンス（オブジェクト）になります。

上記についてはサンプルコードで見てみましょう。（コードの__init__などの詳細については説明しません。）

class Human:
    def __init__(self, name: str, sex: str, age: int, job: str, annual_income: int, hobby: str):
        self.name = name
        self.sex = sex
        self.age = age
        self.job = job
        self.annual_income = annual_income
        self.hobby = hobby

    def greet(self):
        print("Hello")

    def confess(self):
        print("I love you")
    


class Dog:
    def __init__(self, name: str, sex: str, age: int, type: str, favorite_food: str):
        self.name = name
        self.sex = sex
        self.age = age
        self.type = type
        self.favorite_food = favorite_food

    def bark(self):
        print("Bow Bow")


Takeshi = Human("タケシ", "male", 47, "executive", 2000, "bird_watching")
Hitomi = Human("ヒトミ", "female", 38, "nurse", 600, "cooking")

Pochi = Dog("Pochi", "male", 5, "Shiba", "bone")
Rodriguez = Dog("Rodriguez", "female", 3, "Pug", "Churu")

Takeshi.greet()


# 出力
Hello


Takeshi.confess()


# 出力
I love you

class Humanと class Dogがメンバ変数と操作（振る舞い）をまとめているクラス（設計書）であり、その設計書に属性（具体的なデータ）を与えて作られたタケシやポチなどのキャラクターがインスタンス（オブジェクト）になります。

またクラスの中に書かれている操作（振る舞い）の関数のことをメソッドと呼びます。

クラスとインスタンスの関係が何となく理解できたでしょうか。

そもそも、なぜクラスを定義してインスタンスを作るのでしょうか？

別にクラスが無くても今回のタケシやポチは作れると思っていませんか？

クラスがないとオブジェクトは作ることはできませんが、結果としてデータや振る舞いを実装することはできます。

クラスを用いない場合のサンプルコードを見てみましょう。

import copy

def select_dict(animal_type: str) -> dict:
    if animal_type == "human":
        dict = {
            "animal_type": "human",
            "name": "Default Taro",
            "sex": "Default male",
            "age": "Default 20",
            "job": "Default no_job",
            "annual_income": "Default 100",
            "hobby": "Default no_hobby",
            "greet": True,
            "confess": True
        }
    elif animal_type == "dog":
        dict = {
            "animal_type": "dog",
            "name": "Default Pochi",
            "sex": "Default male",
            "age": "Default 1",
            "type": "Default hybrid",
            "favorite_food": "Default dog_food",
            "bark": True
        }
    return dict


def act(object: dict) -> str:
    if object["animal_type"] == "human":
        if object["greet"] == True:
            print("Hello")
        if object["confess"] == True:
            print("I love you")
    elif object["animal_type"] == "dog":
        if object["bark"] == True:
            print("Bow Bow")
    return


human = select_dict("human")

Takeshi = human.copy()

Takeshi = {
    "animal_type": "human",
    "name": "Takeshi",
    "sex": "male",
    "age": 47,
    "job": "executive",
    "annual_income": 2000,
    "hobby": "bird_watching",
    "greet": True,
    "confess": True
}

act(Takeshi)


# 出力
Hello
I love you

サンプルコードを順番にみていきましょう。

select_dictでは引数のanimal_typeで返す辞書を選択しています。返り値の辞書にはデフォルトの値が設定されています。

actではobjectという辞書型の引数を受け取り、その後条件分岐で動作（振る舞い）を決定しています。

変数humanにはselect_dictのデフォルトの値を持った辞書が代入されています。

その後Takeshiにコピーされたhumanを代入しています。

Takeshiの辞書のvalueはまだデフォルト値なので、Takeshi用に上書きしています。

そしてactの引数にTakeshiを渡して動作（振る舞い）を実行しています。

この動作（振る舞い）はTakeshiのgreetとconfessのbool値で決定されています。

これらがTrueならば動作を実行し、Falseならば実行しません。

動作（振る舞い）を制御するために、ここのbool値を都度変更する必要があります。

ここまでがクラスを使わなかった場合のサンプルコードになります。

見ていただいてわかるように、非常に読みにくいコードですよね。

一方クラスを使用した方がパッと見てわかりやすいコードになっています。

このようにクラスに属性や操作（振る舞い）をまとめて、インタンスを作成するコードは読み手にとってもわかりやすいです。

またクラスとオブジェクトに分離することで責任が明確になり、修正や変更がしやすくなります。

冒頭でも述べましたが、オブジェクト指向とは規則やルールではなくプログラミンの重要な考え方（概念）ということを覚えておいてください。

次からはオブジェクト指向の重要な三原則を紹介します。

継承

継承とは、あるクラスをもとに新しいクラスを作っていく考え方のことです。

3-12. 重複コードは避けるでもお伝えしたように同じようなコードがあると可読性が低くなり、またメンテナンスもしにくくなります。

これも具体例で確認していきましょう。

今度はRPGのゲームで見ていきます。

このゲームのキャラクターには戦士や魔法使いなどの「職業」が設定され、職業ごとの特殊スキルを発動できます。

また職業ごとに装備できるアイテムが異なります。

一方で全てのキャラクターには「名前」「level」「HP」「MP」の共通のパラメーターがあります。

ここでキャラクターとして「戦士のガッツ」、「魔法使いのシールケ」が登場するとしましょう。

先程のクラスを用いたサンプルコードを参考にすると以下のようになると思います。

class Warrior:
    def __init__(self, name: str, level: int, HP: int, MP: int, sword: str, armor: str, shield: str):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP
        self.sword = sword
        self.armor = armor
        self.shield = shield

    def special_attack(self):
        print("Enemy died")


class Wizard:
    def __init__(self, name: str, level: int, HP: int, MP: int, wand: str, robe: str):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP
        self.wand = wand
        self.robe = robe
        
    def magic(self):
        print("Heal allies")


Guts = Warrior("Guts", 100, 999, 50, "Dragon Slayer", "Berserk armor", "Huge Shield")
Schierke = Wizard("Schierke", 50, 600, 999, "Wizards wand", "Wizard's robe")

print(Guts.name)
print(Guts.level)
print(Guts.sword)
Guts.special_attack()

print("--------------")

print(Schierke.name)
print(Schierke.level)
print(Schierke.wand)
Schierke.magic()


# 出力
Guts
100
Dragon Slayer
Enemy died
--------------
Schierke
50
Wizards wand
Heal allies

コードを見るとWarrior（戦士）ではsword, armor, shield のメンバ変数があります。

一方、Wizard（魔法使い）にはwand, robe のメンバ変数があります。

またそれぞれのクラスの操作（振る舞い）は戦士だとspecial_attackですが、魔法使いだとmagicになっています。

しかし、それ以外（name, level, HP, MP）は共通していることがわかります。

この共通したメンバ変数を1つにまとめることが可能そうですね。

またWarriorクラスとWizardクラスには「たたかう」操作がありません。

この操作も合わせて追加してみましょう。

class Human:
    def __init__(self, name: str, level: int, HP: int, MP: int):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP

    def attack(self):
        print("Attack Enemy")


class Warrior(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, sword: str, armor: str, shield: str):
        super().__init__(name, level, HP, MP)   
        self.sword = sword
        self.armor = armor
        self.shield = shield

    def special_attack(self):
        print("Enemy died")


class Wizard(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, wand: str, robe: str):
        super().__init__(name, level, HP, MP)
        self.wand = wand
        self.robe = robe
        
    def magic(self):
        print("Heal allies")


Guts = Warrior("Guts", 100, 999, 50, "Dragon Slayer", "Berserk armor", "Huge Shield")
Schierke = Wizard("Schierke", 50, 600, 999, "Wizards wand", "Wizard's robe")

print(Guts.name)
print(Guts.level)
print(Guts.sword)
Guts.attack()

print("--------------")

print(Schierke.name)
print(Schierke.level)
print(Schierke.wand)
Schierke.attack()


# 出力
Guts
100
Dragon Slayer
Attack Enemy
--------------
Schierke
50
Wizards wand
Attack Enemy

新しくclass Humanというクラスを作成し、これにメンバ変数name, level, HP, MPとattackメソッドを持たせています。

そして、class Warriorとclass Wizardの引数にHumanクラスを渡しています。

この時Humanを親クラスといい、WarriorクラスとWizardクラスを子クラスといいます。

親クラスは基底クラスやスーパークラス、子クラスは派生クラスやサブクラスと言われることもあります。

その後super()で親クラス（Human）のメンバ変数とメソッドを子クラス(Warrior、Wizard)が引き継ぐことを定義しています。

そして装備できるアイテム（メンバ変数）と特殊スキル（メソッド）は子クラス別で異なるので、個別で定義しています。

あとは先程のサンプルコードと一緒です。

このように共通コードを1つのクラスにまとめて、そのクラスを利用して新しいクラスを作成する考え方のことを継承と言います。

継承を利用すると、親クラスから派生する子クラスを簡単に作成することができます。

例えば新しく盗賊や忍者などの職業を作ろうとしたとき、親クラスから派生して作れば、共通したメンバ変数やメソッドを職業別に定義する必要がなくなります。

また共通した箇所に修正や変更を加える時も親クラスだけに手を加えるだけで良くなります。

カプセル化

カプセル化とは、プログラムが他のプログラムの影響を受けないようにする考えのことです。具体的にはカプセル化された中身が外部から確認されない、変更できないことです。

カプセル化についてサンプルコードで見てみましょう。

先程のゲームの例から一部引用します。

最初はカプセル化がされていないパターンです。

# カプセル化がされていない

class Human:
    def __init__(self, name: str, level: int, HP: int, MP: int):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP

    def attack(self):
        print("Attack Enemy")


class Warrior(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, sword: str, armor: str, shield: str):
        super().__init__(name, level, HP, MP)   
        self.sword = sword
        self.armor = armor
        self.shield = shield

    def special_attack(self):
        print("Enemy died")

Guts = Warrior("Guts", 100, 999, 50, "Dragon Slayer", "Berserk armor", "Huge Shield")
print(Guts.sword)


# 出力
Dragon Slayer

Guts.sword = "Wood stick"
print(Guts.sword)


# 出力
Wood stick

上記はHumanクラスから派生したWarriorクラスによってGutsインスタンスを最初に作っています。

この時、weaponはDragon Slayerで定義されていたのですがGuts.sword = "Wood stick"でWood stick で変更されております。

このようにインスタンスの属性が変わってしまう状態はカプセル化がされていないと言います。

カプセル化がされていないと、意図しないところでインスタンスの属性が変更され、バグやエラーの原因となってしまいます。

これを防ぐためにカプセル化をした状態のサンプルコードを見てみましょう。

# カプセル化がされている

class Human:
    def __init__(self, name: str, level: int, HP: int, MP: int):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP

    def attack(self):
        print("Attack Enemy")


class Warrior(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, sword: str, armor: str, shield: str):
        super().__init__(name, level, HP, MP)   
        self.__sword = sword
        self.__armor = armor
        self.__shield = shield

    def special_attack(self):
        print("Enemy died")

Guts = Warrior("Guts", 100, 999, 50, "Dragon Slayer", "Berserk armor", "Huge Shield")
print(Guts.sword)


# 出力
AttributeError: 'Warrior' object has no attribute 'sword'

変更箇所はWarriorクラスのメンバ変数にダブルアンダースコア(__)をつけていることです。

これでprint(Guts.sword)でswordを呼び出そうとすると AttributeError(属性エラー)となってしまいました。

メッセージを見るとWarriorクラスにはswordの属性がないよと言われています。

ここでちょっと待てよと思う方がいるかもしれません。

Gutsインスタンスを作った時にswordも定義してるから、そのエラーはおかしいんじゃないかと。

それではGutsインスタンスが持っている属性とメソッドを確認してみましょう。

print(dir(Guts))


# 出力
['HP', 'MP', '_Warrior__armor', '_Warrior__shield', '_Warrior__sword', '__class__',
'__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', '__weakref__', 'level', 'name', 'special_attack']

よく見ると_Warrior__swordが確認できますね。

今回のエラーは、正確にはWarriorクラスのswordはあるが、情報を取得できない（Getできない）ということだったのです。

完全にプライベートなものとなってしまったというわけです。

それでは、swordの中身を確認してみましょう。

class Human:
    def __init__(self, name: str, level: int, HP: int, MP: int):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP

    def attack(self):
        print("Attack Enemy")


class Warrior(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, sword: str, armor: str, shield: str):
        super().__init__(name, level, HP, MP)   
        self.__sword = sword
        self.__armor = armor
        self.__shield = shield

    @property
    def sword(self):
        return self.__sword

    def special_attack(self):
        print("Enemy died")

Guts = Warrior("Guts", 100, 999, 50, "Dragon Slayer", "Berserk armor", "Huge Shield")
print(Guts.sword)


# 出力
Dragon Slayer

今度は出力されましたね。

先程からの変更点は@propertyがついたswordメソッドを追加したことです。

@propertyはデコレーターというのですが、ここでは詳細を説明しません。

こちらの記事にカプセル化の際のデコレーターの使い方が書かれていますので、確認してみてください。

@property（デコレーター）をつけることでプライベートであったswordの中身を確認することができました。

それではswordの中身を変更することはできるのか、確認してみましょう。

class Human:
    def __init__(self, name: str, level: int, HP: int, MP: int):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP

    def attack(self):
        print("Attack Enemy")


class Warrior(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, sword: str, armor: str, shield: str):
        super().__init__(name, level, HP, MP)   
        self.__sword = sword
        self.__armor = armor
        self.__shield = shield

    @property
    def sword(self):
        return self.__sword

    def special_attack(self):
        print("Enemy died")

Guts = Warrior("Guts", 100, 999, 50, "Dragon Slayer", "Berserk armor", "Huge Shield")
print(Guts.sword)

Guts.sword = "Wood stick"


# 出力
AttributeError: property 'sword' of 'Warrior' object has no setter

今回もAttributeError(属性エラー)となってしまいました。

しかしメッセージの中身を見ると、setterが無いよと言われています。

実は最初のswordの中身を見ようとして起きたエラーはgetterというものが関係しており、@property（デコレーター）箇所がgetterの役割を果たしていました。

今回のswordの中身を変更しようとした時のエラーはsetterというものが関係しており、setterの役割を果たすコードがない状態です。

これらの役割を端的に言ってしまうとgetterは属性を取得する、setterは属性を変更するためのものです。

プライベートになった属性は、getterやsetterがないとアクセスすることができないことが確認できました。

ここでもう一度カプセル化について振り返りましょう。

カプセル化とは、プログラムが他のプログラムの影響を受けないようにする考えのことです。具体的はカプセル化された中身が外部から確認されない、変更できないことです。

今回はカプセル化の例として、Warriorクラスのメンバ変数をプライベートにしました。

ただ、中身を確認できなかったため@property（デコレーター）でメンバ変数の中身を見れるようにしました。

しかし、そもそもカプセル化とは中身が見えることも避けたいのです。

getterで情報が見えてしまうということは、インスタンスに機密情報を持たせるようにした際に、場合によっては見られるてしまうことになります。

カプセル化を徹底するためにはsetterもgetterも設定してはいけません。
（もちろん、サービスやアプリケーションの仕様によっては避けられないこともありますが）

ポリモーフィズム

ポリモーフィズムとは、同じ名前のメソッドが異なるクラスやオブジェクトで、それぞれの振る舞いを持つことを意味します。

先ほどまでのサンプルコードでは戦士と魔法使いには「たたかう」という振る舞いがありましたが、攻撃内容が同じになっていました。

ここで、戦士と魔法使いで攻撃の内容を分けたい場合のことを考えましょう。

戦士は「剣で攻撃」、魔法使いは「杖で攻撃」といった具合です。

これを実現するためのコードを見てみましょう。

class Human:
    def __init__(self, name: str, level: int, HP: int, MP: int):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP

    def attack(self):
        print("Attack Enemy")


class Warrior(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, sword: str, armor: str, shield: str):
        super().__init__(name, level, HP, MP)   
        self.sword = sword
        self.armor = armor
        self.shield = shield

    def special_attack(self):
        print("Enemy died")

    def attack(self):
        print(f"Attack Enemy with {self.sword}")


class Wizard(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, wand: str, robe: str):
        super().__init__(name, level, HP, MP)
        self.wand = wand
        self.robe = robe
        
    def magic(self):
        print("Heal allies")

    def attack(self):
        print(f"Attack Enemy with {self.wand}")


Guts = Warrior("Guts", 100, 999, 50, "Dragon Slayer", "Berserk armor", "Huge Shield")
Schierke = Wizard("Schierke", 50, 600, 999, "Wizards wand", "Wizard's robe")

Guts.attack()
Schierke.attack()


# 出力
Attack Enemy with Dragon Slayer


Schierke.attack()


# 出力
Attack Enemy with Wizards wand

WarriorクラスとWizardクラスにattackメソッドを追加し、attackメソッドを呼ぶと、それぞれの武器で敵に攻撃するようになっています。

実際にはHumanクラスから継承したattackメソッドをそれぞれのクラスで処理内容を上書きしています。

このように他のクラスから継承したメソッドの内容を上書きすることをオーバーライドと言います。

ポリモーフィズムは、同じメソッド名が異なるクラスでそれぞれの振る舞いを持つ考え方のことです。

つまり、次のサンプルコードのように継承を用いない場合でも、ポリモーフィズムが成り立っていることになります。

class Human:
    def __init__(self, name: str, level: int, HP: int, MP: int):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP


class Warrior(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, sword: str, armor: str, shield: str):
        super().__init__(name, level, HP, MP)   
        self.sword = sword
        self.armor = armor
        self.shield = shield

    def special_attack(self):
        print("Enemy died")

    def attack(self):
        print(f"Attack Enemy with {self.sword}")


class Wizard(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, wand: str, robe: str):
        super().__init__(name, level, HP, MP)
        self.wand = wand
        self.robe = robe
        
    def magic(self):
        print("Heal allies")

    def attack(self):
        print(f"Attack Enemy with {self.wand}")

Guts = Warrior("Guts", 100, 999, 50, "Dragon Slayer", "Berserk armor", "Huge Shield")
Schierke = Wizard("Schierke", 50, 600, 999, "Wizards wand", "Wizard's robe")

Guts.attack()


# 出力
Dragon Slayerで敵に攻撃


Schierke.attack()


# 出力
Wizards wandで敵に攻撃

Humanクラスからattackメソッドを削除しました。

これにより、子クラスへの継承はメンバ変数のみ(name, level, HP, MP)になりました。

WarriorクラスとWizardクラスそれぞれでattackメソッドを定義しています。

この場合もポリモーフィズムの考えが実現できていることになります。

他の記事では継承してオーバーライドしたり、抽象クラスというものを準備するようなことが書かれていますが、どれもポリモーフィズムを実現するための1つの手段でしかなく、必須というわけではありません。

もう一度言いますが、ポリモーフィズムとは同じ名前のメソッドが異なるクラスやオブジェクトでそれぞれの振る舞いを持つことです。

このサンプルだとポリモーフィズムのメリットがなんなのかよく理解できないと思いますので、もう一つポリモーフィズムを実現するための一例をお伝えしようと思います。

その前に抽象クラスというものを紹介します。

抽象クラスとは少なくも1つの抽象メソッドを持ったクラスのことを言います。

抽象メソッドとは具体的な処理を持たないメソッドのことを言います。

サンプルコードで確認していきましょう。

from abc import ABCMeta, abstractmethod

class Human(metaclass=ABCMeta):
    def __init__(self, name: str, level: int, HP: str, MP: str):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP

    @abstractmethod
    def attack(self):
        pass


class Warrior(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, sword: str, armor: str, shield: str):
        super().__init__(name, level, HP, MP)   
        self.sword = sword
        self.armor = armor
        self.shield = shield

    def special_attack(self):
        print("Enemy died")

    def attack(self):
        print(f"Attack Enemy with {self.sword}")


class Wizard(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, wand: str, robe: str):
        super().__init__(name, level, HP, MP)
        self.wand = wand
        self.robe = robe
        
    def magic(self):
        print("Heal allies")

    def attack(self):
        print(f"Attack Enemy with {self.wand}")

Guts = Warrior("Guts", 100, 999, 50, "Dragon Slayer", "Berserk armor", "Huge Shield")
Schierke = Wizard("Schierke", 50, 600, 999, "Wizards wand", "Wizard's robe")

Guts.attack()


# 出力
Dragon Slayerで敵に攻撃


Schierke.attack()


# 出力
Wizards wandで敵に攻撃

まず、from abc import ABCMeta, abstractmethodで抽象クラスのためのモジュールをインポートしています。

その後、Humanクラスの引数にABCMetaを渡してあげています。

こうすることによってHumanクラスが抽象クラスであることを定義しています。

Humanクラスの中身を見ると@abstractmethodというデコレーターがついたattackメソッドが定義されています。

attackメソッドの中身はpassによって何もしないことになっています。

このattackが抽象メソッドになります。

あとは先ほどまでと同様に｀Warrior ｀クラスとWizardクラスがHumanクラスを継承して、attackメソッドをオーバーライドしています。

それでは、Wizardクラスでattackメソッドを宣言しなかった場合どうなるかみてみましょう。

# Wizardクラスでattackを宣言しなかった場合

from abc import ABCMeta, abstractmethod

class Human(metaclass=ABCMeta):
    def __init__(self, name: str, level: int, HP: int, MP: int):
        self.name = name
        self.level = level
        self.HP = HP
        self.MP = MP

    @abstractmethod
    def attack(self):
        pass


class Warrior(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, sword: str, armor: str, shield: str):
        super().__init__(name, level, HP, MP)   
        self.sword = sword
        self.armor = armor
        self.shield = shield

    def special_attack(self):
        print("Enemy died")

    def attack(self):
        print(f"Attack Enemy with {self.sword}")


class Wizard(Human):
    def __init__(self, name: str, level: int, HP: int, MP: int, wand: str, robe: str):
        super().__init__(name, level, HP, MP)
        self.wand = wand
        self.robe = robe
        
    def magic(self):
        print("Heal allies")


Guts = Warrior("Guts", 100, 999, 50, "Dragon Slayer", "Berserk armor", "Huge Shield")
Schierke = Wizard("Schierke", 50, 600, 999, "Wizards wand", "Wizard's robe")

Guts.attack()
Schierke.attack()


# 出力
AttributeError: 'Wizard' object has no attribute 'attack'

AttributeErrorでattackメソッドがないと言われています。

このように抽象クラスと抽象メソッドを設定してあげると、抽象クラスから作られる子クラスは抽象メソッドを強制的に持たなければならなくなります。

抽象クラスを定義しなくてもポリモーフィズムは実現できますが、プログラムが複雑になってくると共通な振る舞いを持つメソッドの定義漏れが発生することが考えられます。

そうなるとバグやエラーの原因につながります。

抽象クラスを定義してあげることでポリモーフィズムの実現をより堅固なものにすることができます。

以上がオブジェクト指向の3原則（継承・カプセル化・ポリモーフィズム）です。

なお、オブジェクト指向についてはこちらの記事でとても詳しく書かれていましたので、ぜひ確認してみてください。

3-18. デザインパターンとは

オブジェクト指向で、継承・カプセル化・ポリモーフィズムについてお伝えしました。

その際に具体的な例を用いて修正や変更を加えていましたが、より効果的なクラスの設計を教えてくれるのがデザインパターンです。

デザインパターンはthe Gang of Fourと呼ばれる4人の開発者が提案した、オブジェクト指向開発における23個の再利用性の高い設計のことを言います。

この23パターンは、過去に問題に直面した際、より効果的に解決するために生み出されたパターンでありオブジェクト指向開発の設計指針と言われています。

ただし最近では各プログラミング言語のフレームワークでの開発が主流になってきており、フレームワークがよしなに設計してくれるため、個人がデザインパターンを意識して開発する機会が少なくなってきています。

その結果、デザインパターンを知らない人も開発することが可能となってきており、このような人がいる中でデザインパターンを適用したせいで、逆に可読性が落ちるといったこともあるそうです。

このような経緯からデザインパターンを知っておけば開発が効率良くなる場合もあるといったものなので、ここでは詳細については触れないでおきたいと思います。

なおデザインパターンについてはこちらの記事に詳細が書かれていますので、気になる方は確認してみてください。

3-19. ディレクトリの構成の重要性

ディレクトリの構成もプログラミングにおいて大切です。

練習用のプロジェクトでディレクトリを作る程度なら問題ないでしょうが、実務においてディレクトリ構成を軽視するとプロジェクトの全体像を把握できなくなるだけでなく、チームの人もどこにどんなファイルがあるのかわからなくなり、迷惑をかけることになります。

例えば以下のようなデレクトリ構成があったとします。

my_project/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   ├── com/
│   │   │   │   ├── myapp/
│   │   │   │   │   ├── App.java
│   │   ├── resources/
│   │   │   ├── config.properties
├── test/
│   ├── java/
│   │   ├── com/
│   │   │   ├── myapp/
│   │   │   │   ├── AppTest.java
├── build.gradle
├── README.md

このディレクトリ構成が必ずしも正しいわけではないのですが、少なくともどこにどのようなファイルがあるかが把握しやすいと思いませんか？

例えばsrcディレクトリ配下にはプロジェクトの実態に関するコードが置かれていることがわかり、testディレクトリ配下ではテストに関するコードが置かれていることがわかります。

また、プロジェクトの全体像の資料であるREADME.mdがmy_project直下においてありますが、一般的にREADME.md はプロジェクト全体に関することが記載されているので、このファイルの配置の仕方も理にかなっています。

仮にtestディレクトリがcomディレクトリ配下にあった時に、testとcomの関係性がよくわからないので、ファイルを探すのに時間がかかってしまうでしょう。

このようにディレクトリ構成を不適切に設定すると、全体像を把握することが難しくなってしまいます。

プロジェクトに参加し始めは、まずディレクトリの構成を見て全体像の把握するようにしましょう。

そうすることによって、修正や変更が必要なファイルを探す時間を省くことができます。

少し本題とずれてはしまうのですが、適当なファイル名やディレクトリ名も全体の見通しを悪くさせてしまいます。

ディレクトリはどのようなファイルをまとめているのかを一目見てわかる名前にしたほうが良いです。

同様にファイル名もどのようなコードを含んでいるのかがわかる名前にしたほうが良いです。

変数名や関数名をつけるときと同様、慎適切な名前をつけるようにしましょう。

3-20. 既存コードを見る（ルールを知る）

コードが全くない状態からコードを書き始めるときは気にしなくても良いかもしれませんが、すでにコードがある状態（例えば、途中からプロジェクトに参加した場合など）では既存のコードをよく見るようにしましょう。

すでに何かしらのルールに則ってコードを書いている可能性が大きいです。

既存コードのルールを知ることには以下のようなメリットがあります。

• コードの一貫性を保つ
  既存コードのルールを理解することで、コード全体で一貫性のあるスタイルや規則を維持できます。これによりコードが読みやすく、他の開発者との協力が円滑になります。

• バグの早期発見
  既存コードのルールを理解することで、潜在的な問題やバグを早期に発見しやすくなります。あなたがルールを徹底していても、他の開発者がルールを破っている可能性があります。このような時にルールから外れたコードを見つけることが可能になり、将来的にバグとなる可能性をなくすことができます。

• コードの効率的な変更
  既存コードのルールを知ることは、コードの変更やアップデートを行う際に役立ちます。ルールに則った変更を行うことで、リスクの低い変更や、作業期間を短くすることが可能になります。

• プロジェクトへの適応
  新しいプロジェクトやチームに参加する際、既存コードのルールを理解することは、プロジェクトに適応するのに役立ちます。適切なスタイルガイドやコーディング慣行を守ることで、プロジェクトへの適応がスムーズになります。

• ベストプラクティスの学習
  既存コードは、ベストプラクティスや設計パターンの実例となる可能性があります。あなたが知らない、他の開発者が採用したアプローチを学び、自身のスキルを向上させるのに非常に役立ちます。

• メンテナンスの容易化
  既存コードのルールに則ってコードを記述することで、将来のメンテナンスが容易になります。誰でも理解しやすいコードを書くことで、バグの修正や新機能の追加がスムーズに行えます。

このように既存コードのルールを知ることはフォーマットを揃えることにもなり、最終的には可読性を高めることにつながります。

あなたの独自ルールをコードに落とし込んでしまい、他の人にとって読みにくいコードとならないためにも既存コードをよく見るようにしましょう。

4. よく使われる英単語一覧（全759語）

この章ではプログラミングでよく使われる英単語を品詞別で紹介したいと思います。

敢えてこの章を設けているのには理由があります。

それはプログラミングであまり使用されていない英単語を利用すると可読性が下がるからです。

具体例で説明してみます。

あなたがコードを書いている時に「受け入れられたユーザー」という変数名をつけようとしたとしましょう。

おそらくあなたは「受け入れられた」の英語を調べると思います。

Googleで「受け入れる」で検索をすると以下のような候補がいくつか出てくるでしょう。

• accept
• admit
• welcome
• adapt

どれも「受け入れる」という意味ですが、ニュアンスが異なっています。

プログラミングにおいてよく使われているのはacceptやadmitだと思われますが、あなたがここでwelcomeを選んでwelcomedUserと変数名をつけたらどうなるでしょうか。

他の人がこの変数を見たときに直感的に「受け入れられたユーザー」と認識できるでしょうか。

恐らくそうはならず、この変数の意味を理解するためにコードを追うことになるでしょう。

もしくはwelcomeの意味を調べてしまうかもしれません。

仮にあなたが厳密にニュアンスを理解して使い分けていたとしても、他の人がそれを理解しているとは限らず、結局可読性を下げてしまうことになります。

一方、よく使われているacceptやadmitを使えば上記のようなことは避けられるはずです。

大切なことは他の人が読んでもわかりやすいコードを書くことです。

これから紹介する英単語はプログラミングでよく使われる英単語であるため、可読性を下げること防いでくれます。

4-1. 動詞