1. /
  2. /
  3. 【基礎一覧】Pythonの基本文法を全て解説してみた！【初心者】

【基礎一覧】Pythonの基本文法を全て解説してみた！【初心者】

  • このエントリーをはてなブックマークに追加
  • Pocket

こんにちは。タクマ™ [@suwaru_blog] です。

今回、プログラミング言語 Python の基本文法をまとめてみました。
もし書き方を忘れてしまったときはチェックしてみてください。

目次

  1. Python 実行方法
  2. コメントアウト
  3. 変数・定数
  4. データ型
  5. if 文
  6. ループ処理
  7. 関数
  8. class
  9. リスト型 / タプル型
  10. 集合型
  11. 辞書型
  12. イテレータ型
  13. ジェネレータ型
  14. 内包表記

Python 実行方法

  • python コマンド
    • Terminal 上のインタラクティブモードで実行していく方法
  • python [pyファイル]
    • py 拡張子 のファイルを実行する

インタラクティブモードを使う場合

# インタラクティブモード起動
python

Python 3.7.7 (default, May  6 2020, 04:59:01)
[Clang 4.0.1 (tags/RELEASE_401/final)] :: Anaconda, Inc. on darwin
Type "help", "copyright", "credits" or "license" for more information.

# Python コードを記述して実行できる
>>> print("test")
test

# インタラクティブモード終了
exit()

py ファイルを実行する場合

# myapp.py のプログラムを実行する
python myapp.py

UTF8 宣言

  • プログラムの冒頭に coding: utf-8 宣言を行うことがある
    • Python 2
      • ソースコードに日本語が含まれている場合は必須
    • Python3
      • 宣言不要。別に書いても問題はない
 coding: utf-8

コメントアウト

ソースコードに対するコメントの書き方は 3 種類です。

  • #
    • パウンド記号
  • """
    • ダブルクオテーション
  • '''
    • シングルクオテーション
# 文の区切りにセミコロンを使うこともできるが、文末のセミコロンは通常省略する
print("Hello world")

"""
複数行コメントアウト
"""

'''
複数行コメントアウト
'''

変数・定数

  • 定数
    • Python で定数はサポートされていない
    • 大文字で表記しておいて自分で再代入しないよう注意する
# 変数宣言
msg = "Hello World"
print(msg)

# 定数宣言
ADMIN_EMAIL = "ikeda@gmail.com"

データ型

文字列

  • バックスラッシュを使って特殊文字を埋め込むことができる
  • 文字列も演算できる
# \n は改行 \t はTAB
s = "he\nllo wor\tld"

s2 = 'hello again'

# 文字列を 3 回出力する
print("hello" * 3);
  • 複数行の文章を出力したいときはコメントアウトの  """" や ''' を利用できる
    • 改行コードも保持してくれる
html  = """<html>
<body></body>
</html>"""

文字列の中に変数を埋め込む

  • %s
    • 文字列 (string)
  • %d
    • 整数 (decimal)
  • %f
    • 浮動小数点 (float)
name = "ikeda"
score = 52.8

# name: ikeda, score: 52.800000
print("name: %s, score: %f" % (name, score))
  • 埋め込む値に「文字数制限」を設けることもできる
  • 文字の「左寄せ・右寄せ」を指定することもできる
name = "ikeda"
score = 52.8

# %10s: 10 文字の幅だけ表示
# %10.2f: 小数点以下は 2 桁まで表示
print("name: %10s, score: %10.2f" % (name, score))

# %-10s: 左揃えにして表示
print("name: %-10s, score: %10.2f" % (name, score))
format()

同じことを format() 関数でやることもできます。

name = "ikeda"
score = 52.8

# {0} 0 番目の要素に変数 name を埋め込む
# {1} 1 番目の要素に変数 score を埋め込む
print("name: {0}, score: {1}".format(name, score))
name = "ikeda"
score = 52.8

# {0:10s}: 10 文字の幅だけ表示
# {1:10.2f}: 小数点以下は 2 桁まで表示
print("name: {0:10s}, score: {1:10.2f}".format(name, score))

# 右揃え ( > )
# 左揃え ( < )
print("name: {0:>10s}, score: {1:<10.2f}".format(name, score))

