[Day 03] 파이썬 기초 문법 2

[Day 03] 파이썬 기초문법 2

 

1. 강의 복습 내용

1) Python Data Structure

 

Stack

In [2]:

a=[1,2,3,4,5] # list 사용해서 스택 구조 구현
a

Out[2]:

[1, 2, 3, 4, 5]

In [3]:

a.append(10)
a.append(20)
a.pop()

Out[3]:

20

In [4]:

a

c=a.pop() # 파이썬에선 pop() 도 리턴값이 있다!

Out[4]:

[1, 2, 3, 4, 5, 10]

In [7]:

c

Out[7]:

10

In [8]:

word = input("input a word : ")
word_list = list(word)
for _ in range(len(word_list)) :
    print(word_list.pop())
    print(word_list)

 

input a word : dasdkjasdlkasjd
d
['d', 'a', 's', 'd', 'k', 'j', 'a', 's', 'd', 'l', 'k', 'a', 's', 'j']
j
['d', 'a', 's', 'd', 'k', 'j', 'a', 's', 'd', 'l', 'k', 'a', 's']
s
['d', 'a', 's', 'd', 'k', 'j', 'a', 's', 'd', 'l', 'k', 'a']
a
['d', 'a', 's', 'd', 'k', 'j', 'a', 's', 'd', 'l', 'k']
k
['d', 'a', 's', 'd', 'k', 'j', 'a', 's', 'd', 'l']
l
['d', 'a', 's', 'd', 'k', 'j', 'a', 's', 'd']
d
['d', 'a', 's', 'd', 'k', 'j', 'a', 's']
s
['d', 'a', 's', 'd', 'k', 'j', 'a']
a
['d', 'a', 's', 'd', 'k', 'j']
j
['d', 'a', 's', 'd', 'k']
k
['d', 'a', 's', 'd']
d
['d', 'a', 's']
s
['d', 'a']
a
['d']
d
[]

 

 

---

queue

In [14]:

a=[1,2,3,4,5]
a.append(10)

In [15]:

a

Out[15]:

[1, 2, 3, 4, 5, 10]

In [16]:

a.pop(0)
a

Out[16]:

[2, 3, 4, 5, 10]

In [17]:

a.pop(1)
a

Out[17]:

[2, 4, 5, 10]

 

 

---

tuple

 

값의 변경이 불가능한 리스트

왜쓸까?

• 프로그램을 작동하는 동안 변경되지 않은 데이터의 저장
• 함수의 반환 갓등 사용자의 실수에 의한 에러를 사전에 방지

In [20]:

t=(1,2,3,4)
t

Out[20]:

(1, 2, 3, 4)

In [21]:

t[0]=1

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-21-531e22094236> in <module>
----> 1 t[0]=1

TypeError: 'tuple' object does not support item assignment

In [74]:

t.append(1)

 

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-74-c860940312ad> in <module>
----> 1 t.append(1)

AttributeError: 'tuple' object has no attribute 'append'

 

• 위와 같이 Tuple의 수정은 불가능하다.

In [23]:

t=(1,) #값이 하나면 무조건 콤마 (true) 붙여야함

 

 

---

집합(SET)

 

교집합, 차집합 등 수학에서 활용하는 다양한 집합연산 가능¶

In [24]:

s = set([1,2,3,4,5])
s

Out[24]:

{1, 2, 3, 4, 5}

In [25]:

s = set([1,2,3,1,2,3,3,3,3,3,2,2,1,2,3,4])
s

Out[25]:

{1, 2, 3, 4}

In [26]:

s = set([5,4,2,4,12,4,12,4,5,12])
s

Out[26]:

{2, 4, 5, 12}

In [27]:

s= set(["safhashf","A","B","B","A"])

s

In [29]:

s.add("BBAAA")
s

Out[29]:

{'A', 'B', 'BBAAA', 'safhashf'}

In [30]:

s.remove("BBAAA")
s

Out[30]:

{'A', 'B', 'safhashf'}

 

discard 와 remove의 차이점이 뭔가?

