๋‘ ๋ฒˆ์งธ ํŒŒ์ด์ฌ ์‹œ๊ฐ„์ž…๋‹ˆ๋‹ค.
์ด์ „ ์‹œ๊ฐ„(๐ŸPYTHON3_#01 : ์—ฐ์‚ฐ์ž)์—๋Š” ๋‹ค์–‘ํ•œ ์—ฐ์‚ฐ์ž๋“ค๊ณผ ์‚ฌ์šฉ, ๊ทธ ์šฐ์„ ์ˆœ์œ„์— ๋Œ€ํ•ด ์•Œ์•„๋ณด์•˜์Šต๋‹ˆ๋‹ค. ์•„๋ž˜ ๋‚ด์šฉ์„ ์ฝ์–ด๋ณด๊ณ , ์ž˜ ๊ธฐ์–ต์ด ๋‚˜์ง€ ์•Š๋Š”๋‹ค๋ฉด ๋ณต์Šตํ•˜์‹œ๊ธธ ๋ฐ”๋ž๋‹ˆ๋‹ค.

โ—ผ ์‚ฐ์ˆ  ์—ฐ์‚ฐ์ž(matematical operator)์˜ ์ข…๋ฅ˜
โ—ผ ๋น„๊ต ์—ฐ์‚ฐ์ž(comparison operator)์˜ ์ข…๋ฅ˜
โ—ผ ๋…ผ๋ฆฌ ์—ฐ์‚ฐ์ž(logical operator)์˜ ์ข…๋ฅ˜
โ—ผ ๋ณตํ•ฉ ๋Œ€์ž… ์—ฐ์‚ฐ์ž(in-place operator)์˜ ์ข…๋ฅ˜
โ—ผ ๊ฐ ์—ฐ์‚ฐ์ž๋“ค์˜ validํ•œ ์‚ฌ์šฉ๋ฒ• ๋ฐ ์ฃผ์˜์‚ฌํ•ญ
โ—ผ ์—ฐ์‚ฐ์ž๋“ค์˜ ์šฐ์„ ์ˆœ์œ„

์ด๋ฒˆ ์‹œ๊ฐ„์€ ์ž๋ฃŒํ˜•(data type)๊ณผ ์ž๋ฃŒ๊ตฌ์กฐ(data structure)์— ๋Œ€ํ•ด ๊ฐ„๋‹จํžˆ ์•Œ์•„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.
๊ฐ ์ž๋ฃŒํ˜•์— ๋Œ€ํ•œ ์ž์„ธํ•œ ํŠน์„ฑ ๋ฐ ๊ธฐ๋Šฅ๋“ค(methods ๋“ฑ) ์€ ๊ฐœ๋ณ„์ ์œผ๋กœ ๋‹ค๋ฃจ๊ฒ ์Šต๋‹ˆ๋‹ค.

  1. Data Type/Data Structure์˜ ์ข…๋ฅ˜ ๋ฐ ๊ธฐ๋ณธ ํŠน์ง•
  2. Mutable object/Immutable object
  3. Iterable object

Data Type/Data Structure์˜ ์ข…๋ฅ˜ ๋ฐ ๊ธฐ๋ณธ ํŠน์ง•

[Tip!]
object์˜ type์„ ํ™•์ธํ•˜๊ณ  ์‹ถ์„ ๋• python์— ์žˆ๋Š” type(object)๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค. object์˜ type์„ ๋ฐ˜ํ™˜ํ•ด์ค๋‹ˆ๋‹ค.

๐Ÿ“ง ์ž๋ฃŒํ˜•(data type)์˜ ์ข…๋ฅ˜

ํŒŒ์ด์ฌ์—์„œ ์“ฐ์ด๋Š” ์ž๋ฃŒํ˜•์€ ์ด 3๊ฐ€์ง€๊ฐ€ ์กด์žฌํ•ฉ๋‹ˆ๋‹ค.

๐ŸšฉํŒŒ์ด์ฌ์—์„œ ์“ฐ์ด๋Š” ์ž๋ฃŒํ˜•(์ˆ˜์น˜ ์ž๋ฃŒํ˜• ๋ฐ ๊ตฐ์ง‘ ์ž๋ฃŒํ˜•(str), ๋ถˆ ์ž๋ฃŒํ˜•)

int(์ •์ˆ˜, integer), float(์‹ค์ˆ˜, float), str(๋ฌธ์ž์—ด, string), bool(๋ถˆ, boolean)

1. int ์ž๋ฃŒํ˜• (integer, ์ •์ˆ˜)

  • int ์ž๋ฃŒํ˜•์€ ์ •์ˆ˜ type์ธ data๋ฅผ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค. ์ผ๋ฐ˜์ ์œผ๋กœ 10์ง„์ˆ˜๋ฅผ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค.
    ๋‹ค๋ฅธ ์ง„์ˆ˜(2์ง„์ˆ˜, 8์ง„์ˆ˜, 16์ง„์ˆ˜)์ž„์„ ๋‚˜ํƒ€๋‚ด๊ณ  ์‹ถ์„ ๋• ์ˆ˜์— ์ ‘๋‘์‚ฌ๋ฅผ ๋ถ™์ด๋ฉด ๋ฉ๋‹ˆ๋‹ค.
    ๋˜ํ•œ, ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด 10์ง„์ˆ˜ ์ •์ˆ˜๋ฅผ ๋‹ค๋ฅธ ์ง„์ˆ˜๋กœ ๋‚˜ํƒ€๋‚ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

  • ex> 10, 23, 123, -1

2. float ์ž๋ฃŒํ˜• (float, ์‹ค์ˆ˜)

  • float ์ž๋ฃŒํ˜•์€ ์‹ค์ˆ˜ type์ธ data๋ฅผ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค.

  • ex> 1.0, 2.3, 12.3, -1.0, 2**(1/2)

3. str ์ž๋ฃŒํ˜• (string, ๋ฌธ์ž์—ด)

  • str ์ž๋ฃŒํ˜•์€ ๋ฌธ์ž์—ด type์ธ data๋ฅผ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค.
    ํฐ ๋”ฐ์˜ดํ‘œ("") ๋˜๋Š” ์ž‘์€ ๋”ฐ์˜ดํ‘œ('')์•ˆ์— ํ…์ŠคํŠธ๋ฅผ ์ž…๋ ฅํ•จ์œผ๋กœ์จ ๋งŒ๋“ค์–ด์ง€๋ฉฐ, ์ด๋Ÿฌํ•œ ํ˜•ํƒœ๋ฅผ ๊ฐ€์ง€๋Š” ์ž๋ฃŒํ˜•์„ string ์ž๋ฃŒํ˜•์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.
    ํฐ ๋”ฐ์˜ดํ‘œ์™€ ์ž‘์€ ๋”ฐ์˜ดํ‘œ ๊ฐ„์˜ ์ฐจ์ด๋Š” ์—†์Šต๋‹ˆ๋‹ค.

  • ๋ฌธ์ž์—ด์˜ ์ฒซ๋ฒˆ์งธ ๋ฌธ์ž๋ถ€ํ„ฐ ์ˆœ์„œ๋Œ€๋กœ [0], [1], [2], ... ์˜ ์ธ๋ฑ์Šค๊ฐ€ ๋ถ€์—ฌ๋ฉ๋‹ˆ๋‹ค.

  • python3์—์„œ ๋ฌธ์ž์—ด์„ ๊ธฐ๋ณธ์ ์œผ๋กœ ์œ ๋‹ˆ์ฝ”๋“œ ์ž…๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ํ•œ๊ธ€์˜ ์‚ฌ์šฉ์ด ํŽธ๋ฆฌํ•ฉ๋‹ˆ๋‹ค.

  • ์•„๋ž˜์™€ ๊ฐ™์ด ์ž…๋ ฅ ์‹œ, ๊ฐœํ–‰๋ฌธ์ž(enter, \n)๋ฅผ ์ž…๋ ฅํ•˜์ง€ ์•Š๊ณ  ๋‘˜ ์ด์ƒ์˜ ์ค„์„ ๊ฐ€์ง„ ๋ฌธ์ž์—ด์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

> In [1] : a =  """One
                           Two
                           Three"""
> In [2] : a
> Out [2] : 'One\nTwo\nThree'
  • ex> 'string', '2', "12.3", "[1,2,3,4]", "(2,3)"

4. bool ์ž๋ฃŒํ˜• (boolean, ๋ถˆ)

  • 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

๐Ÿ“ช ์ž๋ฃŒ๊ตฌ์กฐ(data structure)์˜ ์ข…๋ฅ˜

ํŒŒ์ด์ฌ์—์„œ ์“ฐ์ด๋Š” ์ž๋ฃŒ๊ตฌ์กฐ๋Š” ์ด 4์ง€๊ฐ€ ์กด์žฌํ•ฉ๋‹ˆ๋‹ค.

๐ŸšฉํŒŒ์ด์ฌ์—์„œ ์“ฐ์ด๋Š” ์ž๋ฃŒ๊ตฌ์กฐ(๊ตฐ์ง‘ ์ž๋ฃŒํ˜•)

list(๋ฆฌ์ŠคํŠธ, list), tuple(ํŠœํ”Œ, tuple), set(์ง‘ํ•ฉ, set), dict(์‚ฌ์ „, dictionary)

1. list ์ž๋ฃŒ๊ตฌ์กฐ (list, ๋ฆฌ์ŠคํŠธ)

  • 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()
  • ex> [,], [1,2,3], [[1,2,], 3, 3.0, "string", True, {1,4,5}, (0,1), {'a' : 1}]

2. tuple ์ž๋ฃŒ๊ตฌ์กฐ (tuple, ํŠœํ”Œ)

  • 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()
  • ex> (), (1,2,3), ([1,2,], 3, 3.0, "string", True, {1,4,5}, (0,1), {'a' : 1})

3. set ์ž๋ฃŒ๊ตฌ์กฐ (set, ์ง‘ํ•ฉ)

  • 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 ์ด๋ฏ€๋กœ
  • ๋นˆ ์ง‘ํ•ฉ(empty set)์€ ์•„๋ž˜์™€ ๊ฐ™์ด ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
#๋นˆ set์„ ๋งŒ๋“œ๋Š”๋ฐฉ๋ฒ• : ํด๋ž˜์Šค ์ƒ์„ฑ์ž ์ด์šฉ
> In [1] : a =  set()
  • ex> {0,1}, {1}, {3, "string", (0,1), True}

4. dict ์ž๋ฃŒ๊ตฌ์กฐ (dictionary, ์‚ฌ์ „)

  • 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()
  • ex> {'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/Immutable object

Mutable 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

  • 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๋ž€, ๋ฐ˜๋ณต ๊ฐ€๋Šฅํ•œ ๊ฐ์ฒด๋ฅผ ๋งํ•ฉ๋‹ˆ๋‹ค.
iterable object๋Š” iterator๋ฅผ ๊ฐ€์ง€๊ณ  ์žˆ๊ณ , ๋ฐ˜๋ณต๋ฌธ์—์„œ๋Š” iterator๋ฅผ ์‚ฌ์šฉํ•ด ํ•˜๋‚˜์”ฉ ์ ‘๊ทผํ•ฉ๋‹ˆ๋‹ค.

๋”ฐ๋ผ์„œ object์˜ element๋ฅผ ํ•˜๋‚˜์”ฉ ์ฐจ๋ก€๋กœ ๋ฐ˜ํ™˜ ๊ฐ€๋Šฅํ•˜๋ฉฐ for๋ฌธ ๋“ฑ์„ ํ†ตํ•ด element๋“ค์„ ํ•˜๋‚˜์”ฉ ๊บผ๋‚ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

  • enumerate(object)๋ฅผ ํ†ตํ•ด index์™€ element๋ฅผ ํ•จ๊ป˜ ๋ฐ˜ํ™˜ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
    iterator๋กœ ํ•˜๋‚˜์”ฉ ์ ‘๊ทผํ•  ๋•Œ ๊ฐ๊ฐ ์š”์†Œ์— ๋ฒˆํ˜ธ๋ฅผ ๋งค๊ธฐ๋Š” ๋ฐฉ์‹์ด๋ฏ€๋กœ, set๊ณผ ๊ฐ™์ด ์ธ๋ฑ์Šค ์‚ฌ์šฉ์ด ๋ถˆ๊ฐ€ํ•œ object๋„ ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.
#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
  • iterable object๋Š” ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

    str
    list
    dict
    set
    tuple
    range : ์ •์ˆ˜์˜ ์—ด์„ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค. ์ž์„ธํ•œ ๋‚ด์šฉ์€ ๋ฐ˜๋ณต๋ฌธ์„ ๋‹ค๋ฃจ๋ฉฐ ์ง„ํ–‰ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.


โœ” Check_List

์ด๋ฒˆ ์‹œ๊ฐ„์—๋Š” ์ž๋ฃŒํ˜•๊ณผ ์ž๋ฃŒ ๊ตฌ์กฐ, mutable object์™€ immutable object, iterable object์— ๋Œ€ํ•ด ์•Œ์•„๋ณด์•˜์Šต๋‹ˆ๋‹ค.
์•„๋ž˜ ๋ฆฌ์ŠคํŠธ๋ฅผ ์ฒœ์ฒœํžˆ ์ฝ์–ด๋ณด๋ฉด์„œ ์˜ค๋Š˜ ํ•™์Šตํ•œ ๋‚ด์šฉ์„ ๋ณต์Šตํ•ด๋ณด๋„๋ก ํ•ฉ์‹œ๋‹ค.

โ—ผ ์ž๋ฃŒํ˜•(data type)์˜ ์ข…๋ฅ˜์™€ ํ˜•ํƒœ
โ—ผ ์ž๋ฃŒ ๊ตฌ์กฐ(data structure)์˜ ์ข…๋ฅ˜์™€ ์ƒ์„ฑ ๋ฐฉ๋ฒ•, ํŠน์ง•, ์ €์žฅํ•  ์ˆ˜ ์žˆ๋Š” ์ž๋ฃŒ์˜ ํ˜•ํƒœ
โ—ผ mutable object์˜ ์ •์˜์™€ ์ข…๋ฅ˜
โ—ผ immutable object์˜ ์ •์˜์™€ ์ข…๋ฅ˜
โ—ผ iterable object์˜ ์ •์˜์™€ ์ข…๋ฅ˜ ๋ฐ ํŠน์ง•
โ—ผ object์˜ ํ˜•๋ณ€ํ™˜, type(), id(), enumerate()

๋‹ค์Œ ์‹œ๊ฐ„์—๋Š” int, float ์ž๋ฃŒํ˜•๊ณผ str ์ž๋ฃŒํ˜•์— ๋Œ€ํ•ด ๋”์šฑ ์ž์„ธํžˆ ๋‹ค๋ฃจ์–ด ๋ณด๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

profile
๋‚ด ๊ฟˆ์€ ์„ธ๊ณ„์ •๋ณต๐Ÿง

0๊ฐœ์˜ ๋Œ“๊ธ€

๊ด€๋ จ ์ฑ„์šฉ ์ •๋ณด

Powered by GraphCDN, the GraphQL CDN