Python 入門

はじめに

本ページは、Python を使ってこれからプログラミングの学習を開始される方を対象に Python の仕様をわかりやすく網羅的に解説した入門ページです。Python の基本的な部分から細かく複雑な部分について、サンプルコードを混じえながら説明します。

Python のダウンロードとインストール

ここでは Windows10 64bit 環境として Python のダウンロードとインストールを行います。まずは Python の本体を以下からダウンロードするため、以下のサイトにアクセスします。

Download のエリアから最新版 (執筆時点では Python 3.7.2) をクリックします。

Python のダウンロード
Python のダウンロード

ページの一番下にダウンロード用のリンク一覧が表示されます。その中から Windows x86-64 executable installer をクリックするとダウンロードが開始されます。

Python のダウンロード
Python のダウンロード

python-3.7.2-amd64.exe という名前のファイルがダウンロードされれば、ダウンロードは完了です。そのファイルをダブルクリックしてインストールを行います。

インストールする場合、Add Python to PATH にチェックを入れてください。チェックを入れることでパスの設定が自動で行われます。その後、Install Now をクリックしてインストールを開始します。

Python のインストール
Python のインストール

インストールが完了するまでしばらく待機します。

Python のインストール
Python のインストール

次の画面が表示されれば、インストールは完了です。Close をクリックしてインストールを終了してください。

Python のインストール
Python のインストール

インストールが正しく行われたかを確認するためには、コマンドプロンプトで python --version コマンドを実行することで確認できます。正常にインストールされていれば、Python のバージョンが返されます。

> python --version
Python 3.7.2
インストール後の確認

Python の実行

