NUMPY 기초 문법 정리2_배열 조회

배열 속성 정보

def array_info(array):
  print(array) # 배열 값
  print("ndim:", array.ndim) # 배열의 차원의 수 
  print("shape:", array.shape) # 배열의 형태 
  print("dtype:", array.dtype) # 배열에 포함된 요소들의 데이터 타입
  print("size:", array.size) # 배열에 포함된 요소들의 총 갯수
  print("itemsize:", array.itemsize) # 배열에 포함된 각 요소의 바이트 크기
  print("nbytes:", array.nbytes) # 배열 전체가 차지하는 메모리의 크기 (byte단위, 'size * itemsize'의 값과 같다)
  print("strides:", array.strides) # 배열의 각 차원에서 한 요소에서 다음 요소로 넘어가는데 필요한 바이트 수

 

• ndim : 배열 차원수
• shape : 배열의 형태
• dtype : 배열에 포함된 요소들의 데이터 타입
• size : 배열에 포함된 요소들의 총 갯수 
• itemsize : 배열에 포함된 각 요소의 바이트 크기
• nbytes : 배열 전체가 차지하는 메모리의 크기 (byte단위, 'size * itemsize'의 값과 같다)
• strides : 배열의 각 차원에서 한 요소에서 다음 요소로 넘어가는데 필요한 바이트 수 

인덱싱 ( Indexing )

• 인덱스를 통해 ndarray에 접근한다.
• 음수 인덱스도 가능하다.
• 행과 열, 차원의 위치를 ' , ' 을 통해 표현 가능하다.
  • ex) a2[0, 0] : 0번 인덱스 행, 0번 인덱스 열 
  • ex) a2[2, -1] : 2번 인덱스 행, -1번 인덱스(뒤에서 첫번째) 열
  • ex) a3[2, -1, -1] : 2번 인덱스 차원, -1번 인덱스(뒤에서 첫번째) 행, -1번 인덱스(뒤에서 첫번째) 열
  • ndim이 3인 경우 차원, 행, 열로 동작한다.

코드

f1 = np.array([1,2,3,4,5])
print("\n1차원 배열\n", f1)
print()
for i in range(len(f1)):
    print(f"1차원 배열 {i}번 인덱스: ", f1[i])
    
for i in range(len(f1)):
    print(f"1차원 배열 {-(i+1)}번 인덱스: ", f1[-(i+1)])

f2 = np.array([[1,2,3],
               [4,5,6],
               [7,8,9]])
print("\n2차원 배열\n", f2)
print("\n2차원 배열 indexing [0, 0]: ", f2[0, 0])
print("2차원 배열 indexing: [0, 2]: ", f2[0, 2])
print("2차원 배열 indexing: [1, 1]: ", f2[1, 1])
print("2차원 배열 indexing: [2, -1]: ", f2[2, -1])

f3 = np.random.rand(3, 3, 3)
print("\n3차원 배열\n", f3)
print("\n3차원 배열 indexing [0, 0, 0]: ", f3[0, 0, 0])
print("3차원 배열 indexing: [1, 1, 1]: ", f3[1, 1, 1])
print("3차원 배열 indexing: [2, 2, 2]: ", f3[2, 2, 2])
print("3차원 배열 indexing: [2, -1, -1]: ", f3[2, -1, -1])

 

결과

1차원 배열
 [1 2 3 4 5]

1차원 배열 0번 인덱스:  1
1차원 배열 1번 인덱스:  2
1차원 배열 2번 인덱스:  3
1차원 배열 3번 인덱스:  4
1차원 배열 4번 인덱스:  5
1차원 배열 -1번 인덱스:  5
1차원 배열 -2번 인덱스:  4
1차원 배열 -3번 인덱스:  3
1차원 배열 -4번 인덱스:  2
1차원 배열 -5번 인덱스:  1

2차원 배열
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

2차원 배열 indexing [0, 0]:  1
2차원 배열 indexing: [0, 2]:  3
2차원 배열 indexing: [1, 1]:  5
2차원 배열 indexing: [2, -1]:  9

3차원 배열
 [[[0.11213435 0.74845811 0.19395187]
  [0.58197833 0.84150272 0.42090707]
  [0.94528089 0.55061718 0.03288636]]

 [[0.15045757 0.82672981 0.20612575]
  [0.49652885 0.38717311 0.21179027]
  [0.95725448 0.63388112 0.0508751 ]]

 [[0.67596948 0.79803933 0.08966538]
  [0.41514639 0.63006891 0.14978205]
  [0.27892148 0.35400763 0.5746168 ]]]

3차원 배열 indexing [0, 0, 0]:  0.11213435119828863
3차원 배열 indexing: [1, 1, 1]:  0.38717310658743387
3차원 배열 indexing: [2, 2, 2]:  0.5746168002761719
3차원 배열 indexing: [2, -1, -1]:  0.5746168002761719

슬라이싱 ( Slicing )

• ndim이 3인 경우 차원, 행, 열로 동작한다.

코드

print(f1)
print("-"*10, "1차원 배열 Slicing", "-"*10)
print(f1[0:2])
print(f1[0:])
print(f1[:1])
print(f1[::2])
print(f1[::-1])
print("\n")

