import numpy as np

[Python/numpy] 기초_attr_2 (reshape(), 인덱싱, sort(), argsort(), dot(), transpose())

reshape()

• ndarray의 차원과 크기를 변경하는 method

array1 = np.arange(8)
print(array1)
array2 = array1.reshape(2,4)
print(array2)
array3 = array2.reshape(2,2,2)
print(array3)

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

[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]

알 수 없는(계산하기 귀찮은) 차원의 자리에 -1을 넣는다면 알아서 계산해 준다.

array2 = array1.reshape(-1, 2)
print(array2) # (4,2) 2차원 4행 2열

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

만약 둘 이상의 인자에 -1을 넣는다면?
ValueError : can only specify one unknown dimension
알 수 없는 차원(-1)을 하나만 지정할 수 있습니다.

인덱싱 - 데이터 세트 선택하기

인덱싱 유형	설명
특정 위치의 단일 값 추출	원하는 위치의 인덱스 값을 지정
슬라이싱	[시작인덱스:끝 인덱스]
팬시 인덱싱(Fancy Indexing)	일정한 인덱싱 집합을 리스트 또는 ndarray 형태로 지정해 해당 위치에 있는 ndarray를 반환한다.
불린 인덱싱(Boolean Indexing)	특정 조건에 해당 여부로 ndarray를 반환한다.

1. 단일 인덱싱

array1 = np.arange(1,11)
print('#-----1차원-----#')
print(array1)
print('1번 인덱스 데이터 >>>',array1[1])
print('[-1]마지막 데이터 >>>',array1[-1])
print('#-----2차원-----#')
array2 = array1.reshape(-1,5)
print(array2)
print('[1,4] 2행 5열의 데이터 >>>',array2[1,4])

#-----1차원-----#
[ 1  2  3  4  5  6  7  8  9 10]
1번 인덱스 데이터 >>> 2
마지막 데이터 >>> 10

#-----2차원-----#
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]]
2행 5열의 데이터 >>> 10

2. 슬라이싱

array1 = np.arange(1,11)
print('#-----1차원-----#')
print(array1[:5])
print(array1[:5:-1])
print(array1[10:5:-1])
print(array1[::2])
print('#-----2차원-----#')
array2 = array2.reshape(5,-1)
print(array2)
print('2차원nd배열[0:1,2:4] \n', array2[0:1, 2:4])
print('2차원nd배열[2:4,0:1] \n', array2[2:4, 0:1])
print('2차원nd배열[:4,:] \n', array2[:4, :])
print('#-----2차원에서 단일 인덱싱 실행 시 차원의 변화-----#')
print('2차원nd배열[0], 2차원nd배열[0].shape \n', array2[0], '차원은?', array2[0].shape)

#-----1차원-----#
[1 2 3 4 5]
[10  9  8  7]
[10  9  8  7]
[1 3 5 7 9]

#-----2차원-----#
[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]]
2차원nd배열[0:1,2:4] 
 []
2차원nd배열[2:4,0:1] 
 [[5]
 [7]]
2차원nd배열[:4,:] 
 [[1 2]
 [3 4]
 [5 6]
 [7 8]]

#-----2차원에서 단일 인덱싱 실행 시 차원의 변화-----#

2차원nd배열[0], 2차원nd배열[0].shape 
 [1 2] 차원은? (2,)

3. 팬시 인덱싱!

• 일정한 인덱싱 집합을 리스트 또는 ndarray 형태로 지정해 해당 위치에 있는 ndarray를 반환한다.

array1 = np.arange(1,11)
array2 = array1.reshape(2,5)
print(array2)
print('2차원nd배열[1, 2:3] \n', array2[[1], 2:3])
print('2차원nd배열[:, [0,2,4]] \n', array2[:, [0,2,4]])
print('2차원nd배열[:, [0,2,4]].tolist() 리스트로 변환해보기 \n', array2[:, [0,2,4]].tolist())

[[ 1  2  3  4  5]
 [ 6  7  8  9 10]]
2차원nd배열[1, 2:3] 
 [[8]]

2차원nd배열[:, [0,2,4]] 
 [[ 1  3  5]
 [ 6  8 10]]

2차원nd배열[:, [0,2,4]].tolist() 리스트로 변환해보기 
 [[1, 3, 5], [6, 8, 10]]

4. 불린 인덱싱!!

• 특정 조건에 해당 여부로 ndarray를 반환한다.

array1 = np.arange(1,11)

print('#-----1차원-----#')
짝수판별_nd배열 = array1 % 2 == 0
print('짝수판별 1차원 ndarray \n',짝수판별_nd배열)
print('타입은?', type(짝수판별_nd배열), '차원은?', 짝수판별_nd배열.shape)