Python をインストールすると、Python のプログラムを実行できるようになります。Python のプログラムを実行する方法には大きく2つの方法があります。

  • Python に付属している対話型インタープリタを使うと小さなプログラムを試すことができます。例えば、print() 関数などを使ってすぐに結果を確認することができます。対話型インタープリタを起動するためには、コマンドプロンプトで python コマンドを入力します。終了する場合は、Ctrl + Z キーを同時に押します。

    > python
    Python 3.7.2 (tags/v3.7.2:9a3ffc0492, Dec 23 2018, 23:09:28) [MSC v.1916 64 bit (AMD64)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    
    >>> print('hello, world!')
    hello, world!
    対話型インタープリタ
  • Python のプログラムをテキストファイルに保存して実行することができます。拡張子には .py を付け、コマンドプロンプトから python コマンドのパラメータとしてプログラムのファイル名を渡す方法です。例えば、テキストファイルに print('hello, world!') と記述し、hello.py という名前で保存したプログラムコードを実行する例は以下のとおりです。

    > python hello.py
    hello, world!
    Python プログラムの実行

コメントアウトと行の継続

Python におけるコメントアウト、およびプログラムコードの行を継続するための特殊な文字列について説明します。

コメントアウト

Python でプログラムをコメントアウトするには # 文字を使用します。# 文字を使用すると、Python はその文字が現れたところから行末までを無視します。コメントは、ブロックコメントとインラインコメントに分類され、行の先頭からのコメントをブロックコメント、途中からのコメントをインラインコメントと呼びます。また、他の言語のように複数行をコメントアウトする /* ... */ のような文字は Python にはありません。

# ブロックコメント
print(xxx)  # インラインコメント
Python のコメントアウト

ただし、文字列の中に # 文字が含まれる場合は、コメントアウトする文字ではなくただの # 文字として扱われます。

>>> print("No comment: quotes make the # harmless.")
No comment: quotes make the # harmless.
(コメントではない。クォートを使うと#は無力になる。)
Python のコメントアウト

PEP8 の推奨ルール

Python のコーディングルールをまとめたドキュメントである PEP8 の中には # 文字を使ったコメントについても推奨のルールが記載されています。

PEP8 のルールを遵守しなくとも文法上のエラーになるわけではありません。ただし、組織やプロジェクト、チームなどの複数人体制で開発を行う場合、コーディング規約として PEP8 に従った方が良いでしょう。

文とコメントの間は少なくとも 2 つのスペースを置くようにします。3 つ以上でも問題ありませんが、コメントの位置を揃えるために不要なスペースは除去します。

# No:
a = 1 # comment

# Yes:
a = 1  # comment

a = 1      # comment
xyz = 100  # comment
Python のコメントアウト (PEP8 推奨ルール)

インラインコメントは # 文字と、スペース 1 つから始めます。# 文字のあとにスペースが無くても 2 つ以上あってもいけません。

# No:
a = 1  #comment
a = 1  #  comment

# Yes:
a = 1  # comment
Python のコメントアウト (PEP8 推奨ルール)

ブロックコメントはコメント内でインデントされたテキストでない限り # 文字と、スペース 1 つから始めます。# 文字のあとにはスペースが 1 つ以上必要です。

# No:
#comment

# Yes:
# comment
#     indented comment
Python のコメントアウト (PEP8 推奨ルール)

先頭の # 文字は 1 つだけにします。

# No:
## comment

# Yes:
# comment
Python のコメントアウト (PEP8 推奨ルール)

行の継続

Python でプログラムコードの行を継続するには、継続文字の \ を使用します。行末に \ を加えると、Python はまだ行替えをしていないものと判断します。

例えば、一般的な継続文字を使用せずに長い文字列を作る場合は以下のようなコードになります。

>>> alphabet = ''
>>> alphabet += 'abcdefg'
>>> alphabet += 'hijklmnop'
>>> alphabet += 'qrstuv'
>>> alphabet += 'wxyz'
長い文字列を作るサンプル

しかし、継続文字を使うと以下のように記述することができます。

>>> alphabet = 'abcdefg' + \
...            'hijklmnop' + \
...            'qrstuv' + \
...            'wxyz'
継続文字を使った長い文字列を作るサンプル

print 関数

Python で文字列や数値、変数に格納された値などを標準出力 (sys.stdout) に表示する print() 関数について説明します。

Python2 と Python3 の print の違い

Python2 では print 文ですが、Python3 では print 関数になります。Python2 の print 文を Python3 で実行すると SyntaxError が発生します。Python2 の print 文を Python3 の print 関数に修正するためには () で囲んでください。

print xxx   # Python2
print(xxx)  # Python3
Python2 と Python3 の print の違い

Python3 では Python2 の print 文が廃止された理由は、Python の仕様をまとめたドキュメントである PEP3150 の中で以下のように述べられています。

  • 関数で実装できるものを構文にしている print 文が例外的な存在になっているから。
  • print 関数を他の関数に置き換えたいときに文字列の置き換えで済むから。
  • print 文のような特殊なシンタックスは文法をこれから拡張するときの障壁になるから。
  • print 文で複数オブジェクトを表示するとき区切り文字列を簡単に指定できないから。(関数だと sep 引数で区切り文字を指定できる。)

このページでは Python3 の print 関数について説明します。

print 関数によるオブジェクトの出力

文字列や数値を print 関数の引数として渡すと、その値が出力されます。リストや辞書型の場合は、全体が出力されます。

print('hello, world')
# hello, world

print(100)
# 100

print([0, 1, 2])
# [0, 1, 2]

print({'a': 0, 'b': 1, 'c': 2})
# {'a': 0, 'b': 1, 'c': 2}
print 関数によるオブジェクトの出力

print 関数では、文字列はそのまま出力されます。それ以外の型がどのような文字列として出力されるかはそれぞれの型の __str__() メソッドで定義されています。

例えば、print 関数に文字列型 '1.00000' を渡すとそのまま出力されますが、浮動小数点 float1.00000 を渡すと 1.0 と出力されます。ただし、format() 関数を使用することで float 型でも小数点以下の桁数を指定して出力できます。format() 関数の詳細については後述します。

print('1.00000')
# 1.00000

print(1.00000)
# 1.0
print 関数によるオブジェクトの出力

print 関数では、デフォルトで文字列のあとに改行を含みます。改行を行いたくない場合は、引数 end に空文字列を追加します。

print('foo', end='')
print('bar')
# foobar
print 関数によるオブジェクトの出力

また、引数 end には終端文字を自由に指定することができます。

print('foo', end=', ')
print('bar')
# foo, bar
print 関数によるオブジェクトの出力

print 関数の引数に複数の変数、および文字列や数値などを指定すると、スペースで区切られて出力されます。

i = 100
print('apple', i, 0.123)
# apple 100 0.123
print 関数によるオブジェクトの出力

引数 sep を指定した場合、区切り文字をデフォルトのスペースから任意の文字列に変更できます。引数 sep には、改行文字 \nを指定することもできます。

i = 100
print('apple', i, 0.123, sep=',')
# apple,100,0.123

print('apple', i, 0.123, sep='\n')
# apple
# 100
# 0.123
print 関数によるオブジェクトの出力

format 関数を使った出力

文字列関数 format()を使用すると、文字列中の置換フィールド {} が引数に指定した変数で置換されます。変数が複数ある場合は , で区切って指定することができます。

# 文字列.format(変数) の形式で指定します
s = 'Alice'
i = 25

print('Alice is {} years old'.format(i))
# Alice is 25 years old

print('{} is {} years old'.format(s, i))
# Alice is 25 years old
format 関数を使った出力

文字列中の置換フィールド {} にインデックスを付与することで、引数の順番に応じた値が置換されます。

s = 'Alice'
i = 25

print('{0} is {1} years old / {0}{0}{0}'.format(s, i))
# Alice is 25 years old / AliceAliceAlice
format 関数を使った出力

文字列の先頭に f を付与した場合、文字列中の置換フィールド {} に変数を直接指定できます。ただし、この文字列を使用する場合は、Python 3.6 以上である必要があります。この文字列は、f 文字列 (f-strings、フォーマット文字列、フォーマット済み文字列リテラル) と呼ばれます。

s = 'Alice'
i = 25

print(f'{s} is {i} years old')
# Alice is 25 years old
format 関数を使った出力

文字列中の {} を置換フィールド {} ではなく、通常の括弧として扱いたい場合は、{{, }} としてエスケープします。

print('{} is {} years old / {{xxx}}'.format(s, i))
# Alice is 25 years old / {xxx}
format 関数を使った出力

format() 関数を指定した文字列や、f 文字列の置換フィールド {} 内に書式指定文字列を指定した文字列は、数値を任意の書式にフォーマットして出力できます。

{:書式指定文字列} のように : のあとに書式化文字列を記述します。置換フィールドにインデックスや、名前を指定する場合は、そのあとに :書式指定文字列 を記述します。

number = 0.45
print('{0:.4f} is {0:.2%}'.format(number))
# 0.4500 is 45.00%

print(f'{number:.4f} is {number:.2%}')
# 0.4500 is 45.00%
format 関数を使った出力

書式指定文字列によって様々なフォーマットにすることが可能です。

i = 255

print('left   : {:<8}'.format(i))   # left    : 255        (スペース埋め8桁で左寄せ)
print('center : {:^8}'.format(i))   # center  :   255      (スペース埋め8桁で中央寄せ)
print('right  : {:>8}'.format(i))   # right   :      255   (スペース埋め8桁で右寄せ)
print('zero   : {:08}'.format(i))   # zero    : 00000255   (0埋め8桁)
print('bin    : {:b}'.format(i))    # bin     : 11111111   (2進数)
print('oct    : {:o}'.format(i))    # oct     : 377        (8進数)
print('hex    : {:x}'.format(i))    # hex     : ff         (16進数)

f = 0.1234

print('digit   : {:.2}'.format(f))  # digit   : 0.12       (小数点以下2桁)
print('digit   : {:.6f}'.format(f)) # digit   : 0.123400   (小数点以下6桁で0埋め)
print('exp     : {:.4e}'.format(f)) # exp     : 1.2340e-01 (指数表記)
print('percent : {:.0%}'.format(f)) # percent : 12%        (パーセント表記)
format 関数を使った出力

上記の例は format() 関数ですが、f 文字列でも同様の書式指定文字列が使用できます。

format() 関数と類似した出力仕様に変換指定子 (%d%s などの文字列フォーマット) があります。ただし、Python3 では format() 関数を使った方が好ましいとされています。

変数

変数とは、実際のデータを指す名前のことです。変数は、ブール値、整数、浮動小数点数、文字列、リスト、タプル、辞書などのオブジェクトにデータを入れた「箱」のような存在です。どのようなデータが入っているのか示すために箱には変数名という名前を付けることができます。

Python では、変数名を前もって宣言をしなくても、値を代入するだけで変数が作成できます。変数名に使用できる文字は以下のとおりです。

  • 小文字の英字 (az)
  • 大文字の英字 (AZ)
  • 数字 (09)
  • アンダースコア (_)

ただし、上記の文字を使用しても以下のルールには注意する必要があります。

  • 数字は変数名の先頭としては使えません
  • 大文字と小文字は区別されます (例えば、SPAMspam は区別されます)
  • 名前の先頭がアンダースコアになっている変数は特別扱いされます
  • 予約語は変数名としては使用できません (後述)

Python では変数名を命名するときにいくつかの慣例があります。例えば、先頭と末尾に 2 つアンダースコアを付けた名前 (__name__ など) は、変数名としては使わないなどが挙げられます。このような名前は、Python にとって特別な意味を持つからです。Python における変数名に関する慣例としては、以下のとおりです。

  • 先頭にアンダースコアを付けた名前 (_x など) は使わない。これは、from module import * ステートメントでインポートできなくなるためです。
  • 先頭と末尾に 2 つアンダースコアを付けた名前 (__name__ など) は使わない。これは、システム定義のインタプリタにとって、特別な意味を持つ名前に使われることが多いためです。
  • 先頭に 2 つアンダースコアを付けた名前 (__x など) は使わない。これは、所属するクラスの名前を付けた名前に自動的に変換 (マングリング) されるためです。このような変数は、クラス外部からの参照ができなくなります。
  • アンダースコアが 1 つだけで構成される名前 (_) は使わない。これは、対話型インタープリタで、直前に実行された式の演算結果を保持するために使用されるためです。

上記の慣例は、いずれも Python インタプリタの機能に関係するものですが、その他にもPythonプログラマが従っている慣例はあります。例えば、以下のようなものです。

  • 大文字で始まる名前はクラスの名前に使用されるため、変数には使用しない。
  • モジュール名は小文字にする。
  • self は予約語ではないが、特別な意味を持つため変数名としては使用しない。

Python の変数において極めて重要なポイントがあります。それは、変数名はただの名前であり、代入したからといって値はコピー (値渡し) されないということです。Python は、変数や関数に値を渡す場合はすべて参照渡しで渡されています。例えば、値渡しのように見える int 型においてさえ、値が変更されるまでは元の値と同一のオブジェクトを参照しています。このような問題は、配列をコピーするときには特に注意すべきです。

list1 = [1, 2, 3]
list2 = list1
list2[2] = 100

print(list1)
# [1, 2, 100]
参照渡し (シャローコピー)

上記の list1list2 は変数名が異なりますが、同じデータを参照しています。同じデータを参照しているかどうかは、id() 関数を使って調べることができます。

list1 = [1, 2, 3]
list2 = list1

print(id(list1))
# 2136166462152
print(id(list2))
# 2136166462152
参照渡し (シャローコピー)

このような問題を回避する方法のひとつとして、copy() 関数を使う方法があります。

list1 = [1, 2, 3]
list2 = list1.copy()

print(id(list1))
# 2829688981000
print(id(list2))
# 2829698365192
値渡し (ディープコピー)

予約語一覧

以下の名前は Python の予約語となっているので、変数名として使うことはできません。(Python 3.7.2)

  • False
  • None
  • True
  • and
  • as
  • assert
  • async
  • await
  • break
  • class
  • continue
  • def
  • del
  • elif
  • else
  • except
  • finally
  • for
  • from
  • global
  • if
  • import
  • in
  • is
  • lambda
  • nonlocal
  • not
  • or
  • pass
  • raise
  • return
  • try
  • while
  • with
  • yield

予約語の確認は、以下のように行うことができます。

>>> __import__('keyword').kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
予約語の確認

使用しない方が良い変数名一覧

識別子として使用できますが、可能な限り使用しない方が良い変数名の代表的なものは、組み込み関数の関数名です。もしも使用した場合、組み込み関数を上書きしてしまう危険性があります。

  • ArithmeticError
  • AssertionError
  • AttributeError
  • BaseException
  • BlockingIOError
  • BrokenPipeError
  • BufferError
  • BytesWarning
  • ChildProcessError
  • ConnectionAbortedError
  • ConnectionError
  • ConnectionRefusedError
  • ConnectionResetError
  • DeprecationWarning
  • EOFError
  • Ellipsis
  • EnvironmentError
  • Exception
  • False
  • FileExistsError
  • FileNotFoundError
  • FloatingPointError
  • FutureWarning
  • GeneratorExit
  • IOError
  • ImportError
  • ImportWarning
  • IndentationError
  • IndexError
  • InterruptedError
  • IsADirectoryError
  • KeyError
  • KeyboardInterrupt
  • LookupError
  • MemoryError
  • ModuleNotFoundError
  • NameError
  • None
  • NotADirectoryError
  • NotImplemented
  • NotImplementedError
  • OSError
  • OverflowError
  • PendingDeprecationWarning
  • PermissionError
  • ProcessLookupError
  • RecursionError
  • ReferenceError
  • ResourceWarning
  • RuntimeError
  • RuntimeWarning
  • StopAsyncIteration
  • StopIteration
  • SyntaxError
  • SyntaxWarning
  • SystemError
  • SystemExit
  • TabError
  • TimeoutError
  • True
  • TypeError
  • UnboundLocalError
  • UnicodeDecodeError
  • UnicodeEncodeError
  • UnicodeError
  • UnicodeTranslateError
  • UnicodeWarning
  • UserWarning
  • ValueError
  • Warning
  • WindowsError
  • ZeroDivisionError
  • __build_class__
  • __debug__
  • __doc__
  • __import__
  • __loader__
  • __name__
  • __package__
  • __spec__
  • abs
  • all
  • any
  • ascii
  • bin
  • bool
  • breakpoint
  • bytearray
  • bytes
  • callable
  • chr
  • classmethod
  • compile
  • complex
  • copyright
  • credits
  • delattr
  • dict
  • dir
  • divmod
  • enumerate
  • eval
  • exec
  • exit
  • filter
  • float
  • format
  • frozenset
  • getattr
  • globals
  • hasattr
  • hash
  • help
  • hex
  • id
  • input
  • int
  • isinstance
  • issubclass
  • iter
  • len
  • license
  • list
  • locals
  • map
  • max
  • memoryview
  • min
  • next
  • object
  • oct
  • open
  • ord
  • pow
  • print
  • property
  • quit
  • range
  • repr
  • reversed
  • round
  • set
  • setattr
  • slice
  • sorted
  • staticmethod
  • str
  • sum
  • super
  • tuple
  • type
  • vars
  • zip

使用しない方が良い変数名 (組み込み関数の関数名) の確認は、以下のように行うことができます。

>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
使用しない方が良い変数名の確認

数値

Python における数値型には 3 種類あります。整数 (int)、 浮動小数点数 (float)、 複素数 (complex)です。また、ブール型 (bool) は、整数のサブタイプです。

整数
5100 など、小数点以下を含まない数値です。
浮動小数点数
3.141.86e4 など、小数点以下を含む数値や、指数表記を含む数値です。
複素数
5j などの虚数単位 (j) を含む数値です。虚数単位は i ではないため注意が必要です。また、虚部が 1 の場合でも省略すると NameError が発生するため 1j と明示的に記述する必要があります。
type(1)
# <class 'int'>

type(3.14)
# <class 'float'>

type(5j)
# <class 'complex'>
数値の種類

これらの数値型は、以下の算術演算子を使うことで計算することができます。

Python の算術演算子一覧
演算説明結果
x + y加算5 + 813
x - y減算90 + 1080
x * y乗算4 * 728
x / y浮動小数点数の除算7 / 23.5
x // y整数の除算 (切り捨て)7 // 23
x % y剰余7 % 31
x ** y指数3 ** 481
-x負数-135-135
+x正数+135135
abs(x)絶対値abs(-271.1)271.1
int(x)整数へ変換 (切り捨て)int(10.5)10
float(x)浮動小数点数へ変換float(10)10.0
divmod(x)商と剰余をまとめて取得divmod(9, 5)(1, 4)
complex(re, im)実部 (re)、虚部 (im) の複素数へ変換complex(3, 4)(3+4j)
c.conjugate()複素数 c を共役複素数へ変換(3+4j).conjugate()(3-4j)

Python の数字の並びは、リテラルの整数と見なされます。ゼロも使用することもできますが、他の数字の前にゼロを置くことはできません。もしもゼロを置いた場合、SyntaxError が発生します。

>>> 5
5

>>> 0
0

>>> 05
  File "<stdin>", line 1
    05
     ^
SyntaxError: invalid token
数値の扱い

Python では、他の言語と同様に以下のような簡略版の記述ができます。

# a = a + 8 と同じ意味
a += 8

# a = a - 8 と同じ意味
a -= 8

# a = a * 8 と同じ意味
a *= 8

# a = a / 8 と同じ意味
a /= 8

# a = a // 8 と同じ意味
a //= 8
簡略版の記述

n進数などの基数の記述方法は以下のとおりです。

>>> 10
10

>>> 0b10
2

>>> 0o10
8

>>> 0x10
16
基数の記述

数値への変換

データ型を変換するには、int() 関数、または float() 関数を使います。

>>> int(10)
10

>>> float(10)
10.0
整数の変換

小数点を含む変換の場合、int() 関数は小数点以下を切り捨てます。

>>> int(10.5)
10

>>> float(10.5)
10.5
小数点を含む数値の変換

文字列から数値に変換する場合、int() 関数は小数点を含む文字列を変換できません。

>>> int("10")
10

>>> int("10.5")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '10.5'

>>> float("10")
10.0

>>> float("10.5")
10.5
文字列の変換

また、数値に変換できない文字列を変換しようとした場合、例外が発生します。

>>> int("abc")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'abc'

>>> int("")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: ''
文字列の変換 (例外発生)

異なる数値型を混ぜて計算すると、Python は片方を自動的に変換する場合があります。

>>> 4 + 7.0
11.0
自動的な変換

bool 値の False は、整数、浮動小数点数と混ぜて計算するときには、0 または 0.0 として扱われます。True の場合は 1 または 1.0 として扱われます。

>>> True + 2
3

>>> False + 5.0
5.0
自動的な変換

一般的に文字列が数値に変換可能かどうか調べるためのアプローチは、以下の3つがあります。

  • try-except を使用する
  • .isdigit() 関数を使用する
  • regex を使用する

以下のコードでは、try-except を用いて float に変換可能な場合は、True を返す関数を実装しています。ただし、指数表記、NanInfTrue を返すため、注意が必要です。

def is_float_expression(s):
    try:
        val = float(s)
        return True
    except ValueError:
        return False

print(is_float_expression(100))    # True
print(is_float_expression("100"))  # True
print(is_float_expression("10.5")) # True
print(is_float_expression(".5"))   # True
print(is_float_expression("10."))  # True
print(is_float_expression("10e2")) # True
print(is_float_expression("NaN"))  # True
print(is_float_expression("Inf"))  # True
print(is_float_expression("a"))    # False
try-except による変換可否の判定

以下のコードでは、isdigit() 関数を用いて数字であれば True を返しています。ただし、isdigit() 関数では小数点は判定できないため、注意が必要です。

"10".isdigit()   # True
"10.5".isdigit() # False
isdigit() 関数による変換可否の判定

以下のコードでは、正規表現を用いて変換可否を判定しています。

import re

def is_float_expression(s):
    if re.match("^-?\d+?\.\d+?$", s) is None:
        return False
    else:
        return True

is_float_expression("10.1")  # True
is_float_expression("-10.1") # True
正規表現による変換可否の判定

int 型の大きさ

Python2 では、int のサイズは 32 ビットに制限されていました。これは -2,147,483,648 から 2,147,483,647 までの整数を表現できます。long は 64 ビットなのでもっと大きな範囲の数値を表現できます。具体的には -9,223,372,036,854,775,808 から 9,223,372,036,854,775,807 までです。

Python3 では long がなくなり int任意のサイズになりました。つまり 64 ビットよりもはるかに大きな数値を表現できるようになりました。

googol = 10**100
# 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

googol * googol
# 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
int 型の大きさ

多くの言語では上記のコードを試そうとすると、整数オーバーフローと呼ばれるエラーが発生します。これは、コンピュータが認めている以上のサイズを数値が求めているために発生するエラーです。しかし、Python は途方もなく大きな整数を問題なく処理できます。

四捨五入する: round, Decimal.quantize

Python で四捨五入する場合、以下の方法があります。

  • 組み込み関数の round() 関数を使う
  • 標準ライブラリの decimal.quantize() 関数を使う
  • 新しい関数を定義する

四捨五入する: round() 関数

Python には組み込み関数として round() 関数が用意されています。

round(number[, ndigits])
round() 関数の構文

round() 関数では、第一引数 (number) に四捨五入したい数値を指定し、オプショナルの第二引数には何桁にするか指定します。第二引数が省略された場合、入力値にもっとも近い整数 (int) を返します。第二引数が指定された場合、浮動小数点数 (float) を返します。ただし、round() 関数は厳密な四捨五入ではなく、偶数への丸めである点に注意してください。偶数への丸めについては後述します。

f = 123.456

print(round(f))
# 123

print(type(round(f)))
# <class 'int'>

print(round(f, 1))
# 123.5

print(round(f, 2))
# 123.46

print(round(f, 0))
# 123.0

print(type(round(f, 0)))
# <class 'float'>
round() 関数の四捨五入

第二引数に負の整数を指定した場合、対応する桁に丸めることができます。

i = 123

print(round(i, -1))
# 120

print(round(i, -2))
# 100

f = 123.456

print(round(f, -1))
# 120.0

print(round(f, -2))
# 100.0
round() 関数の四捨五入

偶数への丸めとは、端数が 0.5 より小さいなら切り捨て、端数が 0.5 より大きいならは切り上げ、端数がちょうど 0.5 なら切り捨てと切り上げのうち結果が偶数となる方へ丸める方法です。つまり端数がちょうど 0.5 の場合、以下のように結果はすべて偶数となります。

print(round(0.5)) # 0
print(round(1.5)) # 2
print(round(2.5)) # 2
print(round(3.5)) # 4
print(round(4.5)) # 4
偶数への丸め

ただし、2進数では小数点以下を浮動小数点数では正確に表現できないため、小数点以下2桁以降の処理では偶数への丸めの定義に当てはまらない場合があるので注意が必要です。

print(round(0.05, 1)) # 0.1
print(round(0.15, 1)) # 0.1
print(round(0.25, 1)) # 0.2
print(round(0.35, 1)) # 0.3
print(round(0.45, 1)) # 0.5
偶数への丸め

正確な偶数への丸めを実現したい場合は、次の decimal.quantize() 関数か、新しい関数を定義する方法を使います。また、Python2 の round() は偶数の丸めではなく四捨五入の処理となるため、注意してください。

四捨五入する: decimal.quantize() 関数

標準ライブラリの decimal モジュールを使うと、正確な十進浮動小数点数を扱うことができます。

decimal モジュールの quantize() 関数を使うと、丸めモードを指定して数値を丸めることができます。

quantize(exp, rounding=None, context=None)
quantize() 関数の構文

quantize() 関数の rounding 引数に、ROUND_HALF_UP を指定すると一般的な四捨五入になります。

from decimal import Decimal, ROUND_HALF_UP

print(Decimal('1.5').quantize(Decimal('1'), ROUND_HALF_UP))
# 2
quantize() 関数での四捨五入

Decimal()Decimal 型のオブジェクトを生成できます。引数に float 型を指定すると、実際に扱われる数値について確認することができます。

print(Decimal(0.05))
# 0.05000000000000000277555756156289135105907917022705078125

print(type(Decimal(0.05)))
# <class 'decimal.Decimal'>
Decimal 型のオブジェクト

上記のように、0.05 は2進数で正確には表現できないため、近似値となります。上述した round 関数で 0.05 を含む数値が正しく丸められなかったのは、これが原因になります。

引数に float 型ではなく str 型を指定すると、正確にその値の Decimal 型として扱われます。

print(Decimal('0.05'))
# 0.05
Decimal 型のオブジェクト

quantize() の第一引数に求めたい桁数と同じ桁数の数値を '0.1''0.01' のように文字列で指定します。引数 rounding には、丸めモードを指定します。例えば、ROUND_HALF_UP を丸めモードとして指定すると、一般的な四捨五入となります。

from decimal import Decimal, ROUND_HALF_UP

f = 123.456

print(Decimal(str(f)).quantize(Decimal('0'),    rounding=ROUND_HALF_UP)) # 123
print(Decimal(str(f)).quantize(Decimal('0.1'),  rounding=ROUND_HALF_UP)) # 123.5
print(Decimal(str(f)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)) # 123.46
quantize() 関数での四捨五入

組み込み関数 round() と異なり、0.51 に丸められています。

from decimal import Decimal, ROUND_HALF_UP

print(Decimal('0.4').quantize(Decimal('0'), rounding=ROUND_HALF_UP)) # 0
print(Decimal('0.5').quantize(Decimal('0'), rounding=ROUND_HALF_UP)) # 1
print(Decimal('0.6').quantize(Decimal('0'), rounding=ROUND_HALF_UP)) # 1
quantize() 関数での四捨五入

四捨五入する: decimal.as_tuple() 関数

整数を任意の桁数で四捨五入する場合、as_tuple() 関数を使います。また、整数 (Decimal('10')) の場合、E を使った指数表記になります。四捨五入を行う場合は、引数の roundingROUND_HALF_UP を指定します。ただし、そのままでは結果も指数表記になるため、整数として演算したい場合、int() で変換する必要があります。

i = 12345

print(Decimal(i).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP))
# 1.235E+4

print(int(Decimal(i).quantize(Decimal('1E1'), rounding=ROUND_HALF_UP)))
# 12350

print(int(Decimal(i).quantize(Decimal('1E2'), rounding=ROUND_HALF_UP)))
# 12300

print(int(Decimal(i).quantize(Decimal('1E3'), rounding=ROUND_HALF_UP)))
# 12000
as_tuple() 関数での四捨五入

整数の場合、浮動小数点数とは異なり指数表記になる理由は、整数 (Decimal('10')) では Decimal オブジェクトの指数 (exponent) が 1 ではなく 0 になるためです。

print(Decimal('10').as_tuple())
# DecimalTuple(sign=0, digits=(1, 0), exponent=0)

print(Decimal('1E1').as_tuple())
# DecimalTuple(sign=0, digits=(1,), exponent=1)
as_tuple() 関数での四捨五入

文字列

シングルクォート ' 、またはダブルクォート " で囲むと文字列 (str 型オブジェクト) になります。シングルクォート ' 、またはダブルクォート " のどちらで囲んでも、値としては等価になります。

s_sq = 'abc'
print(s_sq)
# abc

print(type(s_sq))
# <class 'str'>

s_dq = "abc"
print(s_dq)
# abc

print(type(s_dq))
# <class 'str'>

print(s_sq == s_dq)
# True
クォートを使った文字列

ただしどちらのクォートで囲むかによって、文字列中の引用符の扱いが異なります。シングルクォート ' で囲んだ場合、引用符としてダブルクォート " がそのまま使えますが、シングルクォート ' を使う場合はバックスラッシュでエスケープ \' する必要があります。逆にダブルクォート " で囲んだ場合、引用符としてシングルクォート ' がそのまま使えますが、ダブルクォート " を使う場合はバックスラッシュでエスケープ \" する必要があります。

s_sq = 'a\'b"c'
print(s_sq)
# a'b"c

s_sq = 'a\'b\"c'
print(s_sq)
# a'b"c

s_dq = "a'b\"c"
print(s_dq)
# a'b"c

s_dq = "a\'b\"c"
print(s_dq)
# a'b"c
引用符のエスケープ

シングルクォート ' 、またはダブルクォート " を3つ使ったトリプルクォート ''', """ で囲まれた文字列は、複数行をまとめて扱うことができます。トリプルクォートのなかに複数行の文字列を入れると、改行文字、および先頭や末尾にスペースがある場合、それらも残るため注意が必要です。

>>> poem = '''I do not like thee, Doctor Fell.
...     The reason why, I cannot tell.
...     But this I know, and know full well:
...     I do not like thee, Doctor Fell.
... '''
>>> print(poem)
I do not like thee, Doctor Fell.
    The reason why, I cannot tell.
    But this I know, and know full well:
    I do not like thee, Doctor Fell.

>>>
トリプルクォートの文字列

また、print() の出力と、対話型インタープリタが行う自動エコーの出力には違いがあります。対話型インタープリタでは、以下のように改行文字は \n と表示され、複数回繰り返すスペースも省略されます。

>>> poem2
'I do not like thee, Doctor Fell.\n The reason why, I cannot tell.\n
But this I know, and know full well:\n I do not like thee, Doctor
Fell.\n'
トリプルクォートの文字列

シングルクォート ' 、またはダブルクォート " で囲んだ文字列を複数行にした場合、SyntaxError が発生します。ただし、明示的な改行コード \n を文字列内に含めることで改行することができます。

s = 'I do not like thee, Doctor Fell.
The reason why, I cannot tell.
But this I know, and know full well:
I do not like thee, Doctor Fell.'
# SyntaxError: EOL while scanning string literal

s = 'I do not like thee, Doctor Fell.\nThe reason why, I cannot tell.\nBut this I know, and know full well:\nI do not like thee, Doctor Fell.'
print(s)
# I do not like thee, Doctor Fell.
# The reason why, I cannot tell.
# But this I know, and know full well:
# I do not like thee, Doctor Fell.
文字列内の改行

トリプルクォート ''', """ で囲まれた文字列は、シングルクォート ' 、またはダブルクォート "のどちらでも等価になります。

s_tq_sq = '''\'abc\'
"xyz"'''

print(s_tq_sq)
# 'abc'
# "xyz"

s_tq_dq = """'abc'
\"xyz\""""

print(s_tq_dq)
# 'abc'
# "xyz"

print(s_tq_sq == s_tq_dq)
# True
クォートの文字列の等価

また、括弧を使うことで以下のようも記述できます。

s_multi = ('abc\n'
           'xyz')

print(s_multi)
# abc
# xyz
括弧を使った記述

文字列への変換

コンストラクタ str() を使うと他の型のオブジェクトを文字列(str 型オブジェクト)に変換できます。str() は対象オブジェクトの __str()__ 関数の結果を返します。__str()__ 関数が未定義の場合は、repr() 関数の結果を返します。

整数 int や浮動小数点数 floatstr() で文字列 str に変換します。

i = 100

print(str(i))
# 100

print(type(str(i)))
# <class 'str'>

f = 0.123

print(str(f))
# 0.123

print(type(str(f)))
# <class 'str'>
str への変換

str() で文字列 str に変換した場合、16 進数表記の整数 int や、指数表記の float は標準的な書式の文字列に変換されます。

i = 0xFF
print(str(i))
# 255

f = 1.23e+10
print(str(f))
# 12300000000.0
str への変換

文字列を連結・結合する: +演算子

+ 演算子を使って、文字列リテラル ('...', "...") を連結できます。

print('a' + 'b' + 'c')
# abc
文字列の連結・結合

代入演算子の += 演算子も使えます。左辺の文字列変数に右辺の文字列が連結されます。

s = 'abc'
s += 'xxx'

print(s)
# abcxxx
文字列の連結・結合

単純に文字列リテラルを並べて書いてもその文字列リテラルが連結されます。

s = 'a' 'b' 'c'

print(s)
# abc
文字列の連結・結合

ただし、文字列の変数に対しては上記の書き方はできません。

s1 = 'a'
s2 = 'b'
s3 = 'c'
s = s1 s2 s3

print(s)
# SyntaxError: invalid syntax
文字列の連結・結合

異なる型を + 演算子で連結した場合、TypeError が発生します。

s = 'abc'
i = 100

print(s + i)
# TypeError: must be str, not int
異なる型の連結・結合

数値 (整数型 int や浮動小数点型 float) と文字列を + 演算子で連結する場合、数値を str() で文字列に変換してから連結します。

s = 'abc'
i = 100

print(s + str(i))
# abc100
異なる型の連結・結合

文字列のリストを連結・結合する: join()

join() 関数を使うと、文字列のリストをひとつの文字列に連結することができます。join() 関数の構文は以下のとおりです。str には区切り文字 (セパレータ) を指定し、iterable には連結したいリスト名 (イテラブルオブジェクト) を指定します。

str.join(iterable)
join() 関数の構文

セパレータに空文字を指定した場合はリストが単純に連結され、カンマを指定した場合はカンマ区切りに連結され、改行文字を指定すれば要素ごとに改行されます。

l = ['a', 'b', 'c']

s = ''.join(l)
print(s)
# abc

s = ','.join(l)
print(s)
# a,b,c

s = '\n'.join(l)
print(s)
# a
# b
# c
join() 関数によるリストの連結

文字列を指定して置換する: replace

replace 関数は、置換元文字列 (old) を、置換先文字列 (new) に置換して返します。オプション引数 count が与えられている場合、先頭から最大置換回数分だけを置換します。

str.replace(old, new[, count])
str.replace() の構文
s = 'abc123abc123.'
print(s.replace('abc', '0'))
# 01230123
str.replace() による文字列の置換

count パラメータで、最大置換回数を指定することもできます。最大置換回数を超えた後続の文字列は置換されません。

s = 'abc123abc123.'
print(s.replace('abc', '0', 1))
# 0123abc123
str.replace() による文字列の置換

正規表現で置換する: re.sub, re.subn

re.sub 関数は、stringpattern で指定された正規表現パターンと一致した場合、repl で置換した文字列を返します。パターンが見つからない場合は、文字列がそのまま返されます。これらの関数は、標準ライブラリの re モジュールをインポートすると利用できます。基本的な正規表現の一覧は、基本的な正規表現一覧を参照してください。

re.sub(pattern, repl, string, count=0, flags=0)
re.sub() の構文

正規表現で置換する場合、以下の点に注意してください。

  • エスケープシーケンスを無視する場合は raw 文字列 (r"...") を使用します
  • raw 文字列を使わない場合、エスケープ文字 (\) 自体もエスケープする必要があります
  • 何度も使用する正規表現は事前にコンパイルを行い、使い回す方がパフォーマンスに優れます
import re

filepath = r"C:\work\template.xlsx"
pattern = re.compile(".+\\\\") # raw 文字列では r".+\\" となります
print(re.sub(pattern, '', filepath))
# template.xlsx
str.replace() による文字列の置換

re.subn() 関数は置換処理された文字列と、置換した部分の個数とのタプル (new_string, number_of_subs_made) を返します。

re.subn(pattern, repl, string, count=0, flags=0)
re.subn() の構文
import re

filepath = r"C:\work\template.xlsx"
pattern = re.compile(".+\\\\")
result = re.subn(pattern, '', filepath)
print(result)
# (template.xlsx, 1)

print(type(result))
# <class 'tuple'>

print(result[0])
# template.xlsx

print(result[1])
# 1
re.subn() の構文

複数の文字を指定して置換する: translate

translate() 関数は、複数の文字を指定して置換して返します。複数の文字列を置換するためには、変換テーブルを使います。変換テーブルを作成するためには、str.maketrans() を利用します。

str.translate(table)
str.translate() の構文
text = 'murashun.jp は、WEB 制作のフロントエンド技術情報を解説します。'
table = str.maketrans({
    '、': ',',
    '。': '.',
})
result = text.translate(table)

print(result)
# murashun.jp は,WEB 制作のフロントエンド技術情報を解説します.
re.subn() の構文

リスト

Python には文字列以外にリストタプルの 2 種類のシーケンス構造があり、0 個以上の要素を持つことができます。リストは [, ] でデータを囲み、タプルは (, ) でデータを囲みます。

list = [1, 2, 3]
print(type(list))
# <class 'list'>

tuple = (1, 2, 3)
print(type(tuple))
# <class 'tuple'>
リストとタプル

それぞれの違いは、リストはデータがミュータブル (可変) であり、タプルはデータがイミュータブル (不変) になります。ミュータブルであるリストは、要素の挿入や削除を行うことができますが、イミュータブルであるタプルは要素の変更を伴う関数は使用できません。

リストで使用できる関数は以下のとおりです。

  • append
  • clear
  • copy
  • count
  • extend
  • index
  • insert
  • pop
  • remove
  • reverse
  • sort

タプルで使用できる関数は以下のとおりです。

  • count
  • index

上記のようにタプルは要素に対して変更や削除を行うための関数がありません。また、要素に対して直接変更を行う場合もエラーとなります。

list = [1, 2, 3]
list[0] = 4
print(list)
# [4, 2, 3]

tuple = (1, 2, 3)
tuple[0] = 4
print(tuple)
# 'tuple' object does not support item assignment
リストとタプル

リスト型への変換

文字列をリスト型に変換する方法は、以下のように行います。

>>> list('cat')
['c', 'a', 't']
文字列をリスト型に変換

split() 関数を使えば、任意のセパレータ文字列に対して分割することができます。

>>> birthday = '1982/07/01'
>>> birthday.split('/')
['1982', '07', '01']
文字列をリスト型に変換

ただし、文字列に複数のセパレータ文字列が連続している場合、リスト要素としては空文字が設定されます。

>>> splitme = 'a/b//c/d///e'
>>> splitme.split('/')
['a', 'b', '', 'c', 'd', '', '', 'e']
文字列をリスト型に変換

リスト要素の取り出し

オフセットを指定すればリストからも個々の要素を取り出すことができます。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> marxes[0]
'Groucho'
>>> marxes[1]
'Chico'
>>> marxes[2]
'Harpo'
オフセットを使った要素の取り出し

マイナスのインデックスを使えば末尾から逆に取り出すこともできます。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> marxes[-1]
'Harpo'
>>> marxes[-2]
'Chico'
>>> marxes[-3]
'Groucho'
オフセットを使った要素の取り出し

スライスを使うと、リストのサブシーケンスを取り出すことができます。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> marxes[0:2]
['Groucho', 'Chico']
スライスを使った要素の取り出し

スライスは 1 以外のステップを指定することもできます。以下の例では、先頭から右にひとつおきに要素を取り出しています。

>>> marxes[::2]
['Groucho', 'Harpo']
スライスを使った要素の取り出し

次の例では、末尾から左にひとつおきに要素を取り出しています。

>>> marxes[::-2]
['Harpo', 'Groucho']
スライスを使った要素の取り出し

スライスを使ったテクニックで、リストの要素を逆順にすることもできます。

>>> marxes[::-1]
['Harpo', 'Chico', 'Groucho']
スライスを使った要素の取り出し

リスト要素の追加と削除

リストに要素を追加するための方法のひとつとして append() 関数があります。append() 関数を使うと、末尾に要素をひとつずつ追加することができます。

>>> marxes.append('Zeppo')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo']
append() 関数を使ったリスト要素の追加

extend() 関数を使うと、ふたつのリストをひとつにまとめることができます。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> others = ['Gummo', 'Karl']
>>> marxes.extend(others)
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo', 'Gummo', 'Karl']
extend() 関数を使ったリスト要素の追加

このときに append() 関数を使うと、others の要素が追加されるのではなく、others が 1 個のリスト要素として追加されてしまいます。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> others = ['Gummo', 'Karl']
>>> marxes.append(others)
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo', ['Gummo', 'Karl']]
append() 関数を使ったリスト要素の追加

append() 関数は、リストの末尾にしか要素を追加できません。リストのオフセットを指定し、その前に要素を追加したいときには、insert() 関数を使います。オフセット 0 を指定すると、リストの先頭に挿入されます。末尾、または末尾を越えるオフセットを指定すると、append() 関数と同じようにリストの末尾に挿入されます。

>>> marxes.insert(3, 'Gummo')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']

>>> marxes.insert(10, 'Karl')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo', 'Karl']
insert() 関数を使ったリスト要素の追加

要素を削除する場合は、del を使用します。要素を削除した場合、その後ろの要素は前に移動して削除された要素のスペースを埋め、リストの長さは 1 だけ小さくなります。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']
>>> marxes[2]
'Harpo'

>>> del marxes[2]
>>> marxes
['Groucho', 'Chico', 'Gummo', 'Zeppo']

>>> marxes[2]
'Gummo'
del を使ったリスト要素の削除

削除したい要素がリストのどこにあるか分からない場合は、remove() 関数を使用します。remove() 関数は、値を指定して要素を削除することができます。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']
>>> marxes.remove('Gummo')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo']
remove() 関数を使ったリスト要素の削除

pop() 関数を使えば、リストから要素を取り出し、同時にリストからその要素を削除することができます。オフセットを指定して pop() 関数を呼び出すと、そのオフセットの要素が返されます。引数を指定しなければ、オフセットとして -1 が使われます。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> marxes.pop()
'Zeppo'
>>> marxes
['Groucho', 'Chico', 'Harpo']
>>> marxes.pop(1)
'Chico'
>>> marxes
['Groucho', 'Harpo']
pop() 関数を使ったリスト要素の取り出し (取得と削除)

要素の値からその要素のリスト内でのオフセットを知りたい場合には、index() 関数を使います。もしも、リストに存在しない要素が指定された場合、ValueError が発生します。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> marxes.index('Chico')
1
index() 関数を使ったリスト要素のオフセット位置の確認

リスト内に要素があるかテストするには、in を使います。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> 'Groucho' in marxes
True
>>> 'Bob' in marxes
False
in を使ったリスト内に要素があるかのテスト

ただし、リスト内には複数の位置に同じ値が格納されている場合があります。in を使ったテストでは、少なくとも 1 つ以上の要素があれば Ture を返します。

>>> words = ['a', 'deer', 'a' 'female', 'deer']
>>> 'deer' in words
True
in を使ったリスト内に要素があるかのテスト

リスト要素の計算と変換

特定の値がリスト内にいくつ含まれているかを数えるには、count() 関数を使います。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> marxes.count('Harpo')
1
>>> marxes.count('Bob')
0
count() 関数を使った値の個数の計算

文字列関数の join() 関数を使うことで文字列への変換を行うこともできます。join() 関数はリスト関数ではありませんが、引数にはイテラブルオブジェクトを指定できるため、以下のように実装できます。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> ', '.join(marxes)
'Groucho, Chico, Harpo'
join() 関数を使った文字列への変換

リスト要素を値の順序で並べ替える場合は、sort() 関数、または sorted() 関数を使います。リスト関数の sort() 関数は、指定したリスト自体をソートします。汎用関数の sorted() 関数は、ソートされたリストのコピーを返します。リストの要素が数値ならデフォルトで数値の昇順でソートされ、要素が文字列なら、アルファベット順でソートされます。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> sorted_marxes = sorted(marxes)
>>> sorted_marxes
['Chico', 'Groucho', 'Harpo']
>>> marxes
['Groucho', 'Chico', 'Harpo']
sorted() 関数を使ったリストの並び替え

sorted_marxes はコピーであり、これを作ってもオリジナルのリストは変更されません。しかし、marxes リストからリスト関数の sort() 関数を呼び出すと、marxes リスト自体が書き換えられます。

>>> marxes.sort()
>>> marxes
['Chico', 'Groucho', 'Harpo']
sort() 関数を使ったリストの並び替え

基本的に sort() 関数を使う場合は、リストの要素がすべて同じ型である必要があります。ただし、異なる型が混ざっていても正しく動作する場合があります。例えば、intfloat が同じリストに混在していても Python が自動的に変換できるため問題なく動作します。

>>> numbers = [2, 1, 4.0, 3]
>>> numbers.sort()
>>> numbers
[1, 2, 3, 4.0]
sort() 関数を使ったリストの並び替え

デフォルトのソート順は昇順ですが、引数として reverse=True を追加すれば降順になります。

>>> numbers = [2, 1, 4.0, 3]
>>> numbers.sort(reverse=True)
>>> numbers
[4.0, 3, 2, 1]
sort() 関数を使ったリストの並び替え

len() 関数は、リスト内の要素数を返す。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> len(marxes)
3
len() 関数を使ったリストの長さの取得

タプル

タプルは、リストと同様に任意の要素を集めたシーケンスオブジェクトです。ただし、リストとは異なりタプルはイミュータブル (不変) であり、タプルを定義した後では要素の追加、変更、削除はできません。そのため、タプルは定数リストとして扱うことができます。

タプルはリストと比べて関数がかなり少なく、countindex しかありません。タプルを利用するシーンとしては、以下のような場合があります。

  • タプルは、消費スペースが小さい。
  • タプルの要素は、誤って書き換える危険がない。
  • タプルは辞書のキーとして使える。
  • 名前付きタプルは、オブジェクトの単純な代用品として使える。
  • 関数の引数は、タプルとして渡される。

空のタプルは以下のように実装できます。

>>> empty_tuple = ()
>>> empty_tuple
()
空タプルの作成

1 個以上の要素を持つタプルは、個々の要素をカンマで区切ります。要素が 1 個のタプルも末尾にカンマを付けて作ります。

>>> one_marx = 'Groucho',
>>> one_marx
('Groucho',)
要素が 1 個のタプルの作成

要素が複数ある場合は、すべての要素の後ろにカンマを付けます。ただし、最後の要素の後ろのカンマは省略できます。

>>> marx_tuple = 'Groucho', 'Chico', 'Harpo'
>>> marx_tuple
('Groucho', 'Chico', 'Harpo')
要素が複数のタプルの作成

タプルを表示すると () が追加されますが、定義するときに () が必ずしも必要になるわけではありません。タプルを定義するために必要になるのは、値を区切る , です。しかし、() を使ってもエラーにはなりません。値全体を () で囲むと可読性が向上し、タプルだとわかりやすくなります。

>>> marx_tuple = ('Groucho', 'Chico', 'Harpo')
>>> marx_tuple
('Groucho', 'Chico', 'Harpo')
わかりやすいタプルの定義

タプルを使うと、一度に複数の変数を代入することができます。

>>> marx_tuple = ('Groucho', 'Chico', 'Harpo')
>>> a, b, c = marx_tuple
>>> a
'Groucho'
>>> b
'Chico'
>>> c
'Harpo'
タプルを使った変数の代入

tuple() 関数を使うと他の型からタプルを作ることができます。

>>> marx_list = ['Groucho', 'Chico', 'Harpo']
>>> tuple(marx_list)
('Groucho', 'Chico', 'Harpo')
tuple() 関数を使ったタプルの作成

辞書

辞書は、リストに似ていますが要素の順序が管理されていないため、要素を選択するときにはオフセットを使わず、個々の値に一意なキーを使います。他の言語では、辞書は連想配列、ハッシュ、ハッシュマップなどと呼ばれています。

辞書を作るには、key : value のペアを , で区切って並べ、{} で囲みます。もっとも単純な辞書は、キー/値ペアを持たない空辞書です。

>>> empty_dict = {}
>>> empty_dict
{}
空辞書の作成

key : value のペアは、以下のように書くことができます。対話型インタープリタで辞書の名前を入力すると、その中のキーと値がすべて表示されます。キーを指定すると、対応する値が取得できます。辞書に存在しないキーを指定すると KeyError が発生します。

>>> dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
>>> dict
{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

>>> dict['key1']
value1
辞書の作成と取得

dict() 関数を使うと、ふたつの値のシーケンスを辞書に変換できます。ただし、辞書内のキーの順序は決まっておらず、要素を追加したときの順序とは異なる場合があるため注意が必要です。

>>> lol = [ ['a', 'b'], ['c', 'd'], ['e', 'f'] ]
>>> dict(lol)
{'c': 'd', 'a': 'b', 'e': 'f'}
dict() 関数を使った変換

dict() 関数の変換は、2 要素のシーケンスを含むものなら何でも変換できます。

# 2 要素のタプルのリスト
>>> lot = [ ('a', 'b'), ('c', 'd'), ('e', 'f') ]
>>> dict(lot)
{'c': 'd', 'a': 'b', 'e': 'f'}

# 2 要素のリストのタプル
>>> tol = ( ['a', 'b'], ['c', 'd'], ['e', 'f'] )
>>> dict(tol)
{'c': 'd', 'a': 'b', 'e': 'f'}

# 2 字の文字列のリスト
>>> los = [ 'ab', 'cd', 'ef' ]
>>> dict(los)
{'c': 'd', 'a': 'b', 'e': 'f'}

# 2 文字の文字列のタプル
>>> tos = ( 'ab', 'cd', 'ef' )
>>> dict(tos)
{'c': 'd', 'a': 'b', 'e': 'f'}
dict() 関数を使った変換

要素の追加と変更

辞書に要素を追加するには、キーを使って要素を参照し、値を代入します。辞書にそのキーが既にある場合には、既存の値が新しい値に上書きされます。キーがまだ存在しない場合には、キーと値のペアが追加されます。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

dict['key4'] = 'value4'
print(dict)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}
value1
辞書に要素を追加

辞書のキーは一意でなければなりません。既に存在しているキーを指定すると、既存の値が新しい値に上書きされます。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

dict['key1'] = 'value10'
print(dict)
# {'key1': 'value10', 'key2': 'value2', 'key3': 'value3'}
辞書の要素を変更

キーを複数回使って定義した場合、最後に定義した値が辞書に残ります。下記は、key1 というキーにまず value1 という値を代入し、そこから value2value3 という順番で値を置き換えています。

dict = {
    'key1': 'value1', 
    'key1': 'value2', 
    'key1': 'value3'
    }
print(dict)
# {'key1': 'value3'}
辞書のキーが複数回定義された場合の動作

辞書を結合する: update()

update() 関数を使えば、辞書のキーと値を別の辞書にコピーすることができます。

dict1 = {
    'key1': 'value1', 
    'key2': 'value2'
    }
print(dict1)
# {'key1': 'value1', 'key2': 'value2'}

dict2 = {
    'key3': 'value3', 
    'key4': 'value4'
    }
print(dict2)
# {'key3': 'value3', 'key4': 'value4'}

dict1.update(dict2)
print(dict1)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}
辞書の結合

] 1つ目の辞書と2つ目の辞書に同じキーが含まれている場合、2つ目の辞書の値が残ります。

