๋ณธ๋ฌธ์œผ๋กœ ๊ฑด๋„ˆ๋›ฐ๊ธฐ

Python ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜: ์˜ˆ์ œ๋กœ ์•Œ์•„๋ณด๊ธฐ

์ด Python ํŠœํ† ๋ฆฌ์–ผ์—์„œ๋Š” ์ฝ”๋“œ ์˜ˆ์ œ์™€ ํ•จ๊ป˜ ๊ธฐ๋ณธํ˜• ๋ฐ ๋น„๊ธฐ๋ณธํ˜• ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ์˜ ๋ฌต์‹œ์ /๋ช…์‹œ์  ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜์„ ๋‹ค๋ฃน๋‹ˆ๋‹ค.
ยท 14๋ถ„ ์ฝ๊ธฐ

AI์™€ ํƒํ—˜ํ•ด ๋ณด์„ธ์š”

Python์˜ ๋ชจ๋“  ๊ฐ’์—๋Š” ๋ฐ์ดํ„ฐ ํƒ€์ž…์ด ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฐ์ดํ„ฐ ํƒ€์ž…์€ ๋ฐ์ดํ„ฐ๋ฅผ ์–ด๋–ป๊ฒŒ ์‚ฌ์šฉํ• ์ง€ ์ปดํŒŒ์ผ๋Ÿฌ๋‚˜ ์ธํ„ฐํ”„๋ฆฌํ„ฐ์— ์•Œ๋ ค ์ฃผ๋Š” ๋ฐ์ดํ„ฐ์˜ ๋ถ„๋ฅ˜์ž…๋‹ˆ๋‹ค. ํƒ€์ž…์€ ๋ฐ์ดํ„ฐ์— ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ๋Š” ์—ฐ์‚ฐ๊ณผ ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅํ•  ๊ตฌ์กฐ๋ฅผ ์ •์˜ํ•ฉ๋‹ˆ๋‹ค. ๋ฐ์ดํ„ฐ ๊ณผํ•™์—์„œ๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ๋” ์‰ฝ๊ฒŒ ์‚ฌ์šฉํ•˜๊ณ  ๋‹ค๋ฃจ๊ธฐ ์œ„ํ•ด ํƒ€์ž…์„ ๋ณ€๊ฒฝํ•ด์•ผ ํ•˜๋Š” ์ผ์ด ์ž์ฃผ ์žˆ์Šต๋‹ˆ๋‹ค.

Python์—๋Š” ๋‹ค์–‘ํ•œ ๋ฐ์ดํ„ฐ ํƒ€์ž…์ด ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋ฏธ ๋ช‡ ๊ฐ€์ง€๋Š” ๋ณด์•˜๊ณ  ์‚ฌ์šฉํ•ด ๋ณด์…จ์„ ๊ฒ๋‹ˆ๋‹ค. ์ •์ˆ˜์™€ ์‹ค์ˆ˜๋Š” ์ˆ˜์น˜ ๊ฐ’์„, ๋ถˆ๋ฆฌ์–ธ(bool)์€ ์ฐธ/๊ฑฐ์ง“ ๊ฐ’์„, ๋ฌธ์ž์—ด์€ ์˜์ˆซ์ž ๋ฌธ์ž๋ฅผ ๋‹ค๋ฃจ๋Š” ๋ฐ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ๊ฐ’์˜ ๋ชจ์Œ์„ ์ €์žฅํ•˜๋Š” ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๋กœ๋Š” ๋ฆฌ์ŠคํŠธ, ํŠœํ”Œ, ๋”•์…”๋„ˆ๋ฆฌ, ์„ธํŠธ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ๋” ์ž์„ธํžˆ ์•Œ์•„๋ณด๋ ค๋ฉด DataCamp์˜ Data Types in Python ๊ณผ์ •์„ ํ™•์ธํ•˜์„ธ์š”.

์ด ํŠœํ† ๋ฆฌ์–ผ์˜ ์˜ˆ์ œ ์ฝ”๋“œ๋ฅผ ์ง์ ‘ ์‰ฝ๊ฒŒ ์‹คํ–‰ํ•ด ๋ณด๋ ค๋ฉด, Python์ด ๋ฏธ๋ฆฌ ์„ค์น˜๋˜์–ด ์žˆ๊ณ  ๋ชจ๋“  ์ฝ”๋“œ ์ƒ˜ํ”Œ์ด ํฌํ•จ๋œ DataLab ์›Œํฌ๋ถ์„ ๋ฌด๋ฃŒ๋กœ ์ƒ์„ฑํ•˜์„ธ์š”.

Python์—์„œ ๋ฐ์ดํ„ฐ ํƒ€์ž… ํ™•์ธํ•˜๊ธฐ

ํ˜• ๋ณ€ํ™˜์— ์•ž์„œ ํƒ€์ž…์„ ํ™•์ธํ•˜๋ฉด ์œ ์šฉํ•ฉ๋‹ˆ๋‹ค. Python์€ ๋‘ ๊ฐ€์ง€ ์ฃผ์š” ํ•จ์ˆ˜๋ฅผ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค:

  • type(): ๋ณ€์ˆ˜์˜ ํƒ€์ž…์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
  • isinstance(): ๋ณ€์ˆ˜๊ฐ€ ํŠน์ • ํƒ€์ž…์— ์†ํ•˜๋Š”์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
a = 5.5
print(type(a))  # Output: <class 'float'>

print(isinstance(a, int))  # Output: False
print(isinstance(a, float))  # Output: True

Python์˜ ๋ฌต์‹œ์  ๋ฐ ๋ช…์‹œ์  ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜

Python์—์„œ ํ˜• ๋ณ€ํ™˜์€ ๋‘ ๊ฐ€์ง€ ๋ฐฉ์‹์œผ๋กœ ์ผ์–ด๋‚ฉ๋‹ˆ๋‹ค. ์ปดํŒŒ์ผ๋Ÿฌ์— ์–ด๋–ค ํƒ€์ž…์œผ๋กœ ๋ณ€ํ™˜ํ• ์ง€ ๋ช…์‹œ์ ์œผ๋กœ ์ง€์‹œํ•˜๊ฑฐ๋‚˜, ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์Šค์Šค๋กœ ์ด๋ฅผ ์ดํ•ดํ•˜๊ณ  ๋ณ€ํ™˜์„ ์ˆ˜ํ–‰ํ•˜๋Š” ๋ฐฉ์‹์ž…๋‹ˆ๋‹ค. ์ „์ž๋Š” ๋ช…์‹œ์  ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜์ด๊ณ , ํ›„์ž๋Š” ๋ฌต์‹œ์  ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜์ž…๋‹ˆ๋‹ค.

