[Numpy] 01 Numpy 생성 - zeros, ones, arange, linspace

 

01 넘파이 개요

• Numerical Python 의 줄임말
• 벡터, 행렬 연산을 위한 파이썬 라이브러리
  • 강력크한 다차원 배열(array)지원
  • 빠른 수치 계싼을 위한 structured array, 백터화 연산, 브로드캐스팅 기법등을 통한 다차원 배열과 행렬 연산에 필요한 다양한 함수 제공
  • 파이썬 리스트보다 더 많은 데이터를 더 빠르게 처리
• 많은 과학 연산 라이브러리들이 Numpy를 기반으로 함
  • scipy, matplotlib, pandas, sciket-learn, statsmodels등
• 선형대수, 난수생성, 푸리에 변환 기능 지원

 

02 넘파이 데이터 구조

• 스칼라(Scalar)
  • 하나의 숫자로 이루어진 데이터
• 벡터(Vector)
  • 여러개의 숫자들을 특정한 순서대로 모아놓은 데이터 모음
  • 1D Array(1차원 배열)
• 행렬(Matrix)
  • 벡터들을 모아놓은 데이터 집합
  • 2D Array(2차원 배열)
• 텐서(Tensor)
  • 같은 크기의 행렬들을 모아놓은 데이터 집합
  • ND Array(다차원 배열, N차원 배열)

01 용어

• 축(axis)
  • 값들의 나열 방향
  • 하나의 축(axis)은 하나의 범주(category)이다.
• 랭크(rank)
  • 데이터 집합에서 축의 개수
  • 차원이라고도 한다.
  • Vector에서 차원은 원소의 개수 의미
• 형태/형상(shape)
  • 각 축(axis) 별 데이터의개수
• 크기(size)
  • 배열내 원소의 총 개수

 

03 생성 함수

01 배열 생성 함수

array(배열형태 객체[, dtype])

• 배열형태 객체를 numpy 배열로 변환 
• 원하는 값들로 구성된 배열을 만들 때 사용
• 다차원 배열을 만들 경우 각 축별 데이터의 개수가 동일해야 함
  • 배열형태 객체(array-like: 인덱스 있는 타입들): 리스트, 튜플, 넘파이배열(ndarray), Series

02 데이터 타입

• 원소들의 데이터 타입 
• ndarray는 같은 타입의 데이터만 모아서 관리(배열 자체에 데이터 타입 정해줌)
• 배열 생성 시 dtype 속성을 이용해 데이터타입 설정 가능
• ndarray.dtype 속성을 이용해 조회
• ndarray.astype(데이터타입)
  • 데이터타입 변환하는 메소드
  • 변환한 새로운 ndarray 객체 반환
• 데이터 타입
  • 문자열과 numpy 모듈에서 제공하는 변수를 통해 지정 가능

분류	문자열	numpy 변수
정수형	int8	np.int8
	int16	np.int16
	int32, int	np.int32, np.int
	int64	np.int64
부호없는 정수형	uint8	np.uint8
	uint16	np.uint16
	uint32, uint	np.int32, np.uint
	uint64	np.uint64
실수형	float16	np.float16
	float32	np.float32
	float64, float	np.float64
논리형	bool	np.bool
문자열	str	np.str

** 부호없는 정수형: 0부터 시작

 

1차원 Array 생성 

import numpy as np
a1 = np.array([1, 2, 3, 4, 5]) # 리스트 생성 후 np.array 함수 안에 넣어서 np array 생성
print(type(a)) # <class 'numpy.ndarray'>
print(a1.shape) # (5,)
a1 # array([1, 2, 3, 4, 5])

2차원 Array 생성 

a2 = np.array([[1],
              [2],
              [3],
              [4],
              [5]]) # 2차원 행렬 생성

# shape 메소드 써서 배열 shape 확인 -> 튜플 결과
print(a2.shape) # (5,1)
print(a2.dtype) # int32
a2 # array([[1],
       [2],
       [3],
       [4],
       [5]])

 

3차원 Array 생성

l1 = [
     [1, 2, 3],
     [4, 5, 6],
     [7, 8, 9],
     [10, 11, 12]
]

l2 = [
     [10, 20, 30],
     [40, 50, 60],
     [70, 80, 90],
     [100, 110, 120]
]

l3 = np.array([l1, l2]) # l2 + l3 합쳐서 새로운 행렬 만들어 줌
                        # np.array안에 넣어주지 않으면 그냥 리스트 됨

# shape: 튜플로 축 별 데이터 개수 출력
print(a3.shape) # (2,4,3) 

# dtype: 데이터 타입 출력. 정수 데이터 타입 지정 안해준 경우 디폴트:int32
print(a3.dtype) # int32 

# size: 데이터 총 원소 개수 출력
print(a3.size) # 24

 

타입 변환

• 정수 디폴트 타입: int32,
• 실수 디폴트 타입: float64 

a3.astype('float32') # float32로 데이터타입 변경 

# dtype 메소드 사용해서 데이터 타입 변경되었는지 리체크
a3.dtype # dtype('int32)

 

 

03 zeros(shape, dtype)