整数 / 浮動小数点 / 論理値

  • 論理値: True / False
    • 頭文字は大文字なので注意する
i = 10

f = 23.4

flag = True

論理記号

  • and
    • A and B なら「A かつ B」
  • or
    • A or B なら「A または B」
  • not
    • not A なら「A の逆」
  • Python で以下の論理記号は存在しないので注意する
    • &&
    • ||
    • !
# False
print(True and False);

# True
print(True or False);

# False
print(not True);

キャスト (型変換)

データ型を変更することを「キャスト」と呼ぶ。

  • input()
    • ユーザ入力を受け付ける関数
    • Python 3 では文字列で取得する
    • 他のデータ型で欲しければキャストする
# int() で囲めば整数でキャストする
score =  int(input("score ? "))

if 文

  • インデント
    • 半角スペース 4 つと決まっている
if score > 80:
    print("Great!")
elif  score > 60:
    print("Good!")
else:
    print("so so ...")

条件演算子による if 文 (三項演算子)

  • 条件演算子による if 文
    • 真の結果 if 条件 else 偽の結果
print("Great!" if score > 80 else "so so ..." )

ループ処理

while … else 文

i = 0

while i < 10:
    if i == 5:
        # break で処理を抜ける場合は else 処理は実行されない
        break

    print(i)
    i += 1
# 条件を満たさなくなったときの処理
else:
    print("end")

for … in

# 0 から 10 手前 (つまり 9 ) までのリスト型を作る
for i in range(10):
    if i == 5:
        # スキップ処理
        continue
    print(i)
# 終了処理
else:
    print("end")

関数

  • 関数の引数にはデフォルト値をもたせることができる
# age のデフォルト値 20
def say_hi(name, age = 20):
    print("hi {0} ({1})".format(name, age))

say_hi("tom", 23)
say_hi("bob", 21)
say_hi("steve")

# 関数の引数名を使って渡す、この際、引数の順番は関係ない
say_hi(age = 18, name = "rick")

return

def say_hi():
    return "hi"

msg = say_hi()
print(msg)

None

  • None
    • 空っぽを意味するオブジェクト
  • None の判定
    • is None
    • is not None
  • Python に以下の値は存在しない
    • null / nil
A = None

A is None # True
A is not None # False

# 以下の書き方は間違い
# A == None

pass

  • pass
    • None を return する
    • 以下のような場合に使える
      • 関数の中身が何もない場合
      • 後でコードを記述するのでとりあえず何か書いておきたい場合
def do_pass():
    pass

msg2 = do_pass()
print(msg2)  # None

global

  • グローバル変数
    • ローカル関数の中からでも参照できる
    • ローカル関数内でグローバル変数の値を上書きしようとした場合
      • 同名のローカル変数を定義しただけの扱いになる
      • ※ もし本当にグローバル変数の値を書き換えたい場合
        • global キーワードで明示的に同名の変数を宣言する
msg = "hello"

def say_hi():
    # global キーワードを使う
    global msg
    msg = "hello global"
    print(msg)

# hello global
say_hi()

class

pass

  • 実装がないクラスを作りたいときも pass を使うことができる
  • ちゃんとインスタンス作成できるし、存在しない属性も自由に追加できる
class User:
    pass

# インスタンス作成
tom = User()

# 存在しない属性も自由に追加できる
tom.name = "Tom"
tom.score = 20

bob = User()
bob.name = "Bob"
bob.level = 5

# ちゃんと表示される
print(tom.name)
print(bob.level)

コンストラクタ

  • Python のコンストラクタの第一引数は self
    • 作られるインスタンス自身のこと
  • コンストラクタ内に定義する変数を「インスタンス変数」と呼ぶ
class User:
    # コンストラクタの第一引数は self
    # 第二引数以降は自由に設定できる
    def __init__(self, name):
        # self.name は「インスタンス変数」という
        self.name = name

tom = User("tom")
bob = User("bob")

# インスタンス変数の表示
print(tom.name)
print(bob.name)

クラス変数

  • クラス変数
    • クラス直下に宣言した変数
    • クラス名.クラス変数 で直接呼び出すことができる
    • インスタンスを作成してインスタンス変数を呼んだのに存在しなかった場合
      • 同名のクラス変数があったら呼び出される
class User:
    # クラス変数
    count = 0

    def __init__(self, name):
        # クラス変数にアクセス
        User.count += 1
        self.name = name

print(User.count) # 0

tom = User("name")
print(User.count) # 1

bob = User("bob")
print(User.count) # 2

# count というインスタンス変数がないので、同名のクラス変数 count が呼び出される
print(tom.count) # 2

インスタンスメソッド / クラスメソッド

  • メソッド
    • クラスの中にある関数のこと
    • インスタンスメソッドとクラスメソッドの 2 種類ある
  • インスタンスメソッド
    • クラスのインスンスから呼び出すことができる関数
  • クラスメソッド
    • クラスから直接呼び出すことができる関数
    • デコレーター @classmethod で宣言する
    • クラス変数にアクセスすることができる
class User:
    count = 0

    def __init__(self, name):
        User.count += 1
        self.name = name

    # インスタンスメソッドの宣言
    def say_hi(self):
        print("hi {0}".format(self.name))

    # クラスメソッドの宣言
    @classmethod
    # 引数の cls はこのクラス自身を指す
    def show_info(cls):
        # クラス変数にアクセスできる
        print("{0} instances".format(cls.count))

# インスタンスの作成
tom = User("tom")
bob = User("bob")

# インスタンスからインスタンスメソッドを実行
tom.say_hi()
bob.say_hi()

# クラスから直接クラスメソッドを実行
User.show_info()

アクセス制限

  • アクセス制限
    • python にアクセス制限の仕組みはない
    • しかし以下の慣習的な明示ルールが 2 つ存在する
  • _属性名
    • このアンダースコアが 1 個の書き方は「以下のルールを明示」する
    • クラス内ではアクセス OK
    • クラス外ではアクセス NG
      • ※ しかし「実際にはアクセスできる」ので非推奨
  • __属性名
    • このアンダースコアが 2 個の書き方は「実際にアクセスできなくする」
      • ※ …ように見せる仕掛けが施されている
        • 【NG】 インスタンス._クラス名__属性名
        • ただし上記のように書いた場合はアクセスできるので注意
class User:
    count = 0

    def __init__(self, name):
        # アクセス制限
        self.__name = name

    def say_hi(self):
        print("hi {0}".format(self.__name))

tom = User("tom")

# アクセスエラー
print(tom.__name)
tom.say_hi()

アクセスエラーが本当に起きるかプログラムを実行してみましょう。

python myapp.py

Traceback (most recent call last):
  File "myapp.py", line 14, in 
    print(tom.__name)
AttributeError: 'User' object has no attribute '__name'

インスタンス.クラス名__属性名 のように書いてはいけません。

# アクセスできてしまうので注意
print(tom._User__name)

継承

  • 継承
    • クラス名のあとに (親クラス名) を付けると継承する

super() / オーバーライド

  • super().__init__(引数)
    • 親クラスのコンストラクタを使用する 
class User:
    def __init__(self, name):
        self.name = name

    def say_hi(self):
        print("hi {0}".format(self.name))

# User クラスを継承
class AdminUser(User):
    def __init__(self, name, age):
        # スーパークラス User のコンストラクタを使用
        super().__init__(name)
        self.age = age

    def say_hello(self):
        print("hello {0} ({1})".format(self.name, self.age))

    # オーバーライド (スーパークラスのメソッドを上書き)
    def say_hi(self):
        print("[admin] hi {0}".format(self.name))

bob = AdminUser("bob", 23)

bob.say_hi()
bob.say_hello()

多重継承

# A, B -> C
class A:
    def say_a(self):
        print("A!")
    def say_hi(self):
        print("hi! from A!")
class B:
    def say_b(self):
        print("B!")
    def say_hi(self):
        print("hi! from B!")

# カッコの中の継承順によって、メソッドの優先順位が変わる
class C(B, A):
    pass

c = C()
 c.say_a()
 c.say_b()

# 継承元がどっちも同じ名前のメソッドを持っているとき
# 継承時の継承順によって、呼ばれるメソッドが決まる
c.say_hi()  # class B のメソッドが呼ばれる

モジュール

モジュールの読み込みには 2 種類の書き方が存在する。

import [モジュール名]

  • モジュール名とはファイル名のこと
    • 拡張子の py は不要
  • モジュール内のすべてを取得する
  • 使うときは モジュール名.関数名 や モジュール名.クラス名
import user

 ...

# 以下のように使用する
# モジュール名.クラス名
# モジュール名.関数名
bob = user.AdminUser("bob", 23)

from [モジュール名] import [関数名/クラス名]

  • モジュールから指定したものだけを引っ張ってくる
  • カンマ区切りで複数指定可能
  • 使うときは関数名・クラス名をそのまま使える
 from user import AdminUser, User

# user.AdminUser のように書かなくてよい
bob = AdminUser("bob", 23)

tom = User("tom")

print(bob.name)
bob.say_hi()
bob.say_hello()
class User:
    def __init__(self, name):
        self.name = name
    def say_hi(self):
        print("hi {0}".format(self.name))

class AdminUser(User):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age
    def say_hello(self):
        print("hello {0} ({1})".format(self.name, self.age))
    def say_hi(self):
        print("[admin] hi {0}".format(self.name))

 print("hello")

パッケージ

作成したモジュールはパッケージ (ディレクトリ) ごとに管理したい場合が多いと思います。
Python にパッケージの存在を知らせるには __init__.py というファイルを配置する必要があります。

# ファイル作成
touch __init__.py

ファイルの中身は何も書かなくて大丈夫です。

import [パッケージ名.モジュール名]

mypackage というパッケージを作成して、その中に user.py を作成する。

class User:
    def __init__(self, name):
        self.name = name

    def say_hi(self):
        print("hi {0}".format(self.name))

class AdminUser(User):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age

    def say_hello(self):
        print("hello {0} ({1})".format(self.name, self.age))

    def say_hi(self):
        print("[admin] hi {0}".format(self.name))

 print("hello")

上記パッケージ内にあるモジュールを呼びだします。

# パッケージからモジュールをインポート
import mypackage.user

from [パッケージ名.モジュール名] import [関数名/クラス名]

# 特定のクラス、関数のみインポートした場合
from mypackage.user import AdminUser

# まわりくどい書き方
# bob = mypackage.user.AdminUser("bob", 23)
# bob = mymodule.AdminUser("bob", 23)

# すっきり書ける
bob = AdminUser("bob", 23)

print(bob.name)

bob.say_hi()
bob.say_hello()

as

パッケージが増えると名前が長くなりがちです。
モジュールに別名をつけてあげるとよいでしょう。

# モジュールに別名をつけることができる
import mypackage.user as mymodule

例外処理

  • 例外処理
    • 例外クラスを継承して独自のエラークラスを作成する

try / except / else / finally

  • try
  • except
    • エラーがあったときの処理
    • 他のプログラミング言語いうところの catch
  • else
    • エラーがなかったときの処理
  • finally
    • 最後に必ず実行される処理

raise / as

  • raise エラークラス名("エラーメッセージ")
    • そのエラークラスを使って意図的なエラーを起こす
    • コンストラクタの引数に "エラーメッセージ" が渡される
  • except エラークラス名 as e
    • print(e) するとエラーメッセージを表示できる
# 例外クラスを継承して独自のエラークラスを作成
class MyException(Exception):
    pass

 ...

def div(a, b):
    try:
        if (b < 0):
            # 意図的に MyException クラスのエラーを発生させる
            raise MyException("not minus")

        print(a / b)

    # ZeroDivisionError クラスは Python で定義されているエラークラス
    except ZeroDivisionError:
        print("not by zero!")

    # MyException クラスでエラーが発生したとき、そのエラーを変数 e で受け取る
    except MyException as e:
        print(e)

    # 例外発生しなかったときの処理
    else:
        print("no exception!")

    # 必ず最後に実行される処理
    finally:
        print("-- end --")

# エラーが発生しないパターン
div(10, 3)

# 0 の除算でエラーを発生させるパターン
div(10, 0)

# 独自の例外を発生させるパターン
div(10, -3)

リスト型 / タプル型

リスト型

  • 順序 (index) つき
  • [値] で初期化する
  • len(リスト型)
    • リストの長さを取得する
  • append(値)
    • リストに値を追加する
  • for value in リスト型
    • 要素をすべて変数で取り出すことができる
  • for index, value in enumerate(リスト型)
    • 取り出した要素か何番目の要素か、変数で取り出せるようになる
scores = [40, 50]

print(scores[0])  # 40

scores[0] = 45

print(len(scores))  # 2

scores.append(100)
print(scores)  # 45 50 100

for score in scores:
    print(score)

for i, score in enumerate(scores):
    print("{0}: {1}".format(i, score))

タプル型

  • 順序 (index) つき
  • 複数のデータ型を持てる
    • リスト型を持つことも可能
  • 値の変更ができない
  • (値) で初期化する
items = (50, "apple", 32.5)

print(items[1])

# 書き換えエラー発生
# items[1] = "pen"

タプル型とリスト型の互換性

  • list(タプル型)
    • タプル型をリスト型に変換する
  • tuple(リスト型)
    • リスト型をタプル型に変換する
print(list((1, 3, 5)))

print(tuple([1, 3, 5]))

スライス

  • リストから部分的なリストを作成する
    • 文字列のスライスも可能

リスト型のスライス

scores = [40, 50, 70, 90, 60]

# index 1 から 4 の手前までの要素でリストを作りたい [50, 70, 90]
print(scores[1:4])
scores = [40, 50, 70, 90, 60]

# 一番前から index 2 の手前までの要素でリストを作りたい [40, 50]
print(scores[:2])
scores = [40, 50, 70, 90, 60]

# index 3 から最後の要素までの要素でリストを作りたい [90, 60]
print(scores[3:])
scores = [40, 50, 70, 90, 60]

# 一番後ろの index から 3 つ分の要素でリストを作りたい [70, 90, 60]
print(scores[-3:])

文字列のスライス

s = "hello"
print(s[1:4])  # "ell"

集合型

  • 値の重複なし
  • 順序 (index) なし
    • つまり要素の指定ができない
  • set(リスト型) で初期化する
    • リスト型から集合型に変換している
    • {値} で初期化することもできる
  • 値 in 集合型
    • その値が含まれるか論理値を返す
  • 集合型.add(値)
    • その値を追加する
  • 集合型.remove(値)
    • その値を取り除く
  • len(集合型)
    • 集合型の要素数を返す
  • 集合演算
    • 和集合
      • リスト型1 | リスト型2
    • 積集合
      • リスト型1 & リスト型2
    • 差集合
      • リスト型1 - リスト型2
 a = set([5, 4, 8, 10])

# 省略形
a = {5, 3, 8, 5}

# 5 を含むか論理値を返す
print(5 in a)  # True

a.add(2)
a.remove(3)

print(len(a))

# 集合演算
b = {1, 3, 5, 8}
c = {3, 5, 8, 9}

# 和集合: 登場する数字だけを表示
print(b | c) # {1, 3, 5, 8, 9}

# 積集合: お互い被っている数字だけを表示
print(b & c) # {8, 3, 5}

# 差集合: c と被っている数字をなくした b を表示
print(b - c) # {1}

辞書型

  • キーと値で管理する
  • {キー : 値} で初期化する
  • for key, value in 辞書型.items():
    • キーと値を同時に取り出すことができる
  • del(辞書型[key])
    • キーを指定して要素を削除する
sales = {"ikeda" : 200, "tokunaga" : 400}

print(sales["ikeda"])    # 200

sales["ikeda"] = 300     # 値を書き換え
sales["eeeeg"] = 500     # キー追加

del(sales["tokunaga"])   # キー削除

print(sales)

# キーと値を同時に取り出す
for key, value in sales.items():
    print("{0} : {1}".format(key, value))

イテレータ型

  • イテレータ型は反復可能で数えられる値のオブジェクト
  • 要素を連続で取り出すことができる
  • 次の index に進んで、その要素の値だけ取り出すこともできる
  • iter(list 型) で初期化する
    • リスト型からイテレータ型に変換している
  • next(イテレータ型)
    • 次の要素の値になる
