본문 바로가기
PYTHON

20200317 - 파이썬 Series(시리즈), 종속변수, 행렬, 행렬연산, 전치

by 낫싱 2020. 3. 17.
728x90
반응형

20200317 - Jupyter Notebook.pdf
0.48MB
hw_dataset생성_호지수(선생님 문제풀이).pdf
0.27MB
hw_numpy_0317호지수 - Jupyter Notebook.pdf
0.28MB
20200317.ipynb
0.03MB
hw_numpy_0317호지수.ipynb
0.02MB

Numpy

numerical Python을 의미하는 Numpy는 파이썬에서 선형대수 기반의 프로그램을 쉽게 만들 수 있도록 지원하는 대표적인 패키지

많은 머신러닝 알고리즘이 넘파이 기반으로 작성돼 있으며 알고리즘의 입출력 데이터를 넘파이 배열 타입으로 사용함

넘파이의 기본 데이터 타입은 ndarray.ndarray를 이용해 넘파이에서 다차원 배열을 쉽게 생성하고 다양한 연산 수행

In [5]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#1차원 배열로 3개의 데이터

import numpy as np

 

array1 = np.array([1,2,3])

print('array1 type:',type(array1))

 

#1차원 배열의 shape는 (,열)이 아닌 (열,)형태로 출력

print('array1 array형태:',array1.shape) # 1차원(열의 숫자만 있고 행의 숫자가 없다.)

print(array1)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

array1 type: <class 'numpy.ndarray'> array1 array형태: (3,) [1 2 3]

In [8]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# 2차원 배열로 2개의 row와 3개의 columns 으로 구성된 6개의 데이터

array2 = np.array([[1,2,3],

[2,3,4]])

print('array2 type:',type(array2))

print('array2 array형태 :', array2.shape) # (2, 3) 2행 3열로 구성된 행렬

print(array2)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

array2 type: <class 'numpy.ndarray'> array2 array형태 : (2, 3) [[1 2 3] [2 3 4]]

In [13]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#1개의 row와 3개의 column으로 구성된 2차원 배열

import numpy as np

array3 = np.array([[1,2,3]]) # 배열을 대괄호 내부로 넣어줘서 2차원 배열로 형태를 변경

print('array3 type:',type(array3))

print('array3 array 형태:',array3.shape)

print(array3)

print()

 

print(array1.ndim) #1차원

print(array3.ndim) #2차원
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

array3 type: <class 'numpy.ndarray'> array3 array 형태: (1, 3) [[1 2 3]] 1 2

In [37]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# 데이터 값으로는 서로 동일하나 차원이 달라서 오류가 발생

# 차원의 차수를 변환하여 오류 방지 (참조 : reshape)

ar = np.arange(10) # [0 1 2 3 4 5 6 7 8 9] 0부터 9까지 포함된 배열 생성

ar1 = ar.reshape(2,5) # [0 1 2 3 4 5 6 7 8 9] 을 2행 5열의 2차원 배열로 변경

ar2 = ar.reshape(5,2) # [0 1 2 3 4 5 6 7 8 9] 을 5행 2열의 2차원 배열로 변경

ar3 = ar.reshape(1,10)

ar4 = ar.reshape(-1,1) # -1을 쓰면 어떠한 배열이던지 행을 1행으로 설정해라 라는 의미.(나머지는 -1이 알아서 처리하는 것)

print(ar)

print(ar1)

print(ar2)

print(ar3)

print(ar4)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

In [40]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# Q. array1, array2, array3을 str.format을 사용해서 아래와 같은 출력 결과를 만드세요.

# "array1 : 1차원, array2 : 2차원, array3: 2차원"

 

print('array1:{0}차원, array2:{1}차원, array3:{2}차원'.format(array1.ndim, array2.ndim, array3.ndim))
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

array1:1차원, array2:2차원, array3:2차원

In [43]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# ndarray 데이터 타입

list1 = [1,2,3]

print(type(list1))

array1 = np.array(list1)

print(type(array1))

print(array1,array1.dtype)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

<class 'list'> <class 'numpy.ndarray'> [1 2 3] int32

In [47]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# 다른 데이터 유형이 섞여 있는 리스트를 ndarray로 변경하여

# 데이터 크기가 더 큰 데이터 타입으로 형 변환을 일괄 적용

# int 형이 유니코드 문자열 값으로, int형이 float64형으로 변환

list2 = [1,2,'test']

array2 = np.array(list2)

print(array2, array2.dtype)

 