dict1 = {
    'key1': 'value1', 
    'key2': 'value2'
    }
print(dict1)
# {'key1': 'value1', 'key2': 'value2'}

dict2 = {
    'key1': 'value10', 
    'key2': 'value20'
    }
print(dict2)
# {'key1': 'value10', 'key2': 'value20'}

dict1.update(dict2)
print(dict1)
# {'key1': 'value10', 'key2': 'value20'}
辞書の結合

要素を削除する: del, clear()

要素を削除するためには del を使用します。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

del dict['key1']
print(dict)
# {'key2': 'value2', 'key3': 'value3'}
辞書の要素を削除

すべての要素を削除するためには clear() 関数を使用します。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict)
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

dict.clear()
print(dict)
# {}
辞書の要素をすべて削除

要素を取得する

辞書にあるキーが含まれているか知りたい場合には in を使います。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print('key1' in dict)
# True
print('key4' in dict)
# False
辞書にキーが存在するかテストする

辞書から要素を取得するための一般的な方法はキーを指定して、対応する値を取り出します。もしも辞書に存在しないキーを指定した場合、KeyError が発生します。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict['key1'])
# value1
キーを指定して対応する値を取り出す

KeyError を避けるための方法はふたつあります。ひとつは、事前に in を使ってキーが存在することを確認する方法です。もうひとつは、辞書専用の get() 関数を使う方法です。get() 関数では、キーとオプションを指定することができ、キーがなければ指定したオプションが返されます。オプションを指定しない場合、None が返されます。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict.get('key1', 'not exist in dict'))
# value1
    
