Day8 - Code

Ch7 자료구조¶

스택¶

스택에서 데이터의 저장과 추출¶

In [1]:

a = [1,2,3,4,5]
a

Out[1]:

[1, 2, 3, 4, 5]

In [2]:

# 스택에서 데이터의 저장(push)
a.append(20)
a

Out[2]:

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

In [3]:

# 스택에서 데이터의 추출(pop)
a.pop()

Out[3]:

20

In [4]:

a.pop()

Out[4]:

5

텍스트 역순 추출¶

In [5]:

word = input("Input a word: ")

Input a word: PYTHON

In [6]:

world_list = list(word)
print(world_list)
print(len(world_list))

['P', 'Y', 'T', 'H', 'O', 'N']
6

In [7]:

world_list.pop()

Out[7]:

'N'

In [8]:

result = []
for _ in range(len(world_list)):
    result.append(world_list.pop())

print(result)

['O', 'H', 'T', 'Y', 'P']

In [9]:

print(word[::-1])

NOHTYP

큐¶

In [10]:

a = [1,2,3,4,5]
a

Out[10]:

[1, 2, 3, 4, 5]

In [11]:

a.append(10)
a

Out[11]:

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

In [12]:

a.append(20)
a

Out[12]:

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

In [13]:

a.pop(0)

Out[13]:

1

In [14]:

a.pop(0)

Out[14]:

2

In [15]:

a

Out[15]:

[3, 4, 5, 10, 20]

튜플과 세트¶

In [16]:

# 튜플
t = (1,2,3)

print(t+t, t*2)

(1, 2, 3, 1, 2, 3) (1, 2, 3, 1, 2, 3)

In [17]:

len(t)

Out[17]:

3

In [18]:

# 튜플 값 변경 에러
t[1] = 5

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_17128/2924251401.py in <module>
      1 # 튜플 값 변경 에러
----> 2 t[1] = 5

TypeError: 'tuple' object does not support item assignment

In [19]:

# 세트
s = set([1, 2, 3, 1, 2, 3])
s

Out[19]:

{1, 2, 3}

In [20]:

# 세트의 데이터 하나 추가
s.add(4)
s

Out[20]:

{1, 2, 3, 4}

In [21]:

# 세트의 리스트 추가
s.update([1, 4, 5, 6, 7])
s

Out[21]:

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

In [22]:

# 세트의 데이터 하나 삭제
s.discard(3)
s

Out[22]:

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

In [23]:

# 세트의 데이터 하나 삭제
s.remove(1)
s

Out[23]:

{2, 4, 5, 6, 7}

In [24]:

# 세트의 모든 데이터 삭제
s.clear()
s

Out[24]:

set()

세트의 교집합, 합집합, 차집합¶

In [25]:

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

In [26]:

# 합집합
print(s1.union(s2))
print(s1 | s2)

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

In [27]:

# 교집합
print(s1.intersection(s2))
print(s1&s2)

{3, 4, 5}
{3, 4, 5}

In [28]:

# 차집합
print(s1.difference(s2))
print(s1-s2)

{1, 2}
{1, 2}

딕셔너리¶

In [29]:

# 딕셔너리 선언
student_info = {20140012:'Sungchul', 3.2:'Jiyoung', 20140058:'Jaehong'}
student_info

Out[29]:

{20140012: 'Sungchul', 3.2: 'Jiyoung', 20140058: 'Jaehong'}

In [30]:

# 딕셔너리의 데이터 검색
student_info[20140012]

Out[30]:

'Sungchul'

In [31]:

student_info[3.2]

Out[31]:

'Jiyoung'

In [32]:

# 딕셔너리의 데이터 추가
student_info['20140015'] = 'Janhyeok'
student_info

Out[32]:

{20140012: 'Sungchul',
 3.2: 'Jiyoung',
 20140058: 'Jaehong',
 '20140015': 'Janhyeok'}

딕셔너리의 함수¶

In [33]:

country_code = {'America':1, 'Korea':82, 'China':86, 'Japan':81}
country_code

Out[33]:

{'America': 1, 'Korea': 82, 'China': 86, 'Japan': 81}

In [34]:

country_code.keys()

Out[34]:

dict_keys(['America', 'Korea', 'China', 'Japan'])

In [35]:

country_code.values()

Out[35]:

dict_values([1, 82, 86, 81])

In [36]:

country_code.items()

Out[36]:

dict_items([('America', 1), ('Korea', 82), ('China', 86), ('Japan', 81)])

In [37]:

for k, v in country_code.items():
    print(k)
    print(v, '\n')

America
1 

Korea
82 

China
86 

Japan
81 

In [38]:

'Korea' in country_code.keys()

Out[38]:

True

In [39]:

82 in country_code.values()

Out[39]:

True

Ch8 파이썬 스타일 코드¶

문자열의 분리 및 결합 : split 함수, join 함수¶

In [40]:

# split() : 빈칸을 기준으로 문자열 분리하기
items = 'zero one two three'.split()
items

Out[40]:

['zero', 'one', 'two', 'three']

In [41]:

# ',' 기준으로 문자열 나누기
example = 'python,jquuery,javascript'
example.split(',')

Out[41]:

['python', 'jquuery', 'javascript']

In [42]:

# 리스트의 각 값을 a, b, c 변수로 언패킹
a, b, c = example.split(',')
print(a)
print(b)
print(c)

python
jquuery
javascript

In [43]:

# join() : 리스트의 각 값을 결합하여 문자열로 반환해준다.
colors = ['red', 'blue', 'green', 'yellow']
colors

Out[43]:

['red', 'blue', 'green', 'yellow']

In [44]:

# 일반적인 for문
result = ''
for s in colors:
    result += s    # = result + s
result

Out[44]:

'redbluegreenyellow'

In [45]:

# 빈 칸을 기준으로 리스트 요소들 합쳐서 문자열로 반환하기
result = ' '.join(colors)
result

Out[45]:

'red blue green yellow'

In [46]:

result = ','.join(colors)
result

Out[46]:

'red,blue,green,yellow'

In [47]:

result = '-'.join(colors)
result

Out[47]:

'red-blue-green-yellow'

리스트 컴프리헨션¶

In [48]:

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

Out[48]:

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

In [49]:

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

Out[49]:

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

In [50]:

## 1. 필터링 : if문과 함께 사용하는 리스트 컴프리헨션
result = []
for i in range(10):
    if i%2==0:
        result.append(i)
result

Out[50]:

[0, 2, 4, 6, 8]

In [51]:

# 짝수만 저장하는 리스트 컴프리헨션
result = [i for i in range(10) if i%2==0]
result

Out[51]:

[0, 2, 4, 6, 8]

In [52]:

# if문을 앞으로 옮겨 else 문과 함께 사용할 수도 있음
result = [i if i%2==0 else 10 for i in range(10)]
result

Out[52]:

[0, 10, 2, 10, 4, 10, 6, 10, 8, 10]

In [53]:

## 2. 중첩 반복문
word_1 = 'Hello'
word_2 = 'World'

result = [i+j for i in word_1 for j in word_2]
print(result, end=" ")

['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'] 

In [54]:

## 3. 이차원 리스트
words = 'The quick brown fox jumps over the lazy dog'.split()
words

Out[54]:

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

In [55]:

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

Out[55]:

[['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 [56]:

# 일반적인 반복문 + 리스트
def sclar_vector_product(scalar, vector):
    result = []
    for value in vector:
        result.append(scalar * value)
    return result

iteration_max = 10000

vector = list(range(iteration_max))
scalar = 2

for _ in range(iteration_max):
    sclar_vector_product(scalar, vector)

In [57]:

# 리스트 컴프리헨션 사용
iteration_max = 10000

vector = list(range(iteration_max))
scalar = 2

for _ in range(iteration_max):
    [scalar * value for value in range(iteration_max)]

다양한 방식의 리스트, 딕셔너리 출력¶

enumerate 함수¶

In [58]:

# 리스트값에 인덱스를 붙여 출력
for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

0 tic
1 tac
2 toe

In [59]:

# 딕셔너리에서 인덱스를 키로, 단어를 값으로 출력
# 기본값이 띄어쓰기 이다
{i:j for i,j in enumerate('TEAMLAB is an academic institute lacated in South Korea.'.split())}

Out[59]:

{0: 'TEAMLAB',
 1: 'is',
 2: 'an',
 3: 'academic',
 4: 'institute',
 5: 'lacated',
 6: 'in',
 7: 'South',
 8: 'Korea.'}

In [60]:

{i:j for i,j in enumerate('TEAMLAB is an academic institute lacated in South Korea.'.split(" "))}

Out[60]:

{0: 'TEAMLAB',
 1: 'is',
 2: 'an',
 3: 'academic',
 4: 'institute',
 5: 'lacated',
 6: 'in',
 7: 'South',
 8: 'Korea.'}

zip 함수¶

In [61]:

# 리스트 값을 병렬로 묶어 출력
alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3']

for a, b in zip(alist, blist):
    print(a, b)

a1 b1
a2 b2
a3 b3

In [62]:

# 같은 위치에 있는 리스트 값끼리 더하기
a, b, c = zip((1,2,3), (10,20,30), (100,200,300))

print(a, b, c)

(1, 10, 100) (2, 20, 200) (3, 30, 300)

In [63]:

[sum(x) for x in zip((1,2,3), (10,20,30), (100,200,300))]

Out[63]:

[111, 222, 333]

In [64]:

# enumerate 함수와 zip 함수 연계 사용
alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3']

list(zip(alist, blist))

Out[64]:

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

In [65]:

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

0 a1 b1
1 a2 b2
2 a3 b3

In [66]:

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

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

In [67]:

# i, a, b 로 사용하면
# 완전 하나씩 추출한 것이다
[ [i, a, b, len( list( [i, a, b] ) )] for i, (a, b) in enumerate( zip(alist, blist) ) ]

Out[67]:

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

In [68]:

# i, v 로 사용하면
# (a1, b1) 형태로만 추출한 것이다
[ [i, v, len( list( [i, v] ) ) ] for i, v in enumerate( zip(alist, blist) ) ]

Out[68]:

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

판다스 넘파이 맷플롭립¶

판다스(Pandas)¶

In [69]:

import pandas as pd

• 시리즈(Series)
• 데이터프레임(DataFrame)
• 패널(Panel)

시리즈(Series)¶

In [70]:

sr = pd.Series([17000, 18000, 1000, 5000],
              index=["피자", "치킨", "콜라", "감자튀김"])
print('시리즈 출력 :')
print('-'*15)
print(sr)

시리즈 출력 :
---------------
피자      17000
치킨      18000
콜라       1000
감자튀김     5000
dtype: int64

In [71]:

print('시리즈의 값 : {}'.format(sr.values))
print('시리즈의 인덱스 : {}'.format(sr.index))

시리즈의 값 : [17000 18000  1000  5000]
시리즈의 인덱스 : Index(['피자', '치킨', '콜라', '감자튀김'], dtype='object')

데이터프레임(DataFrame)¶

In [72]:

values = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
index = ['one', 'two', 'three']
columns = ['A', 'B', 'C']

df = pd.DataFrame(values, index=index, columns=columns)

print('데이터프레임 출력 :')
print('-'*18)
print(df)

데이터프레임 출력 :
------------------
       A  B  C
one    1  2  3
two    4  5  6
three  7  8  9

In [73]:

print('데이터프레임의 인덱스 : {}'.format(df.index))
print('데이터프레임의 열이름: {}'.format(df.columns))
print('데이터프레임의 값 :')
print('-'*18)
print(df.values)

데이터프레임의 인덱스 : Index(['one', 'two', 'three'], dtype='object')
데이터프레임의 열이름: Index(['A', 'B', 'C'], dtype='object')
데이터프레임의 값 :
------------------
[[1 2 3]
 [4 5 6]
 [7 8 9]]

데이터프레임의 생성¶

In [74]:

# 리스트로 생성하기
data = [
    ['1000', 'Steve', 90.72], 
    ['1001', 'James', 78.09], 
    ['1002', 'Doyeon', 98.43], 
    ['1003', 'Jane', 64.19], 
    ['1004', 'Pilwoong', 81.30],
    ['1005', 'Tony', 99.14],
]

df = pd.DataFrame(data)
print(df)

      0         1      2
0  1000     Steve  90.72
1  1001     James  78.09
2  1002    Doyeon  98.43
3  1003      Jane  64.19
4  1004  Pilwoong  81.30
5  1005      Tony  99.14

In [75]:

df = pd.DataFrame(data, columns=['학번', '이름', '점수'])
print(df)

     학번        이름     점수
0  1000     Steve  90.72
1  1001     James  78.09
2  1002    Doyeon  98.43
3  1003      Jane  64.19
4  1004  Pilwoong  81.30
5  1005      Tony  99.14

In [76]:

# 딕셔너리로 생성하기
data = {
    '학번' : ['1000', '1001', '1002', '1003', '1004', '1005'],
    '이름' : [ 'Steve', 'James', 'Doyeon', 'Jane', 'Pilwoong', 'Tony'],
    '점수': [90.72, 78.09, 98.43, 64.19, 81.30, 99.14]
    }

df = pd.DataFrame(data)
print(df)

     학번        이름     점수
0  1000     Steve  90.72
1  1001     James  78.09
2  1002    Doyeon  98.43
3  1003      Jane  64.19
4  1004  Pilwoong  81.30
5  1005      Tony  99.14

데이터프레임 조회하기¶

• df.head(n) : 앞 부분을 n개만 보기
• df.tail(n) : 뒷 부분을 n개만 보기
• df['열이름'] : 해당되는 열을 확인

In [77]:

# 앞 부분을 3개만 보기
print(df.head(3))

     학번      이름     점수
0  1000   Steve  90.72
1  1001   James  78.09
2  1002  Doyeon  98.43

In [78]:

# 뒷 부분을 3개만 보기
print(df.tail(3))

     학번        이름     점수
3  1003      Jane  64.19
4  1004  Pilwoong  81.30
5  1005      Tony  99.14

In [79]:

# '학번'에 해당되는 열을 보기
print(df['학번'])

0    1000
1    1001
2    1002
3    1003
4    1004
5    1005
Name: 학번, dtype: object

넘파이(Numpy)¶

In [80]:

import numpy as np

np.array()¶

In [81]:

# 1차원 배열
vec = np.array([1, 2, 3, 4, 5])
print(vec)

[1 2 3 4 5]

In [82]:

# 2차원 배열
mat = np.array([ [10, 20, 30], [60, 70, 80] ])
print(mat)

[[10 20 30]
 [60 70 80]]

In [83]:

print('vec의 타입 :', type(vec))
print('mat의 타입 :', type(mat))

vec의 타입 : <class 'numpy.ndarray'>
mat의 타입 : <class 'numpy.ndarray'>

In [84]:

print('vec의 축의 개수 :', vec.ndim)     # 축의 개수 출력
print('vec의 크기(shape) :', vec.shape)  # 크기 출력

vec의 축의 개수 : 1
vec의 크기(shape) : (5,)

In [85]:

print('mat의 축의 개수 :', mat.ndim)     # 축의 개수 출력
print('mat의 크기(shape) :', mat.shape)  # 크기 출력

mat의 축의 개수 : 2
mat의 크기(shape) : (2, 3)

ndarray의 초기화¶

In [86]:

# 모든 값이 0인 2x3 배열 생성
zero_mat = np.zeros( (2,3) )
print(zero_mat)

[[0. 0. 0.]
 [0. 0. 0.]]

In [87]:

# 모든 값이 1인 2x3 배열 생성
one_mat = np.ones( (2,3) )
print(one_mat)

[[1. 1. 1.]
 [1. 1. 1.]]

In [88]:

# 모든 값이 특정 상수인 배열 생성. 이 경우 7
same_value_mat = np.full((2,2), 7)
print(same_value_mat)

[[7 7]
 [7 7]]

In [89]:

# 대각선 값이 1이고 나머지 값이 0인 2차원 배열을 생성
eye_mat = np.eye(3)
print(eye_mat)

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

In [90]:

# 임의의 값으로 채워진 배열 생성
# random은 0~1 사이
random_mat = np.random.random( (2,2) )
print(random_mat)

[[0.13608385 0.98317187]
 [0.34282476 0.53245617]]

np.arange()¶

In [91]:

# 0부터 9까지
range_vec = np.arange(10)
print(range_vec)

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

In [92]:

# 1부터 9까지 +2씩 적용되는 범위
n = 2
range_n_step_vec = np.arange(1, 10, n)
print(range_n_step_vec)

[1 3 5 7 9]

np.reshape()¶

In [93]:

reshape_mat = np.array(np.arange(30)).reshape((5,6))
print(reshape_mat)

[[ 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]]

Numpy 슬라이싱¶

In [94]:

mat = np.array([ [1, 2, 3], [4, 5, 6] ])
print(mat)

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

In [95]:

# 첫번째 행 출력
slicing_mat = mat[0, :]
print(slicing_mat)

[1 2 3]

In [96]:

# 두번째 열 출력
slicing_mat = mat[:, 1]
print(slicing_mat)

[2 5]

Numpy 정수 인덱싱(integer indexing)¶

In [97]:

mat = np.array([ [1, 2], [4, 5], [7, 8] ])
print(mat)

[[1 2]
 [4 5]
 [7 8]]

In [98]:

# 1행 0열의 원소
# => 0부터 카운트하므로 두번째 행 첫번째 열의 원소
print(mat[1, 0])

4

In [99]:

# mat[[2행, 1행],[0열, 1열]]
# 각 행과 열의 쌍을 매칭하면 2행 0열, 1행 1열의 두 개의 원소
indexing_mat = mat[ [2, 1], [0, 1] ]
print(indexing_mat)

[7 5]

Numpy 연산¶

In [100]:

x = np.array([1, 2, 3])
y = np.array([4, 5, 6])

In [101]:

# result = np.add(x, y)와 동일
result = x + y
print(result)

[5 7 9]

In [102]:

# result = np.subtract(x, y)와 동일
result = x - y
print(result)

[-3 -3 -3]

In [103]:

# result = np.multiply(result, x)와 동일
result = result * x
print(result)

[-3 -6 -9]

In [104]:

# result = np.divide(result, x)와 동일
result = result / x
print(result)

[-3. -3. -3.]

In [105]:

mat1 = np.array([[1,2],[3,4]])
mat2 = np.array([[5,6],[7,8]])
mat3 = np.dot(mat1, mat2)
print(mat3)

[[19 22]
 [43 50]]

나도코딩 유튜브¶

자료형¶

숫자 자료형¶

문자열 자료형¶

boolean 자료형¶

변수¶

• 변수 : 값을 저장하는 공간

In [106]:

# 애완동물을 소개해 주세요~
animal = '강아지'
name = '연탄'
age = 4
hobby = '산책'
is_adult = age >= 3

print('우리집 ' + animal + '의 이름은 ' + name + '이예요.')
print(name + '은 ' + str(age) + '살이며, ' + hobby + '을 아주 좋아해요.')
print(name + '은 어른일까요? ' + str(is_adult))

우리집 강아지의 이름은 연탄이예요.
연탄은 4살이며, 산책을 아주 좋아해요.
연탄은 어른일까요? True

In [107]:

animal = '고양이'
name = '고양고양'
age = 5
hobby = '사냥'
is_adult = age >= 3

print('우리집 ' + animal + '의 이름은 ' + name + '이예요.')
print(name + '은 ' + str(age) + '살이며, ' + hobby + '을 아주 좋아해요.')
print(name + '은 어른일까요? ' + str(is_adult))

우리집 고양이의 이름은 고양고양이예요.
고양고양은 5살이며, 사냥을 아주 좋아해요.
고양고양은 어른일까요? True

주석¶

In [108]:

'''
이렇게 하면
여러 문장이
주석 처리가
되는군요
'''

Out[108]:

'\n이렇게 하면\n여러 문장이\n주석 처리가\n되는군요\n'

퀴즈 #1¶

In [109]:

# Quiz) 변수를 이용하여 다음 문자을 출력하시오  
  
# 변수명  
# : station
  
# 변수값  
# : '사당', '신도림', '인천공항' 순서대로 입력  
  
# 출력 문장  
# : XX행 열차가 들어오고 있습니다.

In [110]:

station1 = '사당'
station2 = '신도림'
station3 = '인천공항'

print(station1 + ' 행 열차가 들어오고 있습니다.')
print(station2 + ' 행 열차가 들어오고 있습니다.')
print(station3 + ' 행 열차가 들어오고 있습니다.')

사당 행 열차가 들어오고 있습니다.
신도림 행 열차가 들어오고 있습니다.
인천공항 행 열차가 들어오고 있습니다.

숫자¶

연산자¶

In [111]:

print(2^3)    # 이건 뭘까?
print(2**3)

1
8

간단한 수식¶

In [112]:

number = 2 + 3 * 4
number += 2
number *= 2
number /= 2
number -= 2
number %= 2

숫자 처리 함수¶

In [113]:

print(abs(-5))    # 절댓값

5

In [114]:

print(pow(4, 2))    # 4를 2번 곱하기

16

In [115]:

print(max(5, 12))

12

In [116]:

print(min(5, 12))

5

In [117]:

print(round(3.14))    # 반올림
print(round(3.74))

3
4

In [118]:

from math import *
print(floor(4.99))    # 내림
print(ceil(3.14))    # 올림
print(sqrt(16))

4
4
4.0

랜덤 함수¶

In [119]:

from random import *

In [120]:

print(random())    # 0.0 ~ 1.0 미만의 임의의 값 생성

0.08224997433786796

In [121]:

print(random() * 10)    # 0.0 ~ 10.0 미만의 임의의 값 생성

3.7571920792521607

In [122]:

print(randrange(1, 45))    # 1 ~ 45 미만의 임의의 정수 생성

30

In [123]:

print(randint(1, 45))    # 1 ~ 45 이하의 임의의 정수 생성

29

퀴즈 #2¶

In [124]:

# Quiz) 당신은 최근에 코딩 스터디 모임을 새로 만들었습니다.
# 월 4회 스터디를 하는데 3번은 온라인으로 하고 1번은 오프라인으로 하기로 했습니다.
# 아래 조건에 맞는 오프라인 모임 날짜를 정해주는 프로그램을 작성하시오.

# 조건1 : 랜덤으로 날짜를 뽑아야 함
# 조건2 : 월별 날짜는 다름을 감안하여 최소 일수인 28일 이내로 정함
# 조건3 : 매월 1~3일은 스터디 준비를 해야 하므로 제외
    
# (출력문 예제)
# 오프라인 스터디 모임 날짜는 매월 x 일로 선정되었습니다.

In [125]:

# from random import *
offline = randint(4, 28)
print('오프라인 스터디 모임 날짜는 매월', str(offline), '일로 선정되었습니다.')

오프라인 스터디 모임 날짜는 매월 8 일로 선정되었습니다.

문자열¶

Ch9 파이썬 스타일 코드2¶

람다 함수¶

In [126]:

# 일반적인 함수
def f(x, y):
    return x + y
f(1, 4)

Out[126]:

5

In [127]:

# 람다 함수
f = lambda x,y : x+y
print(f(1,4))

5

람다 함수의 다양한 형태¶

In [128]:

f = lambda x : x**2
f(9)

Out[128]:

81

In [129]:

f = lambda x : x/2
f(80)

Out[129]:

40.0

ch9.2 맵 리듀스¶

In [130]:

# map 함수 : 연속 데이터를 저장하는 시퀀스 자료형에서 요소마다 같은 기능을 적용할 때 사용

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

# 리스트 ex의 각 요소에 함수 f를 적용하여 다시 리스트로 받기
list(map(f, ex))

Out[130]:

[1, 4, 9, 16, 25]

In [131]:

# 제너레이터 : 시퀀스 자료형 데이터를 처리할 때 실행 시점의 값을 생성하여 효율적으로 메모리 관리

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

# 리스트 없이 map 함수를 사용하는 경우(제너레이터 개념)
for value in map(f, ex):
    print(value)

1
4
9
16
25

최근에는 람다 함수나 map 함수보다 리스트 컴프리헨션을 권장한다.¶

In [132]:

ex = [1,2,3,4,5]

[x**2 for x in ex]

Out[132]:

[1, 4, 9, 16, 25]

In [133]:

# map 함수는 입력값으로 여러 개의 시퀀스 자료형을 받을 수 있다.
ex = [1,2,3,4,5]
f = lambda x,y : x+y

list(map(f, ex, ex))

Out[133]:

[2, 4, 6, 8, 10]

In [134]:

# 리스트 컴프리헨션으로 해결 가능
[x+y for x,y in zip(ex, ex)]

Out[134]:

[2, 4, 6, 8, 10]

In [135]:

# map 함수의 필터링 기능
# ex 각 요소마다 lambda 함수를 적용하라
list(map(lambda x:x**2 if x%2==0 else x, ex))

Out[135]:

[1, 4, 3, 16, 5]

In [136]:

# 리스트 컴프리헨션으로 구현하면 더 간단
[x**2 if x%2==0 else x for x in ex]

Out[136]:

[1, 4, 3, 16, 5]

In [137]:

# 1부터 5까지 정수를 더하는 함수
x=0
for y in [1,2,3,4,5]:
    x += y
x

Out[137]:

15

In [138]:

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

Out[138]:

15

별표의 사용¶

In [139]:

# 가변 인수
def asterisk_test(a, *args):
    print(a, args)
    print(type(args))
    
asterisk_test(1,2,3,4,5,6)
# -> 1은 변수 a에, (2,3,4,5,6)은 변수 args에 할당됨

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

In [140]:

# 별표의 언패킹 기능
# 변수 앞에 별표를 붙이면 여러 개의 변수를 한 번에 넣을 수 있는 컨테이너 역할을 함
def asterisk_test(a, args):
    print(a, *args)
    print(type(args))
    
asterisk_test(1, (2,3,4,5,6))
# -> *args 가 튜플 변수를 언패킹하여 받은 것

1 2 3 4 5 6
<class 'tuple'>

In [141]:

# 키워드 가변 인수
def asterisk_test(a, **kargs):
    print(a, kargs)
    print(type(kargs))
    
asterisk_test(1, b=2, c=3, d=4, e=5, f=6)
# -> 1은 변수 a에, {'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}는 변수 kargs에 할당됨

1 {'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
<class 'dict'>

In [142]:

asterisk_test(1, name=2, hobby=3, dream=4, food=5, place=6)

1 {'name': 2, 'hobby': 3, 'dream': 4, 'food': 5, 'place': 6}
<class 'dict'>

선형대수학(linear algebra)¶

벡터의 연산¶

In [143]:

# 기본적인 for문을 사용한 벡터 덧셈
u = [2,2]
v = [2,3]
z = [3,5]

result = []
for i in range(len(u)):
    result.append(u[i] + v[i] + z[i])

result

Out[143]:

[7, 10]

In [144]:

# zip함수, 리스트 컴프리헨션을 이용한 벡터 덧셈
result = [sum(t) for t in zip(u,v,z)]
result

Out[144]:

[7, 10]

In [145]:

# 변수가 많은 경우 : 별표를 사용한 함수화
def vector_addition(*args):
    return [sum(t) for t in zip(*args)]

vector_addition(u,v,z)

Out[145]:

[7, 10]

스칼라-벡터 연산¶

In [146]:

# 벡터 u,v
u = [1,2,3]
v = [4,4,4]

# 스칼라 alpha
alpha = 2

# 스칼라-벡터 연산
result = [alpha*sum(t) for t in zip(u,v)]
result

Out[146]:

[10, 12, 14]

행렬의 연산¶

In [147]:

# 파이썬 스타일 코드로 행렬의 연산
matrix_a = [[3,6], [4,5]]
matrix_a

Out[147]:

[[3, 6], [4, 5]]

In [148]:

matrix_b = [[5,8], [6,7]]
matrix_b

Out[148]:

[[5, 8], [6, 7]]

In [149]:

result = [[sum(row) for row in zip(*t)] for t in zip(matrix_a, matrix_b)]
result

Out[149]:

[[8, 14], [10, 12]]

In [150]:

list(zip(matrix_a, matrix_b))

Out[150]:

[([3, 6], [5, 8]), ([4, 5], [6, 7])]

전치 행렬(transpose matrix)¶

In [151]:

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

# numpy array로 변환 후 T 적용
# import numpy as np

np.array(matrix_a).T

Out[151]:

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

행렬 곱(내적)¶

In [152]:

matrix_a = [[1,1,2], [2,1,1]]
matrix_b = [[1,1], [2,1], [1,3]]

matrix_a = np.array(matrix_a)
matrix_b = np.array(matrix_b)

print(matrix_a)
print()
print(matrix_b)

[[1 1 2]
 [2 1 1]]

[[1 1]
 [2 1]
 [1 3]]

In [153]:

np.dot(matrix_a, matrix_b)

Out[153]:

array([[5, 8],
       [5, 6]])