Python ๋ฌต์‹œ์  ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜

๋ฌต์‹œ์  ๋ณ€ํ™˜(๋˜๋Š” ๊ฐ•์ œ ๋ณ€ํ™˜, coercion)์€ ์ปดํŒŒ์ผ ์‹œ ๋˜๋Š” ์‹คํ–‰ ์‹œ์— ํ˜• ๋ณ€ํ™˜์ด ์ผ์–ด๋‚˜๋ฉฐ Python์ด ์ด๋ฅผ ์ž๋™์œผ๋กœ ์ฒ˜๋ฆฌํ•˜๋Š” ๊ฒฝ์šฐ๋ฅผ ๋งํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ์ œ๋ฅผ ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค:

a_int = 1
b_float = 1.0
c_sum = a_int + b_float
print(c_sum)
print(type(c_sum))
 2.0
<class 'float'>

ํŒ: Python์—์„œ type() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด ๊ฐ์ฒด์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ด ์˜ˆ์ œ์—์„œ๋Š” ์ •์ˆ˜ ๊ฐ’ a_int์— ์‹ค์ˆ˜ ๊ฐ’ b_float๋ฅผ ๋”ํ–ˆ๊ณ , ๊ฒฐ๊ณผ๋Š” ๋ณ„๋„์˜ ์ง€์‹œ ์—†์ด ์ž๋™์œผ๋กœ ์‹ค์ˆ˜ ๊ฐ’ c_sum์œผ๋กœ ๋ณ€ํ™˜๋˜์—ˆ์Šต๋‹ˆ๋‹ค. ์ด๊ฒƒ์ด ๋ฌต์‹œ์  ํ˜• ๋ณ€ํ™˜์ž…๋‹ˆ๋‹ค.

์™œ ์‹ค์ˆ˜ ๊ฐ’์„ ์ •์ˆ˜๋กœ ๋ณ€ํ™˜ํ•˜์ง€ ์•Š์•˜์„๊นŒ์š”?

์ด๋Š” ์ปดํ“จํ„ฐ ๊ณผํ•™์—์„œ ๋” ๋„“๊ฒŒ ์“ฐ์ด๋Š” ํƒ€์ž… ์Šน๊ฒฉ(type promotion) ๊ฐœ๋… ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ๊ฐ„๋‹จํžˆ ๋งํ•ด, ์ •๋ณด ์†์‹ค ์—†์ด ๊ฐ€๋Šฅํ•œ ํ•œ ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ๋„๋ก ๋ฐ์ดํ„ฐ๋ฅผ ๋” ์ƒ์œ„ ํƒ€์ž…์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ์ปดํŒŒ์ผ๋Ÿฌ์˜ ๋ฐฉ์–ด ๋ฉ”์ปค๋‹ˆ์ฆ˜์ž…๋‹ˆ๋‹ค.

์ฆ‰, ์‹ค์ˆ˜๋ฅผ ์ •์ˆ˜๋กœ ๋ฐ”๊พธ๋ฉด ์†Œ์ˆ˜ ๋ถ€๋ถ„์„ ๋ฒ„๋ ค์•ผ ํ•˜๋ฏ€๋กœ ์ •๋ณด๊ฐ€ ์†์‹ค๋˜์–ด ๊ทธ๋Ÿฐ ๋ณ€ํ™˜์€ ์ˆ˜ํ–‰ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

Python ๋ช…์‹œ์  ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜

๋ช…์‹œ์  ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜(ํƒ€์ž… ์บ์ŠคํŒ…)์€ ํ•œ ๋ฐ์ดํ„ฐ ํƒ€์ž…์˜ ๊ฐ’์„ ๋‹ค๋ฅธ ํƒ€์ž…์œผ๋กœ ์˜๋„์ ์œผ๋กœ ๋ณ€ํ™˜ํ•  ๋•Œ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค. ์ด ๋ฐฉ์‹์€ ์ฝ”๋“œ์—์„œ ๋Œ€์ƒ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ๋ช…์‹œํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๋ณ€ํ™˜์„ ์ง์ ‘ ์ œ์–ดํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. Python์˜ ์ž๋™(๋ฌต์‹œ์ ) ๋ณ€ํ™˜์ด ์š”๊ตฌ ์‚ฌํ•ญ์„ ์ถฉ์กฑํ•˜์ง€ ๋ชปํ•  ๋•Œ ํ”ํžˆ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.

๋ช…์‹œ์  ๋ณ€ํ™˜์˜ ๋ฌธ๋ฒ•์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค:

target_data_type(expression)

์˜ˆ๋ฅผ ๋“ค์–ด, ๋ถ€๋™์†Œ์ˆ˜์ ์„ ์ •์ˆ˜๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ž‘์„ฑํ•ฉ๋‹ˆ๋‹ค:

int(3.14)  # Converts 3.14 to 3

์ฃผ์˜: ๋ช…์‹œ์  ๋ณ€ํ™˜์€ ๋งค์šฐ ์œ ์šฉํ•˜์ง€๋งŒ ์ •๋ณด ์†์‹ค์„ ์ดˆ๋ž˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ๋ถ€๋™์†Œ์ˆ˜์ ์„ ์ •์ˆ˜๋กœ ๋ณ€ํ™˜ํ•˜๋ฉด ์†Œ์ˆ˜ ๋ถ€๋ถ„์ด ๋ฒ„๋ ค์ง‘๋‹ˆ๋‹ค. ์˜๋„์น˜ ์•Š์€ ๊ฒฐ๊ณผ๋ฅผ ํ”ผํ•˜๋ ค๋ฉด ์ด๋Ÿฌํ•œ ๊ฒฐ๊ณผ๋ฅผ ์ดํ•ดํ•˜๋Š” ๊ฒƒ์ด ์ค‘์š”ํ•ฉ๋‹ˆ๋‹ค.

์ด์ œ ์ž์ฃผ ์‚ฌ์šฉํ•˜๋Š” ๋ช…์‹œ์  ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜์„ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

Python์˜ ๊ธฐ๋ณธํ˜•๊ณผ ๋น„๊ธฐ๋ณธํ˜• ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ

๊ธฐ๋ณธํ˜• ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๋Š” ๋ฐ์ดํ„ฐ ์กฐ์ž‘์˜ ๊ตฌ์„ฑ ์š”์†Œ๋กœ, ์ˆœ์ˆ˜ํ•˜๊ณ  ๋‹จ์ˆœํ•œ ๋ฐ์ดํ„ฐ ๊ฐ’์„ ๋‹ด์Šต๋‹ˆ๋‹ค. Python์—๋Š” ๋„ค ๊ฐ€์ง€ ๊ธฐ๋ณธ ๋ณ€์ˆ˜ ํƒ€์ž…์ด ์žˆ์Šต๋‹ˆ๋‹ค:

  • ์ •์ˆ˜
  • ์‹ค์ˆ˜
  • ๋ฌธ์ž์—ด
  • ๋ถˆ๋ฆฌ์–ธ

๋น„๊ธฐ๋ณธํ˜• ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๋Š” ๋‹จ์ผ ๊ฐ’์ด ์•„๋‹ˆ๋ผ ๋‹ค์–‘ํ•œ ํ˜•์‹์˜ ๊ฐ’ ๋ชจ์Œ์„ ์ €์žฅํ•ฉ๋‹ˆ๋‹ค. Python์˜ ๋น„๊ธฐ๋ณธํ˜• ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค:

  • ๋ฆฌ์ŠคํŠธ
  • ํŠœํ”Œ
  • ๋”•์…”๋„ˆ๋ฆฌ
  • ์„ธํŠธ

์ž์„ธํ•œ ๋‚ด์šฉ์€ DataCamp์˜ Data Structures in Python Tutorial์„ ์ฐธ๊ณ ํ•˜์„ธ์š”.

๊ธฐ๋ณธํ˜• ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ ๋ณ€ํ™˜

Python ์ •์ˆ˜์™€ ์‹ค์ˆ˜ ๋ณ€ํ™˜

์ •์ˆ˜์™€ ์‹ค์ˆ˜๋Š” ์ˆซ์ž๋ฅผ ๋‹ค๋ฃจ๋Š” ๋ฐ์ดํ„ฐ ํƒ€์ž…์ž…๋‹ˆ๋‹ค.

์ •์ˆ˜๋ฅผ ์‹ค์ˆ˜๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๋ฉด Python์˜ float() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜์„ธ์š”. ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์‹ค์ˆ˜๋ฅผ ์ •์ˆ˜๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๋ฉด int() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

a_int = 3
b_int = 2

# Explicit type conversion from int to float
c_float_sum = float(a_int + b_int)
print(c_float_sum)
5.0
a_float = 3.3
b_float = 2.0
# Explicit type conversion from float to int
c_int_sum = int(a_float + b_float)
print(c_int_sum)

c_float_sum = a_float + b_float
print(c_float_sum)
5
5.3

์‹ค์ˆ˜ ์ •๋ฐ€๋„ ์ด์Šˆ์™€ Decimal ๋ชจ๋“ˆ

Python์˜ ๋ถ€๋™์†Œ์ˆ˜์  ์—ฐ์‚ฐ์€ ์ •๋ฐ€๋„ ๋ฌธ์ œ๋ฅผ ์ผ์œผํ‚ฌ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค:

print(0.1 + 0.2)  # Output: 0.30000000000000004

์ด๋ฅผ ํ”ผํ•˜๋ ค๋ฉด Decimal ๋ชจ๋“ˆ์„ ์‚ฌ์šฉํ•˜์„ธ์š”:

from decimal import Decimal

print(Decimal('0.1') + Decimal('0.2'))  # Output: 0.3

Python ์‹ค์ˆ˜์—์„œ ๋ณต์†Œ์ˆ˜๋กœ์˜ ํ˜• ๋ณ€ํ™˜

complex(real,imag)์„ ์‚ฌ์šฉํ•ด ์ •์ˆ˜๋ฅผ ๋ณต์†Œ์ˆ˜๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์‹ค์ˆ˜๋ถ€์™€ ํ—ˆ์ˆ˜๋ถ€ ๋‘ ์ •์ˆ˜๊ฐ€ ํ•„์š”ํ•˜๋ฉฐ, ์‹ค์ˆ˜ ๊ฐ’์„ ๋ณต์†Œ์ˆ˜๋กœ ๋ณ€ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

real = 2
imag = 5
print(complex(real, imag))
(2+5j)

Python ๋ฌธ์ž์—ด๊ณผ์˜ ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜

๋ฌธ์ž์—ด์€ ํ•˜๋‚˜ ์ด์ƒ์˜ ๋ฌธ์ž(๋ฌธ์ž, ์ˆซ์ž, ๊ธฐํ˜ธ)์˜ ๋ชจ์Œ์ž…๋‹ˆ๋‹ค. ๋ฌธ์ž์—ด์„ ์ˆซ์ž๋กœ, ๋˜๋Š” ์ˆซ์ž๋ฅผ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ์ž์ฃผ ์žˆ์Šต๋‹ˆ๋‹ค.

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + total  + "$")

 
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-54bd76b9b4bd> in <module>()
      2 price_cookie = 6
      3 total = price_cake + price_cookie
----> 4 print("The total is: " + total  + "$")


TypeError: Can't convert 'int' object to str implicitly

์œ„ ์˜ˆ์ œ๋Š” TypeError๋ฅผ ๋ฐœ์ƒ์‹œํ‚ค๋ฉฐ, ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์ •์ˆ˜ ๊ฐ’์„ ๋ฌธ์ž์—ด๋กœ ๋ฌต์‹œ์ ์œผ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์—†์Œ์„ ์•Œ๋ ค ์ค๋‹ˆ๋‹ค.

ํ”„๋กœ๊ทธ๋žจ์ด ์—ฌ๊ธฐ์„œ ๋ฌด์—‡์„ ํ•ด์•ผ ํ• ์ง€๋Š” ์ง๊ด€์ ์ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ํ•ญ์ƒ ํ™•์‹ ํ•  ์ˆ˜๋Š” ์—†์œผ๋ฏ€๋กœ, ์›ํ•˜๋Š” ๋ฐ”๋ฅผ ๋ช…ํ™•ํžˆ ์ง€์ •ํ•  ์ˆ˜ ์žˆ๋„๋ก ๋ช…์‹œ์  ํƒ€์ž… ์บ์ŠคํŒ… ๋ฉ”์ปค๋‹ˆ์ฆ˜์„ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค. ๋‹ค์Œ์€ str() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด ์ •์ˆ˜๋ฅผ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค:

