Pythonの算術演算子(四則演算、べき乗、リスト・文字列の結合など)

Modified: | Tags: Python

Pythonの算術演算子について説明する。

整数intや浮動小数点数floatなどの数値に対しては四則演算(足し算・引き算・掛け算・割り算)やべき乗、リストや文字列に対しては結合や繰り返しなどの処理を行うことができる。

アスタリスク*, **は関数の定義時や呼び出し時に引数につける使い方もある。

数値の演算(四則演算、べき乗)

足し算(加算): +演算子

+演算子は足し算(加算)。

print(10 + 3)
# 13

引き算(減算): -演算子

-演算子は引き算(減算)。

print(10 - 3)
# 7

掛け算(乗算): *演算子

*演算子は掛け算(乗算)。

print(10 * 3)
# 30

割り算(除算): /演算子

/演算子は割り算(除算)。

print(10 / 3)
# 3.3333333333333335

print(0.1 / 0.03)
# 3.3333333333333335

整数同士の割り算は、Python2までは整数intが返されていたが、Python3からは浮動小数点数floatが返されるようになった。

割り算の整数部(整数除算): //演算子

//演算子は割り算の整数部(整数除算)。

print(10 // 3)
# 3

print(0.1 // 0.03)
# 3.0

浮動小数点数floatを含む場合は答えが整数でもfloatが返される。

割り算の剰余(余り, mod): %演算子

%演算子は割り算の剰余(あまり, mod)。

print(10 % 3)
# 1

print(0.1 % 0.03)
# 0.010000000000000009

上の例のように浮動小数点数floatは誤差を含む場合がある。詳細は以下の記事を参照。

割り算の整数部と剰余をまとめて返すdivmod()という関数もある。

べき乗: **演算子

**演算子はべき乗。

小数や負の値のべき乗も計算できる。00乗は1と定義されている。

print(10**3)
# 1000

print(2**0.5)
# 1.4142135623730951

print(10**-2)
# 0.01

print(0**0)
# 1

ZeroDivisionError

0での割り算はエラーZeroDivisionErrorとなる。

# print(10 / 0)
# ZeroDivisionError: division by zero

# print(10 // 0)
# ZeroDivisionError: integer division or modulo by zero

# print(10 % 0)
# ZeroDivisionError: integer modulo by zero

# print(0**-1)
# ZeroDivisionError: 0.0 cannot be raised to a negative power

例外処理については以下の記事を参照。

累算代入演算子

これまで紹介した+-などの演算子は新たなオブジェクトを返す。なお、ここでは変数の値の出力にf文字列を使っている。

a = 10
b = 3
c = a + b

print(f'{a = }')
print(f'{b = }')
print(f'{c = }')
# a = 10
# b = 3
# c = 13

+=のように=と組み合わせた演算子は累算代入演算子と呼ばれ、左辺のオブジェクトに処理結果が代入、更新される。

a = 10
b = 3
a += b

print(f'{a = }')
print(f'{b = }')
# a = 13
# b = 3

-=, *=, /=だけでなく、剰余やべき乗の累算代入演算子%=, **=もある。

a = 10
b = 3
a %= b

print(f'{a = }')
print(f'{b = }')
# a = 1
# b = 3

a = 10
b = 3
a **= b

print(f'{a = }')
print(f'{b = }')
# a = 1000
# b = 3

整数intと浮動小数点数floatの演算

+演算子、-演算子、*演算子の計算に浮動小数点数floatが含まれていると、結果は整数値でもfloatとなる。

print(2 + 3.0)
print(type(2 + 3.0))
# 5.0
# <class 'float'>

/演算子は、整数int同士の計算で結果が整数値でもfloatとなる(Python3の場合)。

print(10 / 2)
print(type(10 / 2))
# 5.0
# <class 'float'>

べき乗**演算子は、int同士の計算はintとなるが、小数・負の値のべき乗は結果が整数値でもfloatとなる。

print(2**3)
print(type(2**3))
# 8
# <class 'int'>

print(2.0**3)
print(type(2.0**3))
# 8.0
# <class 'float'>

print(25**0.5)
print(type(25**0.5))
# 5.0
# <class 'float'>

print(0.01**-2)
print(type(0.01**-2))
# 10000.0
# <class 'float'>

演算子の優先順位(計算順序)

演算子の優先順位(計算順序)は、算数・数学と同じだと考えて問題ない。

以下の二つの式は等価。

print(100 / 10**2 + 2 * 3 - 5)
# 2.0

print(100 / (10**2) + (2 * 3) - 5)
# 2.0

括弧()で囲むとその部分が先に計算される。これも算数・数学の考え方と同様。

print((100 / 10) ** 2 + 2 * (3 - 5))
# 96.0

リスト、タプル、文字列の演算(連結、繰り返し)

算術演算子には数値以外の型のオブジェクトに対しても特定の処理を行うものがある。

連結: +演算子

+演算子は、リストやタプル、文字列などに対して連結の処理を行う。

l1 = [1, 2, 3]
l2 = [10, 20, 30]

t1 = (1, 2, 3)
t2 = (10, 20, 30)

s1 = 'abc'
s2 = 'xyz'

print(l1 + l2)
# [1, 2, 3, 10, 20, 30]

print(t1 + t2)
# (1, 2, 3, 10, 20, 30)

print(s1 + s2)
# abcxyz

他の型との+演算はエラーTypeErrorとなる。型を揃えれば問題ないので、例えば、リストに値を追加したい場合は要素が一つのリストとして連結すればよい。

# print(l1 + 4)
# TypeError: can only concatenate list (not "int") to list

print(l1 + [4])
# [1, 2, 3, 4]

要素が一つのタプルは最後にカンマ,が必要なので注意。

# print(t1 + 4)
# TypeError: can only concatenate tuple (not "int") to tuple

print(t1 + (4,))
# (1, 2, 3, 4)

累算代入演算子+=も使える。

l1 += l2
print(l1)
# [1, 2, 3, 10, 20, 30]

t1 += t2
print(t1)
# (1, 2, 3, 10, 20, 30)

s1 += s2
print(s1)
# abcxyz

リストやタプル、文字列の連結には+演算子以外の方法もある。詳細は以下の記事を参照。

繰り返し: *演算子

*演算子は、リストやタプル、文字列などに対しては繰り返しの処理を行う。

l = [1, 10, 100]
t = (1, 10, 100)
s = 'Abc'

print(l * 3)
# [1, 10, 100, 1, 10, 100, 1, 10, 100]

print(t * 3)
# (1, 10, 100, 1, 10, 100, 1, 10, 100)

print(s * 3)
# AbcAbcAbc

整数値が先でも同じ結果を返す。

print(3 * l)
# [1, 10, 100, 1, 10, 100, 1, 10, 100]

整数int以外の型のオブジェクトに対してはエラーTypeErrorとなり、負の整数に対しては空のリスト、タプル、文字列を返す。

# print(l * 0.5)
# TypeError: can't multiply sequence by non-int of type 'float'

print(l * -1)
# []

累算代入演算子*=も使える。

l *= 3
print(l)
# [1, 10, 100, 1, 10, 100, 1, 10, 100]

t *= 3
print(t)
# (1, 10, 100, 1, 10, 100, 1, 10, 100)

s *= 3
print(s)
# AbcAbcAbc

*演算子のほうが+演算子より優先順位が高いので、*の演算が先に処理される。もちろん、括弧()で処理順を制御することも可能。

l1 = [1, 2, 3]
l2 = [10, 20, 30]
print(l1 + l2 * 2)
# [1, 2, 3, 10, 20, 30, 10, 20, 30]

print((l1 + l2) * 2)
# [1, 2, 3, 10, 20, 30, 1, 2, 3, 10, 20, 30]

関連カテゴリー

関連記事