Python 강좌 : 제 4강 - 기초 연산 (1)

기초 연산

연산(Operation)은 값을 계산하여 새로운 값을 만드는 것이며, +, -처럼 연산을 나타내는 기호를 연산자(Operator), 연산의 대상이 되는 값을 피연산자(Operand)라 합니다. 3 + 4에서 +는 연산자이고, 3과 4는 피연산자입니다.

이번 강좌에서는 변수에 값을 저장하는 대입 연산, 수학 계산을 하는 사칙 연산, 그리고 Python의 세 가지 수치 자료형인 정수(int), 실수(float), 복소수(complex)가 컴퓨터 안에서 어떻게 표현되는지를 다룹니다. 특히 실수는 컴퓨터가 저장하는 방식 때문에 수학과 다른 결과가 나오는 경우가 있으므로, 그 이유를 이해하는 것이 중요합니다.

대입 연산

대입(Assignment)은 값에 이름을 붙여 나중에 다시 사용할 수 있게 하는 연산입니다. 수학의 =는 양쪽이 같다는 의미이지만, Python의 =는 오른쪽의 값을 계산하여 왼쪽의 이름에 연결하라는 명령입니다.

A = B = C = 3
a, b = 1, 2
C += 1

print(A, B, C, a, b)

결과

3 3 4 1 2

Python에서는 문장 끝에 세미콜론(;)을 입력하지 않아도 연산이 가능합니다. 또한 변수 이름은 대소문자를 구별합니다.

A = B = C = 3처럼 여러 변수에 같은 값을 한 번에 대입할 수 있으며, a, b = 1, 2처럼 여러 변수에 각각의 값을 대입할 수 있습니다.

C += 1은 C = C + 1과 같은 의미이며, -=, *=, /=, //=, %=, **= 등도 사용할 수 있습니다.

print()를 이용하여 출력할 수 있습니다. 쉼표(,)로 변수를 구별하며, 출력 시 공백으로 구분됩니다.

결과를 순서대로 읽어 보면, A, B, C는 모두 3을 가리키다가 C += 1로 C만 4를 가리키게 됩니다. 대소문자를 구별하므로 대문자 A와 소문자 a는 서로 다른 변수이며, a와 b에는 각각 1과 2가 저장됩니다.

C = C + 1이 수학적으로는 성립하지 않는 식인데도 동작하는 이유는 =가 오른쪽을 먼저 계산하기 때문입니다. 현재 C의 값 3에 1을 더한 4를 계산한 뒤, 그 결과를 다시 C라는 이름에 연결합니다.

• Tip : Python에는 C/C++의 ++, -- 증감 연산자가 없으므로 += 1, -= 1을 사용합니다.

언패킹과 값 교환

a, b = 1, 2
a, b = b, a
print(a, b)

first, *rest = [1, 2, 3, 4]
print(first, rest)

결과

2 1
1 [2, 3, 4]

a, b = 1, 2는 사실 오른쪽의 1, 2가 먼저 튜플 (1, 2)로 만들어진 뒤, 그 원소를 순서대로 왼쪽 변수에 나누어 담는 동작입니다. 이를 언패킹(Unpacking)이라 합니다.

이 원리 덕분에 a, b = b, a로 두 변수의 값을 바꿀 수 있습니다. 오른쪽의 b, a가 먼저 (2, 1)로 계산된 다음 왼쪽에 대입되므로, C/C++처럼 임시 변수를 만들 필요가 없습니다.

first, *rest처럼 변수 앞에 *를 붙이면 나머지 값을 모두 리스트로 받습니다. 그래서 first에는 1, rest에는 [2, 3, 4]가 저장됩니다.

try:
    a, b = 1, 2, 3
except ValueError as err:
    print(err)

결과

too many values to unpack (expected 2, got 3)

언패킹은 왼쪽 변수의 개수와 오른쪽 값의 개수가 정확히 같아야 합니다. 변수는 2개인데 값이 3개이면 ValueError가 발생하며, 오류 메시지가 기대한 개수(expected 2)와 실제 개수(got 3)를 알려줍니다.

같은 객체를 가리키는 대입

A = B = []
A.append(1)
print(A, B, A is B)

