KR_Number - somaz94/python-study GitHub Wiki

Python μˆ«μžν˜•(Number) κ°œλ… 정리


1️⃣ μˆ«μžν˜•μ΄λž€?

μˆ«μžν˜•μ€ 숫자 ν˜•νƒœλ‘œ 이루어진 μžλ£Œν˜•μ΄λ‹€. μš°λ¦¬κ°€ ν”νžˆ μ‚¬μš©ν•˜λŠ” 123κ³Ό 같은 μ •μˆ˜, 12.34와 같은 μ‹€μˆ˜, 8μ§„μˆ˜λ‚˜ 16μ§„μˆ˜κ°€ ν¬ν•¨λœλ‹€.

μ’…λ₯˜ Python μ‚¬μš© 예 μ„€λͺ…
μ •μˆ˜ 123, -345, 0 μ–‘μ˜ μ •μˆ˜, 음의 μ •μˆ˜, 0 (크기 μ œν•œ μ—†μŒ)
μ‹€μˆ˜ 123.45, -1234.5, 3.4e10 μ†Œμˆ˜μ μ΄ ν¬ν•¨λœ 숫자
2μ§„μˆ˜ 0b1010, 0b111 0b μ ‘λ‘μ–΄λ‘œ μ‹œμž‘ν•˜λŠ” 2μ§„μˆ˜
8μ§„μˆ˜ 0o34, 0o25 0o μ ‘λ‘μ–΄λ‘œ μ‹œμž‘ν•˜λŠ” 8μ§„μˆ˜
16μ§„μˆ˜ 0x2A, 0xFF 0x μ ‘λ‘μ–΄λ‘œ μ‹œμž‘ν•˜λŠ” 16μ§„μˆ˜
λ³΅μ†Œμˆ˜ 3+4j μ‹€μˆ˜λΆ€μ™€ ν—ˆμˆ˜λΆ€λ‘œ κ΅¬μ„±λœ λ³΅μ†Œμˆ˜
νŠΉμˆ˜κ°’ float('inf'), float('nan') λ¬΄ν•œλŒ€, μˆ«μžκ°€ μ•„λ‹Œ κ°’


2️⃣ μˆ«μžν˜•μ€ μ–΄λ–»κ²Œ λ§Œλ“€κ³  μ‚¬μš©ν• κΉŒ?

μ •μˆ˜ν˜•

μ •μˆ˜ν˜•(integer)은 말 κ·ΈλŒ€λ‘œ μ •μˆ˜λ₯Ό λœ»ν•˜λŠ” μžλ£Œν˜•μ΄λ‹€. Python3μ—μ„œλŠ” μ •μˆ˜μ˜ 크기에 μ œν•œμ΄ μ—†λ‹€.

a = 123      # μ–‘μ˜ μ •μˆ˜
a = -178     # 음의 μ •μˆ˜
a = 0        # 0
a = 999999999999999999  # 큰 μˆ˜λ„ 처리 κ°€λŠ₯

# μ •μˆ˜μ˜ λ©”λͺ¨λ¦¬ μ‚¬μš©λŸ‰ 확인
import sys
print(sys.getsizeof(0))            # 일반적으둜 24 λ°”μ΄νŠΈ
print(sys.getsizeof(999999999999)) # 더 큰 μˆ«μžλŠ” 더 λ§Žμ€ λ©”λͺ¨λ¦¬ μ‚¬μš©

βœ… Tip:

  • Python2μ—μ„œλŠ” int와 long이 κ΅¬λΆ„λ˜μ—ˆμ§€λ§Œ, Python3μ—μ„œλŠ” 톡합됨
  • λ©”λͺ¨λ¦¬κ°€ ν—ˆμš©ν•˜λŠ” ν•œ λ¬΄ν•œλŒ€μ˜ μ •μˆ˜λ₯Ό μ €μž₯ν•  수 있음
  • 큰 μ •μˆ˜μ˜ 경우 ν•„μš”μ— 따라 λ©”λͺ¨λ¦¬κ°€ λ™μ μœΌλ‘œ 할당됨