print(dict.get('key4', 'not exist in dict'))
# not exist in dict
get() 関数を使用して要素を取り出す

keys() 関数を使えば、辞書のすべてのキーを取得できます。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict.keys())
# dict_keys(['key1', 'key2', 'key3'])
keys() 関数を使用してすべてのキーを取得する

values() 関数を使えば、辞書のすべての値を取得できます。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict.values())
# dict_values(['value1', 'value2', 'value3'])
values() 関数を使用してすべての値を取得する

辞書からすべてのキー/値のペアを取り出したい場合は、items() を使います。

dict = {
    'key1': 'value1', 
    'key2': 'value2', 
    'key3': 'value3'
    }
print(dict.items())
# dict_items([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])
items() 関数を使用してすべてのキー/値ペアを取得する

集合

集合は、キーだけの辞書のようなものです。辞書の場合と同様に、個々のキーは一意でなければなりません。集合は、和集合、交叉、差集合、対称差などの集合演算を行うことができます

集合の作成と変換

集合を作るには、set() 関数を使うか、1 個以上のカンマ区切りの値を {} で囲みます。辞書のキーと同様に、集合の要素には順序はありません。

empty_set = set()
print(empty_set)
# set()

even_numbers = {0, 2, 4, 6, 8}
print(even_numbers)
# {0, 8, 2, 4, 6}

