Frank_the_Tank 2021. 1. 20. 15:06

๐Ÿ“ ํŒŒ์ด์ฌ ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋Ÿญ์ฒ˜(Data Structure)

  ๐Ÿ”ฅ ์Šคํƒ(Stack): LIFO(Last In First Out) ํ˜•ํƒœ๋กœ ๋‚˜์ค‘์— ๋„ฃ์€ ๋ฐ์ดํ„ฐ๋ฅผ ๋จผ์ € ๋ฐ˜ํ™˜ํ•˜๋„๋ก ๋งŒ๋“  ๋ฉ”๋ชจ๋ฆฌ ๊ตฌ์กฐ

                      list๋ฅผ ํ™œ์šฉํ•ด ๊ตฌํ˜„์ด ๊ฐ€๋Šฅํ•˜๊ณ  ์ž…๋ ฅ์„ push(append()), ์ถœ๋ ฅ์„ pop(pop())์ด๋ผ๊ณ  ํ•จ

 

  ๐Ÿ”ฅ ํ(Queue): FIFO(First In First Out) ํ˜•ํƒœ๋กœ ๋จผ์ € ๋„ฃ์€ ๋ฐ์ดํ„ฐ๋ฅผ ๋จผ์ € ๋ฐ˜ํ™˜ํ•˜๋„๋ก ๋งŒ๋“  ๋ฉ”๋ชจ๋ฆฌ ๊ตฌ์กฐ

                     list๋ฅผ ํ™œ์šฉํ•ด ๊ตฌํ˜„์ด ๊ฐ€๋Šฅํ•˜๊ณ  ์ž…๋ ฅ์„ push(append()), ์ถœ๋ ฅ์„ pop(pop(0))์ด๋ผ๊ณ  ํ•จ

 

  ๐Ÿ”ฅ ํŠœํ”Œ(Tuple): ๊ฐ’์˜ ๋ณ€๊ฒฝ์ด ๋ถˆ๊ฐ€๋Šฅํ•œ ๋ฆฌ์ŠคํŠธ๋กœ ๋ฆฌ์ŠคํŠธ์˜ ์—ฐ์‚ฐ, ์ธ๋ฑ์‹ฑ, ์Šฌ๋ผ์ด์‹ฑ์€ ๊ฐ€๋Šฅํ•จ. ์„ ์–ธ์‹œ '()' ์‚ฌ์šฉ

    - ์™œ ์“ฐ์ฃ ? ํ”„๋กœ๊ทธ๋žจ ์ค‘๊ฐ„์— ๋ณ€๊ฒฝ๋˜์ง€ ์•Š๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅ(์ด๋ฆ„, ํ•™๋ฒˆ ๋“ฑ)ํ•˜๊ณ  ์‚ฌ์šฉ์ž์˜ ์‹ค์ˆ˜๋ฅผ ์‚ฌ์ „์— ๋ฐฉ์ง€ํ•  ์ˆ˜ ์žˆ์Œ

 

  ๐Ÿ”ฅ ์…‹(Set): ๊ฐ’์„ ์ˆœ์„œ, ์ค‘๋ณต ์—†์ด ์ €์žฅํ•˜๋Š” ์ž๋ฃŒํ˜•, set()๊ฐ์ฒด ์„ ์–ธ์„ ํ†ตํ•ด ์ƒ์„ฑ

                 ์ˆ˜ํ•™์—์„œ์˜ ์ง‘ํ•ฉ ์—ฐ์‚ฐ์ด ๊ฐ€๋Šฅ(๊ต์ง‘ํ•ฉ(intersection, &), ์ฐจ์ง‘ํ•ฉ(difference, -), ํ•ฉ์ง‘ํ•ฉ(union, |))

 

  ๐Ÿ”ฅ ๋”•์…”๋„ˆ๋ฆฌ(dict): ๋ฐ์ดํ„ฐ ์ €์žฅ์‹œ ๊ตฌ๋ถ„์„ ์ง€์„ ์ˆ˜ ์žˆ๋Š” ๊ฐ’(key)์„ ํ•จ๊ป˜ ์ €์žฅํ•˜๊ธฐ ์œ„ํ•œ ์ž๋ฃŒํ˜•(Hash Table์ด๋ผ๊ณ  ๋ถˆ๋ฆผ)

                          ๊ตฌ๋ถ„์„ ์œ„ํ•œ ๋ฐ์ดํ„ฐ ๊ณ ์œ  ๊ฐ’์„ Key, Identifier์ด๋ผ ํ•˜๊ณ  ๋ฐ์ดํ„ฐ ๊ฐ’์„ Value๋ผ๊ณ  ๋ถ€๋ฆ„

                          {key1:value1, key2:value2, ...}ํ˜•์‹์œผ๋กœ ์‚ฌ์šฉ

                          keys(), values(), items()ํ•จ์ˆ˜๊ฐ€ ์žˆ๊ณ  ํŠœํ”Œ๋กœ ๋ฐ˜ํ™˜(for ๋ฌธ์—์„œ iterator์— ๋งŽ์ด ์‚ฌ์šฉ)

 

  ๐Ÿ”ฅ Collections: list, tuple, dict์— ๋Œ€ํ•œ python built-in ํ™•์žฅ ์ž๋ฃŒ ๊ตฌ์กฐ(๋ชจ๋“ˆ)

                      ์‚ฌ์šฉ์ž์—๊ฒŒ ํŽธ์˜์„ฑ, ํšจ์œจ์„ฑ ๋“ฑ์„ ์ œ๊ณต

    - deque: stack๊ณผ queue๋ฅผ ์ง€์›ํ•˜๊ณ  list์— ๋น„ํ•ด ํšจ์œจ์ ์ž„. rotate(), reverse()๋“ฑ linked list์˜ ํŠน์„ฑ์„ ์ง€์›ํ•จ

    - OrderedDict: dict๊ณผ ๋‹ฌ๋ฆฌ ๋ฐ์ดํ„ฐ๋ฅผ ์ž…๋ ฅ ์ˆœ์„œ๋Œ€๋กœ ๋ฐ˜ํ™˜ํ•ด์ฃผ์ง€๋งŒ 3.6๋ฒ„์ „๋ถ€ํ„ฐ๋Š” dict์—๋„ ์ง€์›ํ•ด ์‚ฌ์‹ค์ƒ ํ•„์š” X

    - defaultdict: dict type์˜ ๊ฐ’์— ๊ธฐ๋ณธ ๊ฐ’์„ ์ง€์ •ํ•ด ์‹ ๊ทœ ๊ฐ’์— ๋„ฃ์–ด ์ค„ ์ˆ˜ ์žˆ์Œ.

            d = defaultdict(object)

            d = defaultdict(lambda : 0) --> d['a']๋ฅผ ์‹คํ–‰ํ•˜์˜€์„ ๋•Œ ํ‚ค๊ฐ’์— a๊ฐ€ ์—†๋”๋ผ๋„ 0์„ ๋ฐ˜ํ™˜ํ•ด ์คŒ

    - Counter: Sequence type์˜ ๋ฐ์ดํ„ฐ ์š”์†Œ๋“ค์˜ ๊ฐœ์ˆ˜๋ฅผ dictํ˜•ํƒœ๋กœ ๋ฐ˜ํ™˜

            c = Counter

            c = Counter('hello')

            print(c) --> Counter({'e':1, 'h':1, 'l':2, 'o':1}) ํ˜•ํƒœ๋กœ ์ถœ๋ ฅ

                   elements()๋กœ ๋ฆฌ์ŠคํŠธํ˜•ํƒœ์˜ ๊ฐ’์„ ๋ฐ˜ํ™˜๋ฐ›์„ ์ˆ˜ ์žˆ๊ณ  set ์—ฐ์‚ฐ์ด ๊ฐ€๋Šฅ(ํ•ฉ์ง‘ํ•ฉ, ๊ต์ง‘ํ•ฉ, ์ฐจ์ง‘ํ•ฉ)

    - namedtuple: Tuple ํ˜•ํƒœ๋กœ ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ์ฒด๋ฅผ ์ €์žฅํ•˜๋Š” ๋ฐฉ๋ฒ• Point = namedtuple('Point', ['x', 'y']) ํ˜•ํƒœ.

 

  ๐Ÿ“Œ %timeit ํ•จ์ˆ˜

 -> sys๋ฅผ importํ•˜๊ฒŒ๋˜๋ฉด ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๊ธฐ๋Šฅ์œผ๋กœ ํ•จ์ˆ˜๊ฐ€ ์‹คํ–‰๋˜๋Š”๋ฐ ๊ฑธ๋ฆฌ๋Š” ์‹œ๊ฐ„์„ ํ™•์ธ ํ•  ์ˆ˜ ์žˆ๋‹ค.

 

