最速でわかるPython入門！これだけでOK

By /

最速でわかるPython入門！これだけでOK

はじめに：なぜ今、Pythonなのか？

ようこそ、Pythonの世界へ！

プログラミングを始めたい、でもどの言語から学べばいいか分からない。そんなあなたに自信を持っておすすめできるのが、Pythonです。

なぜPythonなのでしょうか？理由はたくさんありますが、最も大きな理由は以下の3つです。

  1. 圧倒的な人気と汎用性: Pythonは、Web開発（Django, Flask）、データ分析（Pandas, NumPy）、機械学習・AI（TensorFlow, PyTorch, scikit-learn）、自動化、科学技術計算、ゲーム開発など、非常に幅広い分野で使われています。その人気は年々高まる一方で、求人市場でもPythonスキルを持つ人材への需要は非常に高いです。
  2. コードが読みやすく書きやすい: Pythonは、シンプルで直感的な文法が特徴です。他の言語に比べて覚えるべきルールが少なく、まるで英語の文章を読んでいるかのようにコードを理解できます。これにより、プログラミング未経験者でも挫折しにくく、学習コストが低いと言われています。
  3. 強力なコミュニティと豊富なライブラリ: Pythonには世界中に熱心な開発者コミュニティがあり、困ったことがあればすぐに情報を得られます。また、「ライブラリ」と呼ばれる便利な部品が非常に豊富に用意されています。これにより、ゼロからすべてを作る必要がなく、効率的に開発を進めることができます。

この記事では、そんなPythonの基礎中の基礎から、「これだけ知っておけば、まずはPythonで簡単なプログラムを書いて動かせる！」というレベルまでを最速で習得することを目指します。約5000語という大ボリュームで、一つ一つの概念を丁寧に解説し、豊富なコード例とともに学んでいきます。

プログラミングが初めての方も、他の言語経験者でPythonに触れたい方も、この記事を読めばPythonの入り口は完璧です。さあ、私たちと一緒にPythonの楽しい世界に飛び込みましょう！

ステップ１：Pythonを始めるための準備をしよう

Pythonを始めるには、まずあなたのコンピューターにPythonをインストールする必要があります。そして、コードを書くための環境を整えましょう。

Pythonのインストール

多くのOS（macOSやLinux）には最初からPythonがインストールされていることがありますが、最新版ではなかったり、開発に必要なツールが揃っていなかったりします。ここでは、公式サイトから最新版をインストールする方法と、データ科学分野でよく使われるAnacondaという配布版について説明します。

公式サイトからのインストール（推奨）

最も基本的な方法は、Pythonの公式サイト（https://www.python.org/）からインストーラーをダウンロードして実行することです。

  • Windowsの場合:

    • 公式サイトのダウンロードページから、最新版のWindowsインストーラー（例: Python 3.x.x Installer）をダウンロードします。
    • ダウンロードしたexeファイルを実行します。
    • ここで最も重要なポイント！ インストールオプションの画面で、「Add Python 3.x to PATH」というチェックボックスに必ずチェックを入れてください。 これを忘れると、後々コマンドプロンプトなどでPythonを起動するのが面倒になります。
    • 「Install Now」をクリックしてインストールを開始します。
    • インストールが完了したら、コマンドプロンプト（cmd または PowerShell）を開き、python --version または python -V と入力してEnterキーを押してみてください。インストールしたPythonのバージョンが表示されれば成功です。もしエラーになる場合は、PATHが正しく設定されていない可能性があります。

  • macOSの場合:

    • 公式サイトのダウンロードページから、最新版のmacOSインストーラー（例: Python 3.x.x macOS 64-bit installer）をダウンロードします。
    • ダウンロードしたpkgファイルを実行し、画面の指示に従ってインストールします。
    • インストールが完了したら、ターミナルを開き、python3 --version または python3 -V と入力してEnterキーを押してみてください。macOSにはデフォルトでPython 2系や古い3系が入っていることがあるため、インストールした新しいPython 3系を起動するには python3 コマンドを使うのが一般的です。

  • Linuxの場合:

    • 多くのLinuxディストリビューションには、パッケージマネージャー（apt, yum, dnfなど）を使ってPythonをインストールする方法が推奨されます。
    • Ubuntu/Debian系の場合: sudo apt update の後 sudo apt install python3 を実行します。
    • Fedora/CentOS/RHEL系の場合: sudo dnf install python3 または sudo yum install python3 を実行します。
    • インストールが完了したら、ターミナルで python3 --version と入力して確認します。

Anacondaディストリビューション

データ分析や機械学習を中心にPythonを使いたい場合は、Anacondaというディストリビューションのインストールも強力な選択肢です。Anacondaには、Python本体だけでなく、データ分析でよく使われるPandas, NumPy, scikit-learnなどのライブラリや、Jupyter Notebookといった便利なツールがあらかじめ含まれています。

  • 公式サイト（https://www.anaconda.com/）からダウンロードしてインストールします。インストールの際に、PATHに追加するかどうか尋ねられることがありますが、Anaconda NavigatorやAnaconda Prompt（またはターミナル）を使う場合は必ずしも必須ではありません。

この記事では基本的なPythonの機能を説明するため、公式サイトからのインストールでもAnacondaでも、どちらでも学習を進める上で問題ありません。

Pythonインタプリタを使ってみよう

Pythonがインストールできたら、まずは「対話モード」または「インタプリタ」を試してみましょう。これは、Pythonのコードを一行ずつ実行して、その結果をすぐに確認できる便利なツールです。

コマンドプロンプト（Windows）、ターミナル（macOS/Linux）を開き、以下のコマンドを入力します。

  • 公式サイトからインストールした場合：python または python3
  • Anacondaをインストールした場合：python （Anaconda Promptまたはターミナルから）

成功すると、>>> というプロンプトが表示されます。これがPythonインタプリタです。

bash
python

“`python

1 + 1
2
print(“Hello, Python!”)
Hello, Python!
name = “Alice”
print(“My name is”, name)
My name is Alice
exit() # インタプリタを終了するコマンド
“`

インタプリタは、簡単な計算をしたり、コードの一部を試したりするのに非常に役立ちます。

コードエディタ/IDEの準備

短いコードならインタプリタで十分ですが、本格的なプログラムを書くには、コードエディタやIDE（統合開発環境）を使うのが一般的です。これらは、コードの色分け（シンタックスハイライト）、入力補完、エラーチェックなど、様々な開発を効率化する機能を提供してくれます。

初心者におすすめの無料ツールは以下の2つです。

  • VS Code (Visual Studio Code): Microsoftが開発している無料のコードエディタです。非常に高機能でカスタマイズ性が高く、Python開発に必要な拡張機能（Python Extension）をインストールすることで、強力なIDEとして利用できます。多くのプログラマーに愛用されています。
  • PyCharm Community Edition: JetBrainsが開発しているPythonに特化した無料のIDEです。Python開発に特化しているだけあって、非常に高機能な入力補完やデバッグ機能を提供します。VS Codeよりは少し重いですが、Python専門で開発するなら非常に強力なツールです。

どちらを選んでも良いですが、ここでは多くの人が使っているVS Codeをおすすめします。VS Codeをインストールしたら、拡張機能ビューを開き、「Python」と検索してMicrosoftが提供する拡張機能をインストールしておきましょう。これにより、VS CodeがPythonコードをより適切に扱えるようになります。

最初のPythonプログラム：Hello, World!

プログラミング学習の伝統として、最初に書くプログラムは画面に「Hello, World!」と表示するものです。Pythonでは、これは非常に簡単です。

  1. VS Codeなどのエディタを開きます。
  2. 新しいファイルを作成し、hello.py という名前で保存します。（.py という拡張子はPythonファイルの目印です）

  3. ファイルに以下のコードを書きます。

    python
    print("Hello, World!")
    4. ファイルを保存します。
    5. ターミナルまたはコマンドプロンプトを開き、保存したファイルのディレクトリに移動します。
    6. 以下のコマンドを実行します。

    bash
    python hello.py
    またはmacOS/Linuxで python3 hello.py

成功すれば、ターミナルに Hello, World! と表示されるはずです。

Hello, World!

これで、Pythonプログラムを書いて実行する基本的な流れが分かりました。次の章から、いよいよPythonの基本的な文法を学んでいきましょう！

ステップ２：Pythonの基本のキを知ろう

Pythonの文法は非常にシンプルですが、いくつかの基本的なルールや概念を理解する必要があります。

コメントアウト