list3 = [1,2,3.0]

array3 = np.array(list3)

print(array3, array3.dtype)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

['1' '2' 'test'] <U11 [1. 2. 3.] float64

In [49]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#int 32 형을 float 64형으로 전환

array_int = np.array([1,2,3]) # 여기선 int 형

array_float = array_int.astype('float64') # float으로 형태 변환

print(array_float, array_float.dtype)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[1. 2. 3.] float64

In [51]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#float 64형을 다시 int 32형으로 변환

array_int1 = array_float.astype('int32') #astype으로 형변환('변환하고자하는 타입 명시')

print(array_int1, array_int1.dtype) #출력하면 list로 출력되는걸 확인할 수 있음.
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[1 2 3] int32

In [53]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# 데이터 형태 지정하기 (assinging Data Type) : np.array([xx, xx], dtype=np.Type)

# 데이터 형태 확인하기 (checking Data Type) : object.dtype

# 데이터 형태 변환하기 (converting Data Type) : object.astype(np.Type)

array_float1 = np.array([1.1,2.1,3.1])

array_int2 = array_float1.astype('int32')

print(array_int2, array_int2.dtype) #원하는 형태와 자료형 확인 가능
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[1 2 3] int32

In [59]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#Q. 정수와 실수로 구성된 list e = [1.2,2.3,3]을 numpy를 이용해서 실수형과 정수형으로 각각 출력하세요.

e = [1.2,2.3,3]

array_float2 = np.array(e)

array_int3 = array_float2.astype('int32')

print(array_float2, array_float2.dtype)

print(array_int3, array_int3.dtype)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[1.2 2.3 3. ] float64 [1 2 3] int32

In [60]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#ndarray를 편리하게 생성하기 - arange,zeros,ones

#arange

sequence_array=np.arange(10)

sequence_array

print(sequence_array)

print(sequence_array.dtype,sequence_array.shape)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[0 1 2 3 4 5 6 7 8 9] int32 (10,)

In [69]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#zeros

zero_array = np.zeros((3,2),dtype='int32') # float64 로 하면 0. 으로 .이 찍힌다.

print(zero_array)

print(zero_array.dtype,zero_array.shape)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[0 0] [0 0] [0 0]] int32 (3, 2)

In [75]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#ones

one_array = np.ones((3,2), dtype='int32') #float64 로 명시하면 1. 으로 출력된다.

print(one_array)

print(one_array.dtype, one_array.shape)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[1 1] [1 1] [1 1]] int32 (3, 2)

In [77]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#reshape()

#ndarray의 차원과 크기를 변경하는 reshape()

 

array1 = np.arange(10)

print('array1:\n',array1)

print()

array2 = array1.reshape(2,5)

print('array2:\n',array2)

print()

array3 = array2.reshape(5,2)

print('array3:\n',array3)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

array1: [0 1 2 3 4 5 6 7 8 9] array2: [[0 1 2 3 4] [5 6 7 8 9]] array3: [[0 1] [2 3] [4 5] [6 7] [8 9]]

In [82]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#Q. arange() 함수를 이용, 20까지 연속된 ndarray를 만든 후 array_e1에 저장 후 출력하세요.

#array_e1을 3행 7열로 만들어서 array_e2이름으로 출력하세요.

 

array_e1 = np.arange(21)

print('array_e1:\n',array_e1)

print()

array_e2 = array_e1.reshape(3,7)

print('array_e2:\n',array_e2)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

array_e1: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20] array_e2: [[ 0 1 2 3 4 5 6] [ 7 8 9 10 11 12 13] [14 15 16 17 18 19 20]]

In [84]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#reshape()함수를 이용, array_e2를 7행 3열로 변환한 후 array_e3으로 저장 후 출력하세요

array_e3 = array_e2.reshape(7,3)

print('array_e3:\n',array_e3)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

array_e3: [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11] [12 13 14] [15 16 17] [18 19 20]]

In [86]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#2차원 ndarray 만들기

array1 = np.arange(30)

print(array1)

print(type(array1))

print()

array2d=array1.reshape(2,15)

print(array2d)

#2차원 ndarray를 list로 변환

print('array2d:\n',array2d.tolist()) #2차원 배열을 tolist로 변환해준다.(함수)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[ 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] <class 'numpy.ndarray'> [[ 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]] array2d: [[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]]

In [90]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#Q. array1 을 3차원 ndarray로 변환 array3d에 저장 및 출력하고 리스트 형태로 변환해서 출력하시오