scores = [40, 50, 70, 90, 60]

# リスト型 → イテレータ型 に変換する
it = iter(scores)

print(next(it))  # 40
print(next(it))  # 50
print(next(it))  # 70
  • 実は for ...  in の  in のあとの部分はイテレータ型が期待されている
    • リスト型が渡された場合、イテレータ型に変換している
scores = [40, 50, 70, 90, 60]

for score in scores:
    print(score)

ジェネレータ型

  • イテレータ型の一種
    • ただし値を連続で取り出すことはできない
  • 1 つの要素を取り出そうとする度に処理をかけることができる
  • 無限に値を生み出すこともできる

yield

  • yield 値
    • ジェネレータ型のオブジェクト返却する
  • next(ジェネレータ型)
    • yield 値 の値を返却する

無限に値を返すジェネレータの実装方法

def get_infinite():

    i = 0

    # 無限ループ
    while True:
        # ジェネレータ型を返却する ※ 無限ループが中断する
        yield i * 2
        # next(g) されると値を吐き出して、この行から処理を再開する ※ 無限ループが再開する
        # ちゃんと前回までの i の値も保持されている
        i += 1

# ジェネレータ型のオブジェクトを取得
g = get_infinite()

# 値を生成する
print(next(g))  # 0
print(next(g))  # 2
print(next(g))  # 4

map

  • map(関数, イテレータ型)
    • イテレータ型の要素を 1 つずつ関数に渡して、ジェネレータ型を生成する
    • イテレータ型の代わりにリスト型を渡すこともできる
def triple(n):
    return n * 3

g = map(triple, [1, 2, 3])

# ジェネレータ型のままだと print できないのでリスト型に変換する
print(list(g)) # [3, 6, 9]

lambda

  • map(ラムダ式) を書くこともできる
    • つまり map(lambda 無名関数の引数: 無名関数の処理, イテレータ型)
    • イテレータ型の要素を 1 つずつ無名関数の引数として渡して処理する
g = map(lambda n: n * 3, [1, 2, 3])

print(list(g)) # [3, 6, 9]

filter

  • filter(論理値を返す関数, イテレータ型)
    • 条件合致した要素のみ抽出するジェネレータ型を生成する
# 偶数のとき true を返却する
def is_even(n):
    return n % 2 == 0

# range(10) : 0 - 9 まで値をもつリスト型を作成
g = filter(is_even, range(10))
print(list(g)) # [0, 2, 4, 6, 8]

# ラムダ式パターン
# g = filter(lambda n: n % 2 == 0, range(10))
# print(list(g))

内包表記

  • 内包表記
    • 「リスト型・ジェネレータ型・集合型」を生成・加工する際の記法
  • [] で囲む
    • [変数 i を使った処理 for 要素を変数 i として取り回す宣言 in イテレータ型]
    • リスト型を返却する
  • () で囲む
    • (変数 i を使った処理 for 要素を変数 i として取り回す宣言 in イテレータ型)
    • ジェネレータ型を返却する
  • {} で囲む
    • {変数 i を使った処理 for 要素を変数 i として取り回す宣言 in イテレータ型}
    • 集合型を返却する

内包表記の書き方

リスト型の内包表記

# [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
print([i * 3  for i in range(10)])
  • イテレータ型 if 文 とすると、その判定をしてから処理に映る
# if 文で [0, 2, 4, 6, 8] を抽出してから、処理に映る
# [0, 6, 12, 18, 24]
print([i * 3  for i in range(10) if i % 2 == 0])

ジェネレータ型の内包表記

# <generator object <genexpr> at 0x7f36280ded00>
print((i * 3  for i in range(10) if i % 2 == 0))

# print の中では ジェネレータ型の内包表記の () を省略することができる
print(i * 3  for i in range(10) if i % 2 == 0)

集合型の内包表記

# {0, 6, 12, 18, 24}
print({i * 3  for i in range(10) if i % 2 == 0})

お仕事ください！

僕が代表を務める 株式会社 EeeeG では Web 制作・システム開発・マーケティング相談を行っています。
なにかお困りごとがあれば、Twitter DM や Web サイトからお気軽にご相談ください。

コメントを残す

*