note.nkmk.me

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

Date: 2018-04-01 / tags: Python

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

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

  • 数値の演算(四則演算、べき乗)
    • 足し算(加算): +演算子
    • 引き算(減算): -演算子
    • 掛け算(乗算): *演算子
    • 割り算(除算): /演算子
    • 割り算の整数部(整数除算): //演算子
    • 割り算の剰余(余り, mod): %演算子
    • べき乗: **演算子
    • ZeroDivisionError
  • 代入演算子
  • 整数型intと浮動小数点型floatの演算
  • 演算子の優先順位(計算順序)
  • リスト、タプル、文字列の演算(連結、繰り返し)
    • 連結: +演算子
    • 繰り返し: *演算子
スポンサーリンク

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

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

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

print(10 + 3)
# 13

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

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

print(10 - 3)
# 7

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

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

print(10 * 3)
# 30

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

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

print(10 / 3)
# 3.3333333333333335

整数同士の割り算は、Pyrhon2までは整数が返っていたが、Python3からは浮動小数点を返すようになった。

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

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

print(10 // 3)
# 3

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

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

print(10 % 3)
# 1

割り算の整数部と剰余をまとめて返す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: integer division or modulo by zero

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

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

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

代入演算子

これまで紹介した+-などの演算子は新たなオブジェクトを返す。

a = 10
b = 3
c = a + b

print('a:', a)
print('b:', b)
print('c:', c)
# a: 10
# b: 3
# c: 13

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

a = 10
b = 3
a += b

print('a:', a)
print('b:', b)
# a: 13
# b: 3

-=, *=, /=だけでなく、剰余%=やべき乗**=にも代入演算子が用意されている。

a = 10
b = 3
a %= b

print('a:', a)
print('b:', b)
# a: 1
# b: 3

a = 10
b = 3
a **= b

print('a:', a)
print('b:', 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(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

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

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

連結: +演算子

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

a_l = [0, 1, 2]
b_l = [10, 20, 30]

a_t = (0, 1, 2)
b_t = (10, 20, 30)

a_s = 'abc'
b_s = 'xyz'

print(a_l + b_l)
# [0, 1, 2, 10, 20, 30]

print(a_t + b_t)
# (0, 1, 2, 10, 20, 30)

print(a_s + b_s)
# abcxyz

あくまでも、リスト同士やタプル同士、文字列同士の演算なので、他の型とはエラーTypeErrorとなる。

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

# print(a_l + 3)
# TypeError: can only concatenate list (not "int") to list

print(a_l + [3])
# [0, 1, 2, 3]

# print(a_t + (3))
# TypeError: can only concatenate tuple (not "int") to tuple

print(a_t + (3, ))
# (0, 1, 2, 3)

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

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

a_l += b_l
print(a_l)
# [0, 1, 2, 10, 20, 30]

a_t += b_t
print(a_t)
# (0, 1, 2, 10, 20, 30)

a_s += b_s
print(a_s)
# abcxyz

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

繰り返し: *演算子

*演算子は、リストやタプル、文字列に対しては繰り返しの処理を行う。右辺と左辺のどちらが数値でも結果は同じ。

print(b_l * 3)
# [10, 20, 30, 10, 20, 30, 10, 20, 30]

print(3 * b_l)
# [10, 20, 30, 10, 20, 30, 10, 20, 30]

print(b_t * 3)
# (10, 20, 30, 10, 20, 30, 10, 20, 30)

print(3 * b_t)
# (10, 20, 30, 10, 20, 30, 10, 20, 30)

print(b_s * 3)
# xyzxyzxyz

print(3 * b_s)
# xyzxyzxyz

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

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

print(b_l * -1)
# []

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

b_l *= 3
print(b_l)
# [10, 20, 30, 10, 20, 30, 10, 20, 30]

b_t *= 3
print(b_t)
# (10, 20, 30, 10, 20, 30, 10, 20, 30)

b_s *= 3
print(b_s)
# xyzxyzxyz

*演算子のほうが+演算子より優先順位が高いので、*の演算が先に処理される。

a_l = [0, 1, 2]
b_l = [10, 20, 30]

c_l = a_l + b_l * 3
print(c_l)
# [0, 1, 2, 10, 20, 30, 10, 20, 30, 10, 20, 30]
スポンサーリンク
シェア
このエントリーをはてなブックマークに追加

関連カテゴリー

関連記事