array1 = np.arange(30)

array3d = array1.reshape((3,2,5)) # 2, 5는 2행 5열이고 3은 깊이(겹)를 의미한다. (2행 5열 데이터가 3겹으로 존재)

print(array3d)

print()

print(array3d.tolist())
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

In [94]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#reshape(-1,1)

#여러개의 로우를 가지되 반드시 1개의 칼럼을 가진 ndarray로 변환 보장

#-1을 인자로 사용하여 원하는 shape로 변환

array1 = np.arange(10)

print(array1)

print()

array2 = array1.reshape(-1,1) #1개의 칼럼을 가진 ndarray로 변환.

print('array2 shape:',array2.shape)

print(array2)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[0 1 2 3 4 5 6 7 8 9] array2 shape: (10, 1) [[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]]

In [99]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# reshape(-1,1)을 이용해 1차원을 2차원으로 3차원을 2차원으로 변환

array1 = np.arange(10) #1차원을

print(array1)

array2a = array1.reshape(-1,1) #2차원으로

print(array2a)

print()

array3d = array1.reshape((1,2,5)) #2차원을 3차원으로 괄호 2개 주의 (())

print(array3d)

print()

array2b=array3d.reshape(-1,1) #3차원을 2차원으로

print(array2b)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

In [102]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#Q. array1에 reshape()함수를 이용, "array3 shape: (5,2)"가 되도록 array3을 출력하세요

array3 = array1.reshape(5,2)

print(array3)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

In [107]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#3차원 ndarray array3d를 2차원 ndarray로 변환해서 array5에 저장하고 list로 출력하세요.

print(array3d)

array5 = array3d.reshape(-1,2)

print(array5, '\n', array5.shape)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

In [111]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#1차원 ndarray array1을 2차원 ndarray 변환해서 array6에 저장하고 list로 출력하세요.

array6 = array1.reshape(-1,5)

print(array6)

print(array6.tolist())
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

In [131]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#ndarray의 데이트 세트 선택하기 - 인덱싱

#배열 생성

import numpy as np

array1 = np.arange(start=1, stop=10) # 뽑아내고자 하는 범위 지정 가능(구체적 명시)

print('array1:',array1)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

array1: [1 2 3 4 5 6 7 8 9]

In [132]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#array1에서 3과 9를 출력하세요.

# index는 0부터 시작하므로 array1[2]는 3번째 index 위치의 데이터 값을 의미

value = array1[2]

print('value:',value)

print(type(value))

print()

print('맨 뒤 값 :',array1[-1])
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

value: 3 <class 'numpy.int32'> 맨 뒤 값 : 9

In [133]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#array1 에서 맨 뒤에서 두 번째 값을 출력

print(array1)

print('맨 뒤에서 두 번째 값 ', array1[-2])
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[1 2 3 4 5 6 7 8 9] 맨 뒤에서 두 번째 값 8

In [135]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#인덱스 이용해서 첫 번째와 아홉번째 값을 각각 9와 0으로 수정

print(array1)

array1[0] = 9

array1[-1] = 0

print(array1[0],array1[-1])

print(array1)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

In [137]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#index 가리키는 값 구하기

array1d = np.arange(start = 1, stop = 10)

array2d = array1d.reshape(3,3)

print(array2d)

print()

print('(row=0,col=0) index 가리키는 값:',array2d[0,0])

print('(row=0,col=1) index 가리키는 값:',array2d[0,1])

print('(row=1,col=0) index 가리키는 값:',array2d[1,0])

print('(row=2,col=2) index 가리키는 값:',array2d[2,2])
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[1 2 3] [4 5 6] [7 8 9]] (row=0,col=0) index 가리키는 값: 1 (row=0,col=1) index 가리키는 값: 2 (row=1,col=0) index 가리키는 값: 4 (row=2,col=2) index 가리키는 값: 9

In [139]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# slicing

array1 = np.arange(start=1, stop=10)

print(array1)

print()

array3 = array1[0:3] #0번부터 3-1번 방까지 추출

print(array3)

print(type(array3))
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[1 2 3 4 5 6 7 8 9] [1 2 3] <class 'numpy.ndarray'>

In [156]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# array1에서 슬라이싱(':')을 사용해서 아래와 같이 출력하세요.

# [1 2 3]

# [4 5 6 7 8 9]

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

 

print(array1[:3])

print(array1[3:])

print(array1[:])
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

In [ ]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#2차원 배열 생성

print(array2d)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