コードの中に、プログラムの実行には影響しないメモや説明を書きたい場合があります。そのような時に使うのがコメントです。Pythonでは # の後に書かれた内容はその行のコメントとして扱われます。

“`python

これは一行コメントです

print(“コメントは無視されます”) # 行の途中にコメントを書くこともできます

“””
これは
複数行の
コメントとして
よく使われる
トリプルクォーテーションで囲まれた
文字列リテラルです。
（厳密にはコメントではなく文字列ですが、変数に代入されなければ実行に影響しないため慣習的に使われます）
“””
“`

コメントは、後からコードを読んだ人が内容を理解しやすくするために非常に重要です。

変数とデータ型

プログラムでは、様々な種類のデータを扱います。これらのデータを一時的に保存しておく「箱」のようなものが変数です。Pythonでは、変数を使う前に「この変数は整数型です」のように型を宣言する必要がありません。値を代入すると、Pythonが自動的に型を判断してくれます。

変数は = 記号を使って値を代入します。

“`python

変数に値を代入する

age = 30
name = “Alice”
is_student = True
pi = 3.14159

変数の値を表示する

print(age)
print(name)
print(is_student)
print(pi)
“`

Pythonの主なデータ型

Pythonにはいくつかの基本的なデータ型があります。

  • 数値型 (Numeric Types):
    • int (整数): -2, 0, 100 など小数点を含まない数
    • float (浮動小数点数): 3.14, -0.5, 2.0 など小数点を含む数
    • complex (複素数): 1 + 2j など（入門段階ではあまり使いません）
  • 文字列型 (String Type):
    • str: テキストデータを扱います。シングルクォート (') またはダブルクォート (") で囲んで表現します。
  • 真偽値型 (Boolean Type):
    • bool: True (真) または False (偽) のどちらかの値をとります。条件分岐などで使われます。

変数にどのような型の値が入っているかを確認するには、type() 関数を使います。

“`python
num = 10
greeting = “Hello”
flag = False

print(type(num)) #
print(type(greeting)) #
print(type(flag)) #
print(type(3.14)) #
“`

入力と出力

プログラムの基本的な機能の一つは、外部からデータを受け取り（入力）、結果を外部に表示する（出力）ことです。

print() 関数による出力

「Hello, World!」の例でも使いましたが、print() 関数は指定した値を画面（標準出力）に表示します。複数の値を表示したい場合は、カンマ (,) で区切って渡します。デフォルトでは、値の間にスペースが入り、最後に改行が入ります。

“`python
print(“Hello”)
print(“World”) # Hello の次の行に World が表示される

print(“Name:”, “Alice”) # Name: Alice と表示される

デフォルトの区切り文字と行末文字を変更する

print(“A”, “B”, “C”, sep=”-“, end=”!”) # A-B-C! と表示される
print(“Next line”) # Next line は A-B-C! の次の行に表示される
“`

input() 関数による入力

input() 関数は、ユーザーに何かを入力してもらい、その入力値を文字列として受け取ることができます。

“`python
name = input(“あなたの名前を入力してください: “)
print(“こんにちは、” + name + “さん！”)

注意: input() の戻り値は常に文字列型です！

age_str = input(“あなたの年齢を入力してください: “)
print(“あなたの年齢は ” + age_str + ” 歳です。”)
print(type(age_str)) # になる
“`

もし数値として入力値を使いたい場合は、後述する型変換を行う必要があります。

型変換 (キャスト)

input() の例のように、ある型の値を別の型の値に変換したい場合があります。これを型変換（キャスト）と呼びます。Pythonでは、それぞれの型名と同じ名前の関数を使って変換を行います。

  • int(値): 指定した値を整数に変換します。
  • float(値): 指定した値を浮動小数点数に変換します。
  • str(値): 指定した値を文字列に変換します。
  • bool(値): 指定した値を真偽値に変換します。

“`python

文字列を数値に変換

age_str = “25”
age_int = int(age_str)
print(type(age_str), type(age_int)) #

height_str = “175.5”
height_float = float(height_str)
print(type(height_str), type(height_float)) #

数値を文字列に変換

num = 123
num_str = str(num)
print(type(num), type(num_str)) #

数値を真偽値に変換 (0はFalse, それ以外はTrue)

is_zero = bool(0)
is_positive = bool(10)
print(is_zero, is_positive) # False True

文字列を真偽値に変換 (空文字列 ” はFalse, それ以外はTrue)

is_empty = bool(“”)
is_non_empty = bool(“hello”)
print(is_empty, is_non_empty) # False True

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

int(“hello”) # ValueError が発生

float(“world”) # ValueError が発生

“`

input() で受け取った年齢を数値として扱いたい場合は、以下のようにします。

“`python
age_str = input(“あなたの年齢を入力してください: “)
age = int(age_str) # ここでint型に変換
print(“来年には”, age + 1, “歳ですね！”)

“来年には 26 歳ですね！” (例えばageが25の場合)

“`

演算子

Pythonには様々な演算子があります。

算術演算子

演算子 説明 例 結果
+ 加算 5 + 2 7
- 減算 5 - 2 3
* 乗算 5 * 2 10
/ 除算 5 / 2 2.5
// 除算（切り捨て） 5 // 2 2
% 剰余（あまり） 5 % 2 1
** べき乗 5 ** 2 25

python
a = 10
b = 3
print(a + b) # 13
print(a - b) # 7
print(a * b) # 30
print(a / b) # 3.333...
print(a // b) # 3 (小数点以下切り捨て)
print(a % b) # 1 (あまり)
print(a ** 2) # 100 (10の2乗)

比較演算子

二つの値を比較し、結果を真偽値 (True または False) で返します。

演算子 説明 例 結果
== 等しい a == b False
!= 等しくない a != b True
> より大きい a > b True
< より小さい a < b False
>= より大きいか等しい a >= b True
<= より小さいか等しい a <= b False

“`python
x = 10
y = 5
z = 10

print(x == y) # False
print(x != y) # True
print(x > y) # True
print(x < y) # False
print(x >= z) # True
print(y <= z) # True
“`

論理演算子

真偽値を組み合わせて、より複雑な条件を作ります。

演算子 説明 例
and 論理積（かつ） True and False
or 論理和（または） True or False
not 論理否定（〜ではない） not True

“`python
is_sunny = True
is_warm = False

print(is_sunny and is_warm) # False (晴れ かつ 暖かい)
print(is_sunny or is_warm) # True (晴れ または 暖かい)
print(not is_warm) # True (暖かくはない)

比較演算子と組み合わせて使う

age = 25
print(age >= 20 and age < 30) # True (20以上 かつ 30未満)
“`

f-stringによる文字列整形

Python 3.6以降で導入されたf-string (formatted string literals) は、文字列の中に変数の値を埋め込むのに非常に便利です。文字列の前に f をつけ、埋め込みたい変数や式を {} で囲みます。

“`python
name = “Bob”
age = 40

従来の文字列連結

print(“私の名前は” + name + “で、年齢は” + str(age) + “歳です。”)

format() メソッドを使う方法

print(“私の名前は{}で、年齢は{}歳です。”.format(name, age))

f-string (最も推奨)

print(f”私の名前は{name}で、年齢は{age}歳です。”)

{} の中に式も書ける

print(f”来年には{age + 1}歳になります。”)

フォーマット指定も可能

pi = 3.14159265
print(f”円周率は {pi:.2f} です。”) # 少数点以下2桁まで表示
“`

f-stringは可読性が高く、文字列と変数を組み合わせる際によく使われます。

これでPythonの基本的な要素である、コメント、変数、データ型、入出力、演算子、文字列整形について学びました。次は、複数のデータをまとめて扱うための「コレクション」について学びましょう。

ステップ３：複数のデータをまとめて扱う：コレクション

Pythonには、複数のデータをまとめて管理するための便利なデータ構造がいくつか用意されています。代表的なものに、リスト、タプル、セット、辞書があります。

リスト (list)

リストは、複数の要素を順番に並べて格納できるデータ構造です。要素の順番は保持され、後から要素を追加したり、削除したり、変更したりできます。リストは [] を使って作成します。

“`python

リストの作成

fruits = [“apple”, “banana”, “cherry”]
numbers = [1, 2, 3, 4, 5]
mixed_list = [“apple”, 1, True, 3.14] # 異なる型の要素も混在可能

空のリストを作成

empty_list = []
“`

要素へのアクセス

リストの要素には、インデックス（順番を示す番号）を使ってアクセスします。Pythonのインデックスは 0 から始まります。

“`python
fruits = [“apple”, “banana”, “cherry”]

print(fruits[0]) # apple (最初の要素)
print(fruits[1]) # banana
print(fruits[2]) # cherry

負のインデックス: 末尾からのアクセス

print(fruits[-1]) # cherry (最後の要素)
print(fruits[-2]) # banana
“`

インデックスが存在しない場所を指定すると、IndexError というエラーが発生します。

スライス

リストの一部を取り出すには、スライスを使います。[開始インデックス : 終了インデックス : ステップ数] の形式で指定します。終了インデックスの要素は含まれないことに注意してください。

“`python
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(numbers[2:5]) # [2, 3, 4] (インデックス2から5の手前まで)
print(numbers[:3]) # [0, 1, 2] (最初からインデックス3の手前まで)
print(numbers[7:]) # [7, 8, 9] (インデックス7から最後まで)
print(numbers[:]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (リスト全体のコピー)
print(numbers[::2]) # [0, 2, 4, 6, 8] (最初から最後まで2つおき)
print(numbers[1::2]) # [1, 3, 5, 7, 9] (インデックス1から最後まで2つおき)
print(numbers[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (リストを逆順にする)
“`

要素の追加、削除、変更

リストは作成後も内容を変更できます（ミュータブルと言います）。

“`python
fruits = [“apple”, “banana”, “cherry”]

要素の変更

fruits[1] = “blueberry”
print(fruits) # [‘apple’, ‘blueberry’, ‘cherry’]

要素の追加

fruits.append(“orange”) # リストの末尾に追加
print(fruits) # [‘apple’, ‘blueberry’, ‘cherry’, ‘orange’]

fruits.insert(1, “grape”) # 指定したインデックスに挿入
print(fruits) # [‘apple’, ‘grape’, ‘blueberry’, ‘cherry’, ‘orange’]

要素の削除

fruits.remove(“cherry”) # 値を指定して最初に見つかった要素を削除
print(fruits) # [‘apple’, ‘grape’, ‘blueberry’, ‘orange’]

popped_item = fruits.pop() # 末尾の要素を取り出して削除
print(popped_item) # orange
print(fruits) # [‘apple’, ‘grape’, ‘blueberry’]

del fruits[0] # インデックスを指定して削除
print(fruits) # [‘grape’, ‘blueberry’]

リストをクリアする

fruits.clear()
print(fruits) # []
“`

リストの便利なメソッド

リストには他にも便利なメソッドがたくさんあります。

“`python
numbers = [1, 5, 2, 8, 2, 9]

print(len(numbers)) # 6 (リストの要素数)
print(min(numbers)) # 1 (最小値)
print(max(numbers)) # 9 (最大値)
print(sum(numbers)) # 27 (合計値)

print(numbers.count(2)) # 2 (要素 2 が出現する回数)
print(numbers.index(8)) # 3 (要素 8 の最初のインデックス) # 要素が見つからないと ValueError

numbers.sort() # リストを昇順にソート (元のリストが変更される)
print(numbers) # [1, 2, 2, 5, 8, 9]

numbers.reverse() # リストを逆順にする (元のリストが変更される)
print(numbers) # [9, 8, 5, 2, 2, 1]

ソートされた新しいリストを取得する場合

sorted_numbers = sorted([1, 5, 2, 8]) # 元のリストは変更されない
print(sorted_numbers) # [1, 2, 5, 8]
“`

リストは最もよく使われるデータ構造の一つです。これらの基本的な操作をしっかり覚えましょう。

タプル (tuple)

タプルはリストと似ていますが、一度作成すると要素の変更、追加、削除ができません（イミュータブルと言います）。タプルは () を使って作成します。

“`python

タプルの作成

colors = (“red”, “green”, “blue”)
point = (10, 20)
single_element_tuple = (5,) # 要素が1つの場合はカンマが必要
empty_tuple = ()

要素へのアクセスとスライスはリストと同じ

print(colors[0]) # red
print(point[0:1]) # (10,)

要素の変更はできない -> エラーになる

colors[0] = “yellow” # TypeError: ‘tuple’ object does not support item assignment

“`

タプルは、複数の値をまとめて一つの変数で扱いたいが、その値がプログラムの途中で変わるべきではない場合（座標、RGB値など）に使われます。リストよりも処理がわずかに速いという利点もあります。

セット (set)

セットは、重複しない要素の集まりです。要素は順序を持たず、インデックスでアクセスすることはできません。セットは {} または set() を使って作成します。

“`python

セットの作成

fruits_set = {“apple”, “banana”, “cherry”, “apple”} # 重複は無視される
print(fruits_set) # {‘banana’, ‘cherry’, ‘apple’} (順番は保証されない)

リストからセットを作成 (重複を除去したい場合など)

numbers_list = [1, 2, 2, 3, 4, 4, 5]
numbers_set = set(numbers_list)
print(numbers_set) # {1, 2, 3, 4, 5}

空のセットを作成

empty_set = set() # {} は空の辞書になるので注意
“`

セットの操作

セットは集合演算（和集合、差集合、積集合など）に便利です。

“`python
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

和集合 (Union): どちらか一方、または両方に含まれる要素

print(set1 | set2) # {1, 2, 3, 4, 5, 6}
print(set1.union(set2)) # {1, 2, 3, 4, 5, 6}

積集合 (Intersection): 両方に含まれる要素

print(set1 & set2) # {3, 4}
print(set1.intersection(set2)) # {3, 4}

差集合 (Difference): set1に含まれるがset2には含まれない要素

print(set1 – set2) # {1, 2}
print(set1.difference(set2)) # {1, 2}

対称差集合 (Symmetric Difference): どちらか一方にだけ含まれる要素

print(set1 ^ set2) # {1, 2, 5, 6}
print(set1.symmetric_difference(set2)) # {1, 2, 5, 6}

要素の追加と削除

set1.add(5) # 要素を追加
print(set1) # {1, 2, 3, 4, 5} (順不同)
set1.remove(1) # 要素を削除 (要素が存在しないとエラー)
print(set1) # {2, 3, 4, 5}
set1.discard(10) # 要素を削除 (要素が存在しなくてもエラーにならない)
print(set1) # {2, 3, 4, 5}
“`

セットは、要素の重複を許さず、特定の要素が含まれているかどうかのチェックを高速に行いたい場合や、集合演算を行いたい場合に便利です。

辞書 (dictionary)

辞書は、キー (key) と値 (value) のペアを格納するデータ構造です。リストのように順番ではなく、キーを使って値にアクセスします。辞書は {} を使って作成します。

“`python

辞書の作成

person = {“name”: “Alice”, “age”: 30, “city”: “New York”}

異なる型のキーや値も可能

mixed_dict = {1: “one”, “two”: 2, (1, 2): [1, 2]} # キーはイミュータブルな型である必要がある (リストは不可)

空の辞書を作成

empty_dict = {}
“`

要素へのアクセス、追加、変更、削除

キーを使って値にアクセスしたり、新しいキーと値のペアを追加したり、既存の値を変更したりできます。

“`python
person = {“name”: “Alice”, “age”: 30, “city”: “New York”}

値へのアクセス

print(person[“name”]) # Alice
print(person[“age”]) # 30

存在しないキーにアクセスすると KeyError

print(person[“job”]) # KeyError

キーが存在するか確認してからアクセスする

if “job” in person:
print(person[“job”])
else:
print(“キー ‘job’ は存在しません”)

get() メソッドを使うと、キーが存在しない場合にNoneまたは指定したデフォルト値を返す

print(person.get(“job”)) # None
print(person.get(“job”, “Unknown”)) # Unknown (デフォルト値を指定)

要素の追加と変更

person[“job”] = “Engineer” # 新しいキーを追加
print(person) # {‘name’: ‘Alice’, ‘age’: 30, ‘city’: ‘New York’, ‘job’: ‘Engineer’}

person[“age”] = 31 # 既存のキーの値を変更
print(person) # {‘name’: ‘Alice’, ‘age’: 31, ‘city’: ‘New York’, ‘job’: ‘Engineer’}

要素の削除

del person[“city”] # キーを指定して削除
print(person) # {‘name’: ‘Alice’, ‘age’: 31, ‘job’: ‘Engineer’}

popped_value = person.pop(“job”) # キーを指定して値を取り出して削除
print(popped_value) # Engineer
print(person) # {‘name’: ‘Alice’, ‘age’: 31}

辞書をクリアする

person.clear()
print(person) # {}
“`

辞書のキー、値、アイテムを取得する

辞書からキーだけ、値だけ、またはキーと値のペアをまとめて取得するには、以下のメソッドを使います。これらは「ビューオブジェクト」と呼ばれるもので、元の辞書が変更されると連動して変化します。

“`python
person = {“name”: “Alice”, “age”: 30, “city”: “New York”}

print(person.keys()) # dict_keys([‘name’, ‘age’, ‘city’]) (キーのビュー)
print(person.values()) # dict_values([‘Alice’, 30, ‘New York’]) (値のビュー)
print(person.items()) # dict_items([(‘name’, ‘Alice’), (‘age’, 30), (‘city’, ‘New York’)]) (キーと値のペアのビュー)

これらはリストに変換することも可能

list_of_keys = list(person.keys())
list_of_values = list(person.values())
list_of_items = list(person.items())
“`

辞書は、特定の名称やIDに対応する値を素早く見つけたい場合に非常に便利です。データベースのレコードや、設定情報などを表現する際によく使われます。

これで、Pythonの主要なコレクションであるリスト、タプル、セット、辞書について学びました。それぞれの特性を理解し、用途に応じて使い分けることが重要です。

ステップ４：プログラムの流れを制御する：制御フロー

プログラムは通常、上から下に順番に実行されます。しかし、特定の条件によって処理を変えたり、同じ処理を繰り返したりしたいことがよくあります。これを実現するのが制御フロー文です。

条件分岐：if/elif/else

条件に応じて実行するコードを切り替えるには、if文を使います。Pythonでは、コードブロック（複数の行をまとめたかたまり）をインデント（字下げ）で表現します。これがPythonの大きな特徴であり、コードの可読性を高めています。: の後に続く行は、そのブロックの一部であることを示すために字下げが必要です。

“`python
score = 75

if score >= 80:
print(“素晴らしい！”)
elif score >= 60: # 80未満かつ60以上の場合
print(“よくできました”)
else: # それ以外の場合 (60未満)
print(“もう少し頑張りましょう”)

print(“採点終了”) # if/elif/else ブロックの外にあるので、常に実行される
“`

  • if 条件:: 条件がTrueの場合に続くブロックを実行します。
  • elif 条件:: ifの条件がFalseで、このelifの条件がTrueの場合に続くブロックを実行します。elifは複数書くことができます。
  • else:: ifおよび全てのelifの条件がFalseの場合に続くブロックを実行します。elseは省略可能です。

論理演算子との組み合わせ

複雑な条件は、論理演算子 (and, or, not) を使って表現できます。

“`python
age = 25
income = 400

if age >= 20 and income >= 300:
print(“条件を満たしています”)
else:
print(“条件を満たしていません”)

短縮評価 (Short-circuit evaluation)

Pythonは、論理式の評価結果が途中で確定した場合、それ以降の評価を省略します。

例えば、False and ... の場合、andの右側を評価する前に結果がFalseと確定します。

True or ... の場合、orの右側を評価する前に結果がTrueと確定します。

これを利用して、以下のようなエラー回避のコードを書くことがあります。

my_list = []

if my_list[0] == 1: # my_listが空の場合 IndexError が発生

if len(my_list) > 0 and my_list[0] == 1: # len(my_list) > 0 が False なら and の右側は評価されない
print(“リストの最初の要素は1です”)
“`

繰り返し：forループ

リストやタプル、文字列、辞書などのコレクションに含まれる要素を一つずつ取り出して処理したい場合、forループを使います。

“`python

リストの要素を順番に処理

fruits = [“apple”, “banana”, “cherry”]
for fruit in fruits:
print(fruit)

apple

banana

cherry

文字列の文字を順番に処理

for char in “Python”:
print(char)

P

y

t

h

o

n

辞書の要素を処理

person = {“name”: “Alice”, “age”: 30, “city”: “New York”}
for key in person: # デフォルトではキーが取り出される
print(key, person[key])

name Alice

age 30

city New York

for value in person.values(): # 値だけを取り出す
print(value)

for key, value in person.items(): # キーと値のペアをまとめて取り出す
print(key, “:”, value)
“`

range() 関数

特定の回数だけ処理を繰り返したい場合は、range() 関数と for ループを組み合わせるのが一般的です。range() は、指定した範囲の数値を順番に生成するオブジェクトを返します。

  • range(n): 0 から n-1 までの整数を生成します。
  • range(start, stop): start から stop-1 までの整数を生成します。
  • range(start, stop, step): start から stop-1 までの整数を、step 間隔で生成します。

“`python

5回繰り返す (0から4まで)

for i in range(5):
print(i) # 0 1 2 3 4

2から5まで (2, 3, 4)

for i in range(2, 6):
print(i) # 2 3 4 5

1から10まで2つおき (1, 3, 5, 7, 9)

for i in range(1, 11, 2):
print(i) # 1 3 5 7 9

10から1まで逆順 (-1ずつ) (10, 9, …, 1)

for i in range(10, 0, -1):
print(i) # 10 9 8 7 6 5 4 3 2 1
“`

break と continue

ループの途中で繰り返しを中断したり、特定の回だけ処理をスキップしたりしたい場合に break と continue を使います。

  • break: ループを完全に終了します。
  • continue: 現在の繰り返し処理をスキップし、次の繰り返しの先頭に移ります。

“`python
numbers = [1, 5, 2, 8, 4, 10]

for num in numbers:
if num > 7:
print(“7より大きい数が見つかりました:”, num)
break # ループを終了
print(“処理中:”, num)

処理中: 1

処理中: 5

処理中: 2

7より大きい数が見つかりました: 8

print(“-” * 10) # 区切り線

for num in numbers:
if num % 2 == 0: # 偶数の場合
print(“偶数はスキップ:”, num)
continue # 次の繰り返しへ
print(“奇数を処理:”, num)

奇数を処理: 1

奇数を処理: 5

偶数はスキップ: 2

奇数を処理: 8 (ここはbreakでループ終了したため実行されないが、もしbreakがなければ実行される)

偶数はスキップ: 4

偶数はスキップ: 10

“`

繰り返し：whileループ

whileループは、条件がTrueである限り、処理を繰り返します。条件がFalseになった時点でループが終了します。

“`python
count = 0
while count < 5:
print(count)
count = count + 1 # または count += 1

0

1

2

3

4

print(“ループ終了”)
“`

whileループを使う際は、ループの終了条件が満たされるように、ループの本体内で条件に関わる変数を更新するのを忘れないように注意してください。更新を忘れると、条件がいつまでたってもTrueのままになり、無限ループに陥ってしまいます。無限ループになった場合は、通常 Ctrl + C で強制終了できます。

“`python

無限ループの例 (実行注意！)

while True:

print(“これは無限ループです”)

“`

break と continue は while ループでも同様に使えます。

forループは繰り返し回数が分かっている場合（リストの全要素処理、N回繰り返しなど）に、whileループは繰り返し回数が事前に決まっておらず、特定の条件が満たされるまで続けたい場合（ユーザーからの入力がある限り、ファイル末尾に到達するまでなど）に使われることが多いです。

これで、条件分岐と繰り返しという、プログラムの「流れ」を制御する基本的な方法を学びました。これらの制御構造を組み合わせることで、様々な複雑な処理を記述できるようになります。

ステップ５：処理をまとめる：関数

同じ処理を何度も書くのは面倒ですし、コードが読みにくくなります。また、後から修正したい場合も、何か所も変更する必要が出てきます。このような問題を解決するのが「関数」です。関数を使うと、一連の処理に名前を付け、必要なときに呼び出すことができます。

関数の定義と呼び出し

関数を定義するには def キーワードを使います。

“`python

関数の定義

def greet():
print(“こんにちは！”)
print(“Pythonへようこそ”)

関数の呼び出し

greet()
greet() # 何度でも呼び出せる
“`

引数 (ひきすう)

関数に渡す外部からの値を「引数」と呼びます。関数定義の括弧 () の中に引数名を記述します。

“`python

引数を持つ関数の定義

def greet(name):
print(f”こんにちは、{name}さん！”)

関数を呼び出すときに引数の値を渡す

greet(“Alice”)
greet(“Bob”)

複数の引数を持つ関数

def add(a, b):
result = a + b
print(f”{a} + {b} = {result}”)

add(5, 3) # 5 + 3 = 8
add(10, 20) # 10 + 20 = 30
“`

引数の種類

Pythonでは、引数の渡し方にいくつかの種類があります。

  1. 位置引数: 呼び出すときの引数の位置（順番）によって、どの引数に対応するかが決まります。上記の例は位置引数です。

  2. キーワード引数: 引数名を指定して値を渡します。位置に依存しないため、引数の順番を気にする必要がなくなります。可読性も上がります。

    “`python
    def describe_pet(animal_type, pet_name):
    print(f”私の{animal_type}の名前は{pet_name}です。”)

    位置引数で呼び出し

    describe_pet(“犬”, “ハル”)

    キーワード引数で呼び出し (順番を入れ替えてもOK)

    describe_pet(pet_name=”ムギ”, animal_type=”猫”)
    “`
    位置引数とキーワード引数を組み合わせて使うこともできますが、位置引数を先に書く必要があります。

  3. デフォルト引数: 引数にデフォルト値を設定できます。関数呼び出し時にその引数の値が省略された場合、デフォルト値が使われます。

    “`python
    def greet(name, greeting=”こんにちは”): # greeting にデフォルト値設定
    print(f”{greeting}、{name}さん！”)

    greet(“Alice”) # こんにちは、Aliceさん！ (デフォルト値を使用)
    greet(“Bob”, “やあ”) # やあ、Bobさん！ (指定した値を使用)

    デフォルト引数は、デフォルト値を持たない引数の後に書く必要がある

    def greet(greeting=”こんにちは”, name): # これはエラー

    pass

    “`

  4. 可変長引数 (*args, **kwargs): 渡される引数の数が事前に分からない場合に使います。

    • *args: 位置引数をタプルとして受け取ります。
    • **kwargs: キーワード引数を辞書として受け取ります。

    “`python
    def calculate_sum(*numbers): # 任意の数の位置引数を受け取る
    total = 0
    for num in numbers:
    total += num
    return total # 戻り値については後述

    print(calculate_sum(1, 2, 3)) # 6
    print(calculate_sum(10, 20, 30, 40)) # 100

    def print_info(**info): # 任意の数のキーワード引数を受け取る
    for key, value in info.items():
    print(f”{key}: {value}”)

    print_info(name=”Charlie”, age=25)

    name: Charlie

    age: 25

    print_info(country=”Japan”, city=”Tokyo”, population=14000000)

    country: Japan

    city: Tokyo

    population: 14000000

    ``argsとkwargsは慣習的な名前ですが、とが重要です。関数定義の引数リストでは、位置引数、デフォルト引数、*args、キーワード引数（デフォルト値あり）、kwargs`の順で記述するのが一般的です。

戻り値 (return)

関数で処理した結果を関数の外に返すには、return キーワードを使います。return が実行されると、関数はそこで終了し、指定した値を返します。return がない場合、関数はデフォルトで None を返します。

“`python

戻り値を持つ関数

def multiply(a, b):
result = a * b
return result # 結果を返す

関数の戻り値を変数に代入する

x = multiply(4, 6)
print(x) # 24

y = multiply(multiply(2, 3), 5) # 関数の戻り値を別の関数の引数として使う
print(y) # 30

複数の値をタプルとして返すことも可能

def get_name_and_age():
return “David”, 35 # カンマで区切るとタプルとして返される

name, age = get_name_and_age() # 戻り値のタプルを複数の変数で受け取る (タプルアンパッキング)
print(name, age) # David 35

return を書かない関数は None を返す

def do_nothing():
pass # 何もしない文

result = do_nothing()
print(result) # None
“`

スコープ

変数がどの範囲からアクセスできるかを「スコープ」と呼びます。関数の中で定義された変数は、その関数の内部でのみ有効な「ローカル変数」です。関数の外で定義された変数は「グローバル変数」と呼ばれ、関数の内外から参照できますが、関数内でグローバル変数を変更したい場合は global キーワードが必要です（推奨されません）。

“`python
global_var = 100 # グローバル変数

def my_function():
local_var = 10 # ローカル変数
print(“関数内からグローバル変数:”, global_var) # 参照はOK
print(“関数内からローカル変数:”, local_var)

my_function()
print(“関数外からグローバル変数:”, global_var)

print(“関数外からローカル変数:”, local_var) # NameError: name ‘local_var’ is not defined

“`

関数内で同名の変数に代入を行うと、それは新しいローカル変数として扱われ、グローバル変数には影響しません。

“`python
count = 0 # グローバル変数

def increment():
count = 1 # これは新しいローカル変数 ‘count’ を作成している
print(“関数内のcount:”, count)

increment()
print(“関数外のcount:”, count) # グローバル変数の count は 0 のまま

関数内のcount: 1

関数外のcount: 0

“`

本当にグローバル変数を関数内で変更したい場合は global キーワードを使いますが、コードの可読性が下がるため、引数として渡したり戻り値を使ったりする方法が推奨されます。

“`python
count = 0 # グローバル変数

def increment_global():
global count # グローバル変数 count を使うことを宣言
count += 1
print(“関数内のcount:”, count)

increment_global()
print(“関数外のcount:”, count)

関数内のcount: 1

関数外のcount: 1

“`

無名関数（lambda）

lambda キーワードを使うと、名前のない小さな関数（無名関数）を一行で定義できます。主に、他の関数に引数として渡す場合などに使われます。

“`python

def を使った通常の関数

def add_one(x):
return x + 1

print(add_one(5)) # 6

lambda を使った無名関数 (引数: 式)

add_one_lambda = lambda x: x + 1

print(add_one_lambda(5)) # 6

lambda はリストのソートなどによく使われる

pairs = [(1, ‘one’), (2, ‘two’), (3, ‘three’)]

タプルの2番目の要素 (文字列) でソートしたい場合

pairs.sort(key=lambda pair: pair[1])
print(pairs) # [(1, ‘one’), (3, ‘three’), (2, ‘two’)]
“`

関数は、コードを整理し、再利用性を高めるための非常に強力なツールです。積極的に使っていきましょう。

ステップ６：設計の考え方：クラスとオブジェクト（オブジェクト指向の基本）

現実世界のモノや概念をプログラムで表現したい場合に便利な考え方が「オブジェクト指向プログラミング（OOP）」です。Pythonはオブジェクト指向をサポートしており、「クラス」と「オブジェクト」という概念を使ってこれを実現します。入門レベルでは、その基本的な考え方だけを理解しておけば十分です。

クラスとオブジェクトとは？

  • クラス (Class): 特定の種類のもの（例: 「犬」「車」「ユーザー」）が共通して持つ属性（データ、プロパティ）と振る舞い（機能、メソッド）を定義した「設計図」や「ひな形」のようなものです。
  • オブジェクト (Object) / インスタンス (Instance): クラスという設計図に基づいて実際に作られた「モノ」のことです。例えば、「柴犬のハル」や「プリウスの白色」のように、具体的な属性を持った実体です。一つのクラスから、属性の値が異なる複数のオブジェクトを作ることができます。

クラスの定義とオブジェクトの生成

クラスを定義するには class キーワードを使います。

“`python

クラスの定義 (設計図)

class Dog:
# init メソッド: オブジェクトが作られるときに最初に実行される特殊なメソッド (コンストラクタと呼ばれる)
# self は、これから作られるオブジェクト自身を指す (メソッドの第一引数に必ず必要)
def init(self, name, breed):
# 属性 (オブジェクトごとのデータ)
self.name = name
self.breed = breed

# メソッド (オブジェクトの振る舞い、機能)
def bark(self):
    print(f"{self.name} がワンワンと鳴きます。")

def describe(self):
    print(f"名前: {self.name}, 犬種: {self.breed}")

オブジェクト (インスタンス) の生成

クラス名の後に () をつけて呼び出すと、init メソッドが実行され、新しいオブジェクトが作られる

my_dog = Dog(“ハル”, “柴犬”)
your_dog = Dog(“ムギ”, “トイプードル”)

オブジェクトの属性にアクセス

print(my_dog.name) # ハル
print(your_dog.breed) # トイプードル

オブジェクトのメソッドを呼び出す

my_dog.bark() # ハル がワンワンと鳴きます。
your_dog.describe() # 名前: ムギ, 犬種: トイプードル
“`

  • __init__ メソッドは、新しいオブジェクトを初期化するために使われます。引数 self は、作成中のオブジェクト自身を参照します。self.name = name のようにすることで、オブジェクトごとに固有の名前属性を持たせることができます。
  • クラス内で定義された関数は「メソッド」と呼ばれます。メソッドも第一引数に self を取るのが一般的で、self を通じてそのオブジェクトの属性や他のメソッドにアクセスできます。

なぜクラスを使うのか？（オブジェクト指向のメリット）

  • コードの整理: 関連するデータ（属性）とそれを操作する機能（メソッド）を一つのまとまり（クラス）として定義できます。これにより、コードが見通しやすくなります。
  • 再利用性: 一度クラスを定義すれば、それを使って好きなだけオブジェクトを作成できます。同じような構造を持つ複数のモノを扱いたい場合に非常に効率的です。
  • カプセル化: オブジェクトの内部状態（属性）を隠蔽し、外部からはメソッドを通じてのみアクセスさせるように設計することで、予期せぬ変更を防ぎ、コードの安全性を高めることができます（Pythonでは厳密なカプセル化は強制されませんが、アンダースコアなどで慣習的に示します）。
  • 抽象化: 現実世界の複雑なモノを、プログラムで扱いやすいように単純化して表現できます。
  • 継承: 既存のクラス（親クラス）の属性やメソッドを受け継いで、新しいクラス（子クラス）を作成できます。これにより、共通部分を繰り返し書く手間を省き、差分だけを記述することで効率的に開発を進められます。

“`python

継承の例

class Animal: # 親クラス
def init(self, name):
self.name = name

def eat(self):
    print(f"{self.name} は食事をします。")

class Dog(Animal): # Dog は Animal を継承する子クラス
# init をオーバーライド (再定義) する場合は、親クラスの init を呼び出すことが多い
def init(self, name, breed):
super().init(name) # 親クラスの init を呼び出す
self.breed = breed

# bark メソッドは Dog クラス固有のメソッド
def bark(self):
    print(f"{self.name} がワンワンと鳴きます。")

# eat メソッドをオーバーライド (再定義) する
def eat(self):
    print(f"{self.name} はドッグフードを食べます。")

オブジェクト生成とメソッド呼び出し

generic_animal = Animal(“生き物”)
generic_animal.eat() # 生き物 は食事をします。

my_dog = Dog(“ポチ”, “雑種”)
my_dog.eat() # ポチ はドッグフードを食べます。 (子クラスで定義した eat が実行される)
my_dog.bark() # ポチ がワンワンと鳴きます。
print(my_dog.name) # ポチ (親クラスから受け継いだ属性)
“`
このように、継承を使うことで、共通する性質を親クラスにまとめ、子クラスで固有の性質や振る舞いを追加・変更することができます。

オブジェクト指向は奥が深いですが、まずは「クラスは設計図、オブジェクトは実体」「属性はデータ、メソッドは機能」「__init__で初期化、selfは自分自身」という基本的な考え方を理解しておけば、Pythonの多くのコードを読み書きできるようになります。

ステップ７：コードを分けて使いやすく：モジュールとパッケージ

プログラムが大きくなってくると、一つのファイルにすべてのコードを書いていると管理が大変になります。そこで、コードを機能ごとに複数のファイルに分割し、必要に応じて読み込んで使う仕組みが用意されています。これが「モジュール」と「パッケージ」です。

モジュール

モジュールは、Pythonのコード（関数、変数、クラスなど）をまとめた単なるPythonファイル (.py 拡張子がついたファイル）のことです。

例えば、計算関連の関数をまとめた calculations.py というファイルを作ったとします。

“`python

calculations.py ファイルの内容

def add(a, b):
return a + b

def subtract(a, b):
return a – b

PI = 3.14159 # 定数も定義できる
“`

別のファイル（例: main.py）からこのモジュールを使いたい場合、import 文を使います。

“`python

main.py ファイルの内容

calculations モジュール全体をインポート

import calculations

print(calculations.add(10, 5)) # 15 (モジュール名.関数名 の形式で呼び出す)
print(calculations.PI) # 3.14159

from … import … で特定の関数や変数をインポート

from calculations import subtract, PI

print(subtract(10, 5)) # 5 (モジュール名をつけずに直接呼び出せる)
print(PI) # 3.14159

from … import * でモジュール内の全てをインポート (非推奨)

from calculations import *

print(add(10, 5)) # add 関数もモジュール名をつけずに呼び出せる

この方法は名前の衝突を引き起こす可能性があるため、特別な理由がない限り避けるべきです。

import … as … でモジュールに別名をつける

import calculations as calc

print(calc.add(20, 10)) # 30
“`

標準ライブラリの活用

Pythonには、あらかじめインストールされている非常に豊富な「標準ライブラリ」があります。これらもモジュールとして提供されており、import して使うことができます。

よく使われる標準ライブラリの例：

  • math: 数学関数（三角関数、対数、平方根など）や数学定数（π, eなど）を提供します。

    “`python
    import math

    print(math.sqrt(25)) # 5.0 (平方根)
    print(math.pi) # 3.14159… (円周率)
    ``
    * **    random`:** 乱数を生成する機能を提供します。

    “`python
    import random

    print(random.random()) # 0.0以上1.0未満の浮動小数点数
    print(random.randint(1, 10)) # 1以上10以下のランダムな整数
    print(random.choice([“rock”, “paper”, “scissors”])) # リストからランダムに要素を選択
    ``
    * **    datetime`:** 日付や時刻を扱う機能を提供します。

    “`python
    import datetime

    now = datetime.datetime.now()
    print(now) # 現在の日付と時刻 (例: 2023-10-27 10:30:00.123456)
    print(now.year) # 年
    print(now.month) # 月
    print(now.day) # 日
    print(now.hour) # 時
    print(now.minute) # 分
    “`

標準ライブラリはPythonの強力な特徴の一つです。困った時に「もしかして標準ライブラリにないかな？」と探してみると、開発効率が格段に上がります。

パッケージ

モジュールが増えてくると、それらを整理するためにディレクトリ構造を使いたくなります。関連するモジュールをまとめたディレクトリを「パッケージ」と呼びます。

パッケージにするには、そのディレクトリ内に __init__.py という空のファイル（または初期化コードを含むファイル）を置くのが伝統的な方法です（Python 3.3以降は __init__.py がなくてもパッケージとして扱えるようになりましたが、互換性や明示性のために置くことが多いです）。

my_package/
__init__.py
module_a.py
module_b.py
sub_package/
__init__.py
module_c.py
main.py

main.py から module_a.py を使いたい場合は、ドット . を使ってインポートします。

“`python

main.py から my_package/module_a.py をインポート

import my_package.module_a

my_package.module_a.some_function()

from … import … を使う場合

from my_package.sub_package import module_c

module_c.another_function()
“`

外部パッケージのインストール（pipと仮想環境）

Pythonの魅力は、標準ライブラリだけでなく、世界中の開発者が公開している膨大な数の「外部パッケージ」にあります。データ分析のPandas、Web開発のDjango、機械学習のTensorFlow/PyTorchなど、多くの便利なツールが外部パッケージとして提供されています。

これらの外部パッケージをインストールするには、Pythonに標準で付属しているパッケージ管理ツール「pip」を使います。

コマンドプロンプトやターミナルで以下のコマンドを実行します。

“`bash

パッケージをインストールする

pip install パッケージ名

特定のバージョンを指定してインストール

pip install パッケージ名==バージョン番号

インストール済みのパッケージ一覧を表示する

pip list

インストール済みのパッケージをアップグレードする

pip install –upgrade パッケージ名

パッケージをアンインストールする

pip uninstall パッケージ名
“`

例えば、データ分析でよく使われるPandasというパッケージをインストールするには、pip install pandas と実行します。

仮想環境 (Virtual Environment)

複数のPythonプロジェクトを開発していると、プロジェクトごとに使いたいパッケージのバージョンが異なる場合があります。例えば、あるプロジェクトではPandas 1.0が必要だが、別のプロジェクトでは最新の2.0が必要、といった状況です。システム全体にインストールするとバージョン衝突が起こる可能性があります。

これを避けるために、「仮想環境」を作成するのが一般的です。仮想環境は、プロジェクトごとに独立したPython実行環境とパッケージインストール場所を提供するものです。

Python 3.3以降では、標準ライブラリの venv モジュールを使って仮想環境を作成できます。

“`bash

仮想環境を作成する (プロジェクトディレクトリ内で実行)

env_name は好きな名前でOK (venv や .venv がよく使われる)

python -m venv env_name

または python3 -m venv env_name (macOS/Linuxの場合)

仮想環境を有効化する

Windows (PowerShell):

env_name\Scripts\Activate.ps1

Windows (cmd):

env_name\Scripts\activate.bat

macOS/Linux:

source env_name/bin/activate

コマンドラインの表示が (env_name) … のようになるはずです。

この状態で pip install すると、この仮想環境内にパッケージがインストールされます。

仮想環境を無効化する

deactivate
“`

仮想環境を使いこなすことで、プロジェクト間の依存関係の衝突を防ぎ、開発環境をクリーンに保つことができます。これはPython開発において非常に重要なプラクティスです。

モジュールとパッケージ、そしてpipと仮想環境の使い方は、実際のPython開発を進める上で必須の知識です。これらの仕組みを活用することで、効率的に開発を進め、コミュニティが提供する豊富なライブラリの恩恵を受けることができます。

ステップ８：プログラムのトラブルに対処する：エラーと例外処理

プログラムを書いていると、思った通りに動かなかったり、途中で停止してしまったりすることが必ずあります。このような問題に対処するための仕組みが、エラーと例外処理です。

エラーの種類

Pythonで発生する問題は大きく分けて二種類あります。

  1. 構文エラー (Syntax Error): コードの文法が間違っている場合に発生します。プログラムを実行する前に（あるいは実行を開始した直後に）Pythonインタプリタによって検出されます。エディタが警告してくれることも多いです。

    “`python

    閉じ括弧がない構文エラー

    print(“Hello” # SyntaxError: unexpected EOF while parsing
    “`
    構文エラーは、コードを文法通りに修正すれば解消します。

  2. 実行時エラー (Runtime Error) / 例外 (Exception): 文法は正しいものの、プログラムを実行している途中で予期せぬ事態が発生した場合に起こるエラーです。例えば、0で割り算をしようとしたり、存在しないファイルを開こうとしたり、リストの範囲外のインデックスにアクセスしようとしたりした場合などです。

    “`python

    ゼロ除算エラー (ZeroDivisionError)

    result = 10 / 0 # ZeroDivisionError: division by zero

    名前が見つからないエラー (NameError)

    print(undefined_variable) # NameError: name ‘undefined_variable’ is not defined

    型が違うエラー (TypeError)

    “hello” + 5 # TypeError: can only concatenate str (not “int”) to str

    リストのインデックスが範囲外のエラー (IndexError)

    my_list = [1, 2, 3]

    print(my_list[3]) # IndexError: list index out of range

    辞書のキーが見つからないエラー (KeyError)

    my_dict = {“a”: 1}

    print(my_dict[“b”]) # KeyError: ‘b’

    “`
    これらの実行時エラーは「例外」として扱われます。例外が発生すると、デフォルトではプログラムの実行がそこで中断され、エラーメッセージが表示されます。しかし、例外を適切に「処理」することで、プログラムが中断するのを防ぎ、代替処理を行ったり、エラーの原因を記録したりすることができます。

例外処理：try...except

例外が発生しそうなコードを try ブロックの中に書き、例外が発生した場合に行う処理を except ブロックに書きます。

“`python
try:
# 例外が発生する可能性のあるコード
num1 = int(input(“割られる数を入力してください: “))
num2 = int(input(“割る数を入力してください: “))
result = num1 / num2
print(“計算結果:”, result)
except:
# 例外が発生した場合に実行されるコード
print(“エラーが発生しました。0で割ることはできません、または数値を入力してください。”)

print(“プログラム終了”) # 例外を処理したので、ここで中断せず実行が続く
“`

上記の例では、ユーザーが0を入力したり、数値を入力しなかったりした場合に例外が発生しますが、except ブロックがそれを捕まえて処理するため、プログラムはエラーメッセージを表示して終了せず、「プログラム終了」まで実行されます。

特定の例外を捕まえる

except の後に例外の種類を指定することで、特定の例外だけを処理できます。

“`python
try:
num1 = int(input(“割られる数を入力してください: “))
num2 = int(input(“割る数を入力してください: “))
result = num1 / num2
print(“計算結果:”, result)
except ValueError: # 数値に変換できない場合に発生する例外
print(“エラー: 無効な入力です。数値を入力してください。”)
except ZeroDivisionError: # 0で割った場合に発生する例外
print(“エラー: 0で割ることはできません。”)
except Exception as e: # その他の全ての例外を捕まえる (Exceptionは全ての例外の基底クラス)
print(f”予期せぬエラーが発生しました: {e}”)

print(“プログラム終了”)
``
複数のexceptブロックを書く場合、より具体的な例外から先に書くのが一般的です。Exceptionは全ての例外を捕まえるため、一番最後に書きます。as eとすることで、発生した例外オブジェクトをe` という変数に代入し、エラーメッセージなどを確認できます。

else と finally ブロック

try...except には、オプションで else と finally ブロックを追加できます。

  • else: try ブロック内のコードが例外を発生させずに正常に完了した場合に実行されます。
  • finally: try ブロックで例外が発生したかどうかにかかわらず、必ず最後に実行されます。ファイルを開いたら必ず閉じる、といった後処理に使われます。

“`python
try:
file = open(“my_file.txt”, “r”) # ファイルを開く (存在しないと FileNotFoundError)
content = file.read()
print(content)
except FileNotFoundError:
print(“エラー: ファイルが見つかりませんでした。”)
except Exception as e:
print(f”その他のエラー: {e}”)
else:
print(“ファイルを正常に読み込みました。”)
finally:
# file変数が定義されているか確認してからクローズ
if ‘file’ in locals() and not file.closed:
file.close()
print(“ファイルを閉じました。”)
elif ‘file’ in locals(): # ファイルを開こうとしたが例外で失敗した場合
print(“ファイルクローズ処理は不要です。”)
else: # ファイルを開く前に例外が発生した場合 (例: 無効なファイル名)
print(“ファイルに関する処理は行われませんでした。”)

print(“プログラム終了”)
``with open(…)を使うとfinallyで明示的にclose()` を書く必要がなく、自動でファイルを閉じてくれるため推奨されます（後述）。

独自の例外を発生させる：raise

条件を満たさない場合など、意図的に例外を発生させたい場合は raise キーワードを使います。

“`python
def process_positive_number(num):
if not isinstance(num, (int, float)):
raise TypeError(“入力は数値である必要があります。”)
if num <= 0:
raise ValueError(“入力は正の数である必要があります。”)
print(f”正の数 {num} を処理します。”)

try:
process_positive_number(10)
process_positive_number(-5) # ここで ValueError が発生
process_positive_number(“abc”) # ここで TypeError が発生
except ValueError as e:
print(f”ValueError: {e}”)
except TypeError as e:
print(f”TypeError: {e}”)

正の数 10 を処理します。

ValueError: 入力は正の数である必要があります。

``raise` はエラーチェックや、プログラムの異常な状態を示すのに役立ちます。

例外処理は、頑丈で信頼性の高いプログラムを書くために非常に重要です。予期せぬ問題が発生してもプログラムが落ちないように、適切な例外処理を実装するスキルを身につけましょう。

ステップ９：ファイル入出力

プログラムでデータを永続的に保存したり、外部からデータを取り込んだりするには、ファイルを使います。Pythonでファイルとやり取りする方法を学びましょう。

ファイルを開く：open()

ファイルを開くには組み込み関数の open() を使います。open() はファイルのパスと「モード」を指定して呼び出します。成功すると、ファイルオブジェクトを返します。

“`python

ファイルを開く

open(“ファイル名”, “モード”)

モード: ‘r’ (読み込み), ‘w’ (書き込み), ‘a’ (追記), ‘x’ (新規作成書き込み), ‘b’ (バイナリ), ‘t’ (テキスト) など

デフォルトは ‘rt’ (テキスト読み込み)

“`

例：

“`python

writing_example.txt に書き込みモード (‘w’) でファイルを開く

ファイルが存在しない場合は新しく作成、存在する場合は内容が消去される

file = open(“writing_example.txt”, “w”)

ファイルに書き込む

file.write(“これは一行目です。\n”)
file.write(“これは二行目です。\n”)

ファイルを閉じる (非常に重要！)

file.close()

print(“ファイルに書き込みました。”)
“`

ファイルを使い終わったら、必ず close() メソッドを呼び出してファイルを閉じる必要があります。これを忘れると、書き込み内容が保存されなかったり、ファイルが他のプログラムからアクセスできなくなったり、リソースリークの原因になったりします。

with open(...) の利用（推奨）

ファイルのクローズ忘れを防ぎ、例外発生時にも確実にクローズするために、with open(...) as 変数: という構文を使うのが最も推奨される方法です。これはコンテキストマネージャと呼ばれ、with ブロックを抜けるときに自動的にファイルが閉じられます。

“`python

reading_example.txt をテキスト読み込みモード (‘r’) で開く

with ブロックを抜けると自動的にファイルが閉じられる

with open(“reading_example.txt”, “r”) as file:
# ファイルから内容を読み込む (後述)
content = file.read()
print(content)

print(“ファイルは閉じられました。”)
“`

テキストファイルの読み込み

テキストファイルを読み込む主な方法です。

“`python
with open(“reading_example.txt”, “r”) as file:
# read(): ファイル全体を一つの文字列として読み込む
# content = file.read()
# print(content)

# readline(): ファイルから一行ずつ読み込む
# line1 = file.readline()
# line2 = file.readline()
# print(line1, end="") # read() や readline() で読み込んだ行には改行が含まれているので、printのend=""で不要な改行を防ぐ
# print(line2, end="")

# readlines(): ファイルの全行をリストとして読み込む (各行の末尾に改行文字を含む)
# lines = file.readlines()
# print(lines) # ['これは一行目です。\n', 'これは二行目です。\n', ...]

# ループで一行ずつ処理する (メモリ効率が良い方法)
print("一行ずつ読み込み:")
for line in file:
    print(line.strip()) # strip() で行頭・行末の空白や改行文字を除去

“`

テキストファイルへの書き込み

書き込みモード (‘w’) や追記モード (‘a’) でファイルを開き、write() または writelines() メソッドを使います。

  • write(string): 指定した文字列をファイルに書き込みます。
  • writelines(list_of_strings): 文字列のリストをファイルに書き込みます。各要素は改行を含める必要があります。

“`python

‘w’ モード: 既存の内容を上書き

with open(“output_w.txt”, “w”) as file:
file.write(“Hello\n”)
file.write(“World\n”)

‘a’ モード: 既存の内容の後に追加

with open(“output_a.txt”, “a”) as file:
file.write(“Append Line 1\n”)
file.write(“Append Line 2\n”)

writelines の例

lines_to_write = [“Line 1\n”, “Line 2\n”, “Line 3\n”]
with open(“output_writelines.txt”, “w”) as file:
file.writelines(lines_to_write)
“`

その他のファイルモード

  • 'x' モード: ファイルが存在しない場合にのみ書き込みモードで開きます。ファイルが既に存在する場合は FileExistsError が発生します。新しいファイルを作成したい場合に安全です。
  • 'b' モード (バイナリモード): テキスト以外のデータ（画像、音声、実行ファイルなど）を読み書きする場合に使います。モードに b を追加します（例: 'rb', 'wb', 'ab', 'r+b'）。バイナリモードでは、読み書きするのは文字列ではなくバイト列 (bytes オブジェクト) になります。

ファイル入出力は、プログラムと外部データを連携させるための基本的な機能です。with open(...) を常に使うように心がけましょう。

ステップ10：Python学習の次のステップ

おめでとうございます！この記事でPythonの基本的な要素（変数、データ型、コレクション、制御フロー、関数、クラスの基本、モジュール、ファイル入出力、例外処理）を一通り学びました。これだけ知っていれば、「これだけでOK」と自信を持って言えるレベルです。

しかし、これはPythonの広大な世界への最初の扉を開いただけにすぎません。ここからさらに学びを深め、あなたのやりたいことにPythonを活用していくための次のステップについてご紹介します。

振り返りと定着

まず、この記事で学んだ内容をしっかり定着させましょう。

  • コードを書いて動かす: 記事中のコード例を自分で書いて動かしてみてください。色々な値を試したり、少し変更を加えたりしてみましょう。
  • 簡単な練習問題: 自分で簡単なプログラムを考えて書いてみてください。
    • ユーザーから名前と年齢を入力してもらい、あいさつと来年の年齢を表示するプログラム。
    • リスト内の数値の合計を計算し、平均を表示するプログラム。
    • ユーザーに入力された文字列が回文（逆から読んでも同じ文字列、例: level, madam）かどうかを判定するプログラム。
    • 九九の表を表示するプログラム（forループのネストを使う）。
    • 簡単なToDoリストプログラム（リストや辞書を使って項目を管理）。
    • ファイルに今日の天気や日記を書き込むプログラム。
  • エラーに出会うことを恐れない: プログラムはエラーが出ながら完成していくものです。エラーメッセージをよく読み、何が問題なのかを理解しようと努めてください。Stack Overflowなどでエラーメッセージを検索する習慣をつけましょう。

さらなる学習のためのリソース

Pythonをさらに深く学ぶためには、以下のようなリソースを活用しましょう。

  • Python公式ドキュメント: Pythonの全ての機能に関する最も正確で最新の情報源です。最初は難しく感じるかもしれませんが、辞書のように調べ物をする際に非常に役立ちます。特に「チュートリアル」(The Python Tutorial) は初心者にもおすすめです。(https://docs.python.org/ja/)
  • 書籍: 体系的にじっくり学びたい場合は、評価の高いPython入門書を手に取ってみましょう。
  • オンライン学習プラットフォーム: Progate, Coursera, Udacity, Udemy, paizaラーニングなど、インタラクティブな形式で学べるプラットフォームが多数あります。
  • コミュニティ: Pythonの勉強会やオンラインコミュニティ（Slack, Discordなど）に参加してみましょう。他の学習者や経験豊富な開発者と交流することで、モチベーションを維持したり、質問したりできます。
  • YouTubeや技術ブログ: 特定のトピックについて解説した動画や記事も豊富にあります。

Pythonで何をするか？興味のある分野へ進もう

Pythonの基礎が身についたら、いよいよあなたがPythonを使って何をしたいのか、具体的な分野に挑戦してみましょう。Pythonは非常に汎用性が高いため、様々な選択肢があります。

  • Web開発: DjangoやFlaskといったフレームワークを使ってWebサイトやWebアプリケーションを作ることができます。
  • データ分析・科学: Pandas, NumPy, Matplotlib, Seabornなどのライブラリを使って、データを分析し、可視化することができます。Kaggleなどのデータ分析コンペに挑戦するのも良いでしょう。
  • 機械学習・AI: scikit-learn, TensorFlow, PyTorchといった強力なライブラリを使って、機械学習モデルを構築・学習させることができます。近年最も注目されている分野の一つです。
  • 業務自動化: OpenPyXL（Excel操作）、Selenium（Webスクレイピング・自動操作）、Requests（HTTP通信）などのライブラリを使って、日々の定型作業を自動化することができます。『退屈なことはPythonにやらせよう』という有名な書籍もあります。
  • ゲーム開発: Pygameなどのライブラリを使ってシンプルな2Dゲームを作成できます。
  • CLIツール開発: コマンドラインで動作する便利なツールを自作できます。

興味のある分野の入門チュートリアルを探して、実際に手を動かしながら学んでいくのがおすすめです。小さなプロジェクトから始めて、徐々に複雑なものに挑戦していきましょう。

継続することが最も重要

プログラミングの学習において、最も重要なのは「継続」です。毎日少しずつでも良いので、コードに触れる時間を持ちましょう。最初は分からなくても、調べたり、試したりするうちに、少しずつ理解が深まっていきます。

エラーに直面したり、難しいと感じたりすることもきっとあるでしょう。それはプログラミング学習において誰もが通る道です。諦めずに、楽しみながら学び続けてください。

まとめ

この記事では、「最速でわかるPython入門！これだけでOK」をテーマに、Pythonの環境構築から、変数、データ型、コレクション、制御フロー、関数、クラス、モジュール、ファイル入出力、例外処理といった基本的な要素を網羅的に解説しました。

  • 準備: Pythonのインストール、インタプリタ、エディタの準備、Hello World。
  • 基本: 変数、データ型、入出力、演算子、文字列整形。
  • 構造: リスト、タプル、セット、辞書といったコレクション。
  • 流れ: if/elif/else による条件分岐、for/while による繰り返し。
  • 整理: 関数による処理のまとまり、引数と戻り値、スコープ。
  • 設計: クラスとオブジェクトによるオブジェクト指向の基本。
  • 分割: モジュールとパッケージ、標準ライブラリ、pipと仮想環境。
  • 対策: エラーと例外処理による問題対処。
  • 次へ: さらなる学習リソースと応用分野への道。

これらの基礎知識があれば、Pythonのコードを読み書きし、簡単なプログラムを作成するための土台は十分にできています。

この知識を足がかりに、ぜひPythonを使った開発の世界に踏み出してみてください。あなたのアイデアを形にしたり、日々の作業を効率化したり、データから新しい発見をしたりと、Pythonでできることは無限大です。

Pythonの学習は楽しい旅です。この記事がその良いスタート地点となれば幸いです。

さあ、あなたの手でPythonコードを書き始めましょう！応援しています！

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール