[numpy] 배열 생성, 배열 차원 바꾸기, 배열 데이터 타입 변경하기

핵심: array(), arange(), reshape(), linspace(), astype() 

numpy

• 일반적인 배열 + 배열 연산자를 쓰면 배열1배열2 형태로 출력됨
• numpy를 이용하면 배열 안의 요소들의 연산을 쉽게 할 수 있음
• array()
• arange()
• dtype

num1 = [1, 2, 3, 4]
num2 = [3, 4, 5, 6]
num1 + num2

"""출력: [1, 2, 3, 4, 3, 4, 5, 6]"""

arr1 = np.array(num1)
arr1

"""출력: array([1, 2, 3, 4])"""

arr2 = np.array(num2)
arr2

"""출력: array([3, 4, 5, 6])"""

print(arr1 + arr2)
print(arr1 - arr2)
print(arr1 * arr2)
print(arr1 / arr2)
#배열 개수가 다르면 에러가 나옴

"""
출력
[ 4  6  8 10]
[-2 -2 -2 -2]
[ 3  8 15 24]
[0.33333333 0.5        0.6        0.66666667]
"""

np.array([0.5, 1, 0.01, 8]).dtype # float 비트단위 연산으로 출력됨

"""dtype('float64')"""

data1 = [0, 1, 2, 3]
a1 = np.array(data1)
a1

"""array([0, 1, 2, 3])"""

print(a1.dtype) #int32
"""int32"""

print(np.arange(3, 10))
print(np.arange(1, 10, 2))
print(np.arange(10)) #시작인덱스가 0이면 생략가능

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

• np.arange(12) #1차원 배열
• np.arange(12).reshape(a, b) #2차원 배열
• np.arange(12).reshape(c, d, e) #3차원 배열
• reshape를 통해서 다른 차원으로 배열로 변경할 수 있다.
• 이때 a * b = c * d * e = 12. 크기는 유지 되어야 한다.
• 만약 다르면 에러가 발생함
• shape

np.arange(12).reshape(4, 3)

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

print(np.arange(12))
print("")
print(np.arange(12).reshape(3, 4))
print("")
print(np.arange(12).reshape(2, 3, 2))

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

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

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

 [[ 6  7]
  [ 8  9]
  [10 11]]]
"""

b1 = np.arange(27).reshape(3, 3, 3)
b1.shape #shape를 통해서 배열의 차원을 확인할 수 있다.

"""(3, 3, 3)"""

b2 = np.arange(27)
b2.shape #1차원 배열은 (27,) 로 출력됨

"""(27,)"""

np.linspace()

• np.linspapce(시작값, 끝값, 배열의 길이)
• 배열의 길이 = 추출할 값의 개수
• np.linspace(0, 10, 5) #0이상 10 이하의 균일한 간격의 실수 5개의 배열을 생성한다.
• np.arange(0, 11, 2.5) #0이상 11 미만의 2.5 간격의 수의 배열을 생성한다.
• 차이를 알아두자
• zeros()
• ones()
• astype()

np.arange(0, 11, 2.5)

"""array([ 0. ,  2.5,  5. ,  7.5, 10. ])"""

np.linspace(0, 10, 5)

"""array([ 0. ,  2.5,  5. ,  7.5, 10. ])"""

print(np.arange(0, 11, 2.5))
print(np.linspace(0, 10, 5))
#출력 모양은 같지만 실제로는 다름

"""
[ 0.   2.5  5.   7.5 10. ]
[ 0.   2.5  5.   7.5 10. ]
"""

np.linspace(0, np.pi, 10) #0이상 3.14...인 파이값 사이에 10개의 값을 생성한다.

"""
array([0.        , 0.34906585, 0.6981317 , 1.04719755, 1.3962634 ,
       1.74532925, 2.0943951 , 2.44346095, 2.7925268 , 3.14159265])
"""

#초기화 함수
print(np.zeros(10))
print(np.ones(10))

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

np.zeros((2, 10)) #2행 10열의 배열을 만들고 모든 요소를 0으로 초기화.

"""
array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])
"""

np.ones((2, 2, 2))

"""
array([[[1., 1.],
        [1., 1.]],

       [[1., 1.],
        [1., 1.]]])
"""

#단위 행렬 함수
arrI = np.eye(3)
arrI

"""
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
"""

arrI.shape
"""(3, 3)"""

#문자열 데이터 배열
np.array(["1.5", "0.25"]) #dtype='<U4'

"""array(['1.5', '0.25'], dtype='<U4')"""

#문자열 데이터를 연산을 하기 위해서는 정수나 실수 형태로 변환해야 한다.
arr = np.array(["1.5", "0.25", "5"])
numArr = arr.astype(float)
numArr

"""array([1.5 , 0.25, 5.  ])"""

numArr + np.array([1, 2, 3])

"""array([2.5 , 2.25, 8.  ])"""

intArr = numArr.astype(int)
floatArr = numArr.astype(float)
print(intArr) #소수점 아래를 버림. 지양할 타입
print(floatArr) #온전한 형태로 출력됨 

"""
[1 0 5]
[1.5  0.25 5.  ]
"""