print('#-----1차원에 불린 인덱싱 정룔 후 변화-----#')
print(array1[짝수판별_nd배열])
print('차원은?', array1[짝수판별_nd배열].shape)

print('#-----2차원-----#')
array2 = array1.reshape(-1,5)
짝수판별_2차원_nd배열 = array2 % 2 == 0
print('짝수판별 2차원 ndarray \n',짝수판별_2차원_nd배열)
print('타입은?', type(짝수판별_2차원_nd배열), '차원은?', 짝수판별_2차원_nd배열.shape)

print('#-----2차원에 불린 인덱싱 적용 후 변화-----#')
print(array2[짝수판별_2차원_nd배열])
print('차원은?', array2[짝수판별_2차원_nd배열].shape)

#-----1차원-----#
짝수판별 1차원 ndarray 
 [False  True False  True False  True False  True False  True]

타입은? <class 'numpy.ndarray'> 차원은? (10,)

#-----1차원에 불린 인덱싱 정룔 후 변화-----#
[ 2  4  6  8 10]

차원은? (5,)

#-----2차원-----#
짝수판별 2차원 ndarray 
 [[False  True False  True False]
 [ True False  True False  True]]

타입은? <class 'numpy.ndarray'> 차원은? (2, 5)

#-----2차원에 불린 인덱싱 적용 후 변화-----#
[ 2  4  6  8 10]

차원은? (5,)

불린 인덱싱 사용법을 파이썬으로 이해하기

print(array1[array1%2 == 0])

[ 2  4  6  8 10]

파이썬 문법으로 바꿔보기

print(list(x for x in array1 if x%2 == 0))

[2, 4, 6, 8, 10]

sort()

• np.sort() : 원본 배열을 참조하여 새로 정렬된 배열을 반환한다. (Like 파이썬의 sorted() )
• ndarray.sort() : 원본 배열 자체를 정렬한다. 반환 값은 None (Like 파이썬의 .sort() )

원본배열 = np.array([3,1,5,7,4,9])
np.sort사용배열 = np.sort(원본배열)
print('np.sort사용배열', np.sort사용배열, '원본배열', 원본배열)
원본배열.sort()
print('원본배열.sort()실행 후 원본 배열', 원본배열)

np.sort사용배열 [1 3 4 5 7 9] 원본배열 [3 1 5 7 4 9]
원본배열.sort()실행 후 원본 배열 [1 3 4 5 7 9]

원본배열 = np.array([[2,1],[0,3],[9,6],[6,2]])
디폴트이차원정렬배열 = np.sort(원본배열) # 디폴트로 axis = -1 열을 기준으로 정렬해 준다.
행기준이차원정렬배열 = np.sort(원본배열, axis = 0)
print('원본배열\n', 원본배열)
print('기본이차원정렬배열\n', 디폴트이차원정렬배열)
print('행기준이차원정렬배열 \n', 행기준이차원정렬배열)

원본배열
 [[2 1]
 [0 3]
 [9 6]
 [6 2]]
기본이차원정렬배열
 [[1 2]
 [0 3]
 [6 9]
 [2 6]]
행기준이차원정렬배열 
 [[0 1]
 [2 2]
 [6 3]
 [9 6]]

argsort()

• 정렬된 행렬의 인덱스를 반환하는 메서드

array1 = np.array([100,10,1000,10000])
array1_argsort = np.argsort(array1)
print('오름 차순으로 정렬하려면 어떻게 기존 배열에서 어떤 인덱스가 차례로 들어와야 하나요??', array1_argsort)
print(array1[1], array1[0], array1[2], array1[3])

오름 차순으로 정렬하려면 어떻게 기존 배열에서 어떤 인덱스가 차례로 들어와야 하나요?? [1 0 2 3]
10 100 1000 10000

이건 언제 필요하나요?

name_list = np.array(['kim', 'lee', 'park', 'han'])# 우리 팀원들 5명의 리스트
score_list = np.array([25, 99, 12, 39])# 우리 팀원들의 점수 리스트

상황) 우리 팀원들을 점수 순(오름차순과 내림차순)으로 나열해 주세요!

score_argsort = np.argsort(score_list)
print(score_argsort)
print('오름차순',name_list[score_argsort])
print('내림차순',name_list[score_argsort][::-1])

[2 0 3 1]
오름차순 ['park' 'kim' 'han' 'lee']
내림차순 ['lee' 'han' 'kim' 'park']

선형대수 연산 - 행렬 내적(곱셈)과 전치 행렬 구하기!

행렬 내적

행렬의 내적 구하기 유튜브(강추)

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

내적 = np.dot(A, B)
print('행렬 내적 결과 :\n', 내적)

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

transpose() 전치 행렬

print(np.transpose(A))

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