μ‹€μˆ˜ν˜•

μ‹€μˆ˜ν˜•(floating-point)은 μ†Œμˆ˜μ μ΄ ν¬ν•¨λœ 숫자λ₯Ό λ§ν•œλ‹€.

a = 1.2      # 일반적인 μ‹€μˆ˜
a = -3.45    # 음의 μ‹€μˆ˜
a = 0.0      # 0.0

# 컴퓨터식 μ§€μˆ˜ ν‘œν˜„
a = 4.24E10  # 42400000000.0
a = 4.24e-10 # 0.000000000424

# μ‹€μˆ˜ν˜•μ˜ 였차
print(0.1 + 0.2 == 0.3)  # False
print(round(0.1 + 0.2, 1) == 0.3)  # True

# νŠΉμˆ˜ν•œ μ‹€μˆ˜ κ°’
pos_inf = float('inf')   # μ–‘μ˜ λ¬΄ν•œλŒ€
neg_inf = float('-inf')  # 음의 λ¬΄ν•œλŒ€
not_a_num = float('nan') # NaN (Not a Number)

print(1 < pos_inf)       # True - λͺ¨λ“  μˆ«μžλŠ” λ¬΄ν•œλŒ€λ³΄λ‹€ μž‘λ‹€
print(neg_inf < -999999) # True - 음의 λ¬΄ν•œλŒ€λŠ” λͺ¨λ“  μˆ˜λ³΄λ‹€ μž‘λ‹€
print(not_a_num == not_a_num) # False - NaN은 자기 μžμ‹ κ³Όλ„ κ°™μ§€ μ•Šλ‹€

# NaN 확인
import math
print(math.isnan(not_a_num))  # True
print(math.isinf(pos_inf))    # True

βœ… Tip:

  • μ‹€μˆ˜ν˜•μ€ λΆ€λ™μ†Œμˆ˜μ  방식을 μ‚¬μš©ν•˜λ―€λ‘œ 계산 μ‹œ μ˜€μ°¨κ°€ λ°œμƒν•  수 있음
  • μ •ν™•ν•œ 계산이 ν•„μš”ν•  λ•ŒλŠ” decimal λͺ¨λ“ˆ μ‚¬μš© ꢌμž₯
  • λΆ€λ™μ†Œμˆ˜μ  μˆ«μžλŠ” IEEE 754 ν‘œμ€€μ„ λ”°λ₯΄λ©°, νŠΉμˆ˜κ°’(inf, nan)도 ν‘œν˜„ κ°€λŠ₯

2μ§„μˆ˜, 8μ§„μˆ˜, 16μ§„μˆ˜

# 2μ§„μˆ˜ (0b둜 μ‹œμž‘)
a = 0b1010   # 10
a = 0b1111   # 15

# 8μ§„μˆ˜ (0o둜 μ‹œμž‘)
a = 0o177    # 127 (1*8^2 + 7*8^1 + 7*8^0 = 127)

# 16μ§„μˆ˜ (0x둜 μ‹œμž‘)
a = 0x8ff    # 2303
b = 0xABC    # 2748 (A:10, B:11, C:12)

# μ§„μˆ˜ λ³€ν™˜ ν•¨μˆ˜
print(bin(42))    # '0b101010' (2μ§„μˆ˜)
print(oct(42))    # '0o52' (8μ§„μˆ˜)
print(hex(42))    # '0x2a' (16μ§„μˆ˜)

# λ‹€μ–‘ν•œ μ§„λ²•μœΌλ‘œ μ •μˆ˜ 생성
print(int('101010', 2))   # 42 (2μ§„μˆ˜ λ¬Έμžμ—΄μ„ 10μ§„μˆ˜λ‘œ)
print(int('52', 8))       # 42 (8μ§„μˆ˜ λ¬Έμžμ—΄μ„ 10μ§„μˆ˜λ‘œ)
print(int('2a', 16))      # 42 (16μ§„μˆ˜ λ¬Έμžμ—΄μ„ 10μ§„μˆ˜λ‘œ)
print(int('42', 10))      # 42 (10μ§„μˆ˜ λ¬Έμžμ—΄μ„ 10μ§„μˆ˜λ‘œ)