In [ ]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# array2d 에서 슬라이싱을 사용해서 아래와 같이 출력하세요

# [[1 2]

# [4 5]]

 

# (2가지 방법)

 

# [[4 5 6]

# [7 8 9]]

 

# [[1 2 3]

# [4 5 6]

# [7 8 9]]

 

# [[2 3]

# [5 6]]
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

In [196]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

a1 = array2d[:2,:2]

print(a1,'12 45')

a2 = array2d[1:3,:3]

print(a2, '456 789')

a3 = array2d[:3,:3]

print(a3,'123 456 789')

a4 = array2d[:2,1:]

print(a4, '23 56')
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[1 2] [4 5]] 12 45 [[4 5 6] [7 8 9]] 456 789 [[1 2 3] [4 5 6] [7 8 9]] 123 456 789 [[2 3] [5 6]] 23 56

In [198]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# 행 선택

print(array2d[0]) # 0번행 전체선택

print()

print(array2d[1]) # 1번행 전체선택

print()

print('array2d[0] shape:',array2d[0].shape, 'array2d[1] shape:', array2d[1].shape)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[1 2 3] [4 5 6] array2d[0] shape: (3,) array2d[1] shape: (3,)

In [201]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#2차원 배열 생성

array1d = np.arange(start=1, stop =10)

array2d = array1d.reshape(3,3)

print(array2d)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

Q.array2d에서 인덱스를 이용해서 값을 선택하고 리스트로 아래와 같이 출력하세요.

array2d[[0,1],2] => [3,6]

array2d[[0,1],0:2] =>[[1,2],[4,5]]

array2d[[0,1]] =>[[1,2,3],[4,5,6]]

In [213]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

print(array2d[[0,1],2].tolist(),'\n')

print(array2d[[0,1],0:2].tolist(),'\n')

print(array2d[[0,1]].tolist(),'\n')
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

In [215]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# Boolean indexing

array1d = np.arange(start =1, stop=10)

print(array1d)

print()

# [] 안에 array1d > 5 Boolean indexing 을 적용

array3 = array1d[array1d > 5]

print('array1d > 5 불린 인덱싱 결과 값', array3)

print(array1d>5)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[1 2 3 4 5 6 7 8 9] array1d > 5 불린 인덱싱 결과 값 [6 7 8 9] [False False False False False True True True True]

In [218]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# Boolean indexing 으로 필터링

print(array1d)

boolean_indexes = np.array([False, False, False, False, False, True, True, True, True])

array3 = array1d[boolean_indexes]

print('불린 인덱스로 필터링 결과 : ', array3)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[1 2 3 4 5 6 7 8 9] 불린 인덱스로 필터링 결과 : [6 7 8 9]

In [225]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# Q. 1~14 까지 ndarray를 만들어 array_e로 저장하고 (array_e/2) >5를 만족하는 값을 불린인덱스로 출력하세요

array_e = np.arange(start=1,stop=15)

print(array_e)

array_e1 = array_e[(array_e/2)>5]

print(array_e1)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14] [11 12 13 14]

In [228]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

array1d = np.arange(start=1, stop=10)

#array1d 에서 일반 인덱스를 이용, [6 7 8 9] 출력

indexes = np.array([5,6,7,8])

array_e2 = array1d[indexes]

print(array_e2)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[6 7 8 9]

In [230]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#np sort()는 원본 행렬을 변경하지 않고 정렬된 형태로 반환하며 ndarray.sort()는 원본 행렬 자체를 변환

#np.sort()로 정렬

org_array = np.array([3,1,9,5])

print('원본 행렬:',org_array)

#numpy에서 sort호출. np.sort()로 정렬

sort_array1 = np.sort(org_array)

print('np.sort() 호출 후 반환된 정렬 행렬:',sort_array1)

print('np.sort() 호출 후 원본 행렬', org_array) #sort해서 반환하지만 원본행렬은 고정되어있다.
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

원본 행렬: [3 1 9 5] np.sort() 호출 후 반환된 정렬 행렬: [1 3 5 9] np.sort() 호출 후 원본 행렬 [3 1 9 5]

In [232]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# ndarray.sort()로 정렬

org_array = np.array([3,1,9,5])

org_array.sort() #이 방법은 원본 행렬을 변경하는 방법

print('org_array.sort() 호출 후 원본 행렬',org_array)

print(type(org_array))
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

org_array.sort() 호출 후 원본 행렬 [1 3 5 9] <class 'numpy.ndarray'>