• remove는 지우려는 엘레멘트가 존재하지않으면 Error가 발생하지만
• discard는 지우려는 엘레멘트가 존재하지않아도 Error가 발생하지않는다.
• 따라서 discard는 존재하지않음을 보장하려할때 사용하고 remove는 확실히 존재하는것을 지울때 사용된다.

 

 

1. Union (합집합)

ex) union or s1 | s2

In [31]:

s1=set([1,2,3,4,5])
s2=set([3,4,5,6,7])

In [34]:

s1.union(s2)

Out[34]:

{1, 2, 3, 4, 5, 6, 7}

 

2. intersection (교집합)

3. difference (차집합)

 

 

---

Dict

 

In [ ]:

books = {} # dict 생성

In [35]:

books = dict() # 이렇게도 가능

In [36]:

books = {"One" : 1,"Two" :2,"Three":3,"Four":4,"Five":5} # dict 값넣기
books

Out[36]:

{'One': 1, 'Two': 2, 'Three': 3, 'Four': 4, 'Five': 5}

In [78]:

for books_items in books.items() :
    print(books_items)
    print(type(books_items))
    
## Tuple 형태로 나온다

 

('One', 1)
<class 'tuple'>
('Two', 2)
<class 'tuple'>
('Three', 3)
<class 'tuple'>
('Four', 4)
<class 'tuple'>
('Five', 5)
<class 'tuple'>

In [44]:

for k,v in books.items() :
    print(k,v)
## Tuple 형태이므로 언패킹을 사용한 이러한 방식도 가능

 

One 1
Two 2
Three 3
Four 4
Five 5

 

 

---

Collection 모듈

1. deque

 

Stack 과 Queue를 지원하는 모듈

List에 비해 효율적인-빠른 자료 저장 방식 지원

 

• rotate, reverse 등 Linked List의 특성을 지원
• 기존 list 형태의 함수를 모두 지원한다

In [95]:

from collections import deque
deque_list = deque()
for i in range(5) : 
    deque_list.append(i)
deque_list.appendleft(10)
deque_list

Out[95]:

deque([10, 0, 1, 2, 3, 4])

In [96]:

deque_list.rotate(1) ## -> 으로 돌려준다 원형 링크드 리스트
deque_list

Out[96]:

deque([4, 10, 0, 1, 2, 3])

 

• deque는 기존 list보다 효율적인 자료구조를 제공
• 따라서 효율적 메모리 구조로 처리 속도 향상

In [50]:

def general_list():
    just_list=[]
    for i in range(100) :
        for i in range(100):
            just_list.append(i)
            just_list.pop()

%timeit general_list()

 

3.2 ms ± 67.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [53]:

def deque_list():
    deque_list=deque()
    for i in range(100):
        for i in range(100):
            deque_list.append(i)
            deque_list.pop()

%timeit deque_list()

 

1.05 ms ± 14.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

 

일반 리스트와 deque 리스트의 성능차이 (약3배)¶

 

---

OrderedDict

 

그러나 dict도 python 3.6부터 입력한 순서를 보장하여 출력함.. (dict 쓰는게 이득)

 

DefaultDict

 

Dict type의 값에 기본 값을 지정, 신규값 생성 시 사용하는 방법 이걸 쓰면 이제 귀찮게 if 조건문을 따로 안걸어줘도 된다!!

In [56]:

from collections import defaultdict
d=defaultdict(lambda : 0)
d

Out[56]:

defaultdict(<function __main__.<lambda>()>, {})

In [89]:

d=defaultdict(int)
d

Out[89]:

defaultdict(int, {})

In [58]:

def default_value() :
    return 0

In [61]:

d=defaultdict(default_value)
d

Out[61]:

defaultdict(<function __main__.default_value()>, {})

 

defaultdict 초기값을 지정하는 3가지 방법

 

---

Counter

 

• Sequence type의 data element들의 갯수를 dict 형태로 반환

In [63]:

from collections import Counter
b_or_s=["B","S","S","B","B","S"]
c=Counter(b_or_s)
print(c)

 

Counter({'B': 3, 'S': 3})

In [64]:

print(list(c.elements()))

 

['B', 'B', 'B', 'S', 'S', 'S']

 

• Set의 연산들도 지원함