๐Ÿ“ ํŒŒ์ด์ฌ ์Šคํƒ€์ผ ์ฝ”๋“œ(Pythonic Code)

์‚ฌ์šฉ์ด์œ  1. ๋‚จ์˜ ์ฝ”๋“œ์— ๋Œ€ํ•œ ์ดํ•ด๋„ ↑

์‚ฌ์šฉ์ด์œ  2. ํšจ์œจ(๋” ๋นจ๋ผ์ง€๊ณ  ์งง๊ฒŒ ์ฝ”๋“œ๋ฅผ ์งค ์ˆ˜ ์žˆ์Œ)

์‚ฌ์šฉ์ด์œ  3. ๋ฉ‹(์ž˜ ์งœ๋Š”๊ฑฐ ์ฒ˜๋Ÿผ ๋ณด์ž„)

 

  ๐Ÿ”ฅ Split & Join: String type์˜ ๊ฐ’์„ ์ฒ˜๋ฆฌ

    - split(): "๊ธฐ์ค€๊ฐ’"์œผ๋กœ ๋‚˜๋ˆ  list ํ˜•ํƒœ๋กœ ๋ฐ˜ํ™˜

    - join(): "๊ธฐ์ค€๊ฐ’"์œผ๋กœ ํ•ฉ์ณ string ํ˜•ํƒœ๋กœ ๋ฐ˜ํ™˜

 

  ๐Ÿ”ฅ list comprehension: ๊ธฐ์กด์˜ list๋ฅผ ์‚ฌ์šฉํ•ด ๊ฐ„๋‹จํžˆ ๋‹ค๋ฅธ list๋ฅผ ๋งŒ๋“œ๋Š” ๊ธฐ๋ฒ•. for๋ฌธ ๋ณด๋‹ค ๋น ๋ฆ„

            list = [i for i in ๐ŸŸฅ if ์กฐ๊ฑด]

            list = [i+j for i in ๐ŸŸฅ for j in ๐ŸŸจ] -> 2์ค‘ for๋ฌธ ์‹์œผ๋กœ ๋ฐ˜๋ณต(i ์•ˆ์˜ j)

            list = [[i+j for i in ๐ŸŸฅ] for j in ๐ŸŸจ] -> j ๋จผ์ € ๋Œ๊ณ  i๋ฅผ ์‹คํ–‰

 

  ๐Ÿ”ฅ enumerate & zip: ๋ฆฌ์ŠคํŠธ๋ฅผ ์ฒ˜๋ฆฌํ•˜๋Š” ๋ฐฉ๋ฒ•

    - enumerate(): list์˜ element๋ฅผ ์ถ”์ถœํ•  ๋Œ€ ๋ฒˆํ˜ธ๋ฅผ ๋ถ™์—ฌ ์ถ”์ถœ -> ๋”•์…”๋„ˆ๋ฆฌ๋ฅผ ๋งŒ๋“ค๋•Œ ์‚ฌ์šฉ ๊ฐ€๋Šฅ

    - zip(): ๋‘๊ฐœ์˜ list ๊ฐ’์„ ๋ณ‘๋ ฌ์ ์œผ๋กœ ์ถ”์ถœํ•˜๋Š” ๋ฐฉ๋ฒ•

 

  ๐Ÿ”ฅ Lambda & Map & Reduce: PEP8 ์ดํ›„๋กœ ์‚ฌ์šฉ์„ ๊ถŒ์žฅํ•˜์ง€ ์•Š์œผ๋‚˜, ํ˜„์žฌ๊นŒ์ง€ ๋งŽ์ด ์‚ฌ์šฉ.

    - lambda: ํ•จ์ˆ˜์ด๋ฆ„ ์—†์ด, ํ•จ์ˆ˜์ฒ˜๋Ÿผ ์“ธ ์ˆ˜ ์žˆ๋Š” ์ต๋ช…ํ•จ์ˆ˜. ์ˆ˜ํ•™์˜ ๋žŒ๋‹ค ๋Œ€์ˆ˜์—์„œ ์œ ๋ž˜

            f = (lambda x, y: x+y)

            f(10, 50)  => 60 ์ถœ๋ ฅ

           (lambda x, y: x+y)(10, 50) => 60 ์ถœ๋ ฅ

    - map: ๋‘๊ฐœ ์ด์ƒ์˜ list์—๋„ ์ ์šฉ ๊ฐ€๋Šฅํ•จ, if ๋ฌธ๋„ ์‚ฌ์šฉ ๊ฐ€๋Šฅ

              iteration์„ ์ƒ์„ฑ -> listํ•จ์ˆ˜๋กœ list๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Œ.

              ์‹คํ–‰ ์‹œ์ ์˜ ๊ฐ’์„ ์ƒ์„ฑ, ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์  --> list comprehension์œผ๋กœ ๋Œ€์ฒด๊ฐ€ ๊ฐ€๋Šฅ

    - reduce: map๊ณผ ๋‹ฌ๋ฆฌ list์— ๋˜‘๊ฐ™์€ ํ•จ์ˆ˜๋ฅผ ์ ์šฉํ•ด ํ†ตํ•ฉ => ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ์‹œ ์‚ฌ์šฉ

                 from functools import reduce๋กœ ๋ถˆ๋Ÿฌ ์˜ฌ ์ˆ˜ ์žˆ์Œ

 

  ๐Ÿ”ฅ Iterable object: ์‹œํ€€์Šคํ˜• ์ž๋ฃŒํ˜•์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์ˆœ์„œ๋Œ€๋กœ ์ถ”์ถœํ•˜๋Š” object

                           ๋‚ด๋ถ€์ ์œผ๋กœ __iter__์™€ __next__๊ฐ€ ๊ตฌํ˜„๋˜์–ด ์žˆ์Œ. -> iter()์™€ next()ํ•จ์ˆ˜๋กœ iterable ๊ฐ์ฒด๋ฅผ ์‚ฌ์šฉ

            iter_list = iter(["์„œ์šธ", "๋ถ€์‚ฐ", "๋Œ€๊ตฌ"])    ==> ๊ฐ’์ด ์•„๋‹Œ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๊ฐ’์„ ์ €์žฅํ•˜๊ณ  ์žˆ์Œ

            next(iter_list)  -> ์„œ์šธ ์ถœ๋ ฅ

            next(iter_list)  -> ๋ถ€์‚ฐ ์ถœ๋ ฅ

            next(iter_list)  -> ๋Œ€๊ตฌ ์ถœ๋ ฅ

 

  ๐Ÿ”ฅ generator: iterable object๋ฅผ ํŠน์ˆ˜ํ•œ ํ˜•ํƒœ๋กœ ์‚ฌ์šฉํ•ด์ฃผ๋Š” ํ•จ์ˆ˜

                    ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๊ฐ’๋งŒ ๊ฐ€์ง€๊ณ  ์žˆ๋‹ค๊ฐ€ element๊ฐ€ ์‚ฌ์šฉ๋˜๋Š” ์‹œ์ ์— ๊ฐ’์„ ๋ฉ”๋ชจ๋ฆฌ์— ๋ฐ˜ํ™˜

                    -> yield๋ฅผ ์‚ฌ์šฉํ•ด ํ•œ๋ฒˆ์— ํ•˜๋‚˜์˜ element๋งŒ ๋ฐ˜ํ™˜. list comprehension๊ณผ ์œ ์‚ฌํ•˜๊ฒŒ ์ƒ์„ฑ๊ฐ€๋Šฅ-()์‚ฌ์šฉ

                        ์ผ๋ฐ˜์ ์ธ iterator๋ณด๋‹ค generator์ด ํ›จ์”ฌ ์ž‘์€ ๋ฉ”๋ชจ๋ฆฌ ์šฉ๋Ÿ‰ ์‚ฌ์šฉ

            gen_ex = (n*n for n in range(50)) => gen_ex์—๋Š” 0~49์˜ ์ˆ˜๋ฅผ ์ €์žฅํ•  ์ˆ˜ ์žˆ๋Š” ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๊ฐ€ ์ €์žฅ๋จ.

    - ์–ธ์ œ ์‚ฌ์šฉํ•˜๋‚˜์š”? list type์˜ ๋ฐ์ดํ„ฐ๋ฅผ ๋ฐ˜ํ™˜ํ•ด ์ฃผ๋Š” ํ•จ์ˆ˜, ํฐ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ, ํŒŒ์ผ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ์‹œ ์‚ฌ์šฉ

 

  ๐Ÿ”ฅ Function Passng Argument: ํ•จ์ˆ˜์— ์ž…๋ ฅ๋˜๋Š” argument์˜ ๋‹ค์–‘ํ•œ ํ˜•ํƒœ๊ฐ€ ์กด์žฌ

    - Keyword argument: ํ•จ์ˆ˜์— ์ž…๋ ฅ๋˜๋Š” parameter์˜ ๋ณ€์ˆ˜๋ช…์„ ์‚ฌ์šฉํ•ด arguments๋ฅผ ๋„˜๊น€

            def ex(a, b, c):

               return a+b+c

           print(ex(b="am", c ="python", a="I")  => Iampython ์œผ๋กœ ์ถœ๋ ฅ

    - Default argument: parameter์˜ ๊ธฐ๋ณธ ๊ฐ’์„ ์‚ฌ์šฉํ•ด ์ž…๋ ฅ์ด ๋“ค์–ด์˜ค์ง€ ์•Š์•˜์„ ๊ฒฝ์šฐ ๊ธฐ๋ณธ ๊ฐ’ ์ถœ๋ ฅ

            def ex(a = 3, b):

                return a + b

            print(ex(10))  => 13์ด ์ถœ๋ ฅ

    - Variable-length asterisk: ๊ฐœ์ˆ˜๊ฐ€ ์ •ํ•ด์ง€์ง€ ์•Š์€ ๋ณ€์ˆ˜๋ฅผ ํ•จ์ˆ˜ parameter๋กœ ์‚ฌ์šฉ, '*'๊ธฐํ˜ธ ์‚ฌ์šฉ, Tuple ํ˜•ํƒœ๋กœ ์‚ฌ์šฉ

            def ex(a, b, *args):

               return a+b+sum(args)

            print(1,2,3,4,5)  => 1->a, 2->b, (3,4,5)->args๋กœ ๋„˜๊ฒจ์คŒ. ๋”ฐ๋ผ์„œ, 15๊ฐ€ ์ถœ๋ ฅ

    - Keyword variable-length: parameter ์ด๋ฆ„์„ ๋”ฐ๋กœ ์ง€์ •ํ•˜์ง€ ์•Š๊ณ  ์ž…๋ ฅํ• ๋•Œ ์‚ฌ์šฉ, '**'๋ฅผ ์‚ฌ์šฉํ•ด ํ‘œ์‹œ

                                        dict type์œผ๋กœ ์‚ฌ์šฉ ๊ฐ€๋Šฅ, ๊ฐ€๋ณ€์ธ์ž๋Š” ์˜ค์ง ํ•œ๊ฐœ๋งŒ ๊ธฐ์กด ๊ฐ€๋ณ€์ธ์ž ๋‹ค์Œ์— ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Œ

            def ex(**kwargs):

                print(args)

            ex('f' = 1, 's' = 2, 't' = 3) => {'f':1, 's':2, 't':3} ์ด ์ถœ๋ ฅ

 

            def ex(a, b, *args, **kwargs):

                print(a, b, args, kwargs)

            ex(1, 2, 3, 4, 5, 6, 7, 'f' = 1, 's' = 2) => ex(1, 2, (3, 4, 5, 6, 7), {'f':1, 's':2})๋กœ ๊ฐ€๋Š”๊ฒƒ๊ณผ ๋น„์Šท <- ์ˆœ์„œ๊ฐ€ ์ค‘์š”

    - Asterisk: '*' ๊ธฐํ˜ธ๋กœ, ๊ณฑ์…ˆ, ์ œ๊ณฑ, ๊ฐ€๋ณ€์ธ์ž, ๊ทธ๋ฆฌ๊ณ  Unpacking a container๋กœ ์‚ฌ์šฉ์ด ๊ฐ€๋Šฅ

  ๐Ÿ“Œ Unpacking a Container

 -> tuple, dict ๋“ฑ ์ž๋ฃŒํ˜•์— ๋“ค์–ด๊ฐ€ ์žˆ๋Š” ๊ฐ’์„ unpackingํ•˜๋Š” ์—ญํ• , ํ•จ์ˆ˜ ์ž…๋ ฅ๊ฐ’, zip ๋“ฑ์— ์œ ์šฉํ•˜๊ฒŒ ์‚ฌ์šฉ ๊ฐ€๋Šฅ

    def ex(a, * args):

        print(a, *args)

    ex(1, *(2, 3, 4, 5)) => 1 2 3 4 5 ๊ฐ€ ์ถœ๋ ฅ

 

    print(*[1, 2, 3, 4, 5]) => 1 2 3 4 5 ๊ฐ€ ์ถœ๋ ฅ