• 원소들을 0으로 채운 배열 생성(float으로 반환)
  • shape: 형태(크기, 개수)지정 - tuple로 지정
  • dtype: 배열의 타입 지정

 

2차원 제로 배열 생성

z1 = np.zeros(2,3) # 2행 x 3열 배열 생성 
z1 # array([[0., 0., 0.],
            [0., 0., 0.]])
            
print(z1.shape) # (2,3)
print(z1.dtype) # float64

 

1차원 제로 배열 생성

z2 = np.zeros(7) # 일차원은 정수로 shape 변수 부여
z2 # array([0., 0., 0., 0., 0., 0., 0.])

 

다차원 제로 배열 생성

z3 = np.zeros((2, 2, 3, 3)) # 4차원 행렬 생성
print(z3.shape) # (2, 2, 3, 3)
z3 # array([[[[0., 0., 0.],
           [0., 0., 0.],
           [0., 0., 0.]],

          [[0., 0., 0.],
           [0., 0., 0.],
           [0., 0., 0.]]],


         [[[0., 0., 0.],
           [0., 0., 0.],
           [0., 0., 0.]],

          [[0., 0., 0.],
           [0., 0., 0.],
           [0., 0., 0.]]]])

 

 

04 ones(shape,dtype)

일벡터 생성: 원소들을 1로 채운 배열

• shape: 형태(크기, 개수)지정 - tuple로 지정
• dtype: 배열의 타입 지정

1차원 원배열 생성

o1 = np.ones(shape = 5) # 1차원 배열, 정수로 shape 지정
# o1 = np.ones(5) zeros와 동일하게 숫자만 넣어줘도 똑같은 배열 생성

o # array([1., 1., 1., 1., 1.])

print(o1.shape) # (5,)

print(o1.dtype) # dtype('float64')

 

2차원 원배열 생성

o2 = np.ones(shape = (5,3))
# o2 = np.ones((5,3)) shape으로 지정 해줘도 되고 안해줘도 됨

print(o2.dtype) # dtype('float64'))
print(o2,shape) # (5, 3)
o2 # array([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]])

 

 

05 full(shape, fill_value, dtype)

원소들을 원하는 값으로 채운 배열 생성

• shape: 형태(크기, 개수)지정
• fill_value: 채울 값
• dtype: 배열의 타입 지정

 

1차원 배열 생성

f1 = np.full(shape = 5, fill_value = 10)
# f1 = np.full(5, 10) # 변수 지정 없이 위치변수로 줘도 동일한 배열 생성

print(f1, shape) # (5,)
array([10, 10, 10, 10, 10])

 

2차원 배열 생성

f2 = np.full(shape = (2, 2, 3, 2), fill_value = 1.5)
print(f2.shape) # (2, 2, 3, 2)
print(f2.dtpye) # float64
f2 # array([[[[1.5, 1.5],
           [1.5, 1.5],
           [1.5, 1.5]],

          [[1.5, 1.5],
           [1.5, 1.5],
           [1.5, 1.5]]],


         [[[1.5, 1.5],
           [1.5, 1.5],
           [1.5, 1.5]],

          [[1.5, 1.5],
           [1.5, 1.5],
           [1.5, 1.5]]]])

 

06 numpy.XXX_like

• shape은 매개변수로 받은 배열의 shape에 XXX로 원소들을 채운다.
• XXX: zeros, ones, full
  • zeros_like(), ones_like(),full_like()

a = np.array([[1, 2], [3, 4]])
a # array([[1, 2],
           [3, 4]]) 
           
           
z = np.zeros_like(a) # a와 동일한 shape의 0을 원소로 가지는 배열
o = np.ones_like(a) # a와 동일한 shape의 1을 원소로 가지는 배열
f = np.full_like(a, 100) # a와 동일한 shape의 fill_value로 지정한 100을 원소로 가지는 배열

z # array([[0, 0],
          [0, 0]])
          
o # array([[1, 1],
          [1, 1]])
          
f # array([[100, 100],
          [100, 100]])

 

07 arange(start, stop, step, dtype)

start부터 stop 범위에서 step의 일정한 간격의 값들로 구성된 배열 리턴 -> 1차원 배열만 생성

• start: 범위의 시작값을 포함(생략가능 - 기본값:0)
• stop: 범위의 끝값으로 포함되지 않음(필수)
• step: 간격(기본값 1)
• dtype: 요소의 타입
• 1차원 배열만 생성 가능 

np.arange(1, 10, 2) # array([1, 3, 5, 7, 9]) 
                    # 1 ~ 9까지 2step씩 
                    
np.arange(1, 10) # array([1, 2, 3, 4, 5, 6, 7, 8, 9])
                 # # start, stop (증감생략 -1)

np.arange(10) # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
              # stop (start:0, step:1)

np.arange(0, 1.1, 0.1) # array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
                       # 실수값들도 이용 가능 
                       
np.arange(10, 1, -2) # array([10,  8,  6,  4,  2])
                     # 10 부터 1까지 -2step씩
                     