In [65]:

c=Counter(a=4,b=2,c=0,d=-2)
d=Counter(a=1,b=2,c=3,d=4)
print(c+d)

 

Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2})

In [66]:

print(c|d)

 

Counter({'a': 4, 'd': 4, 'c': 3, 'b': 2})

In [68]:

print(c&d)

 

Counter({'b': 2, 'a': 1})

 

 

---

namedtuple

 

• Tuple 형태로 Data 구조체를 저장하는 방법
• 저장되는 data의 variable을 사전에 지정해서 저장함

In [69]:

from collections import namedtuple
Point = namedtuple('Point',['x','y'])

In [70]:

Point

Out[70]:

__main__.Point

In [71]:

p=Point(11,y=22)
p[0], p[1]

Out[71]:

(11, 22)

In [72]:

x,y=p # 언패킹
print (x,y)

 

11 22

In [73]:

print(p.x+p.y)

 

33

 

데이터의 기본적인 체계를 하나로 묶어줄 수 있는 장점이 있다.

2) Pythonic Code

 

 

파이썬 스타일 코드 Pythonic Code

 

• 파이썬 스타일의 코딩 기법
• 파이썬의 특유의 문법을 활용하여 효율적으로 코드를 표현
• 그러나 더이상 파이썬 특유가 아님, 많은 언어들이 서로의 장점을 채용 (다른 언어들의 발전)
• 고급 코드를 작성 할 수록 더 많이 필요해짐

 

• Pythonic Code를 적용한 간단한 예

In [3]:

colors = ['red','blue','green','yellow']
result=''
for s in colors :
    result+=s
result

Out[3]:

'redbluegreenyellow'

In [4]:

colors = ['red','blue','green','yellow']
result=''.join(colors)
result

Out[4]:

'redbluegreenyellow'

 

1. 타인 코드에 대한 이해도

• 많은 개발자들이 python 스타일로 코딩한다

1. 효율

• 단순 for loop append보다 list가 조금 더 빠르다
• 익숙해지면 코드도 짧아진다.

1. 간지

• 쓰면 왠지 코드 잘 짜는 거처럼 보인다.

---

 

1. Split 함수

In [9]:

ex = "adkaljd fhasjhas sadjhadjka asdkljasdkl"
ex=ex.split()
ex

Out[9]:

['adkaljd', 'fhasjhas', 'sadjhadjka', 'asdkljasdkl']

 

 

---

2. Join 함수

In [10]:

colors = ["red","blue","green","yellow"]
"-".join(colors)

Out[10]:

'red-blue-green-yellow'

 

 

---

3. List Comprehension (*)

 

• 기존 List를 사용하여 간단히 다른 List를 만드는 기법
• 포괄적인 List, 포함되는 리스트라는 의미로 사용
• 파이썬에서 가장 많이 사용되는 기법 중 하나
• 일반적으로 for + append 보다 속도가 빠르다.

In [11]:

result = []
for i in range(10) :
    result.append(i)
result

Out[11]:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [13]:

result = [i for i in range(10)]
result

Out[13]:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [15]:

result = [i for i in range(10) if i%2==0]
result

Out[15]:

[0, 2, 4, 6, 8]

In [16]:

word_1 = "Hello"
word_2 ="World"
result=[i+j for i in word_1 for j in word_2]
result

Out[16]:

['HW',
 'Ho',
 'Hr',
 'Hl',
 'Hd',
 'eW',
 'eo',
 'er',
 'el',
 'ed',
 'lW',
 'lo',
 'lr',
 'll',
 'ld',
 'lW',
 'lo',
 'lr',
 'll',
 'ld',
 'oW',
 'oo',
 'or',
 'ol',
 'od']

 

• 이런식으로 2중 for문도 한줄로 바로 list에 담을수있다.

In [17]:

word_1 = "Hello"
word_2 ="World"
result=[i+j for i in word_1 for j in word_2 if not(i==j)]
result

Out[17]:

['HW',
 'Ho',
 'Hr',
 'Hl',
 'Hd',
 'eW',
 'eo',
 'er',
 'el',
 'ed',
 'lW',
 'lo',
 'lr',
 'ld',
 'lW',
 'lo',
 'lr',
 'ld',
 'oW',
 'or',
 'ol',
 'od']

 