price_cake = 15
price_cookie = 6
total = price_cake + price_cookie
print("The total is: " + str(total)  + "$")
The total is: 21$

์‹ค์ˆ˜๋ฅผ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•  ๋•Œ๋„ ๋™์ผํ•˜๊ฒŒ ๋™์ž‘ํ•ฉ๋‹ˆ๋‹ค.

Python์—์„œ๋Š” ๊ฐ€๋Šฅํ•˜๋‹ค๋ฉด ๋ฌธ์ž์—ด์„ ์ •์ˆ˜ ๋ฐ ์‹ค์ˆ˜๋กœ๋„ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋ฌด์Šจ ์˜๋ฏธ์ธ์ง€ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค:

price_cake = '15'
price_cookie = '6'

# String concatenation
total = price_cake + price_cookie
print("The total is: " + total + "$")

# Explicit type conversion to integer
total = int(price_cake) + int(price_cookie)
print("The total is: " + str(total)  + "$")
The total is: 156$
The total is: 21$

์ด์ œ ์ฝ”๋“œ๋ฅผ ๋ถ„ํ•ดํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

price_cake์™€ price_cookie๋Š” ์ฒ˜์Œ์— ๋ฌธ์ž์—ด์ž…๋‹ˆ๋‹ค. ์ดํ•ฉ์„ ๊ตฌํ•˜๋ ค๋ฉด ๋จผ์ € ํ•ด๋‹น ์ •์ˆ˜ ๊ฐ’์œผ๋กœ ๋ณ€ํ™˜ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ์ˆซ์ž ๋ง์…ˆ์ด ์•„๋‹ˆ๋ผ ๋ฌธ์ž์—ด ์ด์–ด๋ถ™์ด๊ธฐ๋ฅผ ํ•˜๋ ค๋Š” ๊ฒƒ์œผ๋กœ ๊ฐ„์ฃผํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ ๋‹ค์Œ ์ด ๊ฐ’์„ ์ตœ์ข… ํ‘œ์‹œ ๋ฌธ์ž์—ด์— ๋„ฃ์–ด์•ผ ํ•˜๋ฏ€๋กœ, ๋ฉ”์‹œ์ง€์˜ ๋‚˜๋จธ์ง€ ๋ถ€๋ถ„๊ณผ ๊ฒฐํ•ฉํ•˜๊ธฐ ์œ„ํ•ด ์ดํ•ฉ์„ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

์ด ์˜ˆ์ œ๊ฐ€ ๋ฐ์ดํ„ฐ ํƒ€์ž… ๋ณ€ํ™˜์˜ ์ค‘์š”์„ฑ์„ ์ดํ•ดํ•˜๋Š” ๋ฐ ๋„์›€์ด ๋˜์—ˆ๊ธฐ๋ฅผ ๋ฐ”๋ž๋‹ˆ๋‹ค. ์•„์ฃผ ์ž‘์€ ์˜ˆ์‹œ์ด์ง€๋งŒ ๊ทธ ์œ ์šฉ์„ฑ์„ ์ด๋ฏธ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ฐธ๊ณ : ๋ฌธ์ž์—ด์„ ์ •์ˆ˜๋‚˜ ์‹ค์ˆ˜๋กœ ๋ณ€ํ™˜ํ•  ๋•Œ "๊ฐ€๋Šฅํ•˜๋‹ค๋ฉด"์ด๋ผ๋Š” ํ‘œํ˜„์„ ๋ณด์…จ๋‚˜์š”? ๋ฌธ์ž์—ด์„ ํ•ญ์ƒ ์ˆซ์ž๋กœ ๋ณ€ํ™˜ํ•˜๊ณ  ์ˆ˜์น˜ ์—ฐ์‚ฐ์„ ์ ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๊ฒƒ์€ ์•„๋‹™๋‹ˆ๋‹ค. ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ์ด๋ฅผ ์ธ์ง€ํ•˜๊ณ  ์žˆ์œผ๋ฉฐ, ์‹œ๋„ํ•  ๊ฒฝ์šฐ ์˜ค๋ฅ˜๋ฅผ ๋ฐœ์ƒ์‹œํ‚ต๋‹ˆ๋‹ค. ์•„๋ž˜ ์˜ˆ์ œ๋ฅผ ํ™•์ธํ•˜์„ธ์š”:

price_cake = 'fifteen'
price_cookie = 'six'
total = int(price_cake) + int(price_cookie)
---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-25-80591b8accda> in <module>()
      1 price_cake = 'fifteen'
      2 price_cookie = 'six'
----> 3 total = int(price_cake) + int(price_cookie)


ValueError: invalid literal for int() with base 10: 'fifteen'

์š”์•ฝ: Python ๊ธฐ๋ณธํ˜• ๋ฐ์ดํ„ฐ ํƒ€์ž… ๋ณ€ํ™˜

๋ณ€ํ™˜ํ•จ์ˆ˜์˜ˆ์‹œ์ถœ๋ ฅ
์ •์ˆ˜ โ†’ ์‹ค์ˆ˜float()float(3)3.0
์‹ค์ˆ˜ โ†’ ์ •์ˆ˜int()int(3.9)3
๋ฌธ์ž์—ด โ†’ ์ •์ˆ˜int()int('123')123
์ •์ˆ˜ โ†’ ๋ฌธ์ž์—ดstr()str(123)'123'

๋น„๊ธฐ๋ณธํ˜• ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ ๋ณ€ํ™˜

Python์—์„œ ํŠœํ”Œ๊ณผ ๋ฆฌ์ŠคํŠธ๋กœ์˜ ๋ณ€ํ™˜

์ •์ˆ˜์™€ ์‹ค์ˆ˜์ฒ˜๋Ÿผ ๋ฆฌ์ŠคํŠธ๋ฅผ ํŠœํ”Œ๋กœ, ํŠœํ”Œ์„ ๋ฆฌ์ŠคํŠธ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

ํŠœํ”Œ๊ณผ ๋ฆฌ์ŠคํŠธ๊ฐ€ ๋ฌด์—‡์ธ์ง€ ๊ธฐ์–ตํ•˜์‹œ๋‚˜์š”? Python์˜ ๋ฆฌ์ŠคํŠธ์™€ ํŠœํ”Œ์€ ๋™์งˆ์˜ ํ•ญ๋ชฉ ๋ชจ์Œ์„ ์ €์žฅํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ๋‘˜์˜ ์ฐจ์ด๋Š” ํŠœํ”Œ์€ ๋ณ€๊ฒฝ ๋ถˆ๊ฐ€๋Šฅ(immutable)ํ•˜๋‹ค๋Š” ์ ์ž…๋‹ˆ๋‹ค. ํ•œ ๋ฒˆ ์ •์˜ํ•˜๋ฉด ๋‚ด๋ถ€์˜ ๊ฐ’์„ ์‚ญ์ œ, ์ถ”๊ฐ€, ์ˆ˜์ •ํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

