01.넘파이 ndarray

import numpy as np

ndarray 생성 np.array()

list1 = [1, 2, 3]
print("list1:",list1)
print("list1 type:", type(list1))

array1 = np.array(list1)
print("array1:", array1)
print("array1 type:", type(array1))

list1: [1, 2, 3]
list1 type: <class 'list'>
array1: [1 2 3]
array1 type: <class 'numpy.ndarray'>

• ndarray내의 데이터값은 숫자, 문자, 불값등 모두 가능하지만 같은 데이터 타입끼리만 묶을수 있다.(ex) [1,2,’홍길동’,True] 불가능 , int와 float 함께 있을 수 없음

• ndarray내의 데이터타입은 nddrray.dtype으로 확인 가능

• astype()을 통해 데이터타입 변환가능, (ex. ndarray.astype(‘str’),(‘int’) 등등

• 대용량 데이터를 ndarray로 만들 때 메모리 절약을 위해 자주 사용

• 0, 1, 2 와 같이 크지않은 범위의 숫자를 위해서 8bit또는 16bit의 integer형으로 변환하는 것이 메모리 절약

• 대용량 데이터를 다룰 시 메모리 절약을 위해서 형변환을 특히 고려해야함.

• axis = 0 -> 행 axis = 1 -> 열 axis = 2 -> 면(3차원)

ndarray의 형태(shape)와 차원

array1 = np.array([1,2,3])
print("array1 type:", type(array1))
print("array1 array 형태:", array1.shape)

array2 = np.array([[1,2,3],
                  [2,3,4]])
print("array2 type :", type(array2))
print("array2 array 형태 :", array2.shape)

• 1차원처럼 보이지만 내포된 리스트(리스트를 요소로 가지고있기 때문에 2차원으로 변환됨)

array3 = np.array([[1,2,3]])
print("array3 type :",type(array3))
print('array3 array 형태:',array3.shape)

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

print('array1: {:0}차원, array2: {:1}차원, array3: {:2}차원'.format(array1.ndim,array2.ndim,array3.ndim))

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

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

• 숫자와 문자가 같이 인자로 넣게되면 정수형 값들이 모두 사이즈가 큰 문자열 값으로 바뀜

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'] <U21
[1. 2. 3.] float64

astype()을 통한 타입 변환

array_int = np.array([1,2,3])
array_float = array_int.astype('float64')
print(array_float, array_float.dtype)

array_int1 = array_float.astype('int32')
print(array_int1, array_int1.dtype)

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.] float64
[1 2 3] int32
[1 2 3] int32

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

print(array2.sum())
print(array2.sum(axis=0))
print(array2.sum(axis=1))

15
[3 5 7]
[6 9]

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

sequence_array = np.arange(10)
print(sequence_array)
print(sequence_array.dtype, sequence_array.shape)

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

zero_array = np.zeros((3,2), dtype = 'int32')
print(zero_array)
print(zero_array.dtype, zero_array.shape)

one_array = np.ones((3,2))
print(one_array)
print(one_array.dtype, one_array.shape)

[[0 0]
 [0 0]
 [0 0]]
int32 (3, 2)
[[1. 1.]
 [1. 1.]
 [1. 1.]]
float64 (3, 2)

ndarray의 shape를 변경하는 rehshape()

array1 = np.arange(10)
print('array1:\n', array1)

array2 = array1.reshape(2,5)
print('array2:\n', array2)

array3 = array1.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]]

• 변환할 수 있는 shape구조를 입력하면 오류 발생.

array1.reshape(4,3)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-7-99d7b05fa31c> in <module>()
      1 # 변환할 수 있는 shape구조를 입력하면 오류 발생.
      2 
----> 3 array1.reshape(4,3)


ValueError: cannot reshape array of size 10 into shape (4,3)

• reshape()에 -1 인자값을 부여하여 특정 차원으로 고정된 가변적인 ndarray형태 변환 ```

array1 = np.arange(10) print(array1)

* 컬럼 axis 크기는 5에 고정하고 로우 axis크기를 이에 맞춰 자동으로 변환, 즉 2*5 형태로 변환

array2 = array1.reshape(-1,5) print(‘array2 shape :’,array2.shape) print(‘array2:\n’, array2)

* 로우 axis 크기는 5로 고정하고 컬럼 axis크기는 이에 맞춰 자동으로 변환, 즉 5*2 형태로 변환

array3 = array1.reshape(5,-1) print(‘array3 shape :’, array3.shape) print(‘array3:\n : ‘, array3)

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


* reshape()는 (-1, 1), (-1,)와 같은 형태로 주로 사용됨.
* 1차원 ndarray를 2차원으로 또는 2차원 ndarray를 1차원으로 변환시 사용.

array1 = np.arange(5)

* 1차원 ndarray를 2차원으로 변환하되, 컬럼axis크기는 반드시 1이어야 함.

array2d_1 = array1.reshape(-1, 1) print(‘array2d_1 shape :’, array2d_1.shape) print(‘array2d_1 \n :’, array2d_1)

2차원 ndarray를 1차원으로 변환

array1d = array2d_1.reshape(-1,) print(‘array1d shape :’, array1d.shape) print(‘array1d \n :’, array1d)

    array2d_1 shape : (5, 1)
    array2d_1 
     : [[0]
     [1]
     [2]
     [3]
     [4]]
    array1d shape : (5,)
    array1d 
     : [0 1 2 3 4]

-1을 적용하여도 변환이 불가능한 형태로의 변환을 요구할 경우 오류 발생

array1 = np.arrange(10) array4 = array1.reshape(-1, 4)

    ---------------------------------------------------------------------------

    AttributeError                            Traceback (most recent call last)

    <ipython-input-17-9f1ad02e0020> in <module>()
          1 # -1을 적용하여도 변환이 불가능한 형태로의 변환을 요구할 경우 오류 발생
          2 
    ----> 3 array1 = np.arrange(10)
          4 array4 = array1.reshape(-1, 4)


    /usr/local/lib/python3.7/dist-packages/numpy/__init__.py in __getattr__(attr)
        213             else:
        214                 raise AttributeError("module {!r} has no attribute "
    --> 215                                      "{!r}".format(__name__, attr))
        216 
        217         def __dir__():


    AttributeError: module 'numpy' has no attribute 'arrange'

반드시 -1 값은 1개의 인자만 입력해야 함.

array1.reshape(-1,-1)

    ---------------------------------------------------------------------------

    ValueError                                Traceback (most recent call last)

    <ipython-input-18-bcebac8291d7> in <module>()
          1 # 반드시 -1 값은 1개의 인자만 입력해야 함.
    ----> 2 array1.reshape(-1,-1)
    

    ValueError: can only specify one unknown dimension


# ndarray의 데이터 세트 선택하기 - 인덱싱(indexing)

* 특정 위치의 단일값 추출 : 원하는 위치의 인덱스 값을 지정하면 해당 위치의 데이터가 반환됨.

* 슬라이싱 : 슬라이싱은 연속된 인덱스상의 ndarray를 추출하는 방식입니다. ':' 기호 사이에 시작 인덱스와 종료 인덱스를 표시하면 시작 인덱스에서 종료 인덱스-1 위치에 있는 ndarray를 반환함. 예를 들어 1:5라고 하면 시작인덱스 1과 종료인덱스 4까지에 해당하는 ndarray를 반환함.

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

* 불린 인덱싱 : 특정 조건에 해당하는지 여부인 True/False 값 인덱싱 집합을 기반으로 True에 해당하는 인덱스 위치에 있는 ndarray를 반환함.


## 특정 위치의 단일값 추출

1에서부터 9까지의 1차원 ndarray 생성

array1 = np.arange(1,10) # np.arange(start=1, stop=10) print(‘array1 :’, array1)

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

value = array1[2] print(‘value :’, value) print(type(value))

    array1 : [1 2 3 4 5 6 7 8 9]
    value : 3
    <class 'numpy.int64'>

print(‘맨 뒤의 값 :’, array1[-1], ‘, 맨 뒤에서 두번째 값’, array1[-2])

    맨 뒤의 값 : 9 , 맨 뒤에서 두번째 값 8

array1[0] = 9 array1[8] = 0 print(‘array1 :’, array1)

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

array1d = np.arange(1,10) array2d = array1d.reshape(3, 3) print(array2d)

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

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

    (row=0, col=0) index 가리키는값 :  1
    (row=0, col=1) index 가리키는값 :  2
    (row=1, col=0) index 가리키는값 :  4
    (row=2, col=2) index 가리키는값 :  9


## 슬라이싱

array1 = np.arange(start=1, stop=10) print(array1) array3 = array1[0:3] print(array3) print(type(array3))

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

array1 = np.arange(start=1, stop=10) array4 = array1[:3] print(array4)

array5 = array1[3:] print(array5)

array6 = array1[:] print(array6)

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

array1d = np.arange(start=1, stop=10) array2d = array1d.reshape(3,3) print(‘array2d:\n’,array2d)

print(‘array2d[0:2, 0:2] \n’, array2d[0:2, 0:2]) print(‘array2d[1:3, 0:3] \n’, array2d[1:3, 0:3]) print(‘array2d[1:3, :] \n’, array2d[1:3, :]) print(‘array2d[:, :] \n’, array2d[:, :]) print(‘array2d[:2, 1:] \n’, array2d[:2, 1:]) print(‘array2d[:2, 0] \n’, array2d[:2, 0])

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



## 팬시 인덱싱

array1d = np.arange(1,10) array2d = array1d.reshape(3,3) print(array2d)

array3 = array2d[[0,1], 2] print(‘array2d[[0,1], 2] => ‘,array3.tolist())

array4 = array2d[[0,2], 0:2] print(‘array2d[[0,2], 0:2] => ‘,array4.tolist())

array5 = array2d[[0,1]] print(‘array2d[[0,1]] => ‘,array5.tolist())

    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    array2d[[0,1], 2] =>  [3, 6]
    array2d[[0,2], 0:2] =>  [[1, 2], [7, 8]]
    array2d[[0,1]] =>  [[1, 2, 3], [4, 5, 6]]



## 불린 인덱싱

array1d = np.arange(1,10) print(array1d)

    [1 2 3 4 5 6 7 8 9]

print(array1d > 5)

var1 = array1d > 5 print(“var1:”,var1) print(type(var1))

    [False False False False False  True  True  True  True]
    var1: [False False False False False  True  True  True  True]
    <class 'numpy.ndarray'>

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

print(array1d) array3 = array1d[array1d > 5] print(‘array1d > 5 불린 인덱싱 결과 값 :’, array3)

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

boolean_indexes = np.array([False, False, False, False, False, True, True, True, True]) array3 = array1d[boolean_indexes] print(‘불린 인덱스로 필터링 결과 :’, array3)

    불린 인덱스로 필터링 결과 : [6 7 8 9]

indexes = np.array([5,6,7,8]) array4 = array1d[ indexes ] print(‘일반 인덱스로 필터링 결과 :’,array4)

    일반 인덱스로 필터링 결과 : [6 7 8 9]

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

for i in range(0, 9): if array1d[i] > 5: target.append(array1d[i])

array_selected = np.array(target) print(array_selected)

    [6 7 8 9]

print(array1d[array1 > 5])

    [6 7 8 9]

print(array1d.sort())

    None

```