• Filter 추가도 가능

In [18]:

words = 'The quick brown fox jumps over the lazy dog'.split()
print(words)

 

['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']

In [19]:

[[w.upper(),w.lower(),len(w)] for w in words]

Out[19]:

[['THE', 'the', 3],
 ['QUICK', 'quick', 5],
 ['BROWN', 'brown', 5],
 ['FOX', 'fox', 3],
 ['JUMPS', 'jumps', 5],
 ['OVER', 'over', 4],
 ['THE', 'the', 3],
 ['LAZY', 'lazy', 4],
 ['DOG', 'dog', 3]]

In [22]:

case_1 = ["A","B","C"]
case_2 = ["D","E","A"]
result = [ [i+j for i in case_1] for j in case_2]
result

Out[22]:

[['AD', 'BD', 'CD'], ['AE', 'BE', 'CE'], ['AA', 'BA', 'CA']]

 

** 뒷 부분이 2중 for문의 맨위 loof를 담당

 

 

---

4. enumerate & zip

 

• enumerate : list의 element를 추출할 때 번호를 붙여서 추출

In [24]:

for i,v in enumerate(['tic','tac','toc']):
    print(i,v)

 

0 tic
1 tac
2 toc

In [25]:

for i,v in enumerate("ABC"):
    print("{0} \t {1}".format(i,v))

 

0 	 A
1 	 B
2 	 C

In [27]:

my_str="ABCD"
{v:i for i, v in enumerate(my_str)}

Out[27]:

{'A': 0, 'B': 1, 'C': 2, 'D': 3}

 

• zip : 두 개의 list의 값을 병렬적으로 추출함

In [29]:

alist=['a1','a2','a3']

blist=['b1','b2','b3']
[[a,b] for a,b in zip(alist,blist)]

Out[29]:

[['a1', 'b1'], ['a2', 'b2'], ['a3', 'b3']]

In [30]:

[ c for c in zip(alist,blist)]

Out[30]:

[('a1', 'b1'), ('a2', 'b2'), ('a3', 'b3')]

In [31]:

math = (100,90,80)
kor=(90,90,70)
eng=(90,80,70)

[sum(value)/3 for value in zip(math,kor,eng)]

Out[31]:

[93.33333333333333, 86.66666666666667, 73.33333333333333]

 

• enumerate & zip 활용

In [32]:

alist=['a1','a2','a3']

blist=['b1','b2','b3']

for i,v in enumerate(zip(alist,blist)):
    print(i,v)

 

0 ('a1', 'b1')
1 ('a2', 'b2')
2 ('a3', 'b3')

In [33]:

list(enumerate(zip(alist,blist)))

Out[33]:

[(0, ('a1', 'b1')), (1, ('a2', 'b2')), (2, ('a3', 'b3'))]

 

 

---

5. lambda & map & reduce

In [34]:

def f(x,y):
    return x+y
f(1,4)

Out[34]:

5

In [35]:

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

Out[35]:

60

In [36]:

(lambda x,y:x+y)(10,50)

Out[36]:

60

In [37]:

up_low = lambda x: x.upper()+x.lower()

In [38]:

up_low("My Happy")

Out[38]:

'MY HAPPYmy happy'

In [39]:

up_low = lambda x : "-".join(x.split())

In [40]:

up_low("My Happy")

Out[40]:

'My-Happy'

 

• Python 3부터는 권장하지는 않으나 여전히 많이 쓰임
• PEP 8에서는 lambda의 사용을 권장하지 않음

 

1. 어려운 문법
2. 테스트의 어려움
3. 문서화 docstring 지원 미비
4. 코드 해석의 어려움
5. 이름이 존재하지 않는 함수의 출현
6. 그럼에도 불구하고 많이 쓴다 <<<<

 

---

 

Map function overview

 

• 두 개 이상의 list에도 적용 가능, if filter도 사용가능

In [41]:

ex = [1,2,3,4,5]
f = lambda x: x**2

list(map(f,ex))

