목차
목차NumPy란NumPy 특징ndarray 클래스NumPy 산술 연산 데이터 타입 종류데이터 형 변환NumPy 차원Ndarray(다차원 array) indexingslicingNumPy 배열배열의 연결과 분할다양한 Matrix 만들기NumPy 함수범용함수 (universal function) 집계 함수Boolean IndexingBroadcast random
NumPy란
- 행렬 연산이나 대규모 다차원 배열을 편리하게 처리할 수 있도록 지원하는 파이썬 라이브러리
- NumPy는 데이터 구조 외에도 수치 계산을 위해 효율적으로 구현된 기능을 제공
출처 : 위키백과
NumPy 특징
- N 차원 배열 객체
- 기본적으로 array 단위로 데이터 관리
- 큰 규모의 데이터 연산을 빠르게 수행 (반복문 없이 배열에 대한 처리 지원)
- 정교한 브로드캐스팅(Broadcast) 기능
ndarray 클래스
- Numpy의 핵심인 다차원 행렬 자료 구조를 지원하는 클래스
# Vector(1차원 행렬) import numpy as np a = np.array([1,2,3,4,5,6,7]) print(type(a))
Out[-] <class 'numpy.ndarray'>
NumPy 산술 연산
import numpy as np data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] dataTwo = [[1, 1, 1], [2, 2, 2], [3, 3, 3]] # 행렬과 스칼라의 곱 for i in range(len(data)): for j in range(len(data[0])): data[i][j] *= 2 print(data) # 행렬끼리 덧셈 for i in range(len(data)): for j in range(len(data[0])): data[i][j] += dataTwo[i][j] print(data)
Out[-] [[2, 4, 6], [8, 10, 12], [14, 16, 18]] [[3, 5, 7], [10, 12, 14], [17, 19, 21]]
import numpy as np data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] dataTwo = [[1, 1, 1], [2, 2, 2], [3, 3, 3]] a = np.array(data) b = np.array(dataTwo) print(a * 2) print(a + a) print(a + b) print(a * b) print(np.dot(a, b)) # 행렬곱
Out[-] [[ 2 4 6] [ 8 10 12] [14 16 18]] [[ 2 4 6] [ 8 10 12] [14 16 18]] [[ 2 3 4] [ 6 7 8] [ 10 11 12]] [[ 1 2 3] [ 8 10 12] [21 24 27]] [[ 14 14 14] [ 32 32 32] [ 50 50 50]]
데이터 타입 종류
- int(8bit, 16bit, 32bit, 64bit) i1, i2, i4, i8
- 부호가 있음
- 비트수 만큼 크기를 가지는 정수형
- 저장할 수 있는 값의 범위
- int8 : 8 비트 부호있는 정수
- int16 : 16 비트 부호있는 정수
- int32 : 32 비트 부호있는 정수
- int64 : 64 비트 부호있는 정수
2. uint(8bit, 16bit, 32bit, 64bit) u1, u2, u4, u8
- 부호가 없음
- 비트수 만큼 크기를 가지는 정수형
- 저장할 수 있는 값의 범위
- uint8 : 8비트 부호없는 정수
- uint16 : 16비트 부호없는 정수
- uint32 : 32비트 부호없는 정수
- uint64 : 64비트 부호없는 정수
3. float(16bit, 32bit, 64bit, 128bit) f2, f4, f8, f16
- 부호가 있음
- 비트수 만큼 크기를 가지는 실수형
4. 복소수형
- complex64 : 두개의 32비트 부동 소수점으로 표시되는 복소수 c8
- complex128 : 두개의 64비트 부동소수점으로 표시되는 복소수 c16
5. unicode
- 고정 길이 문자열 unicode
6. bool
- True, False
data = [1.1, 2, 3] a = np.array(data) a.dtype
Out[-] dtype('float64')
data = [1.1, 2, 3] a = np.array(data, dtype=np.float32) a.dtype
Out[-] dtype('float32')
data = [1.1, 2, 3] a = np.array(data, dtype=np.int32) print(a.dtype) print(a)
Out[-] int32 [1 2 3]
data = [1.1, 2, 3] a = np.array(data, dtype='i4') a.dtype
Out[-] dtype('int32')
데이터 형 변환
방법. 1
- variable(변수) = np.astype(data)
- astype : 변환하고자 하는 데이터 타입 지정
- data : 변환하고자 하는 array 지정
방법. 2
- variable(변수) = ndarray.astype(dtype)
- ndarray : 변환하고자 하는 array 지정
- dtype : 변환하고자 하는 데이터 타입 지정
data = [1.1, 2, 3] a = np.float64(data) print(a.dtype) print(a) a = np.int32(a) print(a.dtype) print(a)
Out[-] float64 [1.1 2. 3. ] int32 [1 2 3]
data = [1.1, 2, 3] a = np.float64(data) print(a.dtype) print(a) a = a.astype(np.int64) print(a.dtype) print(a)
Out[-] float64 [1.1 2. 3. ] int64 [1 2 3]
data = [1.1, 2, 3] a = np.float64(data) print(a.dtype) a = a.astype(np.string_) print(a.dtype) print(a)
Out[-] float64 |S32 [b'1.1' b'2.0' b'3.0']
a = np.uint16(0) print(a.dtype) a = a - 1 print(a.dtype)
Out[-] uint16 int32
a = np.uint16(-1) a
Out[-] 65535
NumPy 차원
- Scalar : 하나의 데이터 값으로만 존재하는 것
- Vector : 숫자들의 배열 (1D array)
- Matrix : 숫자들의 2D array (rows: 행, columns: 열)
# 0 차원 (Scalar) a = np.array(1) print(a) print(a.shape, a.ndim)
Out[-] 1 () 0
# 1 차원 (Vector) a = np.array([1, 2, 3]) print(a) print(a.shape, a.ndim)
Out[-] [1 2 3] (3,) 1
# 1 차원 a = np.array([1]) print(a) print(a.shape, a.ndim)
Out[-] [1] (1,) 1
# 2 차원 a = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]) print(a) print(a.shape, a.ndim)
Out[-] [[1 2 3] [1 2 3] [1 2 3]] (3, 3) 2
# 2 차원 (Matrix) a = np.array([[1]]) print(a) print(a.shape, a.ndim)
Out[-] [[1]] (1, 1) 2
# 3 차원(3차원 이상의 다차원의 행렬을 Tensor) a = np.array([[[1, 2], [1, 2], [1, 2]], [[1, 2], [1, 2], [1, 2]]]) print(a) print(a.shape, a.ndim)
Out[-] [[[1 2] [1 2] [1 2]] [[1 2] [1 2] [1 2]]] (2, 3, 2) 3
Ndarray(다차원 array)
- 서로 다른 타입의 데이터를 담을 수 없다
- 내부 반복문을 사용해서 속도가 빠르다
- 배열 간에 산술 연산이 가능하다
- NumPy는 다차원 배열을 지원하고 배열의 구조는 'shape'로 표현된다
- 다차원 배열은 입체적인 데이터 구조를 가진다
a = np.array([i for i in range(2, 11, 2)]) # range(start, stop, step) a
Out[-] array([ 2, 4, 6, 8, 10])
a = np.array(range(2, 11, 2)) a
Out[-] array([ 2, 4, 6, 8, 10])
print(np.arange(10)) print(np.arange(2, 11, 2)) # np.arange(start, stop, step) print(np.arange(10, 15, .5)) print(np.arange(10, 2, -1)) print(np.arange(10, 2, -1.5))
Out[-] [0 1 2 3 4 5 6 7 8 9] [ 2 4 6 8 10] [10. 10.5 11. 11.5 12. 12.5 13. 13.5 14. 14.5] [10 9 8 7 6 5 4 3] [10. 8.5 7. 5.5 4. 2.5]
a = np.arange(10) print(a.ndim) print(a.shape) print(a.size)
Out[-] 1 (10,) 10
indexing
- 특정 위치를 가리키는 데이터를 가져오는 방법
- 1차원 indexing
a = np.arange(10) a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
a[2]
Out[-] 2
- 2차원 indexing
a = np.arange(12).reshape(3, 4) a
Out[-] array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
a[1][3]
Out[-] 7
a[-2][-1]
Out[-] 7
a[1, 3]
Out[-] 7
- 3차원 indexing
a = np.arange(40).reshape(2, 5, 4) a
Out[-] array([[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11], [12, 13, 14, 15], [16, 17, 18, 19]], [[20, 21, 22, 23], [24, 25, 26, 27], [28, 29, 30, 31], [32, 33, 34, 35], [36, 37, 38, 39]]])
a[0][1][1]
Out[-] 5
a[-1][-3][-3]
Out[-] 29
a[1][2][1]
Out[-] 29
a[-1, -3, -3]
Out[-] 29
a[1, 2, 1]
Out[-] 29
a[a > 30]
Out[-] array([31, 32, 33, 34, 35, 36, 37, 38, 39])
slicing
- 연속된 객체에서 범위를 지정하고 선택한 객체를 가져옴
- 1차원 → [start : end : step]
- 2차원 배열은 행과 열을 콤마로 구분 → [ : , :]
- 3차원 배열 → [ :, :, :]
- 1차원 slicing
a = np.arange(30) a
Out[-] array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])
a[::-1] # 역순
Out[-] array([29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
a[5:20:2] # a[start:stop:step]
Out[-] array([ 5, 7, 9, 11, 13, 15, 17, 19])
a = a.reshape(5, 6) a
- 2차원 slicing
Out[-] array([[ 0, 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23], [24, 25, 26, 27, 28, 29]])
print(a[:, 1]) print(a[1, :]) # a[1]
Out[-] [ 1 7 13 19 25] [ 6 7 8 9 10 11]
a[:3, :3]
Out[-] array([[ 0, 1, 2], [ 6, 7, 8], [12, 13, 14]])
a[::2, ::2] # 처음부터 끝까지 2개 간격으로
Out[-] array([[ 0, 2, 4], [12, 14, 16], [24, 26, 28]])
b = a[::2, ::2] b
Out[-] array([[ 0, 2, 4], [12, 14, 16], [24, 26, 28]])
b[0] = 100 b
Out[-] array([[100, 100, 100], [ 12, 14, 16], [ 24, 26, 28]])
a
Out[-] array([[100, 1, 100, 3, 100, 5], [ 6, 7, 8, 9, 10, 11], [ 12, 13, 14, 15, 16, 17], [ 18, 19, 20, 21, 22, 23], [ 24, 25, 26, 27, 28, 29]])
b = a[::2, ::2].copy() # 원래의 배열과 독립된 배열로 처리 b
Out[-] array([[100, 100, 100], [ 12, 14, 16], [ 24, 26, 28]])
b[0] = 1000 b
Out[-] array([[1000, 1000, 1000], [ 12, 14, 16], [ 24, 26, 28]])
a
Out[-] array([[100, 1, 100, 3, 100, 5], [ 6, 7, 8, 9, 10, 11], [ 12, 13, 14, 15, 16, 17], [ 18, 19, 20, 21, 22, 23], [ 24, 25, 26, 27, 28, 29]])
- 3차원 slicing
a = np.arange(30).reshape(2, 5, 3) # 2x5x3 a
Out[-] array([[[ 0, 1, 2], [ 3, 4, 5], [ 6, 7, 8], [ 9, 10, 11], [12, 13, 14]], [[15, 16, 17], [18, 19, 20], [21, 22, 23], [24, 25, 26], [27, 28, 29]]])
a[:,:,1] # 첫 번째 열만 출력
Out[-] array([[ 1, 4, 7, 10, 13], [16, 19, 22, 25, 28]])
a[:,1,:] # 첫 번째 행만 출력
Out[-] array([[ 3, 4, 5], [18, 19, 20]])
a[1,:,:] # 첫 번째 배열 출력
Out[-] array([[15, 16, 17], [18, 19, 20], [21, 22, 23], [24, 25, 26], [27, 28, 29]])
a[1,:,::-1]
Out[-] array([[17, 16, 15], [20, 19, 18], [23, 22, 21], [26, 25, 24], [29, 28, 27]])
NumPy 배열
배열의 연결과 분할
- 연결
- hStack : 열 추가
- vstack : 행 추가
- concatenate ([a, b], axis = ) : axis=0 → 행 추가, axis=1 → 열추가
- 분할
- vsplit : 수직축으로 분할, 행 분할
- hsplit : 수평축으로 분할, 열 분할
x = [1, 2, 3] y = [4, 5, 6] # np.array(x) + np.array(y) # x와 y의 각 자리에 맞는것 끼리 더함=> array([5, 7, 9]) a = np.array(x) b = np.array(y) np.concatenate([a, b])
Out[-] array([1, 2, 3, 4, 5, 6])
a = np.arange(10).reshape(2, 5) b = np.arange(10, 20).reshape(2, 5) np.concatenate([a, b])
Out[-] array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]])
a = np.arange(10).reshape(2, 5) b = np.arange(10, 20).reshape(2, 5) np.concatenate([[a, b], [a, b]])
Out[-] array([[[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9]], [[10, 11, 12, 13, 14], [15, 16, 17, 18, 19]], [[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9]], [[10, 11, 12, 13, 14], [15, 16, 17, 18, 19]]])
np.concatenate([a, b], axis=1)
Out[-] array([[ 0, 1, 2, 3, 4, 10, 11, 12, 13, 14], [ 5, 6, 7, 8, 9, 15, 16, 17, 18, 19]])
a = np.arange(12).reshape(2, 6) b = np.arange(10, 20).reshape(2, 5) np.hstack([a, b])
Out[-] array([[ 0, 1, 2, 3, 4, 5, 10, 11, 12, 13, 14], [ 6, 7, 8, 9, 10, 11, 15, 16, 17, 18, 19]])
a = np.arange(15).reshape(3, 5) b = np.arange(10, 20).reshape(2, 5) np.vstack([a, b]) # vertical stack
Out[-] array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19]])
a = np.arange(12) # np.split(a, 5) # np.split(a, 2) np.split(a, 3) # a를 3개의 배열로 분할
Out[-] [array([0, 1, 2, 3]), array([4, 5, 6, 7]), array([ 8, 9, 10, 11])]
a = np.arange(10, 121, 10) a
Out[-] array([ 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120])
np.split(a, [3, 5, 9, 10]) # a를 [3,5,9,10]위치까지 나누기 # a[0:3], a[3:5], a[5:9], a[9:10], a[10:]
Out[-] [array([10, 20, 30]), array([40, 50]), array([60, 70, 80, 90]), array([100]), array([110, 120])]
a = np.arange(10, 121, 10).reshape(3, 4) a
Out[-] array([[ 10, 20, 30, 40], [ 50, 60, 70, 80], [ 90, 100, 110, 120]])
np.vsplit(a,3)
Out[-] [array([[10, 20, 30, 40]]), array([[50, 60, 70, 80]]), array([[ 90, 100, 110, 120]])]
np.hsplit(a, 4)
Out[-] [array([[10], [50], [90]]), array([[ 20], [ 60], [100]]), array([[ 30], [ 70], [110]]), array([[ 40], [ 80], [120]])]
np.hsplit(a,4)[0]
Out[-] array([[10], [50], [90]])
다양한 Matrix 만들기
- zeros : 0으로 초기화된 배열 생성
- ones : 1로 초기화 된 배열 생성
- eye : 주대각선의 원소가 모두 1이고 나머지 원소는 0인 정사각행렬 (단위행렬)
- empty : 초기화 하지 않고 배열만 생성, 기존에 메모리에 저장되어 있는 값으로 나타남
- linespace(시작, 끝, 개수, endpoint = ) : 지정한 구간에서 개수만큼 분할
- endpoint = True or False : 마지막 값을 포함시킬지 시키지 않을지 선택
- logspace(시작, 끝, 개수, endpoint = ) : 지정한 구간에서 개수만큼 로그를 이용하여 분할
- ravel : 다차원 배열을 1차원 배열로 변환
a = np.arange(12).reshape(3, 4) a
Out[-] array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
b = np.ones(12) b
Out[-] array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])
c = np.ones([3, 4]) c
Out[-] array([[1., 1., 1., 1.], [1., 1., 1., 1.], [1., 1., 1., 1.]])
c = np.ones([3, 4, 5]) c
Out[-] array([[[1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.]], [[1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.]], [[1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.]]])
c = np.zeros([3, 4, 5]) c
Out[-] 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., 0., 0., 0., 0.]], [[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]]])
d = np.eye(3) d
Out[-] array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]])
e = np.arange(9).reshape(3, 3) e
Out[-] array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
np.dot(d, e)
Out[-] array([[0., 1., 2.], [3., 4., 5.], [6., 7., 8.]])
np.empty(10)
Out[-] array([8.90070286e-308, 2.11393900e-307, 1.27945906e-307, 1.11258192e-307, 9.79098366e-307, 1.00133162e-307, 1.11261027e-306, 1.29061821e-306, 8.90103559e-307, 1.24611470e-306])
np.full((3, 4), 100) # 모든값을 100으로 초기화
Out[-] array([[100, 100, 100, 100], [100, 100, 100, 100], [100, 100, 100, 100]])
np.linspace(2, 10, 6) # 2부터 10까지 6개로 균등하게 분할
Out[-] array([ 2. , 3.6, 5.2, 6.8, 8.4, 10. ])
np.linspace(2, 100, 10)
Out[-] array([ 2. , 12.88888889, 23.77777778, 34.66666667, 45.55555556, 56.44444444, 67.33333333, 78.22222222, 89.11111111, 100. ])
np.logspace(2, 100, 10)
Out[-] array([1.00000000e+002, 7.74263683e+012, 5.99484250e+023, 4.64158883e+034, 3.59381366e+045, 2.78255940e+056, 2.15443469e+067, 1.66810054e+078, 1.29154967e+089, 1.00000000e+100])
a = np.arange(12).reshape(3, 4) a
Out[-] array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
a.ravel()
Out[-] array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
a.ravel(order='C') # 행기준
Out[-] array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
a.ravel(order='F') # 열기준
Out[-] array([ 0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11])
NumPy 함수
범용함수 (universal function)
- 배열의 값에 반복된 연산을 빠르게 수행하는 함수
max(range(100))
Out[-] 99
min(range(100))
Out[-] 0
%%timeit # 셀 코드의 실행시간을 측정하는 IPython 매직 명령 for i in range(10): max(range(1000000))
Out[-] 425 ms ± 23.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%%timeit for i in range(10): np.max(np.arange(1000000))
Out[-] 43.8 ms ± 2.52 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
a = np.arange(12).reshape(3, 4) a
Out[-] array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
np.max(a)
Out[-] 11
np.max(a, axis=1)
Out[-] array([ 3, 7, 11])
a[0][3] = 1 np.max(a, axis = 1)
Out[-] array([ 2, 7, 11])
집계 함수
- mean : 평균 구하는 함수
- median : 중앙값 구하는 함수
- std : 표준편차 구하는 함수
- var : 분산 구하는 함수
- sum : 합계 구하는 함수
- cusum : 누적값 구하는 함수
- argmin : 최소값에 해당하는 index 값 찾는 함수
- any : 배열에서 1개 이상의 원소가 참인지 평가하는 함수
- all : 배열의 모든 원소가 참인지 평가하는 함수
- nansum : NaN을 0으로 간주하고 더는 함수
- where(조건, 조건에 맞을 때 값, 조건과 다를 때 값)
a = np.arange(12).reshape(3, 4) a
Out[-] array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
a[0][0] = 100 np.mean(a)
Out[-] 13.833333333333334
np.median(a)
Out[-] 6.5
np.std(a)
Out[-] 26.15604880116431
np.var(a)
Out[-] 684.138888888889
np.sum(a)
Out[-] 166
np.sum(a, axis=1)
Out[-] array([106, 22, 38])
a
Out[-] array([[100, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
np.cumsum(a)
Out[-] array([100, 101, 103, 106, 110, 115, 121, 128, 136, 145, 155, 166], dtype=int32)
np.min(a)
Out[-] 1
np.argmin(a)
Out[-] 1
np.argmax(a)
Out[-] 0
np.any(a)
Out[-] True
np.all(a)
Out[-] True
np.nansum(a)
Out[-] 166
a
Out[-] array([[100, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
a > 5
Out[-] array([[ True, False, False, False], [False, False, True, True], [ True, True, True, True]])
np.all(a > 5)
Out[-] False
np.all(a > -5)
Out[-] True
np.where(a > 5)
Out[-] (array([0, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 2, 3, 0, 1, 2, 3], dtype=int64))
a
Out[-] array([[100, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
np.where(a > 5, a, -100)
Out[-] array([[ 100, -100, -100, -100], [-100, -100, 6, 7], [ 8, 9, 10, 11]])
a = np.arange(36).reshape(3, 4, 3) a
Out[-] array([[[ 0, 1, 2], [ 3, 4, 5], [ 6, 7, 8], [ 9, 10, 11]], [[12, 13, 14], [15, 16, 17], [18, 19, 20], [21, 22, 23]], [[24, 25, 26], [27, 28, 29], [30, 31, 32], [33, 34, 35]]])
print(np.sum(a)) print(np.sum(a, axis=1)) print(np.sum(a, axis=2))
Out[-] 630 [[ 18 22 26] [ 66 70 74] [114 118 122]] [[ 3 12 21 30] [ 39 48 57 66] [ 75 84 93 102]]
Boolean Indexing
- 조건에 만족 여부를 따져 논리값(True, False)을 출력
- 단, 행 값을 활용한 조건만 선택이 가능
a = np.arange(12).reshape(3, 4) a
Out[-] array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]])
a > 5
Out[-] array([[False, False, False, False], [False, False, True, True], [ True, True, True, True]])
a[a > 5]
Out[-] array([ 6, 7, 8, 9, 10, 11])
a[a > 5] = 1 a
Out[-] array([[0, 1, 2, 3], [4, 5, 1, 1], [1, 1, 1, 1]])
a[~(a == 1)]
Out[-] array([0, 2, 3, 4, 5])
a[~(a == 1) & (a < 4)]
Out[-] array([0, 2, 3])
a[~(a == 1) | (a < 4)]
Out[-] array([0, 1, 2, 3, 4, 5, 1, 1, 1, 1, 1, 1])
Broadcast
- 크기가 다른 배열 간의 연산 함수를 적용한는 규칙 집합
np.array([1, 2, 3]) + 1
Out[-] array([2, 3, 4])
np.arange(9).reshape(3, 3) + np.array([1, 2, 3])
Out[-] array([[ 1, 3, 5], [ 4, 6, 8], [ 7, 9, 11]])
np.arange(27).reshape(3, 3, 3) + np.array([1, 2, 3])
Out[-] array([[[ 1, 3, 5], [ 4, 6, 8], [ 7, 9, 11]], [[10, 12, 14], [13, 15, 17], [16, 18, 20]], [[19, 21, 23], [22, 24, 26], [25, 27, 29]]])
random
- seed : 시작 숫자를 정해 정해진 난수 알고리즘으로 난수 생성
- shuffle : 데이터의 순서를 바꿔줌
- choice : 데이터에서 일부를 무작위로 선택
- rand : 0부터 1까지 균일 분포로 난수 생성
- randn : 가우시안 표준 정규 분포로 난수 생성
import random as r print(r.randint(1, 10)) # 1부터 10까지의 임의의 정수를 리턴 print(r.random()) # 0부터 1까지의 부동소수점 숫자를 리턴 print(r.uniform(1, 10)) # 1부터 10까지의 부동소수점 숫자를 리턴 print(r.randrange(1, 10, 2)) # 1부터 9까지 2 간격으로 임의의 정수를 리턴
Out[-] 2 0.36568891691258554 1.5219903229723613 9
l = [i for i in range(20)] r.shuffle(l) l
Out[-] [3, 9, 4, 19, 17, 11, 0, 14, 5, 7, 12, 15, 13, 8, 1, 10, 2, 6, 18, 16]
r.choice(l)
Out[-] 17
r.sample(l, 5)
Out[-] [9, 15, 12, 17, 19]
r.seed(7) r.randint(1, 10)
Out[-] 6
print(np.random.randint(1, 10)) print(np.random.normal(1, 10, size=(10))) print(np.random.uniform(1, 10, size=(3, 4)))
Out[-] 2 [ 22.54439604 0.06003082 -2.38677184 1.83293534 -5.10144747 -1.16943924 -0.9915091 2.10254182 -13.11856085 3.66203174] [[5.55433615 5.66114991 5.92052974 6.67300498] [8.70958655 5.38328336 3.88877589 6.53031795] [5.80594633 3.99338487 8.55861939 7.99957725]]
np.random.seed(1) np.random.randint(1, 10)
Out[-] 6