์™œ ๋ฆฌ์ŠคํŠธ๋ฅผ ํŠœํ”Œ๋กœ ๋ณ€ํ™˜ํ• ๊นŒ์š”?

ํŠœํ”Œ์€ ๋ณ€๊ฒฝ ๋ถˆ๊ฐ€๋Šฅํ•œ ๋ฐ์ดํ„ฐ ํƒ€์ž…์ด๋ฏ€๋กœ ํ”„๋กœ๊ทธ๋žจ์—์„œ ์ƒ๋‹นํ•œ ์ตœ์ ํ™”๋ฅผ ๊ฐ€๋Šฅํ•˜๊ฒŒ ํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด ์™œ ํŠœํ”Œ์„ ๋ฆฌ์ŠคํŠธ๋กœ ๋ณ€ํ™˜ํ• ๊นŒ์š”?

์ดˆ๊ธฐ ํŠœํ”Œ์— ๋ณ€๊ฒฝ์„ ๊ฐ€ํ•˜๊ณ  ์‹ถ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ๊ฒฝ์šฐ ๋ฆฌ์ŠคํŠธ๋กœ ๋ณ€ํ™˜ํ•ด ๋ณ€๊ฒฝํ•œ ๋‹ค์Œ ๋‹ค์‹œ ํŠœํ”Œ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

Python์—์„œ๋Š” tuple() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด ์ „๋‹ฌ๋œ ๊ฐ’์„ ํŠœํ”Œ๋กœ ๋ฐ”๊ฟ€ ์ˆ˜ ์žˆ๊ณ , ์œ ์‚ฌํ•˜๊ฒŒ list() ํ•จ์ˆ˜๋กœ ํŠœํ”Œ์„ ๋ฆฌ์ŠคํŠธ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค:

a_tuple = ('a', 1) ,('f', 2), ('g', 3)
b_list = [1,2,3,4,5]

print(tuple(b_list))
print(list(a_tuple))
(1, 2, 3, 4, 5)
[('a', 1), ('f', 2), ('g', 3)]

๋งˆ์ฐฌ๊ฐ€์ง€๋กœ, ๋ฌธ์ž์—ด์„ ๋ฆฌ์ŠคํŠธ๋‚˜ ํŠœํ”Œ๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ๋ฐฉ๋ฒ•์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค:

dessert = 'Cake'

# Convert the characters in a string to individual items in a tuple
print(tuple(dessert))

# Convert a string into a list
dessert_list = list(dessert)
dessert_list.append('s')
print(dessert_list)
('C', 'a', 'k', 'e')
['C', 'a', 'k', 'e', 's']

Python์—์„œ ๋”•์…”๋„ˆ๋ฆฌ์™€ ์„ธํŠธ๋กœ์˜ ๋ณ€ํ™˜

dict() ํ•จ์ˆ˜๋กœ ํŠœํ”Œ์„ ๋”•์…”๋„ˆ๋ฆฌ๋กœ, set()์œผ๋กœ ๋ฆฌ์ŠคํŠธ๋ฅผ ์„ธํŠธ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.ย 

print(dict(a_tuple))
print(set(b_list))
{'a': 1, 'f': 2, 'g': 3}
{1, 2, 3, 4, 5}

๋‹ค๋ฅธ ๋ณ€ํ™˜ ํ•จ์ˆ˜๋“ค๊ณผ ์œ ์‚ฌํ•˜๊ฒŒ, ์ ์ ˆํ•œ ํ•จ์ˆ˜ ์ด๋ฆ„์„ ์ œ๊ณตํ•˜๊ธฐ๋งŒ ํ•˜๋ฉด ์–ด๋–ค ๋ฐ์ดํ„ฐ ํƒ€์ž…์ด๋“  ๋”•์…”๋„ˆ๋ฆฌ๋‚˜ ์„ธํŠธ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๊ตฌ์กฐ์  ๋ฐ์ดํ„ฐ๋ฅผ ์œ„ํ•œ dataclasses ํ™œ์šฉ(Python 3.7+)

๋”•์…”๋„ˆ๋ฆฌ๋‚˜ ํŠœํ”Œ ๋Œ€์‹ , dataclasses๋Š” ๊ตฌ์กฐ์  ๋ฐ์ดํ„ฐ๋ฅผ ๋‹ค๋ฃจ๋Š” ๋” ๋‚˜์€ ๋ฐฉ๋ฒ•์„ ์ œ๊ณตํ•ฉ๋‹ˆ๋‹ค.

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    in_stock: bool

item = Product("Laptop", 799.99, True)
print(item)  # Output: Product(name='Laptop', price=799.99, in_stock=True)

์š”์•ฝ: Python ๋น„๊ธฐ๋ณธํ˜• ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ ๋ณ€ํ™˜

๋ณ€ํ™˜ํ•จ์ˆ˜์˜ˆ์‹œ์ถœ๋ ฅ
๋ฆฌ์ŠคํŠธ โ†’ ํŠœํ”Œtuple()tuple([1, 2, 3])(1, 2, 3)
ํŠœํ”Œ โ†’ ๋ฆฌ์ŠคํŠธlist()list(('a', 1))['a', 1]
๋ฌธ์ž์—ด โ†’ ๋ฆฌ์ŠคํŠธlist()list('Cake')['C', 'a', 'k', 'e']
๋ฌธ์ž์—ด โ†’ ํŠœํ”Œtuple()tuple('Cake')('C', 'a', 'k', 'e')
ํŠœํ”Œ โ†’ ๋”•์…”๋„ˆ๋ฆฌdict()dict((('a', 1), ('b', 2))){'a': 1, 'b': 2}
๋ฆฌ์ŠคํŠธ โ†’ ์„ธํŠธset()set([1, 2, 3, 4, 5]){1, 2, 3, 4, 5}

Python์˜ ์œ ๋‹ˆ์ฝ”๋“œ, ์ด์ง„์ˆ˜, 8์ง„์ˆ˜, 16์ง„์ˆ˜ ์ •์ˆ˜