X = []
Y = []
X.append(1)
print(X, Y)

결과

[1] [1] True
[1] []

A = B = []는 빈 리스트를 하나만 만들고 A와 B 두 이름을 모두 연결합니다. 그래서 A에 원소를 추가하면 B로 확인해도 같은 리스트가 바뀌어 있습니다.

숫자처럼 변경할 수 없는 값은 같은 객체를 가리켜도 문제가 없지만, 리스트처럼 변경 가능한 값을 각각 따로 사용하려면 X = [], Y = []처럼 따로 만들어 대입해야 합니다. 이 원리는 제 3강의 이름과 객체에서 설명한 것과 같습니다.

복합 대입의 계산 순서

x = 5
x *= 2 + 3
print(x)

결과

25

x *= 2 + 3은 x = x * 2 + 3(결과 13)이 아니라 x = x * (2 + 3)으로 계산되어 25가 됩니다. +=, *= 같은 복합 대입 연산자는 오른쪽 전체를 먼저 계산한 뒤 그 결과로 연산합니다.

사칙 연산

나누기와 정수 나누기의 차이점은 7/3일 경우 결과는 2.3333333333333335가 출력되며 7//3일 경우 결과는 2가 출력됩니다.

곱하기는 × 대신 *, 나누기는 ÷ 대신 /를 사용합니다. 나눗셈은 /, //, % 세 가지로 나뉘는데, 각각 정확한 나눗셈 결과, 몫, 나머지를 구합니다.