Out[41]:

[1, 4, 9, 16, 25]

In [42]:

def f(x) :
    return x+5
ex = [1,2,3,4,5]
list(map(f,ex))

Out[42]:

[6, 7, 8, 9, 10]

 

• python3는 iteration을 생성 -> list을 붙여줘야 list 사용가능
• 최근에는 map function을 권장하지 않음

In [43]:

def f(x) :
    return x+5
ex = [1,2,3,4,5]

[f(value) for value in ex]

Out[43]:

[6, 7, 8, 9, 10]

 

• Map function 보다 더 간결하고 보기에 편하다

 

---

Reduce function overview

 

• map function과 달리 list에 똑같은 함수를 적용해서 "통합"

In [44]:

from functools import reduce
print(reduce(lambda x, y: x+y, [1,2,3,4,5]))

 

15

 

• 대용량의 데이터를 다룰 때, Reduce function을 많이 사용한다.

 

Summary

• Lambda, map, reduce는 간단한 코드로 다양한 기능을 제공
• 그러나 코드의 직관성이 떨어져서 lambda나 reduce는 python3에서 사용을 권장하지 않음
• Legacy library나 다양한 머신러닝 코드에서는 여전히 사용중

 

---

6. iterable objects

 

• Sequence형 자료형에서 데이터를 순서대로 추출하는 object

 

• 내부적 구현으로 iter와 next가 사용됨
• iter()와 next() 함수로 iterable 객체를 iterator object로 사용

In [45]:

cities=["Seoul","Busan","Jeju"]
cities

Out[45]:

['Seoul', 'Busan', 'Jeju']

In [47]:

memory_address=iter(cities)

In [48]:

next(memory_address)

Out[48]:

'Seoul'

In [49]:

next(memory_address)

Out[49]:

'Busan'

In [50]:

next(memory_address)

Out[50]:

'Jeju'

In [51]:

next(memory_address)

 

---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-51-58f6380dee51> in <module>
----> 1 next(memory_address)

StopIteration: 

 

• iterable object를 특수한 형태로 사용해주는 함수
• element가 사용되는 시점에 값을 메모리에 반환
• yiled를 사용해 한번에 하나의 element를 반환함

In [52]:

def general_list(value) :
    result=[]
    for i in range(value):
        result.append(i)
    return result

print(general_list(50))

 

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]

In [53]:

result = general_list(50)

In [54]:

import sys
result = general_list(50)
sys.getsizeof(result)

Out[54]:

520

 

• 520 byte

In [58]:

def generator_list(value) :
    result=[]
    for i in range(value):
        yield i

In [60]:

result = generator_list(50)
sys.getsizeof(result)

Out[60]:

112

 

• 112 byte

 

---

generator comprehension

 

• list comprehension과 유사한 형태로 generator 형태의 list 생성
• generator expression 이라는 이름으로도 부름
• [] 대신 ()를 사용하여 표현

In [62]:

gen_ex=(n*n for n in range(500))
print(type(gen_ex))

 

<class 'generator'>

In [92]:

list(gen_ex)

 

• 일반적인 iterator는 generator에 반해 훨씬 큰 메모리 용량 사용

In [65]:

import sys

gen_ex = (n*n for n in range(5000)) ## generator
print(sys.getsizeof(gen_ex))
list_ex = [n*n for n in range(5000)] ## 일반적인 list
print(sys.getsizeof(list_ex))

 

112
43032

 

---

When generator

 

• list 타입의 데이터를 반환해주는 함수는 generator로 만들어라
• 읽기 쉬운 장점, 중간 과정에서 loop이 중단될 수 있을 때!
• 큰 데이터를 처리할 때는 generator expression을 고려하라
• 데이터가 커도 처리의 어려움이 없음
• 파일 데이터를 처리할 때도 generator를 쓰자

 

---

Function passing arguments

• 함수에 입력되는 arguments의 다양한 형태

1. Keyword arguments

• 함수에 입력되는 parameter의 변수명을 사용, arguments를 넘김

In [67]:

def print_something(my_name, your_name, third_name):
    print("Hello {0}, My name is {1},".format(your_name,my_name))