์ˆ˜ ์ฒด๊ณ„๋Š” ์–ด๋–ค ์ˆซ์ž ๊ฐ’์„ ๋‚˜ํƒ€๋‚ด๋Š” ๋ฐ ์‚ฌ์šฉํ•˜๋Š” ๊ธฐํ˜ธ๋‚˜ ๋ฌธ์ž์˜ ๊ฐœ์ˆ˜๋ฅผ ๋งํ•ฉ๋‹ˆ๋‹ค. ์ผ์ƒ์—์„œ ๋ณดํ†ต ์‚ฌ์šฉํ•˜๋Š” ์ˆ˜ ์ฒด๊ณ„๋Š” 10์ง„๋ฒ•์ž…๋‹ˆ๋‹ค. 10์ง„๋ฒ•์—์„œ๋Š” 0, 1, 2, 3, 4, 5, 6, 7, 8, 9์˜ ์—ด ๊ฐ€์ง€ ๊ธฐํ˜ธ๋ฅผ ์‚ฌ์šฉํ•ด ๋ชจ๋“  ์–‘์„ ํ‘œํ˜„ํ•ฉ๋‹ˆ๋‹ค. ์œ ๋‹ˆ์ฝ”๋“œ, ์ด์ง„์ˆ˜, 16์ง„์ˆ˜, 8์ง„์ˆ˜๋Š” ์„œ๋กœ ๋‹ค๋ฅธ ์ˆ˜ ์ฒด๊ณ„๋ฅผ ๊ฐ€๋ฆฌํ‚ต๋‹ˆ๋‹ค.

์‚ฌ์šฉ ๊ฐ€๋Šฅํ•œ ๊ธฐํ˜ธ๊ฐ€ ๋‹ค ๋–จ์–ด์ง€๋ฉด ๋‹ค์Œ ์ž๋ฆฟ์ˆ˜๋กœ ๋„˜์–ด๊ฐ‘๋‹ˆ๋‹ค. 10์ง„๋ฒ•์—์„œ๋Š” 9๋ณด๋‹ค ํ•˜๋‚˜ ํฐ ์ˆ˜๋ฅผ 10์œผ๋กœ ํ‘œ๊ธฐํ•˜๋Š”๋ฐ, ์ด๋Š” 10์˜ ์ž๋ฆฌ 1๊ฐœ์™€ 1์˜ ์ž๋ฆฌ 0๊ฐœ๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ๋‹ค๋ฅธ ์ˆ˜ ์ฒด๊ณ„์—์„œ๋Š” ๋‹ค๋ฆ…๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด 0๊ณผ 1 ๋‘ ๊ธฐํ˜ธ๋งŒ ์‚ฌ์šฉํ•˜๋Š” ์ด์ง„์ˆ˜์—์„œ๋Š” ๊ธฐํ˜ธ๊ฐ€ ๋‹ค ๋–จ์–ด์ง€๋ฉด ๋‹ค์Œ ์ž๋ฆฟ์ˆ˜๋กœ ๋„˜์–ด๊ฐ€์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด์ง„์ˆ˜์—์„œ๋Š” ์ด๋ ‡๊ฒŒ ์…‰๋‹ˆ๋‹ค: 0, 1, 10, 11, 100, 101, โ€ฆ

๋‹ค์Œ ์„น์…˜์—์„œ ๋ช‡ ๊ฐ€์ง€ ์ˆ˜ ์ฒด๊ณ„๋ฅผ ๋” ์ž์„ธํžˆ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

Python์—์„œ ์ด์ง„์ˆ˜๋ฅผ 10์ง„์ˆ˜๋กœ ๋ณ€ํ™˜

์ด์ง„์ˆ˜ ์ •์ˆ˜๋Š” ๋ฐ‘์ด 2์ธ ์ˆ˜์ž…๋‹ˆ๋‹ค. ์ฆ‰, ์ด์ง„์ˆ˜ ์ฒด๊ณ„์—์„œ๋Š” ์ˆซ์ž๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ๋ฐ 0๊ณผ 1 ๋‘ ๊ธฐํ˜ธ๋งŒ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ์ด์ง„์ˆ˜๋กœ 0๋ถ€ํ„ฐ ์˜ฌ๋ ค ์„ธ๋ฉด ๊ธฐํ˜ธ๊ฐ€ ๋” ๋นจ๋ฆฌ ์†Œ์ง„๋ฉ๋‹ˆ๋‹ค: 0, 1, ???

์ดํ›„์—๋Š” ๋” ์ด์ƒ ์‚ฌ์šฉํ•  ๊ธฐํ˜ธ๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค. 2๋Š” ์ด์ง„์ˆ˜์— ์กด์žฌํ•˜์ง€ ์•Š์œผ๋ฏ€๋กœ 2๋ผ๋Š” ์ˆซ์ž๋กœ ๊ฐ€์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๋Œ€์‹  1๊ณผ 0์˜ ์กฐํ•ฉ์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ์ด์ง„์ˆ˜ 1000์€ 10์ง„์ˆ˜ 8๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค. ์ด์ง„์ˆ˜์—์„œ๋Š” 2์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ์„ ์‚ฌ์šฉํ•˜๋ฏ€๋กœ, 8์€ (1(2^3)) + (0(2^2)) + (0(2^1)) + (0(2^0)) = 8์ž…๋‹ˆ๋‹ค. 1๊ณผ 0์˜ ์œ„์น˜๊ฐ€ 2๋ฅผ ๋ช‡ ์ œ๊ณฑํ•ด์•ผ ํ•˜๋Š”์ง€๋ฅผ ๊ฒฐ์ •ํ•ฉ๋‹ˆ๋‹ค.

๋” ๋ณต์žกํ•œ ์˜ˆ์ œ๋กœ ํ™•์ธํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค:

Binary Number = 1001111
Decimal value = (1*(2^6)) + (0*(2^5)) + (0*(2^4)) + (1*(2^3)) + (1*(2^2)) + (1*(2^1)) + (1*(2^0))
              = 79

Python์—์„œ๋Š” bin() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด 10์ง„ ๊ฐ’์„ ํ•ด๋‹น ์ด์ง„ ํ‘œํ˜„์œผ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋งˆ์ฐฌ๊ฐ€์ง€๋กœ int() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด ์ด์ง„์ˆ˜๋ฅผ 10์ง„์ˆ˜๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. int() ํ•จ์ˆ˜์˜ ๋‘ ๋ฒˆ์งธ ์ธ์ˆ˜๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜์˜ ๋ฐ‘์„ ์ „๋‹ฌํ•˜๋ฉฐ, ์ด์ง„์ˆ˜์˜ ๊ฒฝ์šฐ 2์ž…๋‹ˆ๋‹ค.

a = 79

# Base 2(binary)
bin_a = bin(a)
print(bin_a)
print(int(bin_a, 2)) #Base 2(binary)
0b1001111
79

Python์—์„œ 8์ง„์ˆ˜๋ฅผ 10์ง„์ˆ˜๋กœ ๋ณ€ํ™˜

8์ง„์ˆ˜๋Š” ์ผ๋ฐ˜์ ์ธ 10์ง„๋ฒ•๋ณด๋‹ค ๊ธฐํ˜ธ๊ฐ€ ๋” ์ ์€ ๋˜ ๋‹ค๋ฅธ ์ˆ˜ ์ฒด๊ณ„์ž…๋‹ˆ๋‹ค. ๋ฐ‘์ด 8๋กœ, ๋ชจ๋“  ์–‘์„ ํ‘œํ˜„ํ•˜๋Š” ๋ฐ 0, 1, 2, 3, 4, 5, 6, 7์˜ ์—ฌ๋Ÿ ๊ฐ€์ง€ ๊ธฐํ˜ธ๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. 7 ๋‹ค์Œ์€ 8์ด ์กด์žฌํ•˜์ง€ ์•Š์œผ๋ฏ€๋กœ 10์ž…๋‹ˆ๋‹ค.

์ด์ง„์ˆ˜์—์„œ ๊ฐ’ ๊ณ„์‚ฐ์— 2์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ์„ ์‚ฌ์šฉํ•œ ๊ฒƒ์ฒ˜๋Ÿผ, 8์ง„์ˆ˜์—์„œ๋Š” ๋ฐ‘์ด 8์ด๋ฏ€๋กœ 8์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

8์ง„์ˆ˜์—์„œ 10์€ 10์ง„์ˆ˜ 8๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค. ํ’€์–ด ์“ฐ๋ฉด: (1(8^1)) + (0(8^0)) = 8.

์ข€ ๋” ๋ณต์žกํ•œ ์˜ˆ:

Octal Number = 117
Decimal value = (1*(8^2)) + (1*(8^1)) + (7*(8^0))
              = 79

Python์—์„œ๋Š” oct() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด 10์ง„ ๊ฐ’์„ ํ•ด๋‹น 8์ง„ ํ‘œํ˜„์œผ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋˜๋Š” int() ํ•จ์ˆ˜์™€ ์˜ฌ๋ฐ”๋ฅธ ๋ฐ‘(8์ง„์ˆ˜์˜ ๊ฒฝ์šฐ 8)์„ ์‚ฌ์šฉํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

a = 79

# Base 8(octal)
oct_a = oct(a)
print(oct_a)
print(int(oct_a, 8))
0o117
79

Python์—์„œ 16์ง„์ˆ˜๋ฅผ 10์ง„์ˆ˜๋กœ ๋ณ€ํ™˜

16์ง„์ˆ˜๋Š” ๋ฐ‘์ด 16์ธ ์ˆ˜ ์ฒด๊ณ„์ž…๋‹ˆ๋‹ค. ์ด์ง„์ˆ˜๋‚˜ 8์ง„์ˆ˜์™€ ๋‹ฌ๋ฆฌ, 10์ง„์ˆ˜์— ์—†๋Š” ์—ฌ์„ฏ ๊ฐœ์˜ ์ถ”๊ฐ€ ๊ธฐํ˜ธ๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด 9 ๋‹ค์Œ์€ ๋ฌด์—‡์ผ๊นŒ์š”?

์ผ๋ฐ˜ ์ˆซ์ž ๊ธฐํ˜ธ๋ฅผ ๋„˜์–ด์„œ๋Š” ์ถ”๊ฐ€ ๊ธฐํ˜ธ๊ฐ€ ํ•„์š”ํ•˜๋ฉด ์•ŒํŒŒ๋ฒณ ๋ฌธ์ž๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ 16์ง„์ˆ˜์—์„œ๋Š” 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

์•ž์˜ ์˜ˆ์™€ ๋™์ผํ•˜๊ฒŒ ์‚ฌ์šฉํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค:

Hexadecimal Number = 4F
Decimal value = (4*(16^1)) + (F*(16^0))
              = 79

Python์—์„œ๋Š” hex() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด 10์ง„ ๊ฐ’์„ ํ•ด๋‹น 16์ง„ ํ‘œํ˜„์œผ๋กœ ๋ณ€ํ™˜ํ•˜๊ฑฐ๋‚˜, int() ํ•จ์ˆ˜์— ๋ฐ‘ 16์„ ์‚ฌ์šฉํ•ด 16์ง„์ˆ˜๋ฅผ 10์ง„์ˆ˜๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

a = 79

# Base 16(hexadecimal)
hex_a = hex(a)
print(hex_a)
print(int(hex_a, 16))
0x4f
79

์œ ๋‹ˆ์ฝ”๋“œ๋ฅผ ๋ฌธ์ž๋กœ ๋ณ€ํ™˜

Python์˜ chr()๋Š” ์œ ๋‹ˆ์ฝ”๋“œ ์ •์ˆ˜๋ฅผ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์œ ๋‹ˆ์ฝ”๋“œ๋Š” ๋‹ค์–‘ํ•œ ์–ธ์–ด์˜ ๋ฌธ์ž๋ฅผ ํ‘œ๊ธฐํ•˜๊ธฐ ์œ„ํ•œ ๋ณดํŽธ์ ์œผ๋กœ ์ธ์ •๋œ ๋ฌธ์ž ์ธ์ฝ”๋”ฉ์ž…๋‹ˆ๋‹ค.

chr() ํ•จ์ˆ˜์— ๋‹ค์–‘ํ•œ ์œ ๋‹ˆ์ฝ”๋“œ ์ •์ˆ˜๋ฅผ ์ „๋‹ฌํ•ด โ€œDATACAMPโ€๋ฅผ ํ‘œ์‹œํ–ˆ์Šต๋‹ˆ๋‹ค. ๋˜ํ•œ ord()๋กœ ๋‹จ์ผ ๋ฌธ์ž๋ฅผ ์œ ๋‹ˆ์ฝ”๋“œ ์ •์ˆ˜๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.ย 