In [234]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#내림차순 정렬(기본은 오름차순 정렬)

print(np.sort(org_array))

sort_array1_desc = np.sort(org_array)[::-1]

print('내림차순으로 정렬:',sort_array1_desc)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[1 3 5 9] 내림차순으로 정렬: [9 5 3 1]

In [236]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# 행렬이 2차원 이상일 경우 axis 축 값 설정을 통해 로우 방향, 컬럼방향으로 정렬 수행

array2d = np.array([[8,12],

[7,1]])

 

sort_array2d_axis0 = np.sort(array2d, axis =0) # 0 은 row방향으로 sort

print('로우 방향으로 정렬:\n', sort_array2d_axis0)

 

sort_array2d_axis1 = np.sort(array2d, axis=1) # 1은 coloumn 방향으로 sort

print('컬럼 방향으로 정렬:\n',sort_array2d_axis1)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

로우 방향으로 정렬: [[ 7 1] [ 8 12]] 컬럼 방향으로 정렬: [[ 8 12] [ 1 7]]

In [237]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#정렬된 행렬의 인덱스 반환 : 기존 원본 행렬의 원소에 대한 인덱스를 필요로 할 때

# np.argsort()를 이용

org_array = np.array([3,1,9,5]) # 1 3 5 9 배열의 각 인덱스 번호를 반환함

sort_indices = np.argsort(org_array)

print(org_array)

print(type(sort_indices))

print('행렬 정렬 시 원본 행렬의 인덱스:',sort_indices) # 3의 인덱스는 1, 1의 인덱스는 0, 9의 인덱스는 3, 5의 인덱스는 2로 반환
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[3 1 9 5] <class 'numpy.ndarray'> 행렬 정렬 시 원본 행렬의 인덱스: [1 0 3 2]

In [239]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#내림차순 정렬 시 원본 행렬의 인덱스

org_array = np.array([3,1,9,5])

sort_indices_desc = np.argsort(org_array)[::-1]

print('행렬 내림차순 정렬 시 원본 행렬의 인덱스:',sort_indices_desc) # [::-1]로 [1 0 3 2]의 역순으로 지정
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

행렬 내림차순 정렬 시 원본 행렬의 인덱스: [2 3 0 1]

행렬 내적(행렬 곱)

행렬 내적은 행렬 곱이며 두 행렬 A 와 B의 내적은 np.dot()을 이용해 계산이 가능

행렬 내적의 특성으로 왼쪽 행렬의 열개수와 오른쪽 행렬의 행개수가 동일해야 내적 연산 가능

In [254]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

# 행렬 내적은 행렬 곱이며 두 행렬 A와 B의 내적은 np.dot()을 이용해 계산이 가능

A = np.array([[1,2,3],

[4,5,6]])

B = np.array([[7,8],

[9,10],

[11,12]])

 

dot_product = np.dot(A,B)

print('행렬 내적결과:\n', dot_product)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

행렬 내적결과: [[ 58 64] [139 154]]

Q. 아래 두 행렬을 np.arange, reshape를 이용해서 생성 각각 a1, b1으로 저장하고 행렬 내적을 계산한 결과를 출력

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

[[10 11] [12 13] [14 15]]

In [253]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

a = np.arange(start=1, stop=7)

a1 = a.reshape(2,3)

print(a1)

 

b = np.arange(start=10, stop=16)

b1 = b.reshape(3,2)

print(b1,'\n')

 

dot_p = np.dot(a1,b1)

print(dot_p)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[1 2 3] [4 5 6]] [[10 11] [12 13] [14 15]] [[ 76 82] [184 199]]

 

 

===============================================숙제(연습문제풀이)======================================================

 

 

Q. random.randint()를 사용하여 array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])를 출력하세요.

In [132]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

import random

import numpy as np

a=np.random.randint(0,1,size=10)

a
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

Out[132]:

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

Q. np.random.rand()를 이용해서 5개의 난수를 생성하고 형변환을 통해서 0보다 큰 정수로 출력하세요.

In [148]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

af = np.random.rand(1,5)*10

print(af)

ai = af.astype('int32')

print(ai)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[1.0959861 8.53029654 7.3901706 1.98946975 7.57803481]] [[1 8 7 1 7]]

Q. arange, zeros, ones를 이용해서 1차원 배열, 2차원 배열(3,3) 을 각각 생성하세요.

In [163]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

a = np.arange(9)

b = a.reshape(3,3)

print(a)

print(b,'\n')

 

