๋ ๋ฒ์งธ ํ์ด์ฌ ์๊ฐ์
๋๋ค.
์ด์ ์๊ฐ(๐PYTHON3_#01 : ์ฐ์ฐ์)์๋ ๋ค์ํ ์ฐ์ฐ์๋ค๊ณผ ์ฌ์ฉ, ๊ทธ ์ฐ์ ์์์ ๋ํด ์์๋ณด์์ต๋๋ค. ์๋ ๋ด์ฉ์ ์ฝ์ด๋ณด๊ณ , ์ ๊ธฐ์ต์ด ๋์ง ์๋๋ค๋ฉด ๋ณต์ตํ์๊ธธ ๋ฐ๋๋๋ค.
โผ ์ฐ์ ์ฐ์ฐ์(matematical operator)์ ์ข
๋ฅ
โผ ๋น๊ต ์ฐ์ฐ์(comparison operator)์ ์ข
๋ฅ
โผ ๋
ผ๋ฆฌ ์ฐ์ฐ์(logical operator)์ ์ข
๋ฅ
โผ ๋ณตํฉ ๋์
์ฐ์ฐ์(in-place operator)์ ์ข
๋ฅ
โผ ๊ฐ ์ฐ์ฐ์๋ค์ validํ ์ฌ์ฉ๋ฒ ๋ฐ ์ฃผ์์ฌํญ
โผ ์ฐ์ฐ์๋ค์ ์ฐ์ ์์
์ด๋ฒ ์๊ฐ์ ์๋ฃํ(data type)๊ณผ ์๋ฃ๊ตฌ์กฐ(data structure)์ ๋ํด ๊ฐ๋จํ ์์๋ณด๊ฒ ์ต๋๋ค.
๊ฐ ์๋ฃํ์ ๋ํ ์์ธํ ํน์ฑ ๋ฐ ๊ธฐ๋ฅ๋ค(methods ๋ฑ) ์ ๊ฐ๋ณ์ ์ผ๋ก ๋ค๋ฃจ๊ฒ ์ต๋๋ค.
- Data Type/Data Structure์ ์ข ๋ฅ ๋ฐ ๊ธฐ๋ณธ ํน์ง
- Mutable object/Immutable object
- Iterable object
[Tip!]
object์ type์ ํ์ธํ๊ณ ์ถ์ ๋ python์ ์๋type(object)
๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค. object์ type์ ๋ฐํํด์ค๋๋ค.
ํ์ด์ฌ์์ ์ฐ์ด๋ ์๋ฃํ์ ์ด 3๊ฐ์ง๊ฐ ์กด์ฌํฉ๋๋ค.
๐ฉํ์ด์ฌ์์ ์ฐ์ด๋ ์๋ฃํ(์์น ์๋ฃํ ๋ฐ ๊ตฐ์ง ์๋ฃํ(str), ๋ถ ์๋ฃํ)
int
(์ ์, integer),float
(์ค์, float),str
(๋ฌธ์์ด, string),bool
(๋ถ, boolean)
int
์๋ฃํ์ ์ ์ type์ธ data๋ฅผ ๋ํ๋
๋๋ค. ์ผ๋ฐ์ ์ผ๋ก 10์ง์๋ฅผ ๋ํ๋
๋๋ค.
๋ค๋ฅธ ์ง์(2์ง์, 8์ง์, 16์ง์)์์ ๋ํ๋ด๊ณ ์ถ์ ๋ ์์ ์ ๋์ฌ๋ฅผ ๋ถ์ด๋ฉด ๋ฉ๋๋ค.
๋ํ, ํจ์๋ฅผ ์ฌ์ฉํด 10์ง์ ์ ์๋ฅผ ๋ค๋ฅธ ์ง์๋ก ๋ํ๋ผ ์ ์์ต๋๋ค.
ex> 10
, 23
, 123
, -1
float
์๋ฃํ์ ์ค์ type์ธ data๋ฅผ ๋ํ๋
๋๋ค.
ex> 1.0
, 2.3
, 12.3
, -1.0
, 2**(1/2)
str
์๋ฃํ์ ๋ฌธ์์ด type์ธ data๋ฅผ ๋ํ๋
๋๋ค.
ํฐ ๋ฐ์ดํ(""
) ๋๋ ์์ ๋ฐ์ดํ(''
)์์ ํ
์คํธ๋ฅผ ์
๋ ฅํจ์ผ๋ก์จ ๋ง๋ค์ด์ง๋ฉฐ, ์ด๋ฌํ ํํ๋ฅผ ๊ฐ์ง๋ ์๋ฃํ์ string ์๋ฃํ์ด๋ผ๊ณ ํฉ๋๋ค.
ํฐ ๋ฐ์ดํ์ ์์ ๋ฐ์ดํ ๊ฐ์ ์ฐจ์ด๋ ์์ต๋๋ค.
๋ฌธ์์ด์ ์ฒซ๋ฒ์งธ ๋ฌธ์๋ถํฐ ์์๋๋ก [0], [1], [2], ... ์ ์ธ๋ฑ์ค๊ฐ ๋ถ์ฌ๋ฉ๋๋ค.
python3์์ ๋ฌธ์์ด์ ๊ธฐ๋ณธ์ ์ผ๋ก ์ ๋์ฝ๋ ์ ๋๋ค. ๋ฐ๋ผ์ ํ๊ธ์ ์ฌ์ฉ์ด ํธ๋ฆฌํฉ๋๋ค.
์๋์ ๊ฐ์ด ์
๋ ฅ ์, ๊ฐํ๋ฌธ์(enter, \n
)๋ฅผ ์
๋ ฅํ์ง ์๊ณ ๋ ์ด์์ ์ค์ ๊ฐ์ง ๋ฌธ์์ด์ ๋ง๋ค ์ ์์ต๋๋ค.
> In [1] : a = """One
Two
Three"""
> In [2] : a
> Out [2] : 'One\nTwo\nThree'
'string'
, '2'
, "12.3"
, "[1,2,3,4]"
, "(2,3)"
bool
์๋ฃํ์ ๋ถ๋ฆฐ type์ธ data๋ฅผ ๋ํ๋
๋๋ค.
๋ถ๋ฆฐ ํ์
์ด๋, ์ฐธ ๋๋ ๊ฑฐ์ง, 0 ๋๋ 1๊ณผ ๊ฐ์ ํ์
์ ๋ปํฉ๋๋ค.
Python์์๋ ๋ถ๋ฆฐ ํ์
์ True
์ False
๋ก ๊ท์ ํ์ผ๋ฉฐ, ์ด๋ฌํ ํํ๋ฅผ ๊ฐ์ง๋ ์๋ฃํ์ bool ์๋ฃํ์ด๋ผ๊ณ ํฉ๋๋ค.
True == 1, False == 0 ์ ๋ถ๋ฆฐ ๊ฐ์ ๊ฐ์ง๋๋ค.
ex> True
, False
, True==False
, not True
, True and False
, False or False
ํ์ด์ฌ์์ ์ฐ์ด๋ ์๋ฃ๊ตฌ์กฐ๋ ์ด 4์ง๊ฐ ์กด์ฌํฉ๋๋ค.
๐ฉํ์ด์ฌ์์ ์ฐ์ด๋ ์๋ฃ๊ตฌ์กฐ(๊ตฐ์ง ์๋ฃํ)
list
(๋ฆฌ์คํธ, list),tuple
(ํํ, tuple),set
(์งํฉ, set),dict
(์ฌ์ , dictionary)
list
์๋ฃ๊ตฌ์กฐ๋ ๋ฐฐ์ด๊ณผ ์ ์ฌํ๋ฉฐ, ์๋ฃ๋ค(items)์ index number๋ฅผ ๋ถ์ฌ ์ ์ฅํฉ๋๋ค. ์ฒซ๋ฒ์งธ ์๋ฃ๋ถํฐ ์์๋๋ก [0], [1], [2], ... ์ ์ธ๋ฑ์ค๊ฐ ๋ถ์ฌ๋ฉ๋๋ค.
๋๊ดํธ([]
) ์์ ์๋ฃ๋ฅผ ์ ์ฅํ๋ฉฐ, ๋น์ด์๋ ๋ฆฌ์คํธ๋ []
๋ก ์ ์ํฉ๋๋ค. ์ผํ(,)๋ฅผ ํตํด ์๋ฃ๋ค(items)์ ๊ตฌ๋ถํฉ๋๋ค.
๋ฐฐ์ด(array, C์ธ์ด) ๊ณผ ๋ฌ๋ฆฌ ๋ฆฌ์คํธ์๋ int
, float
์ธ์๋string
, bool
, tuple
, dict
๋ฑ ๋ค์ํ ํํ์ ์๋ฃ๊ฐ ์ ์ฅ๋ ์ ์์ผ๋ฉฐ, ํ๋์ ๋ฆฌ์คํธ์ ๋ค์ํ ํํ์ item๋ค์ ์ ์ฅํ ์ ์์ต๋๋ค. ๋ํ, ๋ฆฌ์คํธ๋ list
๊ฐ list
๋ฅผ ํฌํจํ๋ nested๊ฐ ๊ฐ๋ฅํฉ๋๋ค. ์ด๋ฅผ ํ์ฉํด 2D Matrix๋ฅผ ๊ตฌํํ ์ ์์ต๋๋ค.
๋น ๋ฆฌ์คํธ(empty list)๋ ์๋์ ๊ฐ์ด ๋ง๋ค ์ ์์ต๋๋ค. ์ฐธ๊ณ ๋ก ์๋์ ๊ฐ์ด ๋ณ์๋ฅผ ์ ์ธํ๊ณ ๋ฆฌ์คํธ๋ฅผ ์ ๋ ฅํด์ฃผ๋ ๊ฒ์ ์ด๊ธฐํ๋ผ๊ณ ํ๋๋ฐ, ์ด๊ธฐํ ์ ๋ฆฌ์คํธ ์์ ๊ฐ์ด ์์ด๋ ๋ฌด๋ฐฉํฉ๋๋ค. ๋ณ์๋ฅผ ์ ์ธํ๊ณ ๊ฐ์ ์ ๋ ฅํด์ฃผ๋ ๊ฒ ์์ฒด๋ฅผ ์ด๊ธฐํ๋ผ๊ณ ํฉ๋๋ค.
#๋น ๋ฆฌ์คํธ๋ฅผ ๋ง๋๋ ์ฒซ๋ฒ์งธ ๋ฐฉ๋ฒ
> In [1] : a = []
#๋น ๋ฆฌ์คํธ๋ฅผ ๋ง๋๋ ๋๋ฒ์งธ ๋ฐฉ๋ฒ
> In [2] : b = list()
[,]
, [1,2,3]
, [[1,2,], 3, 3.0, "string", True, {1,4,5}, (0,1), {'a' : 1}]
tuple
์๋ฃ๊ตฌ์กฐ๋ list
์ ์ ์ฌํ๋ฉฐ, ์๋ฃ๋ค(items)์ index number๋ฅผ ๋ถ์ฌ ์ ์ฅํฉ๋๋ค. ์ฒซ๋ฒ์งธ ์๋ฃ๋ถํฐ ์์๋๋ก [0], [1], [2], ... ์ ์ธ๋ฑ์ค๊ฐ ๋ถ์ฌ๋ฉ๋๋ค.
์๊ดํธ(()
) ์์ ์๋ฃ๋ฅผ ์ ์ฅํ๋, ์๊ดํธ๋ ์๋ต ๊ฐ๋ฅํฉ๋๋ค.
๋น์ด์๋ ํํ์ ()
๋ก ์ ์ํ๋ฉฐ ์ผํ(,)๋ฅผ ํตํด ์๋ฃ๋ค(items)์ ๊ตฌ๋ถํฉ๋๋ค.
list์ ๋ง์ฐฌ๊ฐ์ง๋ก int
, float
์ธ์๋string
, bool
, tuple
, dict
๋ฑ ๋ค์ํ ํํ์ ์๋ฃ๊ฐ ์ ์ฅ๋ ์ ์์ผ๋ฉฐ, ํ๋์ ํํ์ ๋ค์ํ ํํ์ member๋ค์ ์ ์ฅํ ์ ์์ต๋๋ค. ๋ํ, ํํ์ tuple
์ด tuple
์ ํฌํจํ๋ nested๊ฐ ๊ฐ๋ฅํฉ๋๋ค.
๋ฆฌ์คํธ์ ํํ์ ์ฐจ์ด๋ ํ์ ๋์ฌ mutable object/immutable object์ ๊ด๋ จ ์์ต๋๋ค.
๋น ํํ(empty tuple)์ ์๋์ ๊ฐ์ด ๋ง๋ค ์ ์์ต๋๋ค.
#๋น ํํ์ ๋ง๋๋ ์ฒซ๋ฒ์งธ ๋ฐฉ๋ฒ
> In [1] : a = ()
#๋น ํํ์ ๋ง๋๋ ๋๋ฒ์งธ ๋ฐฉ๋ฒ
> In [2] : b = tuple()
()
, (1,2,3)
, ([1,2,], 3, 3.0, "string", True, {1,4,5}, (0,1), {'a' : 1})
set
์๋ฃ๊ตฌ์กฐ๋ list
, dict
์ ์ ์ฌํ๋ฉฐ, ์์๊ฐ ์๊ธฐ(unordered) ๋๋ฌธ์ index ์ฌ์ฉ์ด ๋ถ๊ฐ๋ฅํฉ๋๋ค.
์ค๊ดํธ({}
) ์์ ์๋ฃ๋ฅผ ์ ์ฅํ๋ฉฐ, ์ผํ(,)๋ฅผ ํตํด ์๋ฃ๋ค(items)์ ๊ตฌ๋ถํฉ๋๋ค.
โ {}
๋ dict
๋ก ์ ์๋๋ฉฐ, set
์ด ์๋๋ผ๋ ์ ์ ์ฃผ์ํ๋๋ก ํฉ์๋ค.
set ์์๋ int
, float
, string
, bool
, tuple
๋ง์ด ์ ์ฅ๋ ์ ์์ผ๋ฉฐ, ํ๋์ set์ ๋ค์ํ ํํ์ element๋ค์ ์ ์ฅํ ์ ์์ต๋๋ค.
set์ ์งํฉ๊ณผ ์ ์ฌํ ์ฑ์ง์ ์ง๋
๊ธฐ ๋๋ฌธ์ ์งํฉ๊ณผ ๊ด๋ จ๋ ์ฐ์ฐ์ ์ํํ ์ ์์ต๋๋ค.
๋ํ, ์ค๋ณต element๋ ์ ์ฅํ ์ ์์ต๋๋ค. ๋ง์ผ ์ค๋ณต๋ element๊ฐ ์์ ๊ฒฝ์ฐ, ์๋์ ๊ฐ์ด ์ค๋ณต์ ์ ๊ฑฐํฉ๋๋ค.
#set์ ์ค๋ณต๋ ์์๋ฅผ ์ ์ฅํ๋ฉด ์ค๋ณต์ ์ ๊ฑฐํฉ๋๋ค.
> In [1] : a = {True,1,2,3,3.0,4}
> In [2] : a
> Out [2] : {1,2,3,4} #True == 1, 3 == 3.0 ์ด๋ฏ๋ก
#๋น set์ ๋ง๋๋๋ฐฉ๋ฒ : ํด๋์ค ์์ฑ์ ์ด์ฉ
> In [1] : a = set()
{0,1}
, {1}
, {3, "string", (0,1), True}
dict
์๋ฃ๊ตฌ์กฐ๋ ํค-๊ฐ ์(key-value pair)์ ๋งคํ(mapping)ํฉ๋๋ค. ์ฆ, ์์์ ํค์ ๊ฐ์ ์๋ก ์ฐ๊ฒฐ์ง์ด ์๋ฃ๋ฅผ ์ ์ฅํฉ๋๋ค.
์ค๊ดํธ({}
) ์์ ํค-๊ฐ ์๋ค์ ์ ์ฅํ๋ฉฐ, {key:value}
ํํ๋ก ๋งคํํฉ๋๋ค.์ผํ(,)๋ฅผ ํตํด ์๋ฃ๋ค(items)์ ๊ตฌ๋ถํฉ๋๋ค. ๋น์ด์๋ dictionary๋{}
๋ก ์ ์ํฉ๋๋ค.
key์๋ immutable objct๋ง ์ฌ์ฉํ ์ ์์ต๋๋ค.
mutable๊ณผ immutable์ ๊ด๋ จ๋ ๋ด์ฉ์ ์๋์์ ๋ค๋ฃจ๊ฒ ์ต๋๋ค.
๋น dictionary(empty dictionary)๋ ์๋์ ๊ฐ์ด ๋ง๋ค ์ ์์ต๋๋ค.
#๋น dict๋ฅผ ๋ง๋๋ ์ฒซ๋ฒ์งธ ๋ฐฉ๋ฒ
> In [1] : a = {}
#๋น dict๋ฅผ ๋ง๋๋ ๋๋ฒ์งธ ๋ฐฉ๋ฒ
> In [2] : b = dict()
{'a' : 0,3: 1}
, {1 : [1,2,34]}
, {3:{1,2,3,4}, 0: "string", (0,1) : 'a', True : 0}
[Tip!]
object์ type์ ๋ณํํ๊ณ ์ถ์ ๋ python์ ์๋ Class constructor(ํด๋์ค ์์ฑ์)๋ฅผ ์ด์ฉํ๋ฉด ๋ฉ๋๋ค. ์์ฑ์๋ ๋ฉ์๋์ ํ ์ข ๋ฅ์ด๋ฉฐ, ์์ธํ ๋ด์ฉ์class
๋ฅผ ๋ค๋ฃฐ ๋ ์ด์ผ๊ธฐํ๋๋ก ํ๊ฒ ์ต๋๋ค.
- int(object)
- str(object)
- float(object)
- list(object)
- tuple(object)
- set(object)
mutable object๋ ๊ฐ์ด ๋ณํ ์ ์๋ object๋ฅผ ๋ปํฉ๋๋ค.
์ฝ๊ฒ ๋งํด, object์ ๊ฐ๋ณ element ๊ฐ์ด ์์ ๊ฐ๋ฅํ๋ค๋ฉด mutable object์
๋๋ค.
๋ฉ๋ชจ๋ฆฌ ์ฃผ์ ์ธก๋ฉด์์ 'mutableํ๋ค'๋ผ๋ ๊ฒ์, object์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์ ๋ณ๊ฒฝ ์์ด object์ ๊ฐ๋ณ element๊ฐ์ ๋ณ๊ฒฝํ ์ ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
[Tip!]
object์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์๊ณ ์ถ์ ๋ python์ ์๋id(object)
๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค. object์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋ฐํํด์ค๋๋ค.
mutable object๋ ์๋์ ๊ฐ์ต๋๋ค. ๋ง์ผ ์๋์ object๋ค์ด ์ ๋ง mutableํ์ง ์๊ณ ์ถ๋ค๋ฉด ์์ ์๋ id()๋ฅผ ์ด์ฉํด object์ ์์ ๊ฐ์ ์์ ํด๊ฐ๋ฉฐ ์ง์ ํ์ธํด๋ณด๋๋ก ํฉ์๋ค.
list
์ธ๋ฑ์ค๋ฅผ ํตํ ์ ๊ทผ์ผ๋ก ์์ ๊ฐ์ ์์ ์ด ๊ฐ๋ฅํฉ๋๋ค.
dict
ํค(key)๋ฅผ ํตํ ์ ๊ทผ์ผ๋ก ๊ฐ(value)์ ์์ ์ด ๊ฐ๋ฅํฉ๋๋ค.
set
ํจ์๋ฅผ ํตํ ์ ๊ทผ์ผ๋ก ์์ ๊ฐ์ ์์ ์ด ๊ฐ๋ฅํฉ๋๋ค.
immutable object๋ mutable object์ ๋ฐ๋๋๋ ๊ฐ๋
์
๋๋ค.
๊ฐ์ด ๋ณํ ์ ์๋ object๋ฅผ ๋ปํฉ๋๋ค.
์ฝ๊ฒ ๋งํด, object์ ๊ฐ๋ณ element ๊ฐ์ด ์์ ๋ถ๊ฐ๋ฅํ๋ค๋ฉด immutable object์
๋๋ค.
๋ฉ๋ชจ๋ฆฌ ์ฃผ์ ์ธก๋ฉด์์ 'immutableํ๋ค'๋ผ๋ ๊ฒ์, object์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์ ๋ณ๊ฒฝ ์์ด object์ ๊ฐ๋ณ element๊ฐ์ ๋ณ๊ฒฝํ ์ ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
[Tip!]
python์ ๋ณ์์ ๊ณต๊ฐ์ ํ ๋นํ๊ณ , ํด๋น ๋ณ์์ ๊ฐ์ ์ ์ฅํ๋ ํ์์ด ์๋๋๋ค.
python์์ ๋ณ์๋ pointer์ ์ ์ฌํ๊ฒ ๋์ํ๊ธฐ ๋๋ฌธ์ a = 3์ผ ๋, id(3)์ ๊ฐ๊ณผ id(a)์ ๊ฐ์ด ๋์ผํฉ๋๋ค. ์ดํด๊ฐ ๊ฐ์ง ์๋๋ค๋ฉด ์ง์ id()๋ฅผ ์ด์ฉํด ํ์ธํด๋ณด๋๋ก ํฉ์๋ค.
immutable object๋ ์๋์ ๊ฐ์ต๋๋ค. ๋ง์ผ ์๋์ object๋ค์ด ์ ๋ง immutableํ์ง ์๊ณ ์ถ๋ค๋ฉด id()๋ฅผ ์ด์ฉํด ์ง์ ํ์ธํด๋ณด๋๋ก ํฉ์๋ค.
int
str
์ธ๋ฑ์ค๋ฅผ ํตํ ์ ๊ทผ์ผ๋ก ์์ ๊ฐ์ ์์ ์ด ๋ถ๊ฐ๋ฅํฉ๋๋ค.
tuple
์ธ๋ฑ์ค๋ฅผ ํตํ ์ ๊ทผ์ผ๋ก ์์ ๊ฐ์ ์์ ์ด ๋ถ๊ฐ๋ฅํฉ๋๋ค.
Iterable object๋, ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด๋ฅผ ๋งํฉ๋๋ค.
iterable object๋ iterator๋ฅผ ๊ฐ์ง๊ณ ์๊ณ , ๋ฐ๋ณต๋ฌธ์์๋ iterator๋ฅผ ์ฌ์ฉํด ํ๋์ฉ ์ ๊ทผํฉ๋๋ค.
๋ฐ๋ผ์ object์ element๋ฅผ ํ๋์ฉ ์ฐจ๋ก๋ก ๋ฐํ ๊ฐ๋ฅํ๋ฉฐ for๋ฌธ ๋ฑ์ ํตํด element๋ค์ ํ๋์ฉ ๊บผ๋ผ ์ ์์ต๋๋ค.
enumerate(object)
๋ฅผ ํตํด index์ element๋ฅผ ํจ๊ป ๋ฐํ ํ ์ ์์ต๋๋ค.#enumerate
> In [1] : numbers = [0, 1, 2, 3, 4]
> In [2] : for i, v in enumerate(numbers):
print(i, v)
> Out [2] : 0 0
1 1
2 2
3 3
4 4
str
list
dict
set
tuple
range
: ์ ์์ ์ด์ ์์ฑํฉ๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ฐ๋ณต๋ฌธ์ ๋ค๋ฃจ๋ฉฐ ์งํํ๊ฒ ์ต๋๋ค.
์ด๋ฒ ์๊ฐ์๋ ์๋ฃํ๊ณผ ์๋ฃ ๊ตฌ์กฐ, mutable object์ immutable object, iterable object์ ๋ํด ์์๋ณด์์ต๋๋ค.
์๋ ๋ฆฌ์คํธ๋ฅผ ์ฒ์ฒํ ์ฝ์ด๋ณด๋ฉด์ ์ค๋ ํ์ตํ ๋ด์ฉ์ ๋ณต์ตํด๋ณด๋๋ก ํฉ์๋ค.
โผ ์๋ฃํ(data type)์ ์ข
๋ฅ์ ํํ
โผ ์๋ฃ ๊ตฌ์กฐ(data structure)์ ์ข
๋ฅ์ ์์ฑ ๋ฐฉ๋ฒ, ํน์ง, ์ ์ฅํ ์ ์๋ ์๋ฃ์ ํํ
โผ mutable object์ ์ ์์ ์ข
๋ฅ
โผ immutable object์ ์ ์์ ์ข
๋ฅ
โผ iterable object์ ์ ์์ ์ข
๋ฅ ๋ฐ ํน์ง
โผ object์ ํ๋ณํ, type(), id(), enumerate()