odd_numbers = {1, 3, 5, 7, 9}
print(odd_numbers)
# {9, 3, 1, 5, 7}
集合の作成

リスト、文字列、タプル、辞書から重複する値を取り除けば集合を作ることができます。一部の文字が複数回登場する文字列、例えば 'letters' には 'e''t' がふたつずつ含まれていますが、集合にはひとつずつしか含まれていないことがわかります。

print(set('letters'))
# {'l', 'e', 't', 'r', 's'}
集合の作成

リストから集合を作る場合は以下のとおりになります。

print(set( ['Dasher', 'Dancer', 'Prancer', 'Mason-Dixon'] ))
# {'Dancer', 'Dasher', 'Prancer', 'Mason-Dixon'}
集合の作成

タプルから集合を作る場合は以下のとおりになります。

print(set( ('Ummagumma', 'Echoes', 'Atom Heart Mother') ))
# {'Ummagumma', 'Atom Heart Mother', 'Echoes'}
集合の作成

set() 関数に辞書を渡すと、キーだけが使われます。

print(set( {'apple': 'red', 'orange': 'orange', 'cherry': 'red'} ))
# {'apple', 'cherry', 'orange'}
集合の作成

集合の要素数は組み込み関数 len() 関数で取得できます。

s = set('letters')
print(len(s))
# 5
集合の要素数