azero = np.zeros((5), dtype='int32')

print(azero)

azero2 = np.zeros((3,3), dtype='int32')

print(azero2,'\n')

 

aone=np.ones((5), dtype='int32')

aone2=np.ones((3,3), dtype='int32')

 

print(aone)

print(aone2)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

Q. np.random.randint()를 활용 (4,3) 배열 mt1 을 생성하세요

In [169]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

a = np.random.randint(0,12,size=12)

print(a)

mt1=a.reshape(4,3)

print(mt1)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[ 8 3 5 3 7 3 7 4 3 10 4 4] [[ 8 3 5] [ 3 7 3] [ 7 4 3] [10 4 4]]

Q. mt1을 2x6 행렬로 변환 mt2로 출력하세요.

In [170]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

mt2 = mt1.reshape(2,6)

print(mt2)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[ 8 3 5 3 7 3] [ 7 4 3 10 4 4]]

Q. mt2를 1차원 배열로 변환 후 mt3로 출력하세요.

In [172]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

mt3 = mt2.reshape(1,-1)

print(mt3)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[ 8 3 5 3 7 3 7 4 3 10 4 4]]

Q. arange() 함수를 이용해서 0 ~ 29 정수 배열을 생성하고 2 X 5 X 3 3차원 배열로 변환하세요.

In [7]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

array1 = np.arange(30)

array3d = array1.reshape((2,5,3)) # 2, 5는 2행 5열이고 3은 깊이(겹)를 의미한다. (2행 5열 데이터가 3겹으로 존재)

print(array3d)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

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

Q. 1 ~ 12 연속된 정수 배열을 생성하고 2 X 3 X 2 3차원 배열로 변환 후 list로 출력하세요.

In [9]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

array2 = np.array([1,2,3,4,5,6,7,8,9,10,11,12])

array23d=array2.reshape((2,3,2))

print(array2)

print(array23d)

print(array3d.tolist())
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[ 1 2 3 4 5 6 7 8 9 10 11 12] [[[ 1 2] [ 3 4] [ 5 6]] [[ 7 8] [ 9 10] [11 12]]] [[[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]]]

Q. 0 ~ 29 연속 정수 배열을 생성하고 (10,3) 행렬로 변환 후 인덱싱으로 다음을 출력하세요.

12

[24,25,26]

3번째 열

2번째 ~ 5번째 행

[10,13,16]

In [179]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

arr1 = np.arange(30)

array_1 = arr1.reshape(10,3)

print(array_1) # array_1 출력

print(array_1[4,0]) #12 출력

print(array_1[-2]) #[24,25,26] 출력 : 뒤에서 2번째 꺼

print(array_1[2:6]) # 2~(6-1)번째 행 출력

print(array_1[3,1],array_1[4,1],array_1[5,1]) # 10 13 16 출력

print(array_1[3:6,1])# 10 13 16 출력

print(array_1[3:6,[1]]) # 2차원배열로 3행 1열로 출력
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[ 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]] 12 [24 25 26] [[ 6 7 8] [ 9 10 11] [12 13 14] [15 16 17]] 10 13 16 [10 13 16] [[10] [13] [16]]

Q. 5 ~ 20 연속 정수 배열을 생성하고 불린 인덱싱을 이용하여 짝수만 출력하세요.

Q. 동일 배열에서 12보다 큰 정수만 출력하세요.

In [116]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

a=np.arange(5,21)

b=a[(a%2==0)]

print(b)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[ 6 8 10 12 14 16 18 20]

In [117]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

c=a[(a>12)]

print(c)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[13 14 15 16 17 18 19 20]

Q. random.randint()를 이용해서 10개의 배열을 a1으로 생성후 정렬하세요(내림차순)

In [256]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

a=np.random.randint(0,10,size=10)

b=np.sort(a)[::-1]

print(b)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[9 9 9 8 7 5 5 2 1 0]

Q. 1 ~ 21 정수를 랜덤하게 (3,3) 행렬로 생성 후 row, column 방향으로 각각 정렬하세요.

In [233]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

a = np.random.randint(1,22,size=9)

b = a.reshape(3,3)

print(b)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[20 10 6] [20 9 8] [ 1 19 12]]

Q. 10에서 20사이의 정수로 구성된 (5,3) 행열을 np.random을 이용해서 nmt1으로 생성하세요.

In [271]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

a = np.random.randint(10,20,size=15)

mt1 = a.reshape(5,3)

print(mt1)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[19 19 13] [19 19 16] [12 16 18] [17 14 10] [10 10 15]]