# reshape 메소드 사용해서 다차원 만들기
np.arange(1, 13).reshape(2, 3) # array([[ 1,  2,  3],
                                        [ 4,  5,  6],
                                        [ 7,  8,  9],
                                        [10, 11, 12]])

 

08 linspace(start, stop , num, endpoint, retstep, dtype)

시작과 끝을 균등하게 나눈 값들을 가지는 배열을 생성

• start: 시작값
• stop: 종료값
• num: 나눌개수, 기본 50(양수여야 함)
• endpoint: stop 까지 포함시킬지 여부, 기본 True
• retstep: 생성된 배열 샘플과 함께 간격도 리털할지 여부. True일 경우 간격도 튜플로 리턴
• dtype: 데이터타입
• 1차원 배열만 생성

 

a = np.linspace(1, 10, 10) # 1 ~ 10까지 동일한 간격으로 10개 분리 했을 때 깂들을 원소로 가지는 배열
a # array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

b = np.linespace(1,10) # 1 ~ 10 동일한 간격으로 50개 분리했을때의 값들을 원소로 가지는 배열
b # array([ 1.        ,  1.18367347,  1.36734694,  1.55102041,  1.73469388,
            1.91836735,  2.10204082,  2.28571429,  2.46938776,  2.65306122,
            2.83673469,  3.02040816,  3.20408163,  3.3877551 ,  3.57142857,
            3.75510204,  3.93877551,  4.12244898,  4.30612245,  4.48979592,
            4.67346939,  4.85714286,  5.04081633,  5.2244898 ,  5.40816327,
            5.59183673,  5.7755102 ,  5.95918367,  6.14285714,  6.32653061,
            6.51020408,  6.69387755,  6.87755102,  7.06122449,  7.24489796,
            7.42857143,  7.6122449 ,  7.79591837,  7.97959184,  8.16326531,
            8.34693878,  8.53061224,  8.71428571,  8.89795918,  9.08163265,
            9.26530612,  9.44897959,  9.63265306,  9.81632653, 10.        ])

 

retstep = True

• (생성된 배열, step 값) 튜플형식으로 반환

np.linspace(1, 10, 50, retstep = True) # (array([ 1.        ,  1.18367347,  1.36734694,  1.55102041,  1.73469388,
                                                  1.91836735,  2.10204082,  2.28571429,  2.46938776,  2.65306122,
                                                  2.83673469,  3.02040816,  3.20408163,  3.3877551 ,  3.57142857,
                                                  3.75510204,  3.93877551,  4.12244898,  4.30612245,  4.48979592,
                                                  4.67346939,  4.85714286,  5.04081633,  5.2244898 ,  5.40816327,
                                                  5.59183673,  5.7755102 ,  5.95918367,  6.14285714,  6.32653061,
                                                  6.51020408,  6.69387755,  6.87755102,  7.06122449,  7.24489796,
                                                  7.42857143,  7.6122449 ,  7.79591837,  7.97959184,  8.16326531,
                                                  8.34693878,  8.53061224,  8.71428571,  8.89795918,  9.08163265,
                                                  9.26530612,  9.44897959,  9.63265306,  9.81632653, 10.        ]),
                                          0.1836734693877551)

 

 

linspace 함수만들고 그래프 그릴때 주로 사용

• 매끈한 그래프 그릴 수 있음

def f(x):
    return x**2 + 2*x + 3

x = np.linspace(-3, 3, 100)
y = f(x)
y # array([ 6.        ,  5.76124885,  5.52984389,  5.30578512,  5.08907254,
           4.87970615,  4.67768595,  4.48301194,  4.29568411,  4.11570248,
           3.94306703,  3.77777778,  3.61983471,  3.46923783,  3.32598714,
           3.19008264,  3.06152433,  2.94031221,  2.82644628,  2.71992654,
           2.62075298,  2.52892562,  2.44444444,  2.36730946,  2.29752066,
           2.23507805,  2.17998163,  2.1322314 ,  2.09182736,  2.05876951,
           2.03305785,  2.01469238,  2.00367309,  2.        ,  2.00367309,
           2.01469238,  2.03305785,  2.05876951,  2.09182736,  2.1322314 ,
           2.52892562,  2.62075298,  2.71992654,  2.82644628,  2.94031221,
           3.06152433,  3.19008264,  3.32598714,  3.46923783,  3.61983471,
           3.77777778,  3.94306703,  4.11570248,  4.29568411,  4.48301194,
           4.67768595,  4.87970615,  5.08907254,  5.30578512,  5.52984389,
           5.76124885,  6.        ,  6.24609734,  6.49954086,  6.76033058,
           7.02846648,  7.30394858,  7.58677686,  7.87695133,  8.17447199,
           8.47933884,  8.79155188,  9.11111111,  9.43801653,  9.77226814,
          10.11386593, 10.46280992, 10.81910009, 11.18273646, 11.55371901,
          11.93204775, 12.31772268, 12.7107438 , 13.11111111, 13.51882461,
          13.9338843 , 14.35629017, 14.78604224, 15.2231405 , 15.66758494,
          16.11937557, 16.5785124 , 17.04499541, 17.51882461, 18.        ])

import matplotlib.pyplot as plt
plt.plot(x,y)
plt.show()