集合の追加と削除

集合に要素を追加するには、add() 関数を使います。

s = {0, 1, 2}
s.add(3)

print(s)
# {0, 1, 2, 3}
集合に要素を追加する

集合から要素を削除するには、discard(), remove(), pop(), clear() 関数を使います。

discard() 関数は引数に指定した要素を削除します。集合に存在しない値を指定した場合は何もしません。

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s.discard(10)
print(s)
# {0, 2}
集合から要素を削除する

remove() 関数も引数に指定した要素を削除しますが、集合に存在しない値を指定すると KeyError が発生します。

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

s.discard(10)
# KeyError: 10
集合から要素を削除する

pop() 関数は集合から要素を削除し、その値を返します。どの値を削除するかは選択できません。空集合だと KeyError が発生します。

s = {2, 1, 0}

print(s.pop())
# 0
print(s.pop())
# 1
print(s.pop())
# 2
print(s.pop())
# KeyError: 'pop from an empty set'
集合から要素を削除する

clear() 関数はすべての要素を削除し、空集合とします。

s = {0, 1, 2}

s.clear()
print(s)
# set()
集合から要素を削除する

和集合

和集合 (合併、ユニオン) は | 演算子、または union()関数で取得できます。

s1 = {0, 1, 2}
s2 = {1, 2, 3}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}
和集合