Q. mt1 행렬을 전치 후 mt2로 출력하세요.

In [272]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

mt2 = mt1.T

print(mt2)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[19 19 12 17 10] [19 19 16 14 10] [13 16 18 10 15]]

Q. 6개의 원소로 구성되는 배열을 np.random을 활용하여 생성 mt1으로 출력하세요.

In [277]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

a = np.random.randint(1,20,size=6)

mt1 = a.reshape(1,-1)

mt1
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

Out[277]:

array([[18, 1, 12, 18, 12, 3]])

Q. 행벡터 mt를 전치하여 열벡터로 변환하세요.

In [279]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

mt2=mt1.T

mt2
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

Out[279]:

array([[18], [ 1], [12], [18], [12], [ 3]])

Q. 배열 matrix를 broadcasting을 이용하여 다음 배열을 출력하는 연산을 수행하세요.

array([[101, 202, 303],\ [104, 205, 306],\ [107, 208, 309]])

In [285]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

a = [100,200,300]

b = np.arange(start=1,stop=10)

c = b.reshape(3,3)

print(c,'\n')

print(a+c)
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[1 2 3] [4 5 6] [7 8 9]] [[101 202 303] [104 205 306] [107 208 309]]

Q. (3,3) 2차원 배열을 np.random으로 생성하여 mt1으로 저장하고 차원을 구하세요.

In [293]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

array = np.random.randint(1,100,size=9)

array2d = array.reshape(3,3)

print(array2d, '이 배열의 차원은 {}차원 입니다.'.format(array2d.ndim))
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[90 70 19] [87 11 16] [53 29 3]] 이 배열의 차원은 2차원 입니다.

Q. 아래 두개의 행렬에 대한 덧셈, 뺄셈, 곱셈을 수행하세요

In [308]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

mt1 = np.array([[1, 1, 2],

[1, 1, 1],

[3, 3, 4]])

 

mt2 = np.array([[7, 6, 8],

[7, 7, 6],

[8, 7, 8]])
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

In [310]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

msum = mt1+mt2

print(msum,'덧셈\n')

mmul = np.dot(mt1,mt2)

print(mmul,'곱셈\n')

mmin = mt1-mt2

print(mmin,'뺄셈')
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

[[ 8 7 10] [ 8 8 7] [11 10 12]] 덧셈 [[30 27 30] [22 20 22] [74 67 74]] 곱셈 [[-6 -5 -6] [-6 -6 -5] [-5 -4 -4]] 뺄셈

Q. 응용(종속변수, 예측모델 만들어보기)

In [359]:

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가

열 너비 조절

행 높이 조절

#고객 구매데이터 생성(id, 성별, 연령, 지역, 상품, 가격, 구매시간)

import numpy as np

import pandas as pd

import datetime

import warnings

warnings.filterwarnings('ignore')

 

a= np.random.randint(1,20, size=10) #1번에서 20번정도 구매하는 빈도가 생기는걸 정해줌(10개의 데이터)

sr_a = pd.Series(a, name='Freq')

 

 

b=np.random.choice(['KF94마스크','KF80마스크','N95마스크'],size=10)

sr_b=pd.Series(b,name='Prod')

 

c=np.random.choice(['롯데마트','코스트코','이마트'],size=10)

sr_c=pd.Series(c,name='Mart')

 

d=np.random.randint(1,1000,size=10)

sr_d=pd.Series(d,name='Amount')

 

e=np.random.choice(['Man','Woman'],size=10)

sr_e=pd.Series(e, name='Sex')

 

f=np.random.choice(['Seoul','Daejeon','Daegu','Busan','Changwon', 'Gangwon', 'Mokpo'],size=10)

sr_f=pd.Series(f, name='Region')

 

g=np.random.choice(range(1,15) ,size=10,replace=False)

sr_g=pd.Series(g, name='ID')

 

t=np.random.choice([datetime.datetime.now()],size=10)

sr_t=pd.Series(t, name='time')

 

hour = np.random.randint(1,180,size=10)

sr_hour = pd.Series(hour,name='머문시간(분)')

 

comparison = sr_d/sr_hour

sr_comp = pd.Series(comparison, name='분당판매량')

 

df=pd.concat([sr_a,sr_b,sr_c,sr_d,sr_e,sr_f,sr_g,sr_t,sr_hour,sr_comp],axis=1)

display(df)

 

x = 0

y = 0

z = 0

 

for i in range(10):

