์ ์(Integer)๋ ๋ฌด์์ผ๊น์?
ํ๋ก๊ทธ๋๋ฐ์ ์ฒ์ ์์ํ ๋, ๊ฐ์ฅ ๋จผ์ ๋ฐฐ์ฐ๋ ๊ฐ๋ ์ค ํ๋๊ฐ ๋ฐ๋ก '๋ฐ์ดํฐ ํ์ '์ ๋๋ค. ๋ง์น ์ฐ๋ฆฌ๊ฐ ์ผ์์ํ์์ ์ซ์, ๊ธ์, ์ฐธ/๊ฑฐ์ง ๋ฑ ๋ค์ํ ์ ๋ณด๋ฅผ ๊ตฌ๋ถํ๋ฏ์ด, ํ์ด์ฌ๋ ์ ๋ณด๋ฅผ ์ข ๋ฅ๋ณ๋ก ๋ถ๋ฅํด์ ๋ค๋ฃจ์ฃ .
๊ทธ์ค์์๋ ์ค๋ ์ฐ๋ฆฌ๊ฐ ์ง์คํ ๊ฒ์ ๋ฐ๋ก **์ ์(Integer)**์ ๋๋ค.
์ ์๋ ์ฝ๊ฒ ๋งํด ์์์ ์ด ์๋ ์ซ์๋ฅผ ์๋ฏธํด์. ์ฐ๋ฆฌ๊ฐ ๋งค์ผ ์ฌ์ฉํ๋ 1, 5, 100, -500 ๊ฐ์ ์ซ์๋ค ๋ง์ด์ฃ . ํ์ด์ฌ์์๋ ์ด ์ ์๋ฅผ int๋ผ๋ ์ด๋ฆ์ผ๋ก ๋ถ๋ฆ ๋๋ค.
์ค์ํ ์์:
๊ฐ์ง๊ณ ์๋ ์ฌ๊ณผ์ ๊ฐ์ (10๊ฐ)
๋์ด (30์ด)
์๋ฆฌ๋ฒ ์ดํฐ์ ์ธต์ (-2์ธต, 1์ธต, 10์ธต)
์ด ๋ชจ๋ ๊ฒ์ด ์ ์ ๋ฐ์ดํฐ ํ์ ์ ์์์ ๋๋ค. ์ปดํจํฐ๋ ์ด ์ ์๋ค์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ๊ณ , ๋ง์ , ๋บ์ ๊ฐ์ ๊ณ์ฐ์ ์ํํ๋ ๋ฐ ์ฌ์ฉํฉ๋๋ค.
ํ์ด์ฌ ์ฝ๋๋ก ์ ์(Integer) ์ฌ์ฉํด๋ณด๊ธฐ
ํ์ด์ฌ์์ ์ ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๋งค์ฐ ์ฝ๊ณ ์ง๊ด์ ์ ๋๋ค. ๋ณ์์ ์ซ์๋ฅผ ํ ๋นํ๊ธฐ๋ง ํ๋ฉด ํ์ด์ฌ์ด ์์์ ๊ทธ ๊ฐ์ ์ ์๋ก ์ธ์ํด์!
์๋ ์ฝ๋๋ฅผ ๋ฐ๋ผ ํด ๋ณด์ธ์. print() ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ณ์์ ์ ์ฅ๋ ๊ฐ์ ํ๋ฉด์ ์ถ๋ ฅํ ์ ์๋ต๋๋ค.
#
์ฌ๊ณผ ๊ฐ์๋ฅผ ์ ์ฅํฉ๋๋ค. (์์ ์ ์)
apple_count = 15
print(f"ํ์ฌ ์ฌ๊ณผ ๊ฐ์: {apple_count}๊ฐ")
#
์จ๋๋ฅผ ์ ์ฅํฉ๋๋ค. (์์ ์ ์)
current_temp = -5
print(f"ํ์ฌ ๊ธฐ์จ: {current_temp}๋")
#
์ ์ ๊ฐ์ ๋ง์
์ฐ์ฐ
num1 = 10
num2 = 7
sum_result = num1 + num2 # ๊ฒฐ๊ณผ๋ 17 (์ ์)
print(f"10 ๋ํ๊ธฐ 7์ ๊ฒฐ๊ณผ: {sum_result}")
#
์ ์์ ํ์
์ ํ์ธํ๋ ๋ฐฉ๋ฒ
# type() ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ํ์ด์ฌ์ด ์ด ๋ฐ์ดํฐ๋ฅผ ๋ฌด์์ผ๋ก ์ธ์ํ๋์ง ์๋ ค์ค๋๋ค.
print(type(sum_result)) # ๊ฒฐ๊ณผ: <class 'int'>, ์ฆ ์ ์(Integer)์
๋๋ค!
์ด์ฒ๋ผ ํ์ด์ฌ์์ ์ ์๋ ๊ธฐ๋ณธ์ ์ธ ๊ณ์ฐ์ ํต์ฌ ์ญํ ์ ํฉ๋๋ค.
์ด๋ณด์๊ฐ ์์ฃผ ํ๋ ์ค์์ ํด๊ฒฐ ๋ฐฉ๋ฒ
ํ์ด์ฌ์์ ์ ์๋ฅผ ๋ค๋ฃฐ ๋ ์ด๋ณด์๋ค์ด ๊ฐ์ฅ ๋ง์ด ๊ฒช๋ ํผ๋ ์ค ํ๋๋ '๋ฌธ์์ด'๊ณผ '์ซ์'์ ์ฐจ์ด๋ฅผ ํท๊ฐ๋ฆฌ๋ ๊ฒ์ ๋๋ค.
์ค์ 1: ์ซ์์ ๋ฐ์ดํ๋ฅผ ๋ถ์ด๋ ๊ฒฝ์ฐ
#
์ค์: '5'๋ ์ซ์๊ฐ ์๋๋ผ ๋ฌธ์ '5'์
๋๋ค!
num_string = '5'
num_number = 10
# ๋ฌธ์์ด๊ณผ ์ ์๋ ๋ฐ๋ก ๋ํ ์ ์์ต๋๋ค! (์ค๋ฅ ๋ฐ์)
# result = num_string + num_number
ํด๊ฒฐ ๋ฐฉ๋ฒ:
๋ฐ์ดํ('' ๋๋ "")๋ก ๊ฐ์ธ๋ฉด, ํ์ด์ฌ์ ๊ทธ๊ฒ์ด ์ซ์์ฒ๋ผ ๋ณด์ฌ๋ ๋จ์ํ **๊ธ์(๋ฌธ์์ด)**๋ก ์ทจ๊ธํฉ๋๋ค. ๊ณ์ฐ์ ํ๊ณ ์ถ๋ค๋ฉด ๋ฐ์ดํ๋ฅผ ์ ๊ฑฐํ์ฌ ์์ํ ์ ์ ํํ๋ก ๋ง๋ค์ด์ผ ํฉ๋๋ค.
#
ํด๊ฒฐ: ๋ฐ์ดํ๋ฅผ ์ ๊ฑฐํ์ฌ ์ ์(Integer)๋ก ๋ง๋ญ๋๋ค.
num_string_as_int = int('5')
num_number = 10
result = num_string_as_int + num_number
print(result) # ๊ฒฐ๊ณผ: 15
์ค์ 2: ๋๋์ ๊ฒฐ๊ณผ๋ ์ ์๊ฐ ์๋ ์ ์์ด์!
์ ์ ๋๋๊ธฐ ์ ์๋ฅผ ํ๋๋ผ๋, ํ์ด์ฌ์ ์ผ๋ฐ์ ์ธ ๋๋์
์ฐ์ฐ์(/)๋ ๊ฒฐ๊ณผ๋ฅผ ํญ์ ์์์ (์ค์, float) ํํ๋ก ๋๋ ค์ค๋๋ค.
num_a = 10
num_b = 3
# 10 / 3์ ์ํ์ ๊ฒฐ๊ณผ๋ 3.333...์
๋๋ค.
division_result = num_a / num_b
print(division_result) # ๊ฒฐ๊ณผ: 3.3333333333333335
print(type(division_result)) # ๊ฒฐ๊ณผ: <class 'float'>
ํด๊ฒฐ ๋ฐฉ๋ฒ:
๋๋์
์ ํ์ง๋ง, ์์์ ์ ๋ฒ๋ฆฌ๊ณ ์ ์ ๊ฐ๋ง ์ป๊ณ ์ถ๋ค๋ฉด ๋ชซ ์ฐ์ฐ์์ธ //๋ฅผ ์ฌ์ฉํ์ธ์.
#
ํด๊ฒฐ: ๋ชซ ์ฐ์ฐ์ (//)๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ ๊ฒฐ๊ณผ๋ง ์ป์ต๋๋ค.
integer_division = num_a // num_b
print(integer_division) # ๊ฒฐ๊ณผ: 3
print(type(integer_division)) # ๊ฒฐ๊ณผ: <class 'int'>
์ด ์ฐ์ฐ์ ํนํ ๋ชซ๊ณผ ๋๋จธ์ง๋ฅผ ๊ณ์ฐํ ๋ ์ ์ฉํ๋ฉฐ, ๊ฒฐ๊ณผ๊ฐ ๊น๋ํ ์ ์๋ก ๋์ค๊ฒ ํด์ค๋๋ค.
๋ง๋ฌด๋ฆฌ ์์ฝ: ์ ์(Integer)๋ ์ฝ๋ฉ์ ์ฒซ๊ฑธ์!
์ค๋ ์ฐ๋ฆฌ๋ ํ์ด์ฌ์์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ด ๋๋ ๋ฐ์ดํฐ ํ์ ์ธ **์ ์(Integer)**์ ๋ํด ๋ฐฐ์ ์ต๋๋ค.
์ ์๋ ์์์ ์ด ์๋ ์ซ์์ ๋๋ค.
ํ์ด์ฌ์ ์ด ์ ์๋ฅผ $\text{int}$ ํ์ ์ผ๋ก ์ธ์ํ๊ณ ๊ณ์ฐํฉ๋๋ค.
์ซ์ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ๋๋ ๋ฐ์ดํ๋ฅผ ์ฃผ์ํ๊ณ , ์ ์ ๊ฐ์ ๋๋์ ๊ฒฐ๊ณผ๋ ์ค์๊ฐ ๋ ์ ์์์ ๊ธฐ์ตํ์ธ์.
ํ์ด์ฌ ์ฝ๋ฉ์ ์ด์ฒ๋ผ ์ฌ์ด ์ ์๋ถํฐ ์์ํฉ๋๋ค. ์ง๊ธ ๋ฐฐ์ด ๋ด์ฉ์ ๋ฐํ์ผ๋ก ๊ฐ๋จํ ๊ณ์ฐ๊ธฐ๋ฅผ ๋ง๋ค์ด ๋ณด๊ฑฐ๋, ๋ค๋ฅธ ์ ์ ์ฐ์ฐ๋ ์๋ํด ๋ณด์ธ์! ์ฝ๋ฉ ์ค๋ ฅ์ ์ง์ ํด๋ณด๋ ๊ฒ์์๋ถํฐ ์ฅ์ฅ ๋์ด๋๋ต๋๋ค. ์ฌ๋ฌ๋ถ์ ํ์ด์ฌ ์ฌ์ ์ ์์ํฉ๋๋ค! 
๊ถ๊ธํ ์ ์ด ์๋ค๋ฉด ์ธ์ ๋ ์ง ๋ฌผ์ด๋ณด์ธ์! ๋ค์์๋ '๋ฌธ์์ด'์ ๋ํด ํจ๊ป ๋ฐฐ์๋ณผ๊น์?

๋๊ธ
๋๊ธ ์ฐ๊ธฐ