# μ„œμ‹ν™”λœ 좜λ ₯ (접두어 없이)
print(format(42, 'b'))    # '101010' (접두어 μ—†λŠ” 2μ§„μˆ˜)
print(format(42, 'o'))    # '52' (접두어 μ—†λŠ” 8μ§„μˆ˜)
print(format(42, 'x'))    # '2a' (접두어 μ—†λŠ” 16μ§„μˆ˜)
print(format(42, 'X'))    # '2A' (λŒ€λ¬Έμž 16μ§„μˆ˜)

λ³΅μ†Œμˆ˜

a = 3 + 4j      # μ‹€μˆ˜λΆ€ 3, ν—ˆμˆ˜λΆ€ 4인 λ³΅μ†Œμˆ˜
b = complex(3, 4)  # μœ„μ™€ 동일

print(a.real)    # 3.0 (μ‹€μˆ˜λΆ€)
print(a.imag)    # 4.0 (ν—ˆμˆ˜λΆ€)
print(abs(a))    # 5.0 (λ³΅μ†Œμˆ˜μ˜ 크기)
print(a.conjugate())  # (3-4j) (케레 λ³΅μ†Œμˆ˜)

# λ³΅μ†Œμˆ˜ μ—°μ‚°
c = 1 + 2j
d = 2 + 3j
print(c + d)     # (3+5j)
print(c * d)     # (-4+7j)
print(c / d)     # (0.46153846153846156+0.07692307692307693j)


3️⃣ μˆ«μžν˜•μ„ ν™œμš©ν•˜κΈ° μœ„ν•œ μ—°μ‚°μž

사칙 μ—°μ‚°

a = 3
b = 4

print(a + b)  # 7  (λ§μ…ˆ)
print(a - b)  # -1 (λΊ„μ…ˆ)
print(a * b)  # 12 (κ³±μ…ˆ)
print(a / b)  # 0.75 (λ‚˜λˆ—μ…ˆ)

# μ—¬λŸ¬ μ—°μ‚°μž ν•¨κ»˜ μ‚¬μš©
result = (a + b) * 3 - 2  # μ—°μ‚°μž μš°μ„ μˆœμœ„ 적용

x의 yμ œκ³±μ„ λ‚˜νƒ€λ‚΄λŠ” ** μ—°μ‚°μž

a = 3
b = 4
print(a ** b)  # 81 (3의 4제곱)
print(2 ** 3)  # 8 (2의 3제곱)
print(9 ** 0.5)  # 3.0 (제곱근)

λ‚˜λˆ—μ…ˆ κ΄€λ ¨ μ—°μ‚°μž