if df['Mart'][i] == '이마트':

x = x+1

elif df['Mart'][i] =='롯데마트':

y = y+1

elif df['Mart'][i] =='코스트코':

z = z+1

 

 

v = ['이마트','롯데마트','코스트코']

sr_v = pd.Series(v,name='Mart')

 

arr1 = np.array([x,y,z])

arr2=np.sort(arr1)[::-1] #내림차순 정렬

sr_arr1 = pd.Series(arr2,name='MartValue')

 

df2=pd.concat([sr_v,sr_arr1],axis=1)

df2

display(df2) #많이 팔린순으로 정렬
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 1열 선택1열 다음에 열 추가
  • 2열 선택2열 다음에 열 추가
  • 3열 선택3열 다음에 열 추가
  • 4열 선택4열 다음에 열 추가
  • 5열 선택5열 다음에 열 추가
  • 6열 선택6열 다음에 열 추가
  • 7열 선택7열 다음에 열 추가
  • 8열 선택8열 다음에 열 추가
  • 9열 선택9열 다음에 열 추가
  • 10열 선택10열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가
  • 1행 선택1행 다음에 행 추가
  • 2행 선택2행 다음에 행 추가
  • 3행 선택3행 다음에 행 추가
  • 4행 선택4행 다음에 행 추가
  • 5행 선택5행 다음에 행 추가
  • 6행 선택6행 다음에 행 추가
  • 7행 선택7행 다음에 행 추가
  • 8행 선택8행 다음에 행 추가
  • 9행 선택9행 다음에 행 추가
  • 10행 선택10행 다음에 행 추가

열 너비 조절

행 높이 조절

 

Freq

Prod

Mart

Amount

Sex

Region

ID

time

머문시간(분)

분당판매량

0

2

KF94마스크

이마트

916

Man

Daejeon

6

2020-03-17 18:29:22.018939

143

6.405594

1

4

N95마스크

롯데마트

357

Man

Mokpo

12

2020-03-17 18:29:22.018939

88

4.056818

2

3

N95마스크

이마트

808

Woman

Busan

2

2020-03-17 18:29:22.018939

56

14.428571

3

6

KF80마스크

롯데마트

692

Man

Busan

10

2020-03-17 18:29:22.018939

150

4.613333

4

9

KF94마스크

이마트

314

Woman

Mokpo

7

2020-03-17 18:29:22.018939

92

3.413043

5

15

KF94마스크

이마트

552

Woman

Gangwon

1

2020-03-17 18:29:22.018939

85

6.494118

6

7

KF94마스크

이마트

592

Woman

Mokpo

9

2020-03-17 18:29:22.018939

11

53.818182

7

12

KF94마스크

코스트코

823

Woman

Changwon

5

2020-03-17 18:29:22.018939

53

15.528302

8

9

N95마스크

코스트코

493

Woman

Seoul

8

2020-03-17 18:29:22.018939

17

29.000000

9

8

N95마스크

코스트코

910

Woman

Gangwon

11

2020-03-17 18:29:22.018939

131

6.946565
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

셀 전체 선택

  • 0열 선택0열 다음에 열 추가
  • 1열 선택1열 다음에 열 추가
  • 2열 선택2열 다음에 열 추가
  • 0행 선택0행 다음에 행 추가
  • 1행 선택1행 다음에 행 추가
  • 2행 선택2행 다음에 행 추가
  • 3행 선택3행 다음에 행 추가

열 너비 조절

행 높이 조절

 

Mart

MartValue

0

이마트

5

1

롯데마트

3

2

코스트코

2
  • 셀 병합
  • 행 분할
  • 열 분할
  • 너비 맞춤
  • 삭제

 

 

728x90
반응형

'PYTHON' 카테고리의 다른 글

20200321 - 파이썬(미래 예측 머신러닝 모델(삼성전자, 이더리움))  (1) 2020.03.21
20200320 - 파이썬(타이타닉 생존자 예측 데이터 전처리)  (0) 2020.03.20
20200319 - 파이썬 (사이킷런, 판다스, 넘파이, 행렬, 희소행렬, 정규화, 표준화, 범주화)  (0) 2020.03.19
20200318 - 파이썬, 데이터프레임, 타이타닉, 분석 기초, 데이터 전처리  (0) 2020.03.18
20200316 - Numpy, Pandas 기초 설명 및 연습(랜덤, 데이터셋, 데이터프레임, 시리즈)  (0) 2020.03.16

관련글

댓글

티스토리툴바