union()関数には複数の引数を指定することもできます。

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}
和集合

また、引数には set()で 変換できるリストやタプルなども指定できます。

s1 = {0, 1, 2}
s2 = {1, 2, 3}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}
和集合

差集合

積集合 (共通部分、交差、インターセクション)は、&演算子、または intersection() メソッドで取得できます。

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}
差集合

積集合

差集合は - 演算子、または difference() 関数で取得できます。

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}
積集合

対称差集合

対称差集合は ^ 演算子、または symmetric_difference() で取得できます。対称差集合は、論理演算における排他的論理和 (XOR) に相当します。

s1 = {0, 1, 2}
s2 = {1, 2, 3}

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}
対称差集合

部分集合か判定する: issubset()

ある集合が別の集合の部分集合かを判定するには、<= 演算子、または issubset() 関数を使います。

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True
部分集合か判定する

<= 演算子も issubset() 関数も、等価な集合に対して True を返します。

s1 = {0, 1}

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False
部分集合か判定する

上位集合か判定する: issuperset()

ある集合が別の集合の上位集合かを判定するには、>=演算子、または issuperset() を使います。

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True
上位集合か判定する

>= 演算子も issuperset() 関数も、等価な集合に対して True を返す。真上位集合であるかを判定するには、等価な集合に対して False を返す > 演算子を使う。

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False
上位集合か判定する

互いに素か判定する: isdisjoint()

二つの集合が互いに素かを判定するには、isdisjoint() 関数を使います。

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True
上位集合か判定する

if 文

if 文の基本構造は以下の通りです。条件式や else の末尾には : を付ける必要があります。また、Python の else ifelif と略称のように表記し、複数定義しても問題ありません。条件式が1つだけの場合、elifelse のブロックは省略することができます。

if 条件式 1:
    条件式 1 が True のときに行う処理
elif 条件式 2:
    条件式 1 が False で、条件式 2 が True のときに行う処理
...
else:
    すべての条件式が False のときに行う処理
if 文の基本構造

比較演算子による条件指定

比較演算子による条件指定は、結果が True、または False を返す演算で条件を指定します。Python の比較演算子は以下のとおりです。

x < y
xy より小さければ True
x <= y
xy 以下であれば True
x > y
xy より大きければ True
x >= y
xy 以上であれば True
x == y
xy の値が等しければ True
x != y
xy の値が等しくなければ True
x is y
xy が同じオブジェクトであれば True
x is not y
xy が異なるオブジェクトであれば True
x in y
xy に含まれていれば True
x not in y
xy に含まれていなければ True

以下は比較演算子による条件指定を行った if 文のサンプルコードです。

if num > 100:
    print('100 < num')
elif num > 50:
    print('50 < num <= 100')
elif num > 0:
    print('0 < num <= 50')
elif num == 0:
    print('num == 0')
else:
    print('num < 0')
比較演算子による条件指定を行った if 文のサンプルコード

Python では、他の言語とは異なり比較演算子を連結して記述することもできます。

if 50 < num < 100:
    print('50 < num < 100')
else:
    print('num <= 50 or num >= 100')
比較演算子を連結した if 文のサンプルコード

リストや文字列に特定の要素が含まれているかを条件にする場合は in、または not in を使用します。

s = 'pineapple'

if 'apple' in s:
    print('apple が含まれています')
else:
    print('apple が含まれていません')