print(7 / 3)
print(7 // 3)
print(7 % 3)
print(6 / 3)
print(7.5 // 2)
print(2 ** 10)
print(2 ** -1)

결과

2.3333333333333335
2
1
2.0
3.0
1024
0.5

/는 나누어 떨어지는 경우에도 항상 실수(float)를 반환합니다. 그래서 6 / 3의 결과는 2가 아닌 2.0입니다.

//는 나눈 결과보다 크지 않은 가장 큰 정수인 몫을 반환합니다. 피연산자 중 실수가 있으면 7.5 // 2처럼 결과도 실수(3.0)로 반환됩니다.

**는 거듭제곱이며, 지수가 음수이면 실수를 반환합니다.

결과를 한 줄씩 보면, 7 / 3은 2.333...이 끝없이 이어지는 값이지만 실수는 저장할 수 있는 자릿수가 정해져 있어 마지막 자리가 5로 반올림된 2.3333333333333335가 출력됩니다. 7 // 3은 몫 2, 7 % 3은 나머지 1이며, 항상 7 == 3 * 2 + 1이 성립합니다.

/가 항상 실수를 반환하는 이유는 결과의 자료형이 값에 따라 바뀌지 않도록 하기 위해서입니다. 6 / 3은 2, 7 / 3은 2.333...처럼 나누어 떨어지는지에 따라 자료형이 달라지면 다음 계산에서 예상하지 못한 문제가 생길 수 있으므로, /는 항상 float, //는 정수끼리 계산하면 항상 int를 반환하도록 정해져 있습니다.

2 ** -1은 1 / 2이므로 정수로 표현할 수 없어 0.5가 됩니다.

나머지 연산의 활용

for n in range(5):
    print(n, n % 2 == 0)

seconds = 3725
print(seconds // 3600, seconds % 3600 // 60, seconds % 60)

결과

0 True
1 False
2 True
3 False
4 True
1 2 5

나머지 연산 %는 생각보다 자주 사용됩니다. n % 2 == 0은 n을 2로 나눈 나머지가 0인지, 즉 짝수인지 확인하는 대표적인 방법입니다. 반복문은 이후 강좌에서 다루며, 여기서는 n이 0부터 4까지 바뀌며 실행된다는 것만 확인합니다.

3725초를 시, 분, 초로 바꿀 때도 //와 %를 함께 사용합니다. 3725 // 3600은 1시간이고, 남은 3725 % 3600 = 125초를 // 60하면 2분, 3725 % 60은 남은 5초입니다. 이처럼 //는 큰 단위의 개수, %는 큰 단위로 묶고 남은 양을 구할 때 사용합니다.

0으로 나누기

try:
    print(1 / 0)
except ZeroDivisionError as err:
    print(err)

try:
    print(1 % 0)
except ZeroDivisionError as err:
    print(err)

결과

division by zero
division by zero

/, //, % 모두 나누는 수가 0이면 ZeroDivisionError가 발생합니다. 실수 1.0 / 0도 마찬가지이며, 무한대(inf)가 되지 않습니다. 사용자에게 입력받은 값으로 나누는 경우에는 나누기 전에 0인지 확인해야 합니다.

음수의 나눗셈과 나머지

print(-7 // 3)
print(-7 % 3)
print(7 // -3)
print(7 % -3)

결과

-3
2
-3
-2

Python의 //는 소수점 이하를 버리는 것이 아니라 음의 무한대 방향으로 내림합니다. -7 / 3은 -2.333...이므로, 내림한 -3이 몫이 됩니다.

나머지 %는 항상 x == (x // y) * y + (x % y)를 만족하도록 계산되므로, 나머지의 부호는 나누는 수(y)의 부호를 따릅니다.

-7 % 3은 -7 - (-3 * 3)이므로 2가 되며, 7 % -3은 7 - (-3 * -3)이므로 -2가 됩니다.

수직선으로 생각하면 이해하기 쉽습니다. -2.333...에서 왼쪽(작은 쪽)으로 가장 가까운 정수는 -2가 아니라 -3입니다. 몫이 -3으로 정해지면, 위의 등식을 만족하기 위해 나머지는 -7 - (-9) = 2가 됩니다.

이 방식은 나머지가 항상 0 이상 y 미만(y가 양수일 때)이 되도록 보장하므로, 시계나 요일 계산처럼 값이 일정한 범위 안에서 순환하는 계산에 편리합니다. 예를 들어 오늘이 0번 요일일 때 3일 전의 요일은 (0 - 3) % 7로 계산하면 4가 되어 음수가 나오지 않습니다.

• Tip : C/C++, Java의 정수 나눗셈은 0 방향으로 버림하므로 -7 / 3의 결과가 -2, 나머지가 -1입니다. Python과 결과가 다르므로 주의합니다.

연산자 우선순위

print(-2 ** 2)
print((-2) ** 2)
print(1 + 2 * 3)
print((1 + 2) * 3)

결과

-4
4
7
9

연산자 우선순위는 ** → -x(부호) → *, /, //, % → +, - 순서입니다.

**는 부호 변경보다 우선순위가 높으므로 -2 ** 2는 -(2 ** 2)인 -4가 됩니다. 의도한 순서가 있다면 괄호(())를 사용합니다.

수학의 -2²이 -4인 것과 같은 규칙입니다. -2를 제곱하려면 (-2) ** 2처럼 괄호로 묶어야 4가 됩니다. 곱셈이 덧셈보다 먼저 계산되는 것도 수학과 같습니다.

print(2 ** 3 ** 2)
print((2 ** 3) ** 2)
print(10 - 4 - 3)
print(2 * 3 // 4, 2 * (3 // 4))

결과

512
64
3
1 0

우선순위가 같은 연산자가 이어지면 대부분 왼쪽부터 계산합니다. 10 - 4 - 3은 (10 - 4) - 3이므로 3이고, 2 * 3 // 4는 (2 * 3) // 4이므로 6 // 4 = 1입니다. 괄호로 3 // 4를 먼저 계산하면 0이 되어 결과가 달라집니다.

단, **는 예외적으로 오른쪽부터 계산합니다. 2 ** 3 ** 2는 2 ** (3 ** 2) = 2 ** 9 = 512입니다. 수학에서 지수 위의 지수를 위에서부터 계산하는 것과 같습니다. 순서가 헷갈린다면 괄호를 사용하는 것이 가장 안전합니다.

실수 표현

A = float(3)
B = int(3.2)
C = 3.5

print(A, B, C)

결과

3.0 3 3.5

실수 표현은 명시적으로 소수점을 표기하거나 float()을 통해 표현할 수 있습니다.

반대로, 실수여도 int()를 통해 표현할 경우 정수로 표현됩니다. 이때 소수점 이하는 반올림되지 않고 버려집니다.

int()나 float() 등을 통해 데이터 형식을 변경할 수 있습니다.

float(3)은 정수 3으로 새로운 실수 객체 3.0을 만들고, int(3.2)는 실수 3.2로 새로운 정수 객체 3을 만듭니다. 원래 값이 바뀌는 것이 아니라 새 자료형의 값을 만들어 반환하는 것입니다. 이와 같이 자료형을 바꾸는 것을 형변환(Type Conversion)이라 합니다.

print(int(-3.7))
print(int("42"))
print(float("3.14"))
print(2 ** 100)
print(1_000_000)

결과

-3
42
3.14
1267650600228229401496703205376
1000000

int()는 0 방향으로 버리므로 int(-3.7)은 -4가 아닌 -3입니다.

int(), float()은 숫자 형태의 문자열도 변환할 수 있습니다.

Python의 정수는 크기 제한이 없어 2 ** 100처럼 매우 큰 정수도 정확하게 계산합니다.

숫자 사이에 밑줄(_)을 넣어 1_000_000처럼 자릿수를 구분할 수 있으며, 값에는 영향을 주지 않습니다. (Python 3.6 이상)

int(-3.7)이 -3인 것은 앞의 //가 -7 // 3을 -3으로 내림한 것과 방향이 다르다는 점에 주의합니다. int()는 0 방향으로 버림, //는 음의 무한대 방향으로 내림입니다. 양수에서는 결과가 같지만 음수에서는 다릅니다.

2 ** 100은 31자리 정수입니다. C/C++의 부호 없는 64비트 정수로도 약 1.8 × 10^19까지만 표현할 수 있지만, Python의 int는 숫자가 커지면 내부 저장 공간을 자동으로 늘려 모든 자릿수를 정확하게 저장합니다. 대신 숫자가 커질수록 계산에 걸리는 시간과 메모리도 늘어납니다.

try:
    int("3.14")
except ValueError as err:
    print(err)

print(int(float("3.14")))
print(int(" 42 "))
print(int("ff", 16))

결과

invalid literal for int() with base 10: ‘3.14’
3
42
255

int()에 소수점이 있는 문자열을 전달하면 ValueError가 발생합니다. int()는 문자열을 정수를 적은 글자로만 해석하기 때문입니다. 이런 경우 int(float("3.14"))처럼 실수로 먼저 변환한 뒤 정수로 변환합니다.

앞뒤의 공백은 무시되므로 " 42 "는 정상적으로 변환됩니다. int("ff", 16)처럼 두 번째 인수로 진법을 지정하면 16진수 문자열 ff를 255로 변환합니다. 진법은 제 6강에서 자세히 다룹니다.

부동소수점 오차

import math
from decimal import Decimal
from fractions import Fraction

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(math.isclose(0.1 + 0.2, 0.3))
print(Decimal("0.1") + Decimal("0.2"))
print(Fraction(1, 10) + Fraction(2, 10))

결과

0.30000000000000004
False
True
0.3
3/10

실수(float)는 컴퓨터 내부에서 2진수로 저장되기 때문에 0.1, 0.2처럼 2진수로 정확하게 나타낼 수 없는 값은 미세한 오차가 발생합니다.

그래서 0.1 + 0.2는 0.30000000000000004가 되며, == 0.3 비교는 False가 됩니다. 이는 Python만의 문제가 아니라 대부분의 언어가 사용하는 IEEE 754 부동소수점의 특성입니다.

실수를 비교할 때는 == 대신 math.isclose()를 사용하여 충분히 가까운지를 비교합니다.

금액 계산처럼 10진수의 정확한 표현이 필요한 경우에는 decimal 모듈의 Decimal을, 분수 계산이 필요한 경우에는 fractions 모듈의 Fraction을 사용합니다.

• Tip : Decimal은 Decimal(0.1)처럼 실수로 생성하면 이미 오차가 포함된 값으로 생성되므로, Decimal("0.1")처럼 문자열로 생성합니다.

실수가 저장되는 방식

10진수에서 1/3을 0.333...처럼 끝없이 써야 하듯이, 2진수에서는 0.1(= 1/10)이 끝없이 반복되는 수가 됩니다. 2진수의 소수 자릿수는 1/2, 1/4, 1/8, …이므로 분모가 2의 거듭제곱인 분수만 정확하게 표현할 수 있고, 분모에 5가 들어 있는 1/10은 정확하게 표현할 수 없습니다.

Python의 float은 IEEE 754 배정밀도 형식으로, 64비트를 다음과 같이 나누어 사용합니다.

• 부호(Sign) 1비트 : 양수인지 음수인지
• 지수(Exponent) 11비트 : 소수점의 위치 (2의 몇 제곱인지)
• 가수(Fraction) 52비트 : 유효 숫자

즉, 실수를 가수 × 2^지수 형태의 2진 과학적 표기법으로 저장하며, 이 때문에 부동소수점(Floating Point, 소수점이 떠다니는)이라는 이름이 붙었습니다. 가수의 비트 수가 정해져 있으므로 10진수로 약 15~17자리의 유효 숫자만 저장할 수 있고, 끝없이 이어지는 2진 소수는 그 자리에서 반올림됩니다.

from decimal import Decimal

print(Decimal(0.1))
print((0.1).as_integer_ratio())
print(0.5 + 0.25 == 0.75)
print(0.1 * 3 == 0.3)

결과

0.1000000000000000055511151231257827021181583404541015625
(3602879701896397, 36028797018963968)
True
False

Decimal(0.1)은 실수 0.1이 실제로 저장하고 있는 값을 10진수로 모두 보여줍니다. 우리가 입력한 0.1은 그와 가장 가까운 2진 실수인 0.1000000000000000055511...로 저장되어 있습니다. print(0.1)이 0.1로 출력되는 것은 Python이 같은 실수로 읽히는 가장 짧은 10진수를 골라 보여주기 때문입니다.

(0.1).as_integer_ratio()는 저장된 값을 정확한 분수로 반환하며, 분모 36028797018963968은 2 ** 55입니다. 분모가 2의 거듭제곱이라는 것을 확인할 수 있습니다.

반면 0.5(= 1/2), 0.25(= 1/4), 0.75(= 3/4)는 분모가 2의 거듭제곱이므로 오차 없이 저장되어 0.5 + 0.25 == 0.75는 True입니다. 모든 실수 계산에 오차가 생기는 것이 아니라, 2진수로 정확히 표현할 수 없는 값에서 오차가 생기는 것입니다.

정수와 실수의 정밀도 차이

print(2 ** 53 + 1)
print(float(2 ** 53 + 1))
print(float(2 ** 53) == float(2 ** 53 + 1))
print(1e16 + 1)

결과

9007199254740993
9007199254740992.0
True
1e+16

정수는 크기 제한 없이 모든 자릿수를 정확하게 저장하지만, 실수는 가수 52비트(숨겨진 1비트를 포함하면 53비트)만큼의 유효 숫자만 저장합니다. 그래서 2 ** 53(약 9 × 10^15)을 넘는 정수를 실수로 바꾸면 1 단위의 차이를 구별하지 못합니다.

2 ** 53 + 1은 정수로는 정확히 9007199254740993이지만, 실수로 바꾸면 끝자리가 사라져 9007199254740992.0이 되고, 2 ** 53과 같은 값으로 판단됩니다. 같은 이유로 1e16 + 1은 더한 1이 사라져 1e+16이 그대로 출력됩니다.

큰 정수를 다룰 때는 / 대신 //를 사용하는 등 실수를 거치지 않도록 주의해야 합니다. /는 결과를 실수로 만들기 때문에 큰 정수의 정확도를 잃을 수 있습니다.

실수의 표현 범위

import sys

print(sys.float_info.max)
print(1e308 * 10)
print(-1e308 * 10)
print(float("inf") - float("inf"))

try:
    print(2.0 ** 10000)
except OverflowError as err:
    print(err)

print(len(str(2 ** 10000)))

결과

1.7976931348623157e+308
inf
-inf
nan
(34, ‘Result too large’)
3011

실수는 지수에 11비트를 사용하므로 약 1.8 × 10^308까지 표현할 수 있으며, sys.float_info.max로 확인할 수 있습니다. 이보다 큰 결과가 나오는 곱셈은 무한대(inf)가 되고, 무한대 - 무한대처럼 값을 정할 수 없는 연산은 nan(Not a Number)이 됩니다.

거듭제곱 **은 범위를 넘으면 inf 대신 OverflowError를 발생시킵니다. 같은 계산을 정수 2 ** 10000으로 하면 3011자리의 정수가 정확하게 계산됩니다. 이처럼 정수는 정확하고 범위가 무한하지만, 실수는 범위와 정밀도가 정해진 근사값이라는 차이를 기억해 두면 계산 결과를 해석하기 쉬워집니다.

복소수 표현

복소수(Complex Number)는 실수부 + 허수부 × i 형태의 수이며, i는 제곱하면 -1이 되는 허수 단위입니다. 전기 회로, 신호 처리, 회전 변환 등 공학 계산에서 자주 사용되며, Python은 복소수를 별도의 모듈 없이 기본 자료형으로 지원합니다.

a = complex(3, 2)
b = a.conjugate()
c = 3 + 2j

print(a)
print(b)
print(c)
print(a.real, a.imag)
print(abs(3 + 4j))

결과

(3+2j)
(3-2j)
(3+2j)
3.0 2.0
5.0

복소수는 j를 포함하면 복소수로 입력됩니다. 허수 부분에 j를 붙여줍니다.

complex(x, y)는 x + yj로 표현됩니다.

공액복소수는 허수의 부호를 변경합니다.

a.conjugate()는 a에 영향을 미치지 않습니다. 즉, a의 값 자체가 바뀌지는 않습니다.

a.real은 실수부, a.imag은 허수부를 실수(float)로 반환하며, abs()는 복소수의 크기(절대값)를 반환합니다.

수학에서는 허수 단위로 i를 사용하지만, Python은 공학 분야의 표기법을 따라 j를 사용합니다. 허수부는 2j처럼 숫자 바로 뒤에 j를 붙여야 하며, j만 단독으로 쓰면 변수 이름으로 해석됩니다. 허수 단위 자체는 1j로 적습니다.

복소수는 내부적으로 실수(float) 두 개로 저장되므로, a.real과 a.imag가 3, 2가 아닌 3.0, 2.0으로 출력됩니다. 실수와 마찬가지로 부동소수점 오차가 생길 수 있습니다.

abs(3 + 4j)는 복소평면에서 원점으로부터 점 (3, 4)까지의 거리인 √(3² + 4²) = 5.0입니다.

print(1j * 1j)
print((3 + 2j) * (3 - 2j))
print(type(1 + 2), type(1 + 2.0), type(1 + 2j))

try:
    print((1 + 2j) < (2 + 3j))
except TypeError as err:
    print(err)

결과

(-1+0j)
(13+0j)
<class ‘int’> <class ‘float’> <class ‘complex’>
‘<’ not supported between instances of ‘complex’ and ‘complex’

1j * 1j는 허수 단위의 정의대로 -1이 되며, 결과가 복소수 자료형이므로 (-1+0j)로 표시됩니다. 복소수와 공액복소수를 곱하면 3² + 2² = 13처럼 허수부가 사라진 실수 값이 됩니다.

서로 다른 수치 자료형을 함께 계산하면 결과는 더 넓은 자료형으로 바뀝니다. 정수는 실수로, 실수는 복소수로 표현할 수 있으므로 int → float → complex 순서로 넓어집니다.

복소수는 크기의 순서를 정할 수 없으므로 <, > 같은 크기 비교를 하면 TypeError가 발생합니다. 같은지 다른지를 확인하는 ==, !=는 사용할 수 있습니다. 크기를 비교하려면 abs()로 절대값을 구해 비교합니다.

정리

정수는 크기 제한 없이 정확하고, 실수는 2진수로 근사한 값이며, 복소수는 실수 두 개의 묶음입니다. 계산 결과가 예상과 다를 때는 어떤 자료형으로 계산되었는지를 먼저 확인하면 원인을 찾기 쉽습니다. 다음 강좌에서는 기본 함수와 비교, 논리 연산을 다룹니다.