print_something(third_name="abc",my_name="Kimin",your_name="TEAMLAB")

 

Hello TEAMLAB, My name is Kimin,

 

2. Default arguments

• parameter의 기본 값을 사용, 입력하지 않을 경우 기본값 출력

In [69]:

def print_something_2(my_name, your_name="TEAMLAB") :
    print("Hello {0}, My name is {1}".format(your_name, my_name))
    
print_something_2("Kimin")

 

Hello TEAMLAB, My name is Kimin

 

---

Variable-length asterisk

• 함수의 parameter가 정해지지 않았다?

 

 

가변인자 (Variable-length)

1. 개수가 정해지지 않은 변수를 함수의 parameter로 사용하는 법
2. Keyword arguments와 함께, argument 추가가 가능
3. Asterisk(*) 기호를 사용하여 함수의 parameter를 표시함
4. 입력된 값은 tuple type으로 사용할 수 있음
5. 가변인자는 오직 한 개만 맨 마지막 parameter 위치에 사용가능

 

• 가변인자는 일반적으로 *args를 변수명으로 사용
• 기존 parameter 이후에 나오는 값을 tuple로 저장함

In [71]:

def asterisk_test(a,b,*args):
    print(list(args))
    return a+b+sum(args)

asterisk_test(1,2,3,4,5)

 

[3, 4, 5]

Out[71]:

15

 

---

키워드 가변인자

• Parameter 이름을 따로 지정하지 않고 입력하는 방법
• asterisk(*) 두개를 사용하여 함수의 parameter를 표시
• 입력된 값은 dict type으로 사용할 수 있다
• 가변인자는 오직 한 개만, 기존 가변인자 다음에 사용

In [74]:

def kwargs1(**kwargs) :
    print(type(kwargs))
    print(kwargs)

kwargs1(first=1,second=2,third=5,c=5,d=5)

 

<class 'dict'>
{'first': 1, 'second': 2, 'third': 5, 'c': 5, 'd': 5}

In [75]:

def kwargs_test(one,two,*args,**kwargs):
    print(one+two+sum(args))
    print(kwargs)

kwargs_test(3,4,5,6,7,8,9, first=3,second=4,third=5)

 

42
{'first': 3, 'second': 4, 'third': 5}

 

• one = 3, two=4, args=(5,6,7,8,9) 나머지 kwargs
• 순서가 중요

 

---

asterisk

• 흔히 알고 있는 *를 의미
• 단순 곱셈, 제곱연산, 가변 인자 활용 등 다양하게 사용됨

 

---

unpacking a container

• tuple, dict 등 자료형에 들어가있는 값을 unpacking
• 함수의 입력값, zip 등에 유용하게 사용가능

In [79]:

def asterisk_test(a,*args): ## 이곳의 * 의미는 여러개의 가변인자를 받을 수 있는 의미
    print(a,*args)
    print(a,args)
    print(type(args))
    
asterisk_test(1,*(2,3,4,5,6)) ## 이곳의 *의미는 unpacking

 

1 2 3 4 5 6
1 (2, 3, 4, 5, 6)
<class 'tuple'>

In [84]:

def asterisk_test(a,*args):
    print(a,args)
    print(type(args))

asterisk_test(1,*(2,3,4,5,6))

 

1 (2, 3, 4, 5, 6)
<class 'tuple'>

In [80]:

print(["1","2","3","4"])

 

['1', '2', '3', '4']

In [81]:

print(*["1","2","3","4"])

 

1 2 3 4

In [85]:

a,b,c=([1,2],[3,4],[5,6])
print(a,b,c)

data=([1,2],[3,4],[5,6])
print(*data)

 

[1, 2] [3, 4] [5, 6]
[1, 2] [3, 4] [5, 6]

In [86]:

def asterisk_test(a,b,c,d):
    print(a,b,c,d)

data={"b":1,"c":2,"d":3}
asterisk_test(10,**data)

 

10 1 2 3

In [90]:

ex=([1,2],[3,4],[5,6],[5,6],[5,6])
for value in zip(ex):
    print(value)

 

([1, 2],)
([3, 4],)
([5, 6],)
([5, 6],)
([5, 6],)