比較演算子 in を使用したサンプルコード

論理演算子による条件指定

論理演算子による条件指定によって、複数の条件の論理積 (and)、論理和 (or)、否定 (not) を扱うことができます。

x and y
x かつ yTrue であれば True
x or y
x または yTrue であれば True
not x
xTrue であれば FalsexFalse であれば True

以下は論理演算子による条件指定を行った if 文のサンプルコードです。

if 50 < num and num < 100:
    print('50 < num < 100')
else:
    print('num <= 50 or num >= 100')
論理演算子による条件指定を行った if 文のサンプルコード

bool 型ではない条件指定

if 文の条件式には、bool 型 (True, False) ではない数値やリストなどのオブジェクトを指定することもできます。

if 10:
    print('True')
# True

if [0, 1, 2]:
    print('True')
# True
bool 型ではない条件指定を行った if 文のサンプルコード

Python の if 文の条件式において、False とみなされるのは以下のオブジェクトです。以下のオブジェクト以外は、すべて True とみなされます。

  • bool 型の False
  • None
  • 数値 (int 型や float 型) の 0, 0.0
  • 空の文字列 ('')
  • 空のコンテナ(リスト、タプル、辞書など) ([], (), {})

上記の仕様を利用すると、コンテナが空であるか調べるコードがシンプルに記述できます。

if list:
    print('list is not empty')
else:
    print('list is empty')
bool 型ではない条件指定を行った if 文でコンテナが空かどうかを調べるサンプルコード

for 文

Python の for 文は、以下のように記述します。

for 変数名 in イテラブルオブジェクト:
    処理
for 文の構文

イテラブルオブジェクトとは、イテレータ (リストやタプルなどから要素をひとつずつ取り出して返すもの) に対応しているオブジェクトのことです。イテラブルオブジェクトから取り出された要素は、任意の変数名に代入されて処理が行われます。これらの処理は、イテラブルオブジェクトの要素がなくなるまで繰り返されます。

rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']

for rabbit in rabbits:
    print(rabbit)
# Flopsy
# Mopsy
# Cottontail
# Peter
for 文のサンプル

繰り返し処理を途中で抜ける: break

for 文の途中で繰り返し処理を抜ける場合は、break を使います。

rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']

for rabbit in rabbits:
    if rabbit == 'Mopsy':
        print('BREAK!')
        break
    print(rabbit)
# Flopsy
# BREAK!
for 文のサンプル

繰り返し処理を途中でスキップする: continue

for 文の途中で特定の要素に対する処理をスキップしたい場合は、continue を使います。breakfor ループ全体が終了しますが、continue はその要素に対する continue 文以降の処理がスキップされ、繰り返し処理は継続されます。

rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']

for rabbit in rabbits:
    if rabbit == 'Mopsy':
        print('SKIP!')
        continue
    print(rabbit)
# Flopsy
# SKIP!
# Cottontail
# Peter
for 文のサンプル

ループ正常終了後の処理: else

for 文による繰り返し処理が正常終了後に何らかの処理を行いたい場合は、else を使います。

rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']

for rabbit in rabbits:
    print(rabbit)
else:
    print('FINISH!')
# Flopsy
# Mopsy
# Cottontail
# Peter
# FINISH!
for 文のサンプル

break によって途中で繰り返し処理が終了した場合、else の処理は実行されません。

rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']

for rabbit in rabbits:
    if rabbit == 'Mopsy':
        print('BREAK!')
        break
    print(rabbit)
else:
    print('FINISH!')
# Flopsy
# BREAK!
for 文のサンプル

continue の場合は、繰り返し処理が最後の要素まで到達するため、else の処理は実行されます。

rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']

for rabbit in rabbits:
    if rabbit == 'Mopsy':
        print('SKIP!')
        continue
    print(rabbit)
else:
    print('FINISH!')
# Flopsy
# SKIP!
# Cottontail
# Peter
# FINISH!
for 文のサンプル

数値シーケンスの生成: range()関数

range() 関数は、指定した範囲の数値のストリームを返すことができます。range() はイテラブルなオブジェクトを返すので、戻り値は for in で繰り返し処理するか、リストなどのシーケンスに変換する必要があります。range() 関数の構文は以下のとおりです。

range(start, stop[, step])
range 関数の構文
start
引数 start の値 (この引数が省略された場合は 0)
stop
引数 stop の値
step
引数 step の値 (この引数が省略された場合は 1)

必須の引数は end のみで、最後の値は end の直前の値になります。

for x in range(3):
    print(x)
# 0
# 1
# 2

for x in range(0,3):
    print(x)
# 0
# 1
# 2

print(list(range(0, 3)))
# [0, 1, 2]
range 関数を使った繰り返し処理

step のデフォルト値は 1 ですが、-1 を指定することで逆順にすることができます。逆順で 2 から 0 までの範囲は、以下のように記述できます。

for x in range(2, -1, -1):
    print(x)
# 2
# 1
# 0
range 関数を使った繰り返し処理

step サイズを 2 にすることで偶数の値を取得することも可能です。

for x in range(0, 11, 2):
    print(x)
# 0
# 2
# 4
# 6
# 8
# 10
range 関数を使った繰り返し処理

リストの要素とインデックスを取得する: enumerate()関数

イテラブルオブジェクトの要素とインデックスを同時に取得したい場合は、enumerate() 関数を使います。enumerate() 関数の構文は以下のとおりです。

enumerate(iterable, start=0)
enumerate 関数を使った繰り返し処理
iterable
イテラブルオブジェクト
start
開始値 (この引数が省略された場合は 0)
rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']

for i, rabbit in enumerate(rabbits):
    print(i, rabbit)
# 0 Flopsy
# 1 Mopsy
# 2 Cottontail
# 3 Peter

for i, rabbit in enumerate(rabbits, 10):
    print(i, rabbit)
# 10 Flopsy
# 11 Mopsy
# 12 Cottontail
# 13 Peter
enumerate 関数を使った繰り返し処理

複数リストの要素(複数変数): zip()関数

複数のイテラブルオブジェクトの要素をまとめて取得したい場合は、zip() 関数を使います。

nums = ['10', '20', '30', '40']
rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']

for num, rabbit in zip(nums, rabbits):
    print(num, rabbit)
# 10 Flopsy
# 20 Mopsy
# 30 Cottontail
# 40 Peter
zip 関数を使った繰り返し処理

zip() 関数は、イテラブルオブジェクトをいくつでもまとめることができます。

days = ['Monday', 'Tuesday', 'Wednesday']
fruits = ['banana', 'orange', 'peach']
drinks = ['coffee', 'tea', 'beer']
desserts = ['tiramisu', 'ice cream', 'pie', 'pudding']

for day, fruit, drink, dessert in zip(days, fruits, drinks, desserts):
    print(day, ": drink", drink, ", eat", fruit, ", enjoy", dessert)
# Monday : drink coffee , eat banana , enjoy tiramisu
# Tuesday : drink tea , eat orange , enjoy ice cream
# Wednesday : drink beer , eat peach , enjoy pie
zip 関数を使った繰り返し処理

ただし、zip() 関数はもっとも小さいシーケンスの要素に合わせて止まります。上記の例では desserts のリストが他のリストよりも長くなっています。そのため他のリストを長くしない限り、プリン (pudding) を取得することはできません。

逆順で繰り返し処理を行う: reversed()関数

イテラブルオブジェクトの要素を逆順で取得したい場合は、reversed() 関数を使います。

rabbits = ['Flopsy', 'Mopsy', 'Cottontail', 'Peter']

for rabbit in reversed(rabbits):
    print(rabbit)
# Peter
# Cottontail
# Mopsy
# Flopsy
reversed 関数を使った繰り返し処理

多重の繰り返し処理を行う: itertools.product()関数

一般的な多重の繰り返し処理は以下のように記述します。

list1 = ['a', 'b']
list2 = [1, 2]

for i in list1:
    for j in list2:
        print(i, j)
# a 1
# a 2
# b 1
# b 2
多重の繰り返し処理

Python では標準ライブラリ itertools モジュールの itertools.product() 関数を使うことで for 文をネストせずに上記と同様の結果を得られます。

import itertools
list1 = ['a', 'b']
list2 = [1, 2]

for i, j in itertools.product(list1, list2):
    print(i, j)
# a 1
# a 2
# b 1
# b 2
多重の繰り返し処理

辞書型オブジェクトの繰り返し処理: for in

辞書型オブジェクトを for in で繰り返し処理を行うと、辞書のキーが取得できます。

dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

for key in dict:
    print(key)
# key1
# key2
# key3
辞書型オブジェクトの繰り返し処理

キーに対応する値を取得したい場合は、以下のとおり記述します。

dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

for value in dict.values():
    print(value)
# value1
# value2
# value3
辞書型オブジェクトの繰り返し処理

キーと値を両方取得したい場合は、以下のとおり記述します。

dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

for key, value in dict.items():
    print(key, value)
# key1 value1
# key2 value2
# key3 value3
辞書型オブジェクトの繰り返し処理
Category:
プログラミング
公開日:
更新日:
Pageviews:
509
Shares:
4
Tag:
Python
hatebu icon
hatebu