print(f2)
print("-"*10, "2차원 배열 Slicing", "-"*10)
print(f2[1])
print(f2[1, :])
print(f2[:2, :2])
print(f2[1:, ::-1])
print(f2[::-1, ::-1])
print("\n")

print(f3)
print("-"*10, "3차원 배열 Slicing", "-"*10)
print("\n1.\n", f3[1])
print("\n2.\n", f3[:, :, :1])
print("\n3.\n", f3[:1, 2:3])
print("\n4.\n", f3[::2, 1:2])
print("\n5.\n", f3[::-1])
print("\n")

 

결과

[1 2 3 4 5]
---------- 1차원 배열 Slicing ----------
[1 2]
[1 2 3 4 5]
[1]
[1 3 5]
[5 4 3 2 1]


[[1 2 3]
 [4 5 6]
 [7 8 9]]
---------- 2차원 배열 Slicing ----------
[4 5 6]
[4 5 6]
[[1 2]
 [4 5]]
[[6 5 4]
 [9 8 7]]
[[9 8 7]
 [6 5 4]
 [3 2 1]]


[[[0.11213435 0.74845811 0.19395187]
  [0.58197833 0.84150272 0.42090707]
  [0.94528089 0.55061718 0.03288636]]

 [[0.15045757 0.82672981 0.20612575]
  [0.49652885 0.38717311 0.21179027]
  [0.95725448 0.63388112 0.0508751 ]]

 [[0.67596948 0.79803933 0.08966538]
  [0.41514639 0.63006891 0.14978205]
  [0.27892148 0.35400763 0.5746168 ]]]
---------- 3차원 배열 Slicing ----------

1.
 [[0.15045757 0.82672981 0.20612575]
 [0.49652885 0.38717311 0.21179027]
 [0.95725448 0.63388112 0.0508751 ]]

2.
 [[[0.11213435]
  [0.58197833]
  [0.94528089]]

 [[0.15045757]
  [0.49652885]
  [0.95725448]]

 [[0.67596948]
  [0.41514639]
  [0.27892148]]]

3.
 [[[0.94528089 0.55061718 0.03288636]]]

4.
 [[[0.58197833 0.84150272 0.42090707]]

 [[0.41514639 0.63006891 0.14978205]]]

5.
 [[[0.67596948 0.79803933 0.08966538]
  [0.41514639 0.63006891 0.14978205]
  [0.27892148 0.35400763 0.5746168 ]]

 [[0.15045757 0.82672981 0.20612575]
  [0.49652885 0.38717311 0.21179027]
  [0.95725448 0.63388112 0.0508751 ]]

 [[0.11213435 0.74845811 0.19395187]
  [0.58197833 0.84150272 0.42090707]
  [0.94528089 0.55061718 0.03288636]]]

불리언 인덱싱 ( Boolean Indexing )

코드

print("\na1 배열: \n", a1)
bi = [False, True, True, False, True]
print("\nBoolean Indexing\n", a1[bi])
bi = [True, False, True, True, False]
print("\nBoolean Indexing\n", a1[bi])

print("\na2 배열: \n", a2)
bi = np.random.randint(0, 2, (3,3), dtype = bool)
print("\nbi 배열: \n", bi)
print("\nBoolean Indexing\n", a2[bi])

 

결과

a1 배열: 
 [1 2 3 4 5]

Boolean Indexing
 [2 3 5]

Boolean Indexing
 [1 3 4]

a2 배열: 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

bi 배열: 
 [[False  True  True]
 [False  True False]
 [ True False  True]]

Boolean Indexing
 [2 3 5 7 9]

팬시 인덱싱 ( Fancy Indexing )

코드

print("a1 배열\n", a1)
print("\n일반 indexing을 통해 리스트 만들기\n", [a1[0], a1[2]])
ind = [0, 2]
print("\na1 fancy indexing\n", a1[ind])
ind = np.array([[0,1],
                [2,0]])
print("a1 fancy indexing\n", a1[ind])


print("\n\na2 배열\n", a2)
row = np.array([0,2])
col = np.array([1,2])
print("\na2 fancy indexing\n", a2[row, :])
print("a2 fancy indexing\n", a2[:, col])
print("a2 fancy indexing\n", a2[row, 1])
print("a2 fancy indexing\n", a2[2, col])
print("a2 fancy indexing\n", a2[row, 1:])
print("a2 fancy indexing\n", a2[1:, col])

 

결과

a1 배열
 [1 2 3 4 5]

일반 indexing을 통해 리스트 만들기
 [1, 3]

a1 fancy indexing
 [1 3]
a1 fancy indexing
 [[1 2]
 [3 1]]


a2 배열
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

a2 fancy indexing
 [[1 2 3]
 [7 8 9]]
a2 fancy indexing
 [[2 3]
 [5 6]
 [8 9]]
a2 fancy indexing
 [2 8]
a2 fancy indexing
 [8 9]
a2 fancy indexing
 [[2 3]
 [8 9]]
a2 fancy indexing
 [[5 6]
 [8 9]]

출처: 이수안 컴퓨터 연구소