print(7 % 3)   # 1 (λ‚˜λ¨Έμ§€)
print(3 % 7)   # 3 (λ‚˜λ¨Έμ§€)
print(7 / 4)   # 1.75 (일반 λ‚˜λˆ—μ…ˆ)
print(7 // 4)  # 1 (λͺ«)
print(-7 // 4) # -2 (음수 λ‚˜λˆ—μ…ˆμ˜ λͺ«)

λΉ„νŠΈ μ—°μ‚°μž

a = 60      # 0b111100
b = 13      # 0b1101

# λΉ„νŠΈ AND μ—°μ‚°
print(a & b)   # 12 (0b1100)

# λΉ„νŠΈ OR μ—°μ‚°
print(a | b)   # 61 (0b111101)

# λΉ„νŠΈ XOR μ—°μ‚°
print(a ^ b)   # 49 (0b110001)

# λΉ„νŠΈ NOT μ—°μ‚°
print(~a)      # -61

# λΉ„νŠΈ μ‹œν”„νŠΈ μ—°μ‚°
print(a << 2)  # 240 (0b11110000) - μ™Όμͺ½μœΌλ‘œ 2λΉ„νŠΈ 이동
print(a >> 2)  # 15 (0b1111) - 였λ₯Έμͺ½μœΌλ‘œ 2λΉ„νŠΈ 이동

# λΉ„νŠΈ μ—°μ‚° ν™œμš©
def is_even(num):
    return num & 1 == 0  # λΉ„νŠΈ AND μ—°μ‚°μœΌλ‘œ 홀짝 νŒλ‹¨

print(is_even(42))  # True
print(is_even(43))  # False


4️⃣ 볡합 μ—°μ‚°μž

볡합 μ—°μ‚°μžλŠ” μ‚°μˆ  μ—°μ‚°μžμ™€ λŒ€μž… μ—°μ‚°μž(=)λ₯Ό 합쳐 놓은 것이닀.

a = 1

# 기본적인 증가
a = a + 1     # 2

# 볡합 μ—°μ‚°μž μ‚¬μš©
a += 1        # a = a + 1 κ³Ό 동일
a -= 1        # a = a - 1 κ³Ό 동일
a *= 2        # a = a * 2 와 동일
a /= 2        # a = a / 2 와 동일
a //= 2       # a = a // 2 와 동일
a %= 2        # a = a % 2 와 동일
a **= 2       # a = a ** 2 와 동일

# λΉ„νŠΈ μ—°μ‚° 볡합 μ—°μ‚°μž
a &= b        # a = a & b 와 동일
a |= b        # a = a | b 와 동일
a ^= b        # a = a ^ b 와 동일
a <<= 2       # a = a << 2 와 동일
a >>= 2       # a = a >> 2 와 동일


5️⃣ μœ μš©ν•œ λ‚΄μž₯ ν•¨μˆ˜

# μ ˆλŒ€κ°’
print(abs(-3))      # 3

# 반올림, 올림, λ‚΄λ¦Ό
print(round(3.14))  # 3
print(round(3.14, 1))  # 3.1
import math
print(math.ceil(3.14))   # 4 (올림)
print(math.floor(3.14))  # 3 (λ‚΄λ¦Ό)
print(math.trunc(3.14))  # 3 (μ†Œμˆ˜μ  버림)

# μ΅œλŒ€κ°’, μ΅œμ†Œκ°’
print(max(1, 2, 3))  # 3
print(min(1, 2, 3))  # 1

# 합계, κ³±
print(sum([1, 2, 3]))  # 6
import math
print(math.prod([1, 2, 3, 4]))  # 24 (Python 3.8 이상)

# κ±°λ“­μ œκ³±
print(pow(2, 3))     # 8 (2의 3제곱)
print(pow(2, 3, 5))  # 3 (2의 3μ œκ³±μ„ 5둜 λ‚˜λˆˆ λ‚˜λ¨Έμ§€)

βœ… Tip:

  • μˆ˜ν•™ κ΄€λ ¨ κ³ κΈ‰ ν•¨μˆ˜λŠ” math λͺ¨λ“ˆ μ‚¬μš©
  • μ •λ°€ν•œ μ‹­μ§„ 연산이 ν•„μš”ν•  λ•ŒλŠ” decimal λͺ¨λ“ˆ μ‚¬μš©
  • λ³΅μž‘ν•œ μˆ˜ν•™ 계산은 numpy 라이브러리 ꢌμž₯


6️⃣ μ •λ°€ν•œ 수치 계산

Decimal λͺ¨λ“ˆ

decimal λͺ¨λ“ˆμ€ λΆ€λ™μ†Œμˆ˜μ  였차 없이 μ •ν™•ν•œ μ‹­μ§„ 연산을 μ œκ³΅ν•œλ‹€.

from decimal import Decimal, getcontext

# 일반 λΆ€λ™μ†Œμˆ˜μ  계산 (였차 λ°œμƒ)
print(0.1 + 0.2)  # 0.30000000000000004

# Decimal μ‚¬μš© (μ •ν™•ν•œ 계산)
print(Decimal('0.1') + Decimal('0.2'))  # 0.3

# 정밀도 μ„€μ •
getcontext().prec = 28  # 28자리 정밀도
print(Decimal(1) / Decimal(7))  # 0.1428571428571428571428571429

# 반올림 λͺ¨λ“œ μ„€μ •
getcontext().rounding = 'ROUND_HALF_UP'
print(Decimal('1.5').quantize(Decimal('1')))  # 2

# 금육 계산
price = Decimal('19.99')
tax_rate = Decimal('0.075')
tax = price * tax_rate
total = price + tax
print(f"μ„ΈκΈˆ: {tax}, 총앑: {total}")  # μ •ν™•ν•œ 금육 계산

Fraction λͺ¨λ“ˆ

fractions λͺ¨λ“ˆμ€ λΆ„μˆ˜ 연산을 μ§€μ›ν•œλ‹€.

from fractions import Fraction

# λΆ„μˆ˜ 생성
f1 = Fraction(1, 3)  # 1/3
f2 = Fraction('2.5')  # 5/2
f3 = Fraction('0.25')  # 1/4

print(f1)  # 1/3
print(f2)  # 5/2
print(f3)  # 1/4

# λΆ„μˆ˜ μ—°μ‚°
print(f1 + f2)  # 17/6
print(f1 * f3)  # 1/12
print(f2 / f3)  # 10

# λΆ„μž, λΆ„λͺ¨ μ ‘κ·Ό
print(f1.numerator)    # 1 (λΆ„μž)
print(f1.denominator)  # 3 (λΆ„λͺ¨)

# μ‹€μˆ˜ λ³€ν™˜
print(float(f1))  # 0.3333333333333333


7️⃣ μˆ˜ν•™ 라이브러리

math λͺ¨λ“ˆ

math λͺ¨λ“ˆμ€ 기본적인 μˆ˜ν•™ ν•¨μˆ˜λ“€μ„ μ œκ³΅ν•œλ‹€.

import math

# μƒμˆ˜
print(math.pi)     # 3.141592653589793 (파이)
print(math.e)      # 2.718281828459045 (μžμ—° μƒμˆ˜)
print(math.inf)    # λ¬΄ν•œλŒ€
print(math.nan)    # Not a Number

# μ‚Όκ°ν•¨μˆ˜ (λΌλ””μ•ˆ λ‹¨μœ„)
print(math.sin(math.pi/2))  # 1.0
print(math.cos(math.pi))    # -1.0
print(math.tan(math.pi/4))  # 0.9999999999999999

# 각도 λ³€ν™˜
print(math.degrees(math.pi))  # 180.0 (λΌλ””μ•ˆ -> 각도)
print(math.radians(180))      # 3.141592653589793 (각도 -> λΌλ””μ•ˆ)

# 둜그 ν•¨μˆ˜
print(math.log(10))      # 2.302585092994046 (μžμ—° 둜그)
print(math.log10(100))   # 2.0 (밑이 10인 둜그)
print(math.log2(8))      # 3.0 (밑이 2인 둜그)
print(math.exp(2))       # 7.38905609893065 (e^2)

# 제곱근과 μ§€μˆ˜
print(math.sqrt(16))     # 4.0 (제곱근)
print(math.pow(2, 3))    # 8.0 (κ±°λ“­μ œκ³±)

# 기타 ν•¨μˆ˜
print(math.factorial(5))  # 120 (νŒ©ν† λ¦¬μ–Ό)
print(math.gcd(12, 18))   # 6 (μ΅œλŒ€κ³΅μ•½μˆ˜)
print(math.isclose(0.1 + 0.2, 0.3, rel_tol=1e-9))  # False

numpy 라이브러리

numpyλŠ” 수치 계산을 μœ„ν•œ κ°•λ ₯ν•œ λΌμ΄λΈŒλŸ¬λ¦¬λ‹€. (별도 μ„€μΉ˜ ν•„μš”: pip install numpy)

import numpy as np

# λ°°μ—΄ 생성
arr = np.array([1, 2, 3, 4, 5])
print(arr)  # [1 2 3 4 5]

# 벑터화 μ—°μ‚°
print(arr * 2)       # [2 4 6 8 10]
print(arr ** 2)      # [1 4 9 16 25]
print(np.sqrt(arr))  # [1. 1.41421356 1.73205081 2. 2.23606798]

# 톡계 ν•¨μˆ˜
print(np.mean(arr))   # 3.0 (평균)
print(np.median(arr)) # 3.0 (쀑앙값)
print(np.std(arr))    # 1.4142135623730951 (ν‘œμ€€νŽΈμ°¨)

# μ„ ν˜•λŒ€μˆ˜
matrix = np.array([[1, 2], [3, 4]])
print(np.linalg.det(matrix))  # -2.0 (행렬식)
print(np.linalg.inv(matrix))  # [[-2.   1. ] [ 1.5 -0.5]] (μ—­ν–‰λ ¬)

# μ‚Όκ°ν•¨μˆ˜ (벑터화)
angles = np.array([0, np.pi/4, np.pi/2])
print(np.sin(angles))  # [0.         0.70710678 1.        ]

# λ‚œμˆ˜ 생성
print(np.random.rand(3))     # 3개의 0~1 사이 균등뢄포 λ‚œμˆ˜
print(np.random.randn(3))    # 3개의 ν‘œμ€€μ •κ·œλΆ„ν¬ λ‚œμˆ˜
print(np.random.randint(1, 10, 5))  # 1~9 사이 5개 μ •μˆ˜ λ‚œμˆ˜


8️⃣ μ»΄ν“¨ν„°μ—μ„œμ˜ 숫자 ν‘œν˜„

λΆ€λ™μ†Œμˆ˜μ κ³Ό 이진 ν‘œν˜„

# IEEE 754 λΆ€λ™μ†Œμˆ˜μ  ν‘œν˜„ μ΄ν•΄ν•˜κΈ°
import struct

def float_to_bin(num):
    """float 값을 이진 ν‘œν˜„μœΌλ‘œ λ³€ν™˜"""
    # IEEE 754 ν‘œμ€€μ— 따라 floatλ₯Ό λΉ„νŠΈ νŒ¨ν„΄μœΌλ‘œ λ³€ν™˜
    bits = struct.unpack('!I', struct.pack('!f', num))[0]
    return bin(bits)[2:].zfill(32)

# 0.1의 이진 ν‘œν˜„
print(float_to_bin(0.1))  # IEEE 754 λΆ€λ™μ†Œμˆ˜μ  이진 ν‘œν˜„
print(0.1.hex())  # 0x1.999999999999ap-4 (16μ§„μˆ˜ ν‘œν˜„)

# λΆ€λ™μ†Œμˆ˜μ  정밀도 확인
print(sys.float_info.dig)  # 일반적으둜 15 (10μ§„ 정밀도)
print(sys.float_info.epsilon)  # 2.220446049250313e-16 (기계 μ—‘μ‹€λ‘ )

# μ •μˆ˜ ν‘œν˜„ λ²”μœ„
print(sys.maxsize)  # 일반적으둜 9223372036854775807 (64λΉ„νŠΈ μ‹œμŠ€ν…œ)

βœ… μˆ«μžν˜•μ˜ λ©”λͺ¨λ¦¬ κ΄€λ ¨ νŠΉμ§•:

  • μ •μˆ˜: Python은 μž„μ˜ 정밀도 μ •μˆ˜λ₯Ό μ‚¬μš©ν•˜μ—¬ λ©”λͺ¨λ¦¬ μ œν•œ 없이 큰 μ •μˆ˜ 처리 κ°€λŠ₯
  • μ‹€μˆ˜: IEEE 754 배정밀도 λΆ€λ™μ†Œμˆ˜μ  μ‚¬μš© (일반적으둜 64λΉ„νŠΈ)
  • μ‹€μˆ˜ ν‘œν˜„μ˜ ν•œκ³„λ‘œ 인해 μ •λ°€ν•œ κ³„μ‚°μ—λŠ” decimal λͺ¨λ“ˆ μ‚¬μš© ꢌμž₯
  • λ³΅μ†Œμˆ˜λŠ” μ‹€μˆ˜λΆ€μ™€ ν—ˆμˆ˜λΆ€μ— 각각 λΆ€λ™μ†Œμˆ˜μ  μ‚¬μš©


⚠️ **GitHub.com Fallback** ⚠️