In [91]:

ex=([1,2],[3,4],[5,6],[5,6],[5,6])
for value in zip(*ex):
    print(value)

 

(1, 3, 5, 5, 5)
(2, 4, 6, 6, 6)

 

2. 피어 세션

---

오늘의 피어세션은 전날에 부여된 과제 총 리뷰, 금일 강의 내용에 대한 토의 및 리뷰, 자체 미션 문제풀이 해설 및 금일 추가 미션 7문제 리뷰로 이루어졌다.

먼저 과제에 대한 리뷰로는, 구현 난이도는 크게 어렵지 않았지만 사소한 실수가 나왔던 부분에 대해 공유하고 다음엔 실수하지 말자는 의미에서 다시 되새기는 시간을 가졌다.

강의에 대한 토의 내용으로는 조원 모두가 공감했던 부분이 Generator 개념에서, 생각보다 난해하고 어려웠던 부분이라 코어타임이 끝나고도 다시 개별적으로 공부해서 다음날 피어세션에서 다시 의견을 나누기로 하였다.

그밖에도 강의에 나왔던 예제의 범주에서 더 나아가 '이런 코드도 작동할까?' 하는 생각으로 다양한 코드들도 같이 실행하고 결과에 대해 토의를 했었다.

 

그리고 피어세션 자체 BOJ 문제풀이를 진행하고있는데, 어제 부여된 6문제에 대해 각자 다 풀어보고 소스 비교도 해보고, 더 좋은 코드가 있는지 살펴보면서 각자 피드백을 해보기도 했으며 모르는 부분을 어떻게 해결했었는지 공유도 했었다. 또 오늘로 추가된 7문제들에 대해서도 간략하게 강의내용과 연결시켜 풀수 있는 방법을 집고 넘어가고 각자 오늘도 코어타임 이외에 개별적으로 풀어서 팀 깃허브에 업로드할 예정이다.

 

또 오늘은 피어 세션 시간을 제외하고도 17시부터 조교님과 온라인 미팅을 가졌으며, 이 시간에 조교님께서 AI에 대해 공부해나갈 방향 그리고 노하우, 그 밖에도 현업 기준으로 알려주시는 AI 분야에서 중요한 부분, 내가 갖추어야할 경쟁 전략 등 많은 좋은 정보들을 공유해주셨다. 직접 현업 기준에서 알려주시는 정보라 더욱 더 새겨듣고 동기 부여가 되었던 유익한 시간이였다. 

 

---

 

 

3. Conclusion

---

 

오늘은 파이썬의 자료구조, 그리고 Pythonic Code를 배웠다. 

그리고 파이썬에 대해 공부하면서 느끼는점은 왜 요즘 Python을 배우는지 알것 같았다. 예를 들면, deque 자료구조도 원형으로 연결된 Linked List로 사용하기 쉽게 구현되어있고 스택, 큐, deque 모두 제공하면서 인덱스로 접근도 가능할 뿐더러 pop()함수는 인자로 인덱스를 집어넣으면 그부분만 빠져나온다. 사실 이러한 부분은 C++을 사용할때는 직접 구현해야했었는데, 왜 인간의 시간을 아끼려면 Python을 사용하라는지 와닿았던 부분이였다.

 

게다가 List Comprehension은 파격적으로 편리한 기능을 제공한다. 세상에 리스트(배열) 선언과 동시에 for문을 통해 값도 집어넣을 수 있다니, 이것이 단 한줄로 가능하다니. 빨리 익숙해져서 자유롭게 사용하고 싶다.

 

오늘 강의에서 배운 내용 중에서 가장 어려웠던 부분은 피어세션에서도 의견을 나누었지만, Generator 부분이였다. 난생 처음보는 개념이였고 메모리적 성능과 관련이 있는 스킬이라 빅데이터, AI에서도 굉장히 많이 쓰인다고 한다. 아직 이해가 되지 않았기 때문에, 따로 더 깊게 공부하고 구글링을 통해서든, 토의를 통해서든 완전히 내것으로 만들고 넘어가야 나중에 고생을 안할것 같다.

 

---