์ด ์์ ์์๋ ์ ์ ๊ฐ 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์ ๋ค๋ฃจ๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์๋๋ค. ๋ํ ๋ฐ๋ณต๋ฌธ์ผ๋ก ํ๋ก๊ทธ๋จ์ ํ๋ฆ์ ์ ์ดํ๋ ๋ฐฉ๋ฒ๋ ์ดํด๋ด ๋๋ค. ๊ณผ์ ๋ง์ง๋ง์๋ ํ์ตํ ๋ด์ฉ์ ์ข ํฉ์ ์ผ๋ก ์ ์ฉํด ๋ณผ ์ ์๋ ์ฌ๋ก ์ฐ๊ตฌ๊ฐ ์ค๋น๋์ด ์์ต๋๋ค!ย
Python์ ๋ชจ๋ ๊ฐ์๋ ๋ฐ์ดํฐ ํ์ ์ด ์์ต๋๋ค. ๋ฐ์ดํฐ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ์ด๋ป๊ฒ ์ฌ์ฉํ ์ง ์ปดํ์ผ๋ฌ๋ ์ธํฐํ๋ฆฌํฐ์ ์๋ ค ์ฃผ๋ ๋ฐ์ดํฐ์ ๋ถ๋ฅ์ ๋๋ค. ํ์ ์ ๋ฐ์ดํฐ์ ์ํํ ์ ์๋ ์ฐ์ฐ๊ณผ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๊ตฌ์กฐ๋ฅผ ์ ์ํฉ๋๋ค. ๋ฐ์ดํฐ ๊ณผํ์์๋ ๋ฐ์ดํฐ๋ฅผ ๋ ์ฝ๊ฒ ์ฌ์ฉํ๊ณ ๋ค๋ฃจ๊ธฐ ์ํด ํ์ ์ ๋ณ๊ฒฝํด์ผ ํ๋ ์ผ์ด ์์ฃผ ์์ต๋๋ค.
Python์๋ ๋ค์ํ ๋ฐ์ดํฐ ํ์ ์ด ์์ต๋๋ค. ์ด๋ฏธ ๋ช ๊ฐ์ง๋ ๋ณด์๊ณ ์ฌ์ฉํด ๋ณด์ จ์ ๊ฒ๋๋ค. ์ ์์ ์ค์๋ ์์น ๊ฐ์, ๋ถ๋ฆฌ์ธ(
bool)์ ์ฐธ/๊ฑฐ์ง ๊ฐ์, ๋ฌธ์์ด์ ์์ซ์ ๋ฌธ์๋ฅผ ๋ค๋ฃจ๋ ๋ฐ ์ฌ์ฉํฉ๋๋ค. ๊ฐ์ ๋ชจ์์ ์ ์ฅํ๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ก๋ ๋ฆฌ์คํธ, ํํ, ๋์ ๋๋ฆฌ, ์ธํธ๊ฐ ์์ต๋๋ค. ๋ ์์ธํ ์์๋ณด๋ ค๋ฉด DataCamp์ Data Types in Python ๊ณผ์ ์ ํ์ธํ์ธ์.์ด ํํ ๋ฆฌ์ผ์ ์์ ์ฝ๋๋ฅผ ์ง์ ์ฝ๊ฒ ์คํํด ๋ณด๋ ค๋ฉด, Python์ด ๋ฏธ๋ฆฌ ์ค์น๋์ด ์๊ณ ๋ชจ๋ ์ฝ๋ ์ํ์ด ํฌํจ๋ DataLab ์ํฌ๋ถ์ ๋ฌด๋ฃ๋ก ์์ฑํ์ธ์.
Python์์ ๋ฐ์ดํฐ ํ์ ํ์ธํ๊ธฐ
ํ ๋ณํ์ ์์ ํ์ ์ ํ์ธํ๋ฉด ์ ์ฉํฉ๋๋ค. Python์ ๋ ๊ฐ์ง ์ฃผ์ ํจ์๋ฅผ ์ ๊ณตํฉ๋๋ค:
type(): ๋ณ์์ ํ์ ์ ๋ฐํํฉ๋๋ค.isinstance(): ๋ณ์๊ฐ ํน์ ํ์ ์ ์ํ๋์ง ํ์ธํฉ๋๋ค.Python์ ๋ฌต์์ ๋ฐ ๋ช ์์ ๋ฐ์ดํฐ ํ ๋ณํ
Python์์ ํ ๋ณํ์ ๋ ๊ฐ์ง ๋ฐฉ์์ผ๋ก ์ผ์ด๋ฉ๋๋ค. ์ปดํ์ผ๋ฌ์ ์ด๋ค ํ์ ์ผ๋ก ๋ณํํ ์ง ๋ช ์์ ์ผ๋ก ์ง์ํ๊ฑฐ๋, ์ปดํ์ผ๋ฌ๊ฐ ์ค์ค๋ก ์ด๋ฅผ ์ดํดํ๊ณ ๋ณํ์ ์ํํ๋ ๋ฐฉ์์ ๋๋ค. ์ ์๋ ๋ช ์์ ๋ฐ์ดํฐ ํ ๋ณํ์ด๊ณ , ํ์๋ ๋ฌต์์ ๋ฐ์ดํฐ ํ ๋ณํ์ ๋๋ค.
Python ๋ฌต์์ ๋ฐ์ดํฐ ํ ๋ณํ
๋ฌต์์ ๋ณํ(๋๋ ๊ฐ์ ๋ณํ, coercion)์ ์ปดํ์ผ ์ ๋๋ ์คํ ์์ ํ ๋ณํ์ด ์ผ์ด๋๋ฉฐ Python์ด ์ด๋ฅผ ์๋์ผ๋ก ์ฒ๋ฆฌํ๋ ๊ฒฝ์ฐ๋ฅผ ๋งํฉ๋๋ค. ์์ ๋ฅผ ๋ณด๊ฒ ์ต๋๋ค:
ํ: Python์์
type()ํจ์๋ฅผ ์ฌ์ฉํด ๊ฐ์ฒด์ ๋ฐ์ดํฐ ํ์ ์ ํ์ธํ ์ ์์ต๋๋ค.