print(
    chr(68),
    chr(65),
    chr(84),
    chr(65),
    chr(67),
    chr(65),
    chr(77),
    chr(80),
)
D A T A C A M P

์š”์•ฝ: Python ์ˆ˜ ์ฒด๊ณ„ ๋ณ€ํ™˜

๋ณ€ํ™˜ํ•จ์ˆ˜์˜ˆ์‹œ์ถœ๋ ฅ
10์ง„์ˆ˜ โ†’ 2์ง„์ˆ˜bin()bin(79)0b1001111
2์ง„์ˆ˜ โ†’ 10์ง„์ˆ˜int()int('1001111', 2)79
10์ง„์ˆ˜ โ†’ 8์ง„์ˆ˜oct()oct(79)0o117
8์ง„์ˆ˜ โ†’ 10์ง„์ˆ˜int()int('117', 8)79
10์ง„์ˆ˜ โ†’ 16์ง„์ˆ˜hex()hex(79)0x4f
16์ง„์ˆ˜ โ†’ 10์ง„์ˆ˜int()int('4F', 16)79
์œ ๋‹ˆ์ฝ”๋“œ โ†’ ๋ฌธ์žchr()chr(68)'D'
๋ฌธ์ž โ†’ ์œ ๋‹ˆ์ฝ”๋“œord()ord('D')68

์ž˜ํ•˜์…จ์Šต๋‹ˆ๋‹ค!

์ถ•ํ•˜ํ•ฉ๋‹ˆ๋‹ค! ์ฃผ๋กœ ๋‚ด์žฅ ๋ฉ”์„œ๋“œ๋ฅผ ์‚ฌ์šฉํ•ด Python์˜ ๋ฐ์ดํ„ฐ ํ˜• ๋ณ€ํ™˜์„ ํ•™์Šตํ–ˆ์Šต๋‹ˆ๋‹ค. ์ด๋Š” ๋‹ค์–‘ํ•œ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ์œ ์—ฐํ•˜๊ฒŒ ๋‹ค๋ฃจ๋ฉฐ ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜๋Š” ๋ฐ ํฐ ๋„์›€์ด ๋ฉ๋‹ˆ๋‹ค.

Intermediate Python for Data Science ๊ณผ์ •์—์„œ๋Š” matplotlib๋กœ ๋ฐ์ดํ„ฐ๋ฅผ ์‹œ๊ฐํ™”ํ•˜๊ณ , ๋”•์…”๋„ˆ๋ฆฌ์™€ ์œ ๋ช…ํ•œ pandas DataFrame์„ ๋‹ค๋ฃจ๋Š” ๋ฐฉ๋ฒ•์„ ๋ฐฐ์›๋‹ˆ๋‹ค. ๋˜ํ•œ ๋ฐ˜๋ณต๋ฌธ์œผ๋กœ ํ”„๋กœ๊ทธ๋žจ์˜ ํ๋ฆ„์„ ์ œ์–ดํ•˜๋Š” ๋ฐฉ๋ฒ•๋„ ์‚ดํŽด๋ด…๋‹ˆ๋‹ค. ๊ณผ์ • ๋งˆ์ง€๋ง‰์—๋Š” ํ•™์Šตํ•œ ๋‚ด์šฉ์„ ์ข…ํ•ฉ์ ์œผ๋กœ ์ ์šฉํ•ด ๋ณผ ์ˆ˜ ์žˆ๋Š” ์‚ฌ๋ก€ ์—ฐ๊ตฌ๊ฐ€ ์ค€๋น„๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค!ย 

FAQs

Python์—์„œ ์ •์ˆ˜ ๋ฆฌ์ŠคํŠธ๋ฅผ ํ•˜๋‚˜์˜ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๋ฉด ์–ด๋–ป๊ฒŒ ํ•˜๋‚˜์š”?

map()๊ณผ join() ๋ฉ”์„œ๋“œ๋ฅผ ํ•จ๊ป˜ ์‚ฌ์šฉํ•ด ๊ฐ ์ •์ˆ˜๋ฅผ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•œ ๋’ค ์—ฐ๊ฒฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

int_list = [1, 2, 3, 4]
result = ''.join(map(str, int_list))
print(result)  # Output: '1234'
์ˆซ์ž๊ฐ€ ์•„๋‹Œ ๋ฌธ์ž์—ด์„ ์ •์ˆ˜๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๊ณ  ํ•˜๋ฉด ์–ด๋–ป๊ฒŒ ๋˜๋‚˜์š”?

ValueError๊ฐ€ ๋ฐœ์ƒํ•˜๋ฉฐ, ํ•ด๋‹น ๋ฌธ์ž์—ด์ด ์œ ํšจํ•œ ์ •์ˆ˜๊ฐ€ ์•„๋‹ˆ๋ผ๊ณ  ํ‘œ์‹œ๋ฉ๋‹ˆ๋‹ค.

int('abc')  # Raises ValueError: invalid literal for int() with base 10: 'abc'
Python์—์„œ ์„ธํŠธ๋ฅผ ๋ฆฌ์ŠคํŠธ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ๋‚˜์š”? ๋ฐฉ๋ฒ•์€?

์˜ˆ, list() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด ์„ธํŠธ๋ฅผ ๋ฆฌ์ŠคํŠธ๋กœ ๋ณ€ํ™˜ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

a_set = {1, 2, 3}
a_list = list(a_set)
print(a_list)  # Output: [1, 2, 3]
๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„๋œ ์ˆซ์ž ๋ฌธ์ž์—ด์„ ์ •์ˆ˜ ๋ฆฌ์ŠคํŠธ๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๋ฉด ์–ด๋–ป๊ฒŒ ํ•˜๋‚˜์š”?

split() ๋ฉ”์„œ๋“œ๋กœ ๋ฌธ์ž์—ด์„ ๋ถ„๋ฆฌํ•œ ๋’ค map()์œผ๋กœ ๊ฐ ๋ถ€๋ถ„์„ ์ •์ˆ˜๋กœ ๋ณ€ํ™˜ํ•˜์„ธ์š”.

numbers = "1 2 3 4"
int_list = list(map(int, numbers.split()))
print(int_list)  # Output: [1, 2, 3, 4]
Python์—์„œ ๋ณ€์ˆ˜์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ํ™•์ธํ•˜๋Š” ํ•จ์ˆ˜๋Š” ๋ฌด์—‡์ธ๊ฐ€์š”?

type() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด ๋ณ€์ˆ˜์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

x = 5
print(type(x))  # Output: <class 'int'>

์ฃผ์ œ