4. NumPy 기본: 배열과 벡터 계산¶
Numerical Python의 줄임말
- 빠르고 메모리를 효율적으로 사용하며 벡터 산술연산과 세련된 브로드캐스팅 기능을 제공하는 다차원 배열인 ndarray
- 반복문을 작성할 필요없이 전체 데이터 배열에 대해 빠른 연산을 제공하는 표준 수학 함수
- 배열 데이터를 디스크에 쓰거나 읽을 수 있는 도구와 메모리에 올려진 파일을 사용하는 도구
- 선형대수, 난수 발생기, 푸리에 변환 기능
- C, C++, 포트란으로 쓰여진 코드를 통합하는 도구
대부분의 데이터 분석 애플리케이션에서 중요하게 사용하는 기능¶
- 벡터 배열상에서 데이터 개조, 정제, 부분 집합, 필터링 변형, 다른 종류 연산의 빠른 수행
- 정렬, 유일 원소 찾기, 집합연산 같은 일반적인 배열 처리 알고리즘
- 통계의 효과적인 표현과 데이터의 수집/요약
- 다른 종류의 데이터 묶음을 병합하고 엮기 위한 데이터 정렬과 데이터 간의 관계 조작
- if-elif-else를 포함하는 반복문 대신 사용할 수 있는 조건절을 표현할 수 있는 배열 표현
- 데이터 그룹 전체에 적용할 수 있는 수집, 변형, 함수 적용같은 데이터 처리
이 책에서 표준 NumPy의 컨벤션을 import numpy as np로 사용¶
물론, from numpy import *를 사용해서 np.을 생략해도 괜찮다. 하지만 좋은 코딩 습관은 아니다.¶
4.1 NumPy ndarray: 다차원 배열 객체¶
일반적인 리스트 사용¶
In [45]:
data = [[0.9526, -0.246, -0.8856],
[0.5639, 0.2379, 0.9104]]
In [46]:
data * 10
Out[46]:
[[0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104], [0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104], [0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104], [0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104], [0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104], [0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104], [0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104], [0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104], [0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104], [0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104]]
In [47]:
data + data
Out[47]:
[[0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104], [0.9526, -0.246, -0.8856], [0.5639, 0.2379, 0.9104]]
ndarray 사용¶
In [48]:
import numpy as np
In [49]:
data = [[0.9526, -0.246, -0.8856],
[0.5639, 0.2379, 0.9104]]
In [50]:
nd_data = np.array(data)
In [51]:
nd_data
Out[51]:
array([[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]])
In [52]:
nd_data * 10
Out[52]:
array([[ 9.526, -2.46 , -8.856],
[ 5.639, 2.379, 9.104]])
In [53]:
nd_data + nd_data
Out[53]:
array([[ 1.9052, -0.492 , -1.7712],
[ 1.1278, 0.4758, 1.8208]])
In [54]:
nd_data.shape
Out[54]:
(2, 3)
In [55]:
nd_data.dtype
Out[55]:
dtype('float64')
파이썬을 이용한 과학계산의 고수가 되는 지름길¶
- 배열 위주의 프로그래밍과 생각하는 방법에 능숙해지는 것
- '배열', 'NumPy 배열', 'ndarray'는 아주 극소수의 예외를 제외하면 모두 ndarray 객체를 이르는 말
4.1.1 ndarray 생성¶
In [56]:
data1 = [6, 7.5, 8, 0, 1]
In [57]:
arr1 = np.array(data1)
In [58]:
arr1
Out[58]:
array([ 6. , 7.5, 8. , 0. , 1. ])
In [59]:
data2 = [[1,2,3,4], [5,6,7,8]]
In [60]:
arr2 = np.array(data2)
In [61]:
arr2
Out[61]:
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
In [62]:
arr2.ndim?
In [63]:
arr2.ndim
Out[63]:
2
In [64]:
arr2.nbytes
Out[64]:
64
In [65]:
arr2.shape
Out[65]:
(2, 4)
nd.array는 생성될 때 적절한 자료형을 추정한다.¶
In [66]:
arr1.dtype
Out[66]:
dtype('float64')
In [67]:
arr2.dtype
Out[67]:
dtype('int64')
zeros - 주어진 길이나 모양에 각각 0이 들어있는 배열 생성
ones - 주어진 길이나 모양에 각각 1이 들어있는 배열 생성
(3, 6) - 앞은 행, 뒤는 열¶
In [68]:
np.zeros(10)
Out[68]:
array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
In [69]:
np.zeros((3,6))
Out[69]:
array([[ 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0.]])
In [70]:
np.empty((2,3))
Out[70]:
array([[ 2.31584178e+077, 2.31584178e+077, 2.18830816e-314],
[ 1.47267102e-212, 2.31584178e+077, 2.31584178e+077]])
In [71]:
np.empty((2,3,4))
Out[71]:
array([[[ 2.31584178e+077, 1.49166824e-154, 5.92878775e-323,
0.00000000e+000],
[ 2.31584178e+077, 2.14027814e+161, 5.04621383e+180,
4.50618615e-144],
[ 1.16071308e-028, 2.01069581e-052, 1.07949264e-061,
4.43900471e-052]],
[[ 2.36230891e-047, 3.83819517e+151, 1.47721841e+179,
8.37404147e+242],
[ 4.31999013e-096, 9.08366793e+223, 3.21133546e+030,
3.86586411e-057],
[ 1.81195722e-042, 6.75655658e-067, -2.00023867e+000,
1.66880553e-308]]])
In [72]:
np.empty((3,2))
Out[72]:
array([[ 2.31584178e+077, 1.36673907e-315],
[ 4.22764845e-307, 2.13686428e-314],
[ 2.31584178e+077, 2.31584178e+077]])
In [73]:
np.empty((1,2,3))
Out[73]:
array([[[ 2.31584178e+077, 1.72723382e-077, 2.12358237e-314],
[ 2.12358407e-314, 2.12358405e-314, 4.44480170e-309]]])
- np.empty는 0으로 초기화된 배열을 반환하지 않는다. 앞에서 살펴본 바와 같이 대부분의 경우 empty는 초기화되지 않은 값으로 채워진 배열을 반환
In [74]:
np.arange(15)
Out[74]:
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
In [75]:
type(np.arange(15))
Out[75]:
numpy.ndarray
Colons can be used to align columns.
| Tables | Are | Cool |
|---|---|---|
| col 3 is | right-aligned | $1600 |
| col 2 is | centered | $12 |
| zebra stripes | are neat | $1 |
The outer pipes (|) are optional, and you don't need to make the raw Markdown line up prettily. You can also use inline Markdown.
| Markdown | Less | Pretty |
|---|---|---|
| Still | renders |
nicely |
| 1 | 2 | 3 |
In [76]:
np.asarray(nd_data)
Out[76]:
array([[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]])
In [77]:
np.asarray(data)
Out[77]:
array([[ 0.9526, -0.246 , -0.8856],
[ 0.5639, 0.2379, 0.9104]])
In [78]:
d = [1,2,3,4]
In [79]:
np.asarray([1,2,3,4])
Out[79]:
array([1, 2, 3, 4])
In [80]:
np.asarray(np.array([1,2,3,5]))
Out[80]:
array([1, 2, 3, 5])
In [81]:
np.eye(5)
Out[81]:
array([[ 1., 0., 0., 0., 0.],
[ 0., 1., 0., 0., 0.],
[ 0., 0., 1., 0., 0.],
[ 0., 0., 0., 1., 0.],
[ 0., 0., 0., 0., 1.]])
In [82]:
np.identity(4)
Out[82]:
array([[ 1., 0., 0., 0.],
[ 0., 1., 0., 0.],
[ 0., 0., 1., 0.],
[ 0., 0., 0., 1.]])
| 함수 | 설명 |
|---|---|
| array | 입력 데이터(리스트, 튜플, 배열 또는 다른 순차형 데이터)를 ndarray로 변환하며 dtype이 명시되지 않은 경우에는 자료형을 추론하여 저장하낟. 기본적으로 입력 데이터는 복사된다. |
| asarray | 입력 데이터를 ndarray로 변환하지만 입력 데이터가 이미 ndarray일 경우, 복사가 되지 않는다. |
| arange | 내장 range 함수와 유사하지만 리스트 대신 ndarray를 반환한다. |
| ones, ones_like | 주어진 dtype과 주어진 모양을 가지는 배열을 생성하고 내용응ㄹ 모두 1로 초기화한다. ones_like는 주어진 배열과 동일한 모양과 dtype을 가지는 배열을 새로 생성하여 내용을 모두 1로 초기화한다. |
| zeros, zeros_like | ones, ones_like와 같지만 내용을 0으로 채운다. |
| empty, empty_like | 메모리를 할당하여 새로운 배열을 생성하지만 ones나 zeros처럼 값을 초기화하지는 않는다. |
| eye, identity | N x N 크기의 단위 행렬을 생성한다(좌상단에서 우하단을 잇는 대각선은 1로 채워지고 나머지는 0으로 채워진다). |
4.1.2 ndarray의 자료형¶
dtype이 있기에 NumPy가 강력하면서도 유연한 도구가 될 수 있다.
- 대부분의 데이터는 디스크에서 데이터를 읽기 쓰기 편하도록 하위 레벨의 표현에 직접적으로 맞춰져 있으며 C나 포트란 같은 저수준 언어로 작성된 코드와 쉽게 연동
- 산술 데이터의 dtype은 float, int 같은 자료형의 이름과 하나의 원소가 차지하는 비트수로 이루어짐
- 파이썬의 float 객체에서 사용되는 표준 배정밀도 부동소수점 값은 8바이트 혹은 64바이트로 이루어짐
- NumPy 자료형
In [83]:
arr1 = np.array([1,2,3], dtype=np.float64)
In [84]:
arr2 = np.array([1,2,3], dtype=np.int32)
In [85]:
arr1.dtype, arr2.dtype
Out[85]:
(dtype('float64'), dtype('int32'))
ndarray의 astype 메소드 -> 배열의 dtype을 다른형으로 명시적 변경 가능(다른 언어의 cast와 같은 역할)¶
In [86]:
arr = np.array([1,2,3,4,5])
In [87]:
arr.dtype
Out[87]:
dtype('int64')
In [88]:
float_arr = arr.astype(np.float64)
In [89]:
float_arr
Out[89]:
array([ 1., 2., 3., 4., 5.])
In [90]:
float_arr.dtype
Out[90]:
dtype('float64')
정수형 -> 부동소수점
부동소수점 -> 정수형(소수점 아랫자리 버려짐)¶
In [91]:
arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
In [92]:
arr
Out[92]:
array([ 3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
In [93]:
arr.astype(np.int32)
Out[93]:
array([ 3, -1, -2, 0, 12, 10], dtype=int32)
숫자형 문자열 -> 정수, float¶
In [94]:
numeric_strings = np.array(['1.25', '-9.6', '42'], dtype=np.string_)
In [95]:
numeric_strings
Out[95]:
array(['1.25', '-9.6', '42'],
dtype='|S4')
In [96]:
numeric_strings.astype(float)
Out[96]:
array([ 1.25, -9.6 , 42. ])
In [97]:
# 중간에 문자열로 넣지 않고 그냥 int로 넣었는데도 dtype을 np.string_으로 설정해주니
# 문자열로 변경
numeric_strings = np.array(['1.25', '-9.6', 42], dtype=np.string_)
In [98]:
numeric_strings
Out[98]:
array(['1.25', '-9.6', '42'],
dtype='|S4')
In [99]:
numeric_strings.astype(float)
Out[99]:
array([ 1.25, -9.6 , 42. ])
In [100]:
int_array = np.arange(10)
In [101]:
int_array
Out[101]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [102]:
calibers = np.array([.22, .270, .357, .380, .44, .50], dtype=np.float64)
In [103]:
calibers
Out[103]:
array([ 0.22 , 0.27 , 0.357, 0.38 , 0.44 , 0.5 ])
In [104]:
int_array.astype(calibers.dtype)
Out[104]:
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
- 0., 1., 처럼 뒤의 0이 생략된 경우가 발생하는데 이건 뒤의 소수점이 없으면 자동으로 0을 빼주는 것으로 생각하면 된다.
dtype 축약코드(u4 = uint32)¶
In [105]:
empty_uint32 = np.empty(8, dtype='u4')
- astype을 호출하면 새로운 dtype이 이전 dtype과 같아도 항상 새로운 배열을 생성(데이터를 복사)한다.
- float64나 float32 같은 부동소수점은 근사 값이라는 사실을 염두에 두는 게 중요하다. 복잡한 연산 중에는 부동소수점 오류가 누적되어 비교를 할 때 특정 소수자리까지만 유효한 경우가 생길 수 있다.
4.1.3 배열과 스칼라 간의 연산¶
- 배열은 for 반복문을 작성하지 않고 데이터를 일괄처리하기 때문에 중요(벡터화)
- 같은 크기의 배열 간 산술연산은 배열의 각 요소 단위로 적용
In [106]:
arr = np.array([[1., 2., 3.], [4., 5., 6.]])
In [107]:
arr
Out[107]:
array([[ 1., 2., 3.],
[ 4., 5., 6.]])
In [108]:
arr * arr
Out[108]:
array([[ 1., 4., 9.],
[ 16., 25., 36.]])
In [109]:
arr - arr
Out[109]:
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
스칼라(scalar)란 크기와 방향을 가지는 벡터에 대비하는 개념으로, 크기만 있고 방향을 가지지 않는 양을 말한다. 예를 들면 속도가 방향도 포함한 벡터인데 대해, 그 절대값인 속력은 방향을 가지지 않는 스칼라 값이다.
In [110]:
1 / arr
Out[110]:
array([[ 1. , 0.5 , 0.33333333],
[ 0.25 , 0.2 , 0.16666667]])
In [111]:
arr
Out[111]:
array([[ 1., 2., 3.],
[ 4., 5., 6.]])
In [112]:
# **는 square root of x
arr ** 0.5
Out[112]:
array([[ 1. , 1.41421356, 1.73205081],
[ 2. , 2.23606798, 2.44948974]])
크기가 다른 배열 간의 연산은 브로드캐스팅¶
In [113]:
import math
math.sqrt(3)
Out[113]:
1.7320508075688772
4.1.4 색인과 슬라이싱 기초¶
In [114]:
arr = np.arange(10)
In [115]:
arr
Out[115]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [116]:
arr[5]
Out[116]:
5
In [117]:
arr[5:8]
Out[117]:
array([5, 6, 7])
In [118]:
arr[5:8] = 12
In [119]:
arr
Out[119]:
array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])
np.array 예¶
In [120]:
arr_slice = arr[5:8]
In [121]:
arr_slice[1] = 12345
In [122]:
arr
Out[122]:
array([ 0, 1, 2, 3, 4, 12, 12345, 12, 8, 9])
Slicing :의 예¶
- [:]: 배열 전체
- [0:1]: 0번째부터 1번째까지, 단 1번은 포함하지 않는다. 즉, 1개의 결과값만 slicing 된다.
- [:5]: 0번째부터 5번째까지, 단 5번은 포함하지 않는다.
- [2:]: 2번째부터 끝까지
- [-1]: 제일 끝에 있는 배열값 반환
- [:-1]: 0번째부터 끝까지(-1 이라는 것은 제일 끝에 있는 숫자를 뜻함
In [123]:
arr_slice[:] = 64
In [124]:
arr_slice
Out[124]:
array([64, 64, 64])
In [125]:
arr_slice[0:2]
Out[125]:
array([64, 64])
In [126]:
arr
Out[126]:
array([ 0, 1, 2, 3, 4, 64, 64, 64, 8, 9])
Python list 예¶
In [127]:
l = range(10)
In [128]:
l_slice = l[5:8]
In [129]:
l_slice[1] = 12345
In [130]:
l
Out[130]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [131]:
# Python list는 브로드 캐스팅이 안됨
l_slice[:] = 64
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-131-b3886f71da0e> in <module>() 1 # Python list는 브로드 캐스팅이 안됨 ----> 2 l_slice[:] = 64 TypeError: can only assign an iterable
In [132]:
l
Out[132]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [133]:
l_slice
Out[133]:
[5, 12345, 7]
In [134]:
l_slice[0] = 64
In [135]:
l_slice
Out[135]:
[64, 12345, 7]
In [136]:
# l_slice의 값을 변경해도 원본 l은 영향을 받지 않는다. 복사한 값이기 때문이다.
l
Out[136]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- Python list는 위의 예제에서 보듯이 원본에는 영향을 미치지 않음
- Python list는 브로드 캐스팅이 안됨
Why? NumPy does not copy?¶
- 대용량 데이터 처리 염두
- 만약 NumPy가 데이터 복사를 남발한다면 성능과 메모리 문제 직면
- 뷰 대신 ndarray 슬라이스의 복사본을 얻고 싶다면 arr[5:8].copy()를 사용해서 명시적으로 배열 복사
ndarray 슬라이스 복사본 명시적 정의 .copy¶
In [137]:
arr_slice2 = arr[5:8].copy()
In [138]:
arr_slice2
Out[138]:
array([64, 64, 64])
In [139]:
arr
Out[139]:
array([ 0, 1, 2, 3, 4, 64, 64, 64, 8, 9])
In [140]:
arr_slice2[:] = 33333
In [141]:
arr
Out[141]:
array([ 0, 1, 2, 3, 4, 64, 64, 64, 8, 9])
In [142]:
arr_slice2
Out[142]:
array([33333, 33333, 33333])
2차원 배열 제어¶
In [143]:
arr2d = np.array([[1,2,3], [4,5,6], [7,8,9]])
In [144]:
arr2d[2]
Out[144]:
array([7, 8, 9])
In [145]:
arr2d[0][2]
Out[145]:
3
In [146]:
# ,로도 구분 가능
arr2d[0, 2]
Out[146]:
3
In [147]:
arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
In [148]:
arr3d
Out[148]:
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
In [149]:
arr3d.ndim
Out[149]:
3
In [150]:
arr2d.ndim
Out[150]:
2
In [151]:
arr3d[0]
Out[151]:
array([[1, 2, 3],
[4, 5, 6]])
In [152]:
old_values = arr3d[0].copy()
In [153]:
old_values
Out[153]:
array([[1, 2, 3],
[4, 5, 6]])
In [154]:
arr3d[0] = 42
In [155]:
arr3d
Out[155]:
array([[[42, 42, 42],
[42, 42, 42]],
[[ 7, 8, 9],
[10, 11, 12]]])
In [156]:
old_values
Out[156]:
array([[1, 2, 3],
[4, 5, 6]])
In [157]:
arr3d[0] = old_values
In [158]:
arr3d
Out[158]:
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
In [159]:
arr3d[1, 0]
Out[159]:
array([7, 8, 9])
슬라이스 색인¶
In [160]:
arr[1:6]
Out[160]:
array([ 1, 2, 3, 4, 64])
In [161]:
arr2d
Out[161]:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [162]:
arr2d[:2]
Out[162]:
array([[1, 2, 3],
[4, 5, 6]])
In [164]:
arr2d[:2, 1:]
Out[164]:
array([[2, 3],
[5, 6]])
In [123]:
arr2d[:2][1:]
Out[123]:
array([[4, 5, 6]])
In [124]:
arr2d[1, :2]
Out[124]:
array([4, 5])
In [125]:
arr2d[2, :1]
Out[125]:
array([7])
In [126]:
arr2d[:, :1]
Out[126]:
array([[1],
[4],
[7]])
In [127]:
arr2d[:2, 1:] = 0
In [128]:
arr2d
Out[128]:
array([[1, 0, 0],
[4, 0, 0],
[7, 8, 9]])
4.1.5 불리언 색인¶
In [173]:
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
정규분포¶
인간과 자연 세상에서 일어나는 수많은 일을 설명하는 핵심 개념이다.
통계학에서 사용하는 각종 확률분포 중에서도 가장 중요하게 다루는 분포이다. 물리학 실험용으로 무작위 표본추출을 통해 도출시킨 확률밀도곡선에 극한값을 적용시켜 만든 것을 형태로 정립한 것인데, 그 그래프를 함수식으로 풀어쓰면 (σ:표준편차, μ:평균) 이다. 으어어어 이 식을 -∞에서 ∞까지 정적분하면 1이다. 당연하지만 확률밀도함수에서 나온 것이기 때문이다. 가장 중요한 성질.
정규분포는 특정값의 출현비율을 그렸을 때, 중심(평균값)을 기준으로 좌우 대칭 형태가 나타나며, 좌우 극단으로 갈 수록 급격하게 수치가 낮아지는 특징을 지닌다. 하지만 표준편차의 수치가 위의 이미지처럼 꼭 기계적으로 딱딱 맞아야 하는 것은 아니고 대략 저런 '종'형태로 나타난다. 식스 시그마라는 용어도 여기에서 비롯한 것이다.[2]
In [174]:
# Return a sample (or samples) from the "standard normal" distribution.
data = np.random.randn?
In [175]:
data = np.random.randn
In [176]:
data = np.random.randn
In [177]:
data = np.random.randn
In [178]:
data = np.random.randn(7,4)
In [179]:
names
Out[179]:
array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'],
dtype='|S4')
In [180]:
data
Out[180]:
array([[ 1.77221108, 0.40225415, -1.13369729, 0.09811456],
[-0.8974136 , -1.68999202, 0.13735165, -0.34520354],
[ 0.28554592, 0.67873863, -0.28538987, -0.14202489],
[-0.84161162, -0.2952734 , -1.86067794, -0.18273331],
[ 0.29432671, 0.29031815, 0.71247686, 1.08140858],
[-0.44048201, 0.76291664, -0.05339118, 0.08658191],
[-1.15092796, 0.05599653, 0.1364142 , -0.1197934 ]])
- 2차원 배열 슬라이싱(책 참고: p.132) 그림으로 설명이 잘되어 있네요.
- img src="files/ch04/slice.jpg" width="500" 이렇게 해야 되는구나..
- 앞에 files를 붙여야 되는거였어.. 엄청난 삽질 끝에 얻어낸 정보
In [181]:
# names에서 보듯이 0, 3번째 열이 True
names == 'Bob'
Out[181]:
array([ True, False, False, True, False, False, False], dtype=bool)
In [182]:
# names에서 Bob는 0, 3번째에 존재한다.
# 그러므로 0, 3번 로우값은 True가 되어 data의 0, 3번째 로우값이 반환된다.
# 이렇게 되면 반복문을 쓸 필요도 없네..
data[names == 'Bob']
Out[182]:
array([[ 1.77221108, 0.40225415, -1.13369729, 0.09811456],
[-0.84161162, -0.2952734 , -1.86067794, -0.18273331]])
불리언 주의 사항¶
- 불리언 배열은 반드시 색인하려는 축의 길이와 동일한 길이??? 쓰기는 했는데 무슨 소리인지 나도 이해가 안간다..
- 불리언 배열 색인도 슬라이스 또는 숫자 색인과 함께 혼용
In [193]:
names2 = np.array(['Bob', 'Joe', 'Will'])
In [196]:
data[names2 == 'Bob']
Out[196]:
array([[ 1.77221108, 0.40225415, -1.13369729, 0.09811456]])
In [183]:
data[names == 'Bob', 2:]
Out[183]:
array([[-1.13369729, 0.09811456],
[-1.86067794, -0.18273331]])
In [184]:
data[names == 'Bob', 3]
Out[184]:
array([ 0.09811456, -0.18273331])
!=, -, ~ 으로 부정¶
In [185]:
names != 'Bob'
Out[185]:
array([False, True, True, False, True, True, True], dtype=bool)
In [186]:
data[-(names == 'Bob')]
Out[186]:
array([[-0.8974136 , -1.68999202, 0.13735165, -0.34520354],
[ 0.28554592, 0.67873863, -0.28538987, -0.14202489],
[ 0.29432671, 0.29031815, 0.71247686, 1.08140858],
[-0.44048201, 0.76291664, -0.05339118, 0.08658191],
[-1.15092796, 0.05599653, 0.1364142 , -0.1197934 ]])
In [187]:
data[~(names == 'Bob')]
Out[187]:
array([[-0.8974136 , -1.68999202, 0.13735165, -0.34520354],
[ 0.28554592, 0.67873863, -0.28538987, -0.14202489],
[ 0.29432671, 0.29031815, 0.71247686, 1.08140858],
[-0.44048201, 0.76291664, -0.05339118, 0.08658191],
[-1.15092796, 0.05599653, 0.1364142 , -0.1197934 ]])
In [188]:
mask = (names == 'Bob') | (names == 'Will')
In [143]:
mask
Out[143]:
array([ True, False, True, True, True, False, False], dtype=bool)
In [144]:
data[mask]
Out[144]:
array([[-0.83835174, 0.60824064, -1.71982262, 0.98534612],
[ 0.18016504, -1.09498744, -0.7676533 , 0.52049666],
[ 0.47402157, -0.44598838, 0.96611024, -0.82171886],
[ 0.12207348, -1.35923971, 0.9028664 , -0.62213383]])
In [145]:
data[mask, 3:]
Out[145]:
array([[ 0.98534612],
[ 0.52049666],
[-0.82171886],
[-0.62213383]])
불리언 색인시 항상 데이터 복사(바뀌지 않더라도)¶
- 파이썬 예약어인 and, or는 불리언 배열에서는 사용 불가
In [146]:
data[data < 0] = 0
In [147]:
data
Out[147]:
array([[ 0. , 0.60824064, 0. , 0.98534612],
[ 0. , 0.52443732, 0. , 0.80825771],
[ 0.18016504, 0. , 0. , 0.52049666],
[ 0.47402157, 0. , 0.96611024, 0. ],
[ 0.12207348, 0. , 0.9028664 , 0. ],
[ 0.61517386, 0.82523529, 0. , 0. ],
[ 0.33102606, 0. , 0. , 0. ]])
In [148]:
data[names != 'Joe'] = 7
In [149]:
data
Out[149]:
array([[ 7. , 7. , 7. , 7. ],
[ 0. , 0.52443732, 0. , 0.80825771],
[ 7. , 7. , 7. , 7. ],
[ 7. , 7. , 7. , 7. ],
[ 7. , 7. , 7. , 7. ],
[ 0.61517386, 0.82523529, 0. , 0. ],
[ 0.33102606, 0. , 0. , 0. ]])
4.1.6 팬시 색인¶
- 팬시 색인: 정수 배열을 사용한 색인을 설명하기 위해 NumPy에서 차용한 단어
In [237]:
arr = np.empty((8, 4))
In [240]:
for i in range(8):
arr[i] = i
In [241]:
arr
Out[241]:
array([[ 0., 0., 0., 0.],
[ 1., 1., 1., 1.],
[ 2., 2., 2., 2.],
[ 3., 3., 3., 3.],
[ 4., 4., 4., 4.],
[ 5., 5., 5., 5.],
[ 6., 6., 6., 6.],
[ 7., 7., 7., 7.]])
In [153]:
# 특정한 순서로 로우 선택
arr[[4, 3, 0, 6]]
Out[153]:
array([[ 4., 4., 4., 4.],
[ 3., 3., 3., 3.],
[ 0., 0., 0., 0.],
[ 6., 6., 6., 6.]])
In [154]:
arr[[-3, -5, -7]]
Out[154]:
array([[ 5., 5., 5., 5.],
[ 3., 3., 3., 3.],
[ 1., 1., 1., 1.]])
In [242]:
np.arange(32)
Out[242]:
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])
In [244]:
arr = np.arange(32).reshape((8, 4))
In [245]:
arr
Out[245]:
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]])
In [246]:
# 이건 1개만 선택하는 것
arr[[1, 5, 7, 2], [0, 3, 1, 2]]
Out[246]:
array([ 4, 23, 29, 10])
- 결과를 보면 (1, 0), (5, 3), (7, 1), (2, 2)에 대응하는 요소가 선택
In [248]:
# 1, 5, 7, 2 로우
# 컬럼 열에서 :,로 모든 행을 선택해 주어야 한다.
# 0, 3, 1, 2 열을 순서대로 선택
# 이건 열 순서대로 선택해서 보여주기
arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]
Out[248]:
array([[ 4, 7, 5, 6],
[20, 23, 21, 22],
[28, 31, 29, 30],
[ 8, 11, 9, 10]])
In [159]:
# Construct an open mesh from multiple sequences.
# 이것을 써야 우리가 예상했던 로우 열과 컬럼의 순서대로 볼 수 있다.
np.ix_
Out[159]:
<function numpy.lib.index_tricks.ix_>
In [160]:
arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])]
Out[160]:
array([[ 4, 7, 5, 6],
[20, 23, 21, 22],
[28, 31, 29, 30],
[ 8, 11, 9, 10]])
4.1.7 배열 전치와 축 바꾸기¶
- 행렬의 내적을 구하기도 하기 때문에 이론적인 배경이 필요하다.
- [Matrix - wiki](http://en.wikipedia.org/wiki/Matrix_(mathematics)
- Matrix - kor
- Matrix - enha
In [161]:
arr = np.arange(15).reshape((3, 5))
In [162]:
arr
Out[162]:
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
In [163]:
arr.T
Out[163]:
array([[ 0, 5, 10],
[ 1, 6, 11],
[ 2, 7, 12],
[ 3, 8, 13],
[ 4, 9, 14]])
In [164]:
arr.transpose()
Out[164]:
array([[ 0, 5, 10],
[ 1, 6, 11],
[ 2, 7, 12],
[ 3, 8, 13],
[ 4, 9, 14]])
In [165]:
# Returns a view of the array with axes transposed.
arr.transpose?
In [166]:
arr.T?
In [167]:
arr = np.random.randn(6, 3)
In [168]:
arr
Out[168]:
array([[-1.20187504, -0.44927834, 0.4785346 ],
[ 0.76190465, 0.26996071, 0.36518358],
[-1.0754374 , 0.85590102, 1.4926309 ],
[-1.59364266, 0.11719942, 0.64195019],
[ 1.16087939, 0.11679662, -0.22670051],
[-0.79711903, 1.18209902, 1.40534745]])
In [169]:
arr.T
Out[169]:
array([[-1.20187504, 0.76190465, -1.0754374 , -1.59364266, 1.16087939,
-0.79711903],
[-0.44927834, 0.26996071, 0.85590102, 0.11719942, 0.11679662,
1.18209902],
[ 0.4785346 , 0.36518358, 1.4926309 , 0.64195019, -0.22670051,
1.40534745]])
Matrix Product¶
In [170]:
# Dot product of two arrays.
np.dot?
In [171]:
np.dot(arr.T, arr)
Out[171]:
array([[ 7.70430453, -1.16826805, -4.30857517],
[-1.16826805, 2.43203161, 2.87115248],
[-4.30857517, 2.87115248, 5.02879605]])
In [172]:
# Matrices are not aligned.
# ex) (3, 6) * (6, 3) is available
# but (3, 6) * (3, 6) is not avaiable.
np.dot(arr.T, arr.T)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-172-c1f28fdc3b9b> in <module>() 2 # ex) (3, 6) * (6, 3) is available 3 # but (3, 6) * (3, 6) is not avaiable. ----> 4 np.dot(arr.T, arr.T) ValueError: matrices are not aligned
In [173]:
arr = np.arange(16).reshape((2, 2, 4))
In [174]:
arr
Out[174]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
In [175]:
arr.transpose((1, 0, 2))
Out[175]:
array([[[ 0, 1, 2, 3],
[ 8, 9, 10, 11]],
[[ 4, 5, 6, 7],
[12, 13, 14, 15]]])
In [176]:
arr.T
Out[176]:
array([[[ 0, 8],
[ 4, 12]],
[[ 1, 9],
[ 5, 13]],
[[ 2, 10],
[ 6, 14]],
[[ 3, 11],
[ 7, 15]]])
In [177]:
arr
Out[177]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
In [178]:
arr.swapaxes(1, 2)
Out[178]:
array([[[ 0, 4],
[ 1, 5],
[ 2, 6],
[ 3, 7]],
[[ 8, 12],
[ 9, 13],
[10, 14],
[11, 15]]])
In [179]:
arr.swapaxes(1, 1)
Out[179]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
In [180]:
arr.swapaxes(2, 1)
Out[180]:
array([[[ 0, 4],
[ 1, 5],
[ 2, 6],
[ 3, 7]],
[[ 8, 12],
[ 9, 13],
[10, 14],
[11, 15]]])
In [181]:
arr.swapaxes(1, 3)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-181-b561d3de0019> in <module>() ----> 1 arr.swapaxes(1, 3) ValueError: bad axis2 argument to swapaxes
In [182]:
arr.swapaxes(2, 2)
Out[182]:
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
- swapaxes도 마찬가지로 데이터를 복사하지 않고 원래 데이터에 대한 뷰를 반환
4.2 유니버설 함수¶
- ufunc 유니버설 함수는 ndarray 안에 있는 데이터 원소별로 연산을 수행하는 함수
- 유니버설 함수는 하나 이상의 스칼라 값을 받아서 하나 이상의 스칼라 결과 값을 반환하는 간단한 함수를 고속으로 수행할 수 있는 벡터화된 래퍼 함수
단항 유니버설 함수¶
- 1개 넘겨서 1개 받기
In [183]:
arr = np.arange(10)
In [184]:
np.sqrt(arr)
Out[184]:
array([ 0. , 1. , 1.41421356, 1.73205081, 2. ,
2.23606798, 2.44948974, 2.64575131, 2.82842712, 3. ])
In [185]:
arr
Out[185]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [186]:
np.exp(arr)
Out[186]:
array([ 1.00000000e+00, 2.71828183e+00, 7.38905610e+00,
2.00855369e+01, 5.45981500e+01, 1.48413159e+02,
4.03428793e+02, 1.09663316e+03, 2.98095799e+03,
8.10308393e+03])
이항 유니버설 함수¶
- add나 maximum처럼 2개의 인자를 취해서 단일 배열 반환
In [187]:
x = randn(8)
In [188]:
y = randn(8)
In [189]:
x
Out[189]:
array([-0.62685006, 0.37365086, -1.63413592, -1.44971004, -0.2559731 ,
0.5667106 , 0.64417184, 0.54335809])
In [190]:
y
Out[190]:
array([ 1.00109709, -0.23689464, -0.44450783, 0.4087495 , 0.3417837 ,
-0.0570952 , -0.0734767 , 0.27575651])
In [191]:
np.maximum(x, y)
Out[191]:
array([ 1.00109709, 0.37365086, -0.44450783, 0.4087495 , 0.3417837 ,
0.5667106 , 0.64417184, 0.54335809])
In [192]:
arr = randn(7) * 5
In [193]:
arr
Out[193]:
array([ 0.83759254, 1.70632069, -2.54516606, -8.71779902,
10.01517079, 3.96593556, 15.58338999])
In [194]:
np.modf(arr)
Out[194]:
(array([ 0.83759254, 0.70632069, -0.54516606, -0.71779902, 0.01517079,
0.96593556, 0.58338999]),
array([ 0., 1., -2., -8., 10., 3., 15.]))
In [195]:
# Return the fractional and integral parts of an array, element-wise
# 파이썬 내장 함수인 divmod의 벡터화 버전이며, modf는 분수를 받아 몫과 나머지를 함께 반환한다.
np.modf?
4.3 배열을 사용한 데이터 처리¶
- 반복문 작성하지 않고 간결한 배열연산을 통해 많은 종류의 데이터 처리 작업
- 배열연산을 사용해서 반복문을 명시적으로 제거하는 기법을 흔히 벡터화
- 순수 파이썬보다 2~3배, 많게는 수십, 수백 배까지 빠르다.
- 12장 브로드캐스팅 아주 강력한 벡터 연산 방법
In [3]:
points = np.arange(-5, 5, 0.01)
In [4]:
len(points)
Out[4]:
1000
In [5]:
xs, ys = np.meshgrid(points, points)
In [6]:
ys
Out[6]:
array([[-5. , -5. , -5. , ..., -5. , -5. , -5. ],
[-4.99, -4.99, -4.99, ..., -4.99, -4.99, -4.99],
[-4.98, -4.98, -4.98, ..., -4.98, -4.98, -4.98],
...,
[ 4.97, 4.97, 4.97, ..., 4.97, 4.97, 4.97],
[ 4.98, 4.98, 4.98, ..., 4.98, 4.98, 4.98],
[ 4.99, 4.99, 4.99, ..., 4.99, 4.99, 4.99]])
In [7]:
len(ys)
Out[7]:
1000
In [8]:
import matplotlib.pyplot as plt
In [9]:
z = np.sqrt( xs ** 2 + ys ** 2)
In [10]:
z
Out[10]:
array([[ 7.07106781, 7.06400028, 7.05693985, ..., 7.04988652,
7.05693985, 7.06400028],
[ 7.06400028, 7.05692568, 7.04985815, ..., 7.04279774,
7.04985815, 7.05692568],
[ 7.05693985, 7.04985815, 7.04278354, ..., 7.03571603,
7.04278354, 7.04985815],
...,
[ 7.04988652, 7.04279774, 7.03571603, ..., 7.0286414 ,
7.03571603, 7.04279774],
[ 7.05693985, 7.04985815, 7.04278354, ..., 7.03571603,
7.04278354, 7.04985815],
[ 7.06400028, 7.05692568, 7.04985815, ..., 7.04279774,
7.04985815, 7.05692568]])
In [29]:
plt.imshow(z, cmap=plt.cm.gray); plt.colorbar()
plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")
Out[29]:
<matplotlib.text.Text at 0x112c93290>
In [30]:
# Display an image on the axes.
# `~matplotlib.colors.Colormap`
plt.imshow?
In [13]:
plt.imshow(z, cmap=plt.cm.Blues)
# plt.cm = This module provides a large set of colormaps,
# functions for registering new colormaps and for getting a colormap by name,
# and a mixin class for adding color mapping functionality.
plt.cm?
In [14]:
plt.colorbar()
--------------------------------------------------------------------------- RuntimeError Traceback (most recent call last) <ipython-input-14-194bafcd0567> in <module>() ----> 1 plt.colorbar() /Library/Python/2.7/site-packages/matplotlib-1.4.x-py2.7-macosx-10.8-intel.egg/matplotlib/pyplot.pyc in colorbar(mappable, cax, ax, **kw) 2117 mappable = gci() 2118 if mappable is None: -> 2119 raise RuntimeError('No mappable was found to use for colorbar ' 2120 'creation. First define a mappable such as ' 2121 'an image (with imshow) or a contour set (' RuntimeError: No mappable was found to use for colorbar creation. First define a mappable such as an image (with imshow) or a contour set (with contourf).
<matplotlib.figure.Figure at 0x1087608d0>
matplotlib 주의사항¶
- Mac에서 canopy를 설치 후 삭제했더니 matplotlib가 이상한데로 꼬여 버렸음.
- 다시 canopy를 설치했더니 matplotlib path가 제대로 설정 됨.
- 이 모든 현상은 라이브러리 패스가 잘못 지정되어 생긴 일
matplotlib 삽질기¶
In [22]:
import matplotlib
In [23]:
matplotlib.matplotlib_fname()
Out[23]:
u'/Library/Python/2.7/site-packages/matplotlib-1.4.x-py2.7-macosx-10.8-intel.egg/matplotlib/mpl-data/matplotlibrc'
In [24]:
import matplotlib.pyplot as p
In [25]:
p.plot(range(20), range(20))
Out[25]:
[<matplotlib.lines.Line2D at 0x111fda590>]
In [26]:
p.show()
In [27]:
import matplotlib.rcsetup as rcsetup
print(rcsetup.all_backends)
[u'GTK', u'GTKAgg', u'GTKCairo', u'MacOSX', u'Qt4Agg', u'TkAgg', u'WX', u'WXAgg', u'CocoaAgg', u'GTK3Cairo', u'GTK3Agg', u'WebAgg', u'agg', u'cairo', u'emf', u'gdk', u'pdf', u'pgf', u'ps', u'svg', u'template']
4.3.1 배열연산으로 조건절 표현하기¶
In [31]:
xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
In [32]:
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
In [33]:
cond = np.array([True, False, True, True, False])
In [34]:
cond
Out[34]:
array([ True, False, True, True, False], dtype=bool)
순수 파이썬 문제점¶
- 큰 배열 빠르게 처리 불가
- 다차원 배열 사용 불가
In [35]:
result = [(x if c else y)
for x, y, c in zip(xarr, yarr, cond)]
In [36]:
result
Out[36]:
[1.1000000000000001, 2.2000000000000002, 1.3, 1.3999999999999999, 2.5]
np.where¶
- 아주 간결
In [37]:
result = np.where(cond, xarr, yarr)
In [38]:
result
Out[38]:
array([ 1.1, 2.2, 1.3, 1.4, 2.5])
In [6]:
arr = np.random.randn(4, 4)
In [7]:
arr
Out[7]:
array([[-0.22738371, 1.00962082, -0.73187583, 0.00972816],
[-1.02646242, -0.56073136, 0.19004584, 0.29742716],
[ 0.93338441, 1.28053344, -1.13966449, -1.16674502],
[ 1.09996334, 0.65299153, 0.29683578, 0.82472068]])
np.where¶
- 2번째, 3번째 인자는 배열이 아니라도 됨
- 둘 중 하나 혹은 둘 다 스칼라 값도 동작
- 다른 배열에 기반한 새로운 배열 생성
- np.where(조건, 참값, 거짓값)
- 조건이 True일 때 참값이 실행되며, 조건이 False일 때 거짓값이 실행
In [8]:
np.where(arr > 0, 2, -2)
Out[8]:
array([[-2, 2, -2, 2],
[-2, -2, 2, 2],
[ 2, 2, -2, -2],
[ 2, 2, 2, 2]])
In [9]:
np.where(arr > 0, 2, arr)
Out[9]:
array([[-0.22738371, 2. , -0.73187583, 2. ],
[-1.02646242, -0.56073136, 2. , 2. ],
[ 2. , 2. , -1.13966449, -1.16674502],
[ 2. , 2. , 2. , 2. ]])
2개의 불리언 배열로 조합 가능한 4가지 경우¶
result = []
for i in range(n):
if cond1[i] and cond2[i]:
result.append(0)
elif cond1[i]:
result.append(1)
elif cond2[i]:
result.append(2)
else:
result.append(3)
중첩 where¶
In [10]:
cond1 = False
cond2 = True
In [11]:
np.where(cond1 & cond2, 0,
np.where(cond1, 1,
np.where(cond2, 2, 3)))
Out[11]:
array(2)
In [12]:
result = 1 * (cond1 & -cond2) + 2 * (cond2 & -cond1) + 3 * -(cond1 | cond2)
In [13]:
result
Out[13]:
-3
In [14]:
(cond1 & -cond2)
Out[14]:
0
In [15]:
2 * (cond2 & -cond1)
Out[15]:
0
In [16]:
3 * -(cond1 | cond2)
Out[16]:
-3
4.3.2 수학 메서드와 통계 메서드¶
In [40]:
arr = np.random.randn(5, 4)
In [41]:
arr
Out[41]:
array([[-0.63678953, -0.62168485, 0.02496119, -1.59948229],
[ 1.50743692, -0.55029167, 1.36859314, -1.07390982],
[-1.07246643, 1.66566843, 0.21434562, -0.11323983],
[ 0.15297739, -0.14143016, -1.76468442, 0.59774678],
[-0.936252 , 1.1050578 , -0.11289262, -0.36526419]])
In [42]:
arr.mean()
Out[42]:
-0.11758002809084407
In [43]:
np.mean(arr)
Out[43]:
-0.11758002809084407
In [44]:
arr.sum()
Out[44]:
-2.3516005618168814
mean이나 sum 같은 함수는 선택적으로 axis 인자를 받아 해당 axis에 대한 통계 계산하고 한 차수 낮은 배열을 반환¶
In [45]:
arr.mean(axis=1)
Out[45]:
array([-0.70824887, 0.31295714, 0.17357695, -0.28884761, -0.07733775])
In [49]:
# axis 인자를 넘긴 것과 넘기지 않은 것의 결과값이 같다.
arr.sum(axis=0)
Out[49]:
array([-0.98509366, 1.45731955, -0.2696771 , -2.55414935])
In [46]:
arr.sum(0)
Out[46]:
array([-0.98509366, 1.45731955, -0.2696771 , -2.55414935])
In [50]:
arr.sum(axis=1)
Out[50]:
array([-2.83299548, 1.25182856, 0.6943078 , -1.15539042, -0.30935102])
In [47]:
arr.sum(1)
Out[47]:
array([-2.83299548, 1.25182856, 0.6943078 , -1.15539042, -0.30935102])
In [51]:
arr.sum?
cumsum과 cumprod 메서드는 중간 계산 값을 담고 있는 배열을 반환¶
In [23]:
arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
In [24]:
arr
Out[24]:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
In [25]:
# Return the cumulative sum of the elements along the given axis.
arr.cumsum?
np.cumsum?
In [26]:
# 세로로 더하기
# 0은 column
arr.cumsum(0)
Out[26]:
array([[ 0, 1, 2],
[ 3, 5, 7],
[ 9, 12, 15]])
In [27]:
# 가로로 곱하기
# 1은 row
arr.cumprod(1)
Out[27]:
array([[ 0, 0, 0],
[ 3, 12, 60],
[ 6, 42, 336]])
In [28]:
arr.cumprod(0)
Out[28]:
array([[ 0, 1, 2],
[ 0, 4, 10],
[ 0, 28, 80]])
4.3.3 불리언 배열을 위한 메서드¶
- 앞의 메서드에서 불리언 값은 1(True), 0(False)으로 취급
- 따라서 불리언 배열에 대한 sum 메서드를 실행하면 True인 원소의 개수를 반환
In [29]:
arr = randn(100)
In [30]:
(arr > 0).sum()
Out[30]:
51
In [31]:
arr
Out[31]:
array([ -3.23981577e-01, 8.28471364e-01, -2.28531600e-01,
7.81542231e-01, 7.65533575e-01, -2.30715331e-01,
-7.90815091e-01, -1.51521142e+00, 9.02727281e-01,
-7.96393829e-01, -1.48280372e+00, 2.14388106e+00,
1.22935275e+00, 9.08580945e-01, -3.17050232e+00,
-3.19110230e-01, -7.02813098e-01, -1.33922041e-01,
3.23867223e-01, -5.41750422e-01, 7.19855447e-01,
1.53577806e+00, -5.33780671e-01, -3.06636492e-01,
2.22113202e+00, 4.74560650e-01, 5.32113570e-02,
4.08017943e-01, -1.34531648e+00, -1.04639008e+00,
-3.64408292e-01, -5.69251804e-01, -3.04232587e-01,
-9.34929999e-01, -1.22969197e+00, -2.70477054e-01,
8.81988283e-01, 6.38303932e-02, -1.84218189e-01,
-9.37450358e-02, 1.43859306e+00, 2.28406301e-01,
-3.17556858e-01, -5.85153395e-01, -1.44669215e-02,
1.57324249e-03, 1.18927149e+00, 6.92504354e-01,
3.17347370e-01, -6.44348559e-01, -6.87929676e-01,
1.06098783e+00, 3.41548590e-01, 9.72900494e-01,
-1.02978994e+00, 2.06980280e+00, 2.35221308e+00,
-1.42752411e+00, 1.44456522e+00, 5.16166548e-01,
7.78068763e-03, -1.01988745e+00, -1.34798508e+00,
5.30907112e-01, 1.32554042e+00, -1.14103792e+00,
-1.35376884e+00, -1.65932729e+00, -6.92428198e-01,
-3.76567403e-01, 4.58025510e-01, 1.70369468e+00,
-6.22888746e-01, -8.00883755e-01, -3.91857714e-01,
2.04939933e-01, 8.23046230e-01, 3.93639430e-01,
2.08406878e-01, -5.24268456e-02, 1.15119295e+00,
8.63978530e-01, 4.14495650e-01, -2.29354833e+00,
9.70715934e-01, 6.35288166e-01, 1.19324100e+00,
2.40637663e-01, 8.95268524e-01, 7.65764883e-01,
-1.96315521e-02, 9.32871736e-02, -4.54868527e-01,
-3.47747570e-01, -1.68156608e+00, -6.87830148e-01,
4.88761296e-02, 1.46764057e+00, -1.85496551e+00,
8.81609302e-01])
- any: 하나 이상의 True값 검사
- all: 모든 원소가 True인지 검사
In [32]:
bools = np.array([False, False, True, False])
In [33]:
bools.any()
Out[33]:
True
In [34]:
bools.all()
Out[34]:
False
In [35]:
bools = np.array([True, True, True, True])
In [36]:
bools.any()
Out[36]:
True
In [37]:
bools.all()
Out[37]:
True
In [52]:
# 0만 아니면 True
# 불리언 배열이 아니어도 동작
arr.any()
Out[52]:
True
In [53]:
arr.all()
Out[53]:
True
4.3.4 정렬¶
In [38]:
arr = np.random.randn(8)
In [39]:
arr
Out[39]:
array([-1.29426519, 0.14954979, 0.12856676, 0.98922155, 0.51783933,
0.08145027, 1.34539112, -1.5399891 ])
In [40]:
arr.sort()
In [41]:
arr
Out[41]:
array([-1.5399891 , -1.29426519, 0.08145027, 0.12856676, 0.14954979,
0.51783933, 0.98922155, 1.34539112])
다차원 배열의 정렬은 sort 메서드에 넘긴 축의 값에 따라 1차원 부분 정렬¶
In [65]:
arr = randn(5, 3)
In [66]:
arr
Out[66]:
array([[-0.64670479, -0.61555955, 0.46512793],
[ 2.45875721, 0.30812392, -2.07493597],
[-1.93571858, 0.17247077, -1.41579888],
[-0.67120369, -0.6021445 , -0.47781563],
[-0.45793084, 0.21905382, -0.39171426]])
In [67]:
# row sort
arr.sort(1)
In [68]:
arr
Out[68]:
array([[-0.64670479, -0.61555955, 0.46512793],
[-2.07493597, 0.30812392, 2.45875721],
[-1.93571858, -1.41579888, 0.17247077],
[-0.67120369, -0.6021445 , -0.47781563],
[-0.45793084, -0.39171426, 0.21905382]])
In [69]:
# column sort
arr.sort(0)
In [70]:
arr
Out[70]:
array([[-2.07493597, -1.41579888, -0.47781563],
[-1.93571858, -0.61555955, 0.17247077],
[-0.67120369, -0.6021445 , 0.21905382],
[-0.64670479, -0.39171426, 0.46512793],
[-0.45793084, 0.30812392, 2.45875721]])
In [63]:
# row sort == arr.sort(1)
arr.sort()
In [64]:
arr
Out[64]:
array([[ -2.04858580e+00, -1.17193396e+00, 1.32127939e-01],
[ -1.47844830e+00, -7.15492360e-01, 4.59896618e-01],
[ -1.28286231e+00, -5.63080466e-01, 9.40448815e-01],
[ -4.58628453e-01, 2.07478453e-01, 1.01902093e+00],
[ 1.35560421e-03, 5.62354352e-01, 2.26660736e+00]])
- 배열의 분위수가 뭐지??
- 우선 배열을 정렬한 후에 특정 부위의 값을 선택
In [71]:
large_arr = randn(1000)
In [72]:
large_arr
Out[72]:
array([ -4.29508395e-01, -1.36200493e+00, 4.95139033e-01,
4.00047918e-01, -4.60536691e-01, -2.12402831e-01,
-9.06761307e-01, -4.58112023e-01, -1.89420493e-01,
5.88505389e-01, 1.54879159e+00, 1.94523033e+00,
-1.10438705e+00, -2.00339405e-01, 4.40621245e-01,
-6.73178500e-01, -8.11953485e-01, -5.02833922e-01,
1.10495039e-02, 5.13181343e-02, -3.05642333e-01,
2.99366103e-01, 4.45071326e-01, -1.57670159e+00,
2.41872881e-01, -3.03246248e-01, -2.69677731e+00,
-1.44213262e-01, 4.95691564e-01, 1.47744247e+00,
2.47281292e+00, -5.58374769e-01, -5.48004074e-01,
1.47523041e+00, -1.42483309e+00, 6.88823001e-01,
-2.32917572e-01, 7.93444413e-01, -6.87697145e-01,
9.60635202e-02, -9.06197430e-01, 4.54872711e-02,
1.79188637e-01, 8.69338847e-01, 9.68360788e-01,
-6.70549697e-02, -5.37811590e-01, 2.51251245e-01,
1.32979384e+00, -9.09943189e-01, 1.61039789e+00,
-6.34625947e-01, -1.84791886e-01, -3.48497830e-02,
4.63259730e-01, 2.30507960e-01, 1.22105211e-01,
1.13231687e+00, 5.09248157e-01, -1.00935787e+00,
-6.99156259e-01, 6.92762353e-01, 1.07228328e+00,
2.63261095e-01, -4.61268649e-01, -1.21295079e-02,
1.79632812e+00, -9.65936552e-02, -4.08273329e-01,
-3.00067241e-01, -1.10413596e+00, -7.83237493e-01,
-2.22909413e-01, 1.03801629e+00, -2.09290504e-01,
-8.62668264e-01, 7.14459623e-01, -1.73361316e-01,
1.07723630e+00, 2.23126720e-01, 3.72277818e-01,
1.17767020e+00, -7.58352226e-01, -5.02207697e-01,
-3.60673507e-01, -2.23833716e+00, -1.13628708e+00,
6.73188450e-01, -7.92321106e-01, 5.21635062e-01,
5.44919937e-01, -1.47894173e+00, 5.16450627e-01,
1.19299429e+00, 1.43446337e-01, -9.28864070e-01,
-8.76316357e-01, 3.73573015e-01, -8.04425224e-01,
5.24236617e-01, -9.08890292e-01, -6.34736133e-01,
1.34623284e+00, -9.29476165e-01, 1.91166008e+00,
2.60012822e-01, -9.89962582e-01, -9.99338803e-02,
-6.12590213e-01, -5.95791161e-01, -8.59075224e-01,
-5.84090801e-02, -1.71179541e+00, -1.81882533e+00,
-1.67316878e+00, -2.03148775e+00, -3.99763191e-01,
1.02217992e-01, -7.63591358e-01, 6.27405302e-01,
-6.48137038e-01, 8.02724324e-01, 7.29054021e-01,
8.45711411e-01, -6.27447749e-01, 9.68040204e-01,
-1.20479407e+00, -6.84909828e-01, -1.32033351e+00,
-6.74435778e-01, -2.03561662e-01, -1.29237414e+00,
2.33811627e+00, 1.83776057e+00, 1.11556763e-01,
-1.68339529e-01, 6.56059095e-02, 2.65158367e-01,
2.66335457e+00, 7.03558990e-01, -2.69842939e-01,
-7.02982583e-01, -4.74552810e-01, 2.34925495e-02,
-1.37147570e+00, 1.58684535e-02, -5.67087413e-01,
3.92901939e-03, -6.60641701e-01, 8.90034849e-01,
2.44293395e+00, -1.88248419e+00, 1.14142368e-02,
6.25897745e-02, 7.56576704e-01, 3.29939470e-01,
2.20075664e-01, 9.79923464e-01, 5.32580306e-02,
-6.75553770e-01, 1.35057852e+00, -4.50302535e-01,
1.68233640e+00, 2.79554382e-01, 5.38503551e-02,
3.56232141e-01, -4.94321902e-01, -8.86454436e-01,
1.44427854e+00, -2.02695546e-01, -1.39553176e-03,
4.24066238e-01, -9.31776849e-01, -4.03702618e-01,
1.24251395e+00, 1.80955269e+00, -5.71768210e-01,
2.39689099e-01, 1.63196605e+00, 8.07407676e-01,
1.53420395e+00, 1.42179316e+00, 2.27843853e+00,
8.03832220e-01, -1.85708357e-01, -3.84618866e-01,
-9.73839901e-01, -6.40194272e-01, -1.11862402e+00,
-7.72480188e-01, -1.36718409e+00, -1.07401935e+00,
1.59331230e+00, 8.72952920e-01, 1.42536690e-01,
6.60584412e-01, 3.60638582e-01, 2.30646928e-03,
-9.49153500e-01, 7.48317714e-02, 1.17793492e+00,
-9.43259531e-01, -1.63496881e+00, -1.40158392e+00,
-1.88909547e+00, 1.04035212e+00, -7.34070917e-02,
2.36539211e-01, 4.96466550e-01, 1.06531880e-01,
7.68190763e-01, 1.62263596e+00, -2.16199725e-01,
5.50272846e-01, -2.22164026e+00, -9.05457240e-01,
-8.25657951e-01, -2.35960958e-02, 1.57733609e+00,
-8.42690033e-01, 1.01029149e+00, -3.89522140e-01,
2.24196358e+00, 1.40676970e+00, -7.23178560e-01,
3.77128096e-01, 1.76395097e-01, -1.20027683e+00,
1.68082983e+00, 9.36354944e-01, 3.28059562e-01,
1.11334640e+00, -5.50203604e-01, -7.28600779e-01,
3.77103373e-01, -7.55643567e-01, -8.83098102e-02,
3.54852365e-01, -7.71534792e-01, -6.92987535e-03,
-4.46883339e-01, -1.13253883e+00, -1.74730807e+00,
-2.90835798e-01, -2.64816142e-01, -1.12801293e+00,
8.87401625e-01, -2.02248839e-01, -1.07404348e+00,
-7.64295571e-01, -9.13545357e-01, -1.52115886e+00,
8.35135084e-01, -2.63538561e-01, 2.91623652e-01,
-8.77624702e-01, -4.12720393e-02, 8.68549898e-01,
2.87465694e-01, 6.16241466e-02, 2.49722884e-01,
-3.57049160e-01, 8.80203727e-01, 7.53353403e-01,
-2.64328904e-01, 9.55666238e-01, 2.39277732e-01,
5.13352635e-02, 1.33661969e-01, 8.29789594e-02,
2.83774160e-01, -1.43584702e+00, -9.07379596e-02,
8.29396005e-01, -7.23347532e-01, 1.29933332e+00,
3.16552961e-01, -2.90766277e-01, 1.02591928e+00,
2.50048040e-01, 1.62370749e-01, 5.84664973e-01,
-3.78158131e-01, 1.81228938e+00, -8.33741222e-01,
-1.51988731e+00, -2.44823924e-01, -6.12378686e-01,
-1.91732894e+00, -6.30232869e-01, 3.16687225e-01,
1.15717681e+00, -7.12191015e-01, 6.42571088e-01,
-1.49411865e+00, -8.70006521e-02, -6.10247820e-01,
-1.91302577e-01, 1.35799894e+00, -1.95041755e+00,
-3.51379530e-01, 3.71495503e-01, -2.00287859e+00,
1.41282095e+00, 1.85591212e+00, -8.01882224e-01,
-6.98175787e-04, -3.05526912e-01, -3.90661627e-01,
-1.73071827e+00, -8.76039187e-01, -1.79323245e+00,
-4.51736762e-01, 9.80646954e-01, 9.38154844e-02,
5.11654704e-01, 6.15532721e-01, -1.14700052e-01,
4.85996352e-01, 7.51639064e-02, 5.35474476e-01,
-9.88417001e-02, -8.33385972e-01, -7.31626734e-01,
-6.08904215e-01, -9.21113698e-01, -2.13082227e-01,
7.09102578e-01, -5.41494507e-01, 3.05555972e-01,
9.55230292e-02, -3.69808547e-01, 1.92172171e+00,
-5.58850774e-01, -1.10528092e+00, 4.24916854e-01,
-8.72818054e-02, 6.21175240e-01, 8.25144871e-01,
-9.61513023e-01, -1.62155561e+00, 3.47142814e-02,
-1.69636901e-01, 2.47938480e+00, 4.80396091e-01,
1.24418065e+00, 2.45412578e+00, -3.43163489e-02,
3.62465604e-01, 2.42711151e-01, -4.74011779e-01,
1.16674977e-01, 8.97977547e-01, -2.37991927e+00,
2.21798841e-01, -1.10939751e+00, -1.11119638e+00,
2.72332092e-01, -1.45628595e+00, 3.20351615e-02,
4.07968884e-01, 1.01627667e+00, -2.58984149e-02,
-2.35832288e+00, -2.31968076e-02, -2.40170151e-01,
1.62098680e+00, -5.75439430e-01, -6.09768274e-01,
-1.21109933e+00, -7.73292408e-01, -6.22048657e-01,
-4.40869265e-01, 5.53117253e-01, 8.57001000e-01,
-8.79901838e-01, 7.15984218e-01, -1.02821296e+00,
1.78075394e-01, -8.04159948e-01, 1.17595832e+00,
5.28495647e-01, 5.80977393e-02, 1.33655351e+00,
-4.06637081e-01, -2.05456235e+00, -6.52023036e-01,
1.45482527e+00, 1.73943375e+00, 6.28849148e-01,
-1.64283521e+00, 2.12507256e-01, 4.63925360e-01,
-1.16238730e+00, 7.20037298e-01, -4.03416456e-01,
6.54250059e-01, 6.47219824e-01, -2.20080147e+00,
-9.97843974e-02, -1.80832610e-01, -1.10556494e-01,
2.60359081e-01, 2.40179505e+00, 6.22851851e-02,
-2.13086313e+00, -1.29896815e+00, -4.18185758e-01,
6.10711929e-01, 7.16393388e-01, -1.42035186e+00,
9.40327241e-01, 6.76687404e-01, 3.50961733e-01,
-9.77133508e-01, -1.15802802e+00, 6.88848230e-01,
4.72212304e-01, -3.23382923e-01, -1.36623347e-01,
-1.55208294e-01, -7.29429389e-01, 6.13177446e-02,
3.13487245e-01, -3.70044577e-02, -9.82971433e-01,
-6.14031485e-01, -1.11019736e+00, 3.28132639e-01,
1.90203360e+00, 1.37839177e+00, 5.04850922e-01,
1.55736851e+00, -4.80397363e-01, 1.93732087e+00,
7.77678537e-01, -4.20329928e-01, 3.36142107e-01,
-1.62302623e-01, 5.44727047e-01, 7.33916407e-01,
1.35574227e+00, -3.41454302e-02, 2.52098960e+00,
1.33278528e+00, 4.48731345e-01, 1.55389587e+00,
-6.80416636e-01, -1.10077282e+00, -1.39536547e+00,
4.33739200e-01, 1.38480391e+00, 6.54759422e-01,
-1.21447063e-01, -4.63864933e-01, 2.77641308e-01,
1.40542176e+00, -1.79853054e-01, -2.42234125e+00,
-5.99723068e-01, 9.36188901e-01, 5.78450429e-01,
7.05092627e-03, 1.01614086e+00, -6.24630235e-01,
1.17857022e+00, -3.02260214e-01, 1.07950240e+00,
-6.33355327e-01, 1.33641767e-02, 7.19690584e-02,
-1.01628323e+00, -1.12636781e+00, -8.89987133e-02,
5.65151389e-01, 2.06625009e-01, 7.43459540e-01,
1.99156262e+00, 1.48835038e+00, -2.50286866e-01,
-7.27403363e-01, -1.24200346e+00, -3.06306850e+00,
-1.80778446e+00, -3.33644156e-01, -1.43404006e+00,
-2.15953652e+00, 3.76675514e-01, 9.79053581e-01,
5.43741044e-01, 2.21124759e-01, 5.60466563e-01,
-1.91870650e-01, -1.22448926e+00, 1.78564790e-01,
-6.65430848e-01, 4.21908324e-01, 1.85672416e-01,
-3.41986446e-01, 9.89644593e-01, 1.26244858e-01,
6.88194354e-01, 1.25838367e-01, 1.25238296e-01,
6.17139237e-01, -4.75649906e-01, -6.93480958e-01,
1.18864588e+00, 2.01864890e-01, 7.90335342e-01,
-1.28902614e-01, 4.58601573e-01, -3.80931197e-01,
-4.08259872e-01, 1.21775430e+00, 1.61416839e-01,
-5.96590011e-01, 6.96609989e-01, -1.44672347e+00,
-1.33769274e+00, 9.22626621e-01, -3.89547785e-01,
-1.76797055e-01, 2.46675920e-02, 4.40859374e-01,
-2.58293339e-01, 1.85961612e+00, -8.76651861e-01,
1.72902552e+00, 7.80398510e-01, -4.87105846e-01,
7.17534644e-01, 3.44022541e-01, 5.92497233e-01,
-4.29391939e-01, 7.47938330e-01, -1.17035423e+00,
-1.10064561e+00, 6.09757025e-01, -1.25808772e+00,
-8.52684024e-01, 2.58162718e-01, -1.33686422e+00,
1.10106603e+00, 2.66032633e+00, 1.87994318e-01,
3.49947032e-02, 1.85858430e-01, -7.24792358e-01,
2.64808895e+00, 2.45444623e-01, -1.34336055e+00,
-7.72446599e-01, -1.51602891e+00, -6.50233076e-01,
-1.56844751e+00, -1.05062346e+00, -2.86973260e-01,
7.09962361e-02, -5.39234173e-01, -2.82752854e-01,
2.15517546e-01, -7.03144813e-01, 1.18600101e+00,
-7.00184252e-01, -8.32132624e-01, -3.78653229e-02,
-1.88972355e+00, -6.38183518e-01, -4.65591527e-02,
-7.61785553e-01, 1.46353111e+00, 7.79171044e-01,
-1.46324939e-01, 7.29982555e-02, 1.15421810e+00,
-2.02005208e+00, 2.11417505e+00, -6.42565116e-01,
3.35868153e+00, 6.80035733e-01, -1.26182384e+00,
-9.75333995e-01, 5.67174934e-01, 2.39942339e-01,
-5.03370558e-01, 2.08472782e-01, 4.14567129e-01,
2.18867297e+00, 1.94173622e+00, 5.10886461e-02,
-1.50998301e-01, 2.77117503e+00, 7.48789039e-01,
-4.15478038e-01, -1.13996536e+00, 1.51877559e-01,
-4.87385112e-02, 4.08771408e-01, -9.42060459e-01,
6.88676421e-01, -1.49426942e+00, -1.00135323e+00,
1.52729803e+00, -4.67584671e-01, -1.61988635e+00,
-1.10527813e+00, 1.06891791e-01, -6.54341299e-01,
9.41014842e-01, 2.28082939e+00, -8.45188292e-01,
-8.26822509e-01, 2.13322954e-02, 4.10757063e-01,
-1.47180689e+00, -7.74095839e-01, 1.36211756e-01,
2.75901949e-01, 1.81900254e+00, -2.33384892e+00,
-1.29414249e+00, -4.50153119e-01, -2.05601179e-01,
1.87965751e-01, -8.17752911e-01, 1.07559648e+00,
-2.38538151e-01, 2.13688230e-01, 1.91924925e+00,
-2.49130302e-02, 7.77207484e-01, -2.84147970e-01,
-7.87791709e-01, -2.85567202e-02, -1.00152846e+00,
-1.11487337e+00, -3.34068438e-01, -1.10442514e+00,
-3.10453464e-01, 2.20479749e-01, 4.92794308e-01,
-8.61866176e-01, 1.22720947e+00, 2.61509433e+00,
7.23622094e-01, 8.74436635e-01, -1.40880195e+00,
-1.43649743e-01, 1.78329843e+00, 3.00309866e-01,
-1.26393003e+00, 3.38722686e-01, -9.79864530e-02,
-1.13247094e+00, -2.86781448e+00, -1.64946873e+00,
-4.05287624e-01, -5.45433262e-01, -1.95246018e-01,
2.39543750e-01, -4.98774227e-01, -1.21814350e-02,
-5.06007174e-01, 7.68324470e-01, -2.12053662e+00,
-8.22306466e-01, -6.24000188e-01, -7.76546717e-01,
-1.23826293e+00, -2.51329803e-01, 2.00795361e-01,
-1.81302408e+00, -3.00796763e-01, 9.77384496e-01,
-5.17927752e-01, 4.42469682e-01, 2.56194557e-01,
1.11326882e+00, -8.73586836e-02, 7.20254122e-01,
-1.55356457e+00, -2.83373537e-01, -5.44600031e-01,
-1.77836190e-01, -6.97885512e-01, 2.93182988e-01,
2.23250396e-01, -2.00184656e-01, 4.53104013e-01,
-8.99839543e-01, -2.63440759e-01, 1.73555024e+00,
-8.65562209e-01, 8.87114990e-02, 1.49192944e+00,
4.92897939e-01, 5.84869831e-01, 1.41941060e-01,
5.71834441e-01, -1.17015462e+00, 8.82357243e-01,
-2.74077065e-01, -3.54206587e-01, 7.96728656e-01,
-1.13585621e+00, -2.81575824e-01, 1.67728342e+00,
-9.97413801e-01, -1.56432424e+00, 1.05543157e+00,
-1.85721071e-01, -1.08844987e+00, 2.30777471e+00,
-3.98923030e-01, -1.52689531e+00, -1.30988472e-01,
7.48857114e-01, -3.16926160e-01, -4.01547413e-01,
2.61188599e+00, -7.87303611e-01, -8.64018266e-02,
1.48648294e+00, 1.98419381e-01, -1.47456655e+00,
-7.32414736e-01, 3.46203803e-01, -1.85189266e+00,
7.82567139e-01, 6.82734123e-01, -9.44323685e-01,
-1.87257316e-01, -1.06771291e+00, 1.08064620e+00,
-7.66393733e-02, 9.80222553e-01, -1.47727385e+00,
4.08454658e-01, 1.89668089e+00, -1.88790295e-02,
-6.58958311e-02, 4.73879817e-01, -1.28187179e-01,
4.34665769e-01, 2.50449352e-01, 1.63058445e-01,
-2.03782588e+00, 8.63814259e-01, -7.42734565e-01,
-1.22266620e-01, -7.04399843e-01, 1.50658853e-01,
5.12510391e-01, 1.19559712e+00, -4.06416997e-01,
3.42040589e-01, 3.65108960e-01, -4.74748622e-01,
2.24683364e-01, 2.40113935e+00, -9.24880883e-01,
1.62616343e+00, 4.60089251e-01, 9.57186419e-01,
-1.18852773e+00, 4.02634261e-01, -8.94951593e-02,
-1.58434473e+00, -6.33301119e-01, 1.63076520e+00,
7.02202941e-01, 4.04983214e-01, -4.69827009e-01,
-1.17511971e+00, -1.06989636e+00, 1.72591774e+00,
1.29562104e+00, -1.26193161e+00, 1.79053389e+00,
-1.10715627e+00, 3.24061122e-01, 1.38537009e-01,
1.51724631e+00, 1.62207931e-01, 1.41439807e+00,
-1.27736321e+00, -2.16237283e+00, 9.65604403e-02,
-1.86342044e-02, 4.61363769e-01, -3.08867090e-01,
-1.69491323e-01, -9.59122944e-01, -1.56478776e+00,
7.95927622e-01, -1.02158175e+00, -1.71476029e+00,
-1.61932435e+00, -2.01502285e+00, -4.49689106e-01,
-2.34354770e+00, -3.30105942e-01, -7.32951375e-03,
-8.36623505e-02, 4.26072922e-01, 2.19353979e-01,
1.22479187e+00, 1.19254879e+00, -8.04625281e-01,
4.11856826e-01, 2.39721580e+00, -1.59760131e+00,
9.04523377e-01, 3.94967156e-01, 7.12154848e-01,
-4.65484065e-02, -4.98318008e-02, -1.00875851e-01,
7.54675058e-01, 6.28805068e-01, -9.09272660e-01,
-2.34259096e+00, 1.57635169e+00, -1.25166398e+00,
6.78547266e-02, 1.25630775e+00, -1.93908789e-01,
-6.00056825e-01, -2.91714609e-01, 1.55098025e-01,
9.05506330e-01, -3.92652143e-01, 4.85622749e-01,
1.90143683e+00, 1.01600482e+00, -5.69249135e-01,
-3.19852665e-02, -5.34632662e-01, -4.47829818e-01,
6.37598585e-01, -1.04838837e-01, -1.75949403e+00,
-6.64564117e-01, -5.23301481e-01, 1.20324045e+00,
5.59718853e-01, 1.43650472e+00, 2.31763710e-01,
3.99944809e-01, -4.80131315e-01, 2.46383893e-01,
-7.58240568e-01, -3.95459908e-01, 4.74421627e-02,
1.04142021e+00, -1.85600715e+00, -5.20732886e-01,
-7.65829831e-01, 3.03178443e-01, 2.40769604e-01,
-9.52693138e-01, -2.53175152e-01, -3.61232252e-01,
6.70420510e-01, -6.91753453e-01, -4.69661353e-01,
8.32496698e-01, 5.95664666e-01, 8.60709015e-01,
-6.00647042e-01, -3.92609128e-01, -1.15103600e+00,
8.80570781e-01, 5.72100646e-01, -6.43346289e-01,
1.11319831e+00, 1.45815845e+00, -3.57908899e-01,
2.16407885e-02, 3.09683660e-01, 2.10969740e+00,
-4.86025303e-01, 2.06043707e+00, -2.27583903e-01,
3.37812391e-01, -8.66030298e-01, 5.31815471e-01,
-3.04041167e-01, 7.92199769e-01, -1.80331770e+00,
-1.96914402e+00, -1.38389701e+00, 2.17982344e-01,
4.82257069e-01, 1.35463083e+00, -5.62271966e-01,
9.90198843e-01, -2.35984141e-01, -5.27349929e-01,
-4.56075258e-02, -5.82049390e-01, -5.36539610e-01,
1.92096253e-01, -1.98882554e-01, 6.77706899e-01,
-2.17204851e-01, -4.84412234e-01, 6.25187882e-02,
-1.52047818e-01, -1.61634677e-01, -3.06279413e-01,
-1.41152153e+00, -1.09372297e+00, -1.44265009e+00,
-2.53147106e-01, -8.89935140e-02, 4.10404084e-01,
-6.07883105e-01, 3.18176412e-01, -7.48708208e-01,
-6.44991708e-01, -4.65583587e-01, 5.13852326e-01,
-1.79461424e-01, 1.40860971e+00, 3.85209228e-01,
-1.93957680e+00, 7.32086042e-01, 3.25055708e-01,
-3.20540178e-01, 1.09525185e-01, 3.55497256e-01,
-2.44301493e-01, 6.30860391e-02, -2.00332466e+00,
7.13372324e-01, -1.89384649e+00, 1.09057189e+00,
-5.84535175e-01, 9.55037730e-01, 8.08094003e-01,
7.21255488e-01, 8.70521349e-01, -1.07160654e+00,
3.68817734e-01, -1.20169678e+00, -1.86614879e+00,
1.17480438e+00, 1.34851916e+00, -3.33241044e-01,
-8.25865193e-01, -1.00180734e-01, 4.35692098e-01,
-1.05751208e+00, -8.97325897e-01, -8.94678084e-01,
3.26291177e-01, 1.55247072e+00, 1.12318897e+00,
4.34361064e-01, 6.19221545e-01, -4.02797021e-01,
1.13527092e+00, -1.30091498e+00, 1.08391983e+00,
-8.23290340e-01, -1.53585005e+00, -1.00746423e-01,
3.39686865e-01, 5.54838806e-01, -1.01445556e+00,
-1.14410079e+00, 1.10134860e+00, 3.27000521e-01,
5.82213994e-01, 9.56807182e-01, -3.20736912e-02,
1.99519577e-01, 2.96282262e-01, 2.24547095e-01,
-8.67865620e-01, -8.02078530e-01, -2.53432136e+00,
1.21763219e+00, -1.60727166e+00, 5.67089675e-02,
-1.07681000e+00, -1.58144448e+00, 1.41052682e+00,
5.57275658e-01, 2.73073742e-01, -5.91073898e-01,
-5.74964650e-02, 7.13222633e-01, 7.38507361e-02,
-7.10852978e-01, 1.52470350e+00, 1.79084849e-01,
6.53579705e-01])
In [73]:
large_arr.sort()
In [75]:
int(0.05 * len(large_arr))
Out[75]:
50
In [76]:
large_arr[int(0.05 * len(large_arr))]
Out[76]:
-1.6198863490901547
In [77]:
large_arr[50]
Out[77]:
-1.6198863490901547
4.3.5 집합 함수¶
In [52]:
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
In [53]:
np.unique(names)
Out[53]:
array(['Bob', 'Joe', 'Will'],
dtype='|S4')
In [54]:
ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
In [55]:
np.unique(ints)
Out[55]:
array([1, 2, 3, 4])
순수 파이썬 구현¶
In [56]:
sorted(set(names))
Out[56]:
['Bob', 'Joe', 'Will']
In [57]:
%timeit np.unique(names)
100000 loops, best of 3: 11 µs per loop
In [58]:
%timeit sorted(set(names))
100000 loops, best of 3: 2.4 µs per loop
In [59]:
values = np.array([6, 0, 0, 3, 2, 5, 6])
np.in1d¶
- 2개의 배열을 인자로 받아 첫 번째 배열의 각 ㅇ원소가 두 번째 배열의 원소를 포함하는지를 나타내는 불리언 배열을 반환
In [60]:
# Test whether each element of a 1-D array is also present in a second array.
# Returns a boolean array the same length as 'ar1' that is True
# where an element of `ar1` is in `ar2` and False otherwise.
# in 1 dictionary?
np.in1d?
In [61]:
np.in1d(values, [2, 3, 6])
Out[61]:
array([ True, False, False, True, True, False, True], dtype=bool)
배열 집합 연산¶
| Method | Comment |
|---|---|
| unique(x) | 배열 x에서 중복된 원소를 제거한 후 정렬하여 반환한다. |
| intersect1d(x, y) | 배열 x와 y에 공통적으로 존재하는 원소를 정렬하여 반환한다. |
| union1d(x, y) | 두 배열의 합집합을 반환한다. |
| in1d(x, y) | x의 원소 중 y의 원소를 포함하는지를 나타내는 불리언 배열을 반환한다. |
| setdiff1d(x, y) | x와 y의 차집합을 반환한다. |
| setxor1d(x, y) | 한 배열에는 포함되지만 두 배열 모두에는 포함되지 않는 원소들의 집합인 대칭차집합을 반환한다. |
4.4 배열의 파일 입∙출력¶
- NumPy는 디스크에서 텍스트나 바이너리 형식의 파일로부터 데이터를 불러오거나 저장 가능
4.4.1 배열을 바이너리 형식으로 디스크에 저장하기¶
In [62]:
arr = np.arange(10)
In [63]:
# add file extension '.npy'
np.save('some_array', arr)
In [64]:
!ls
2014년 5월 대안언어 축제 정모 후기.ipynb AMINOCIDS.ipynb CodeAcademy_Python.ipynb Crawler_qna.ipynb Hacker Challenge - Programming.ipynb Learn to Program(Coursera).ipynb Module 1_Python Language Essentials.ipynb Module 2_System Programming.ipynb Multiprocessing.ipynb NewDirectory Notebook_자동화.ipynb Part 3 - Plotting with Matplotlib.ipynb Performance_MNR.xml Python 3 Object Oriented Programming.ipynb Requests test.ipynb Unpythonic Python.ipynb Untitled0.ipynb Untitled1.ipynb Untitled2.ipynb Untitled3.ipynb Untitled4.ipynb Untitled5.ipynb Untitled6.ipynb Untitled7.ipynb array_archive.npz array_ex.txt ch00_Feeling.ipynb ch00_Python for Data Analysis - link.ipynb ch01_Preliminaries.ipynb ch02 ch02_Introduction Examples.ipynb ch02_w.py ch03 ch03_Introduction IPython.ipynb ch04_Numpy.ipynb ch05_Pandas.ipynb ch06 ch06_Data loading.ipynb ch07 ch07_Data loading_again.ipynb ch07_Data_prepare_fixing_transform_merge.ipynb ch08 ch09 ch11 ch13 cover.jpg data.csv debugger.csv ex1.csv foo.py foo.py.prof foo.pyc ghostdriver.log images ipython_log.py ipython_log.py.001~ ipython_script_test.py lambda_sorted.ipynb massspec mydata.csv mysql_test.ipynb plfda_ch07.ipynb rpy2.ipynb some_array.npy spse.txt spse2.txt test_filename text.txt
In [65]:
np.load('some_array.npy')
Out[65]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [66]:
np.savez('array_archive.npz', a=arr, b=arr)
In [67]:
arch = np.load('array_archive.npz')
In [68]:
arch['b']
Out[68]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [69]:
arch['a']
Out[69]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [70]:
a = randn(10)
In [71]:
a
Out[71]:
array([ 1.44432567, 0.98120731, 0.11043039, 1.39949054, 0.71862609,
-1.66603304, 0.32605269, 0.02229856, 0.04036821, -0.53039062])
4.4.2 텍스트 파일 불러오기와 저장하기¶
In [72]:
%%writefile array_ex.txt
2.23342715,-0.37376633,-1.05142871
-0.57247149,-1.35777871,0.28676036
-0.01042671,-0.0211314,-0.72049352
Overwriting array_ex.txt
In [73]:
!cat array_ex.txt
2.23342715,-0.37376633,-1.05142871 -0.57247149,-1.35777871,0.28676036 -0.01042671,-0.0211314,-0.72049352
In [74]:
arr = np.loadtxt('array_ex.txt', delimiter=',')
In [75]:
arr
Out[75]:
array([[ 2.23342715, -0.37376633, -1.05142871],
[-0.57247149, -1.35777871, 0.28676036],
[-0.01042671, -0.0211314 , -0.72049352]])
- np.savetxt: np.loadtxt와 반대로 배열을 파일로 저장
- genfromtxt: loadtxt와 유사하지만 구조화된 배열과 누락된 데이터 처리를 위해 설계
파일 입∙출력에 대한 자세한 내용, 특히 스프레드시트 형식의 데이터 입∙출력에 대한 내용은 다음 장에서 pandas와 DataFrame객체와 함께 살펴보겠다.¶
4.5 선형대수¶
- 행렬의 곱셈, 분할, 행렬식, 정사각 행렬 수학 같은 선형대수는 배열을 다루는 라이브러리에서 중요한 부분
- MATLAB 같은 다른 언어와 달리 2개의 2차원 배열을 * 연산자로 곱하는 건 행렬 곱셈이 아니라 대응하는 각각의 원소의 곱을 계산하는 것
- 행렬 곱셈은 배열 메서드이자 numpy 네임스페이스 안에 있는 함수인 dot 함수를 사용해서 계산
In [78]:
x = np.array([[1., 2., 3.], [4., 5., 6.]])
In [79]:
y = np.array([[6., 23.], [-1, 7], [8, 9]])
In [80]:
x
Out[80]:
array([[ 1., 2., 3.],
[ 4., 5., 6.]])
In [93]:
x.shape
Out[93]:
(2, 3)
In [96]:
# Understand. 2 * 3 dot 3 * 1 -> 2 * 1
np.ones(3).shape
Out[96]:
(3,)
In [81]:
y
Out[81]:
array([[ 6., 23.],
[ -1., 7.],
[ 8., 9.]])
In [82]:
x.dot(y) # np.dot(x, y) is same
Out[82]:
array([[ 28., 64.],
[ 67., 181.]])
In [83]:
1*6 + 2*-1 + 3*8
#6 + -2 + 24
Out[83]:
28
In [84]:
np.dot(x, np.ones(3))
Out[84]:
array([ 6., 15.])
In [85]:
np.ones(3)
Out[85]:
array([ 1., 1., 1.])
In [86]:
1*1 + 2*1 + 3*1
Out[86]:
6
- numpy.linalg는 행렬의 분할과 역행렬, 행렬식 같은 것 포함
- 이는 MATLAB, R 같은 언어에서 사용하는 표준 포트란 라이브러리인 BLAS, LAPACK 또는 Intel MKL(NumPy 빌드에 따라 다르다)를 사용해서 구현
In [84]:
from numpy.linalg import inv, qr
In [85]:
# Core Linear Algebra Tools
numpy.linalg?
In [86]:
# Inverse of a square matrix
inv?
In [87]:
# QR decomposition of a matrix
qr?
In [88]:
X = randn(5, 5)
In [89]:
mat = X.T.dot(X)
In [90]:
mat
Out[90]:
array([[ 2.87598785, -3.21343638, -1.70180817, -0.49037638,
-0.08239518],
[ -3.21343638, 10.70211909, -0.02810709, 0.32085212,
5.27753009],
[ -1.70180817, -0.02810709, 3.64969751, 0.8101601 ,
3.00981921],
[ -0.49037638, 0.32085212, 0.8101601 , 1.55438619, 2.5745824 ],
[ -0.08239518, 5.27753009, 3.00981921, 2.5745824 ,
15.12401822]])
In [91]:
inv(mat)
Out[91]:
array([[ 605.75721027, 286.68894835, 406.87869992, 298.32436502,
-228.49681949],
[ 286.68894835, 135.80319411, 192.6025786 , 141.24158107,
-108.20012647],
[ 406.87869992, 192.6025786 , 273.64302113, 200.30686605,
-153.54805702],
[ 298.32436502, 141.24158107, 200.30686605, 147.86204307,
-112.69469828],
[-228.49681949, -108.20012647, -153.54805702, -112.69469828,
86.31939245]])
In [92]:
# 원래 행렬 * 역행렬 = 단위 행렬
# 선형대수에 대한 기본적인 지식이 있어야 이해가 된다.
mat.dot(inv(mat))
Out[92]:
array([[ 1.00000000e+00, -1.24344979e-14, -1.86517468e-13,
-5.68434189e-14, 1.13686838e-13],
[ 0.00000000e+00, 1.00000000e+00, -1.13686838e-13,
1.13686838e-13, 0.00000000e+00],
[ -2.27373675e-13, 0.00000000e+00, 1.00000000e+00,
5.68434189e-14, 2.84217094e-14],
[ 0.00000000e+00, 5.68434189e-14, 5.68434189e-14,
1.00000000e+00, -2.84217094e-14],
[ 4.54747351e-13, 6.82121026e-13, 0.00000000e+00,
2.27373675e-13, 1.00000000e+00]])
In [93]:
q, r = qr(mat)
In [94]:
r
Out[94]:
array([[ 4.66271257e+00, -9.47447021e+00, -2.50078085e+00,
-1.02825530e+00, -5.32453372e+00],
[ 0.00000000e+00, 7.94052899e+00, -3.12819979e-01,
1.17508664e+00, 1.09384797e+01],
[ 0.00000000e+00, 0.00000000e+00, 4.42502461e+00,
2.39248980e+00, 1.10032116e+01],
[ 0.00000000e+00, 0.00000000e+00, -0.00000000e+00,
1.37194037e+00, 1.79188567e+00],
[ 0.00000000e+00, -0.00000000e+00, -0.00000000e+00,
0.00000000e+00, 3.04789951e-03]])
In [95]:
q
Out[95]:
array([[ 0.61680573, 0.33127153, -0.01258385, -0.15693731, -0.69643534],
[-0.68917745, 0.52547227, -0.35868968, -0.10722938, -0.32978311],
[-0.36498243, -0.43902897, 0.58748134, -0.33148748, -0.46799905],
[-0.10516976, -0.08507943, 0.11763528, 0.92189088, -0.34348212],
[-0.01767108, 0.64354729, 0.71568916, 0.06407652, 0.26309283]])
4.6 난수 생성¶
numpy 장점¶
- numpy.random 모듈은 파이썬 내장 random 함수를 보강하여 다양한 종류의 확률분포로부터 효과적으로 표본 값을 생성하는 데 주로 사용
- 예를 들어 normal을 사용하여 표준정규분포로부터 4 * 4 크기의 표본 생성
In [96]:
samples = np.random.normal(size=(4, 4))
In [97]:
samples
Out[97]:
array([[ -7.07105991e-01, 3.99861073e-01, -9.98456073e-02,
3.17546390e-01],
[ -1.36656129e+00, -4.78290944e-01, -3.38881567e-01,
-1.00527089e+00],
[ -1.34366135e-03, 3.64203731e-01, 2.93014657e-01,
1.13504417e+00],
[ -1.02982622e+00, -4.03534516e-01, -6.03830553e-01,
-3.05782586e-01]])
파이썬 내장 random 단점¶
- 파이썬 내장 random 모듈은 한 번에 하나의 값만 생성
- 큰 표본을 생성할 때 훨씬 빠름
In [98]:
from random import normalvariate
In [99]:
N = 1000000
In [101]:
%timeit samples = [normalvariate(0, 1) for i in xrange(N)]
1 loops, best of 3: 1.22 s per loop
In [102]:
%timeit np.random.normal(size=N)
10 loops, best of 3: 38.1 ms per loop
4.7 계단 오르내리기 예제¶
순수 파이썬 버전¶
In [123]:
import random
position = 0
walk = [position]
steps = 1000
for i in xrange(steps):
step = 1 if random.randint(0, 1) else -1
position += step
walk.append(position)
In [124]:
from matplotlib.pyplot import plot as plt
In [125]:
plt(walk)
Out[125]:
[<matplotlib.lines.Line2D at 0x1140a0bd0>]
In [126]:
walk
Out[126]:
[0, 1, 2, 1, 2, 1, 2, 3, 4, 3, 2, 1, 2, 1, 0, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 4, 3, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 0, -1, 0, -1, -2, -3, -2, -3, -2, -1, 0, -1, 0, 1, 2, 3, 2, 3, 2, 3, 4, 5, 4, 3, 4, 5, 4, 5, 4, 5, 4, 3, 4, 5, 4, 5, 4, 3, 2, 1, 2, 1, 0, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 1, 0, -1, 0, -1, -2, -3, -2, -1, -2, -3, -2, -3, -4, -5, -4, -5, -6, -7, -8, -7, -6, -5, -6, -7, -6, -7, -8, -9, -8, -9, -10, -9, -10, -11, -10, -11, -12, -11, -12, -11, -10, -11, -12, -11, -10, -9, -10, -11, -12, -11, -10, -11, -10, -9, -10, -11, -10, -11, -12, -13, -14, -13, -14, -15, -14, -13, -14, -13, -12, -11, -10, -11, -10, -11, -10, -11, -12, -13, -12, -11, -10, -11, -10, -9, -8, -7, -8, -7, -8, -9, -10, -9, -10, -9, -8, -9, -8, -9, -8, -7, -6, -5, -6, -7, -8, -9, -10, -9, -10, -11, -10, -11, -12, -11, -10, -11, -10, -9, -8, -7, -8, -7, -6, -7, -6, -7, -6, -5, -4, -3, -4, -5, -6, -7, -6, -5, -4, -5, -4, -5, -6, -7, -8, -9, -10, -9, -10, -9, -8, -9, -10, -9, -8, -7, -6, -7, -6, -7, -8, -7, -6, -7, -6, -5, -6, -5, -4, -5, -4, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -18, -19, -20, -19, -20, -21, -22, -21, -20, -19, -18, -17, -18, -17, -18, -17, -18, -17, -18, -19, -20, -21, -22, -23, -22, -21, -20, -19, -20, -21, -22, -23, -24, -25, -26, -25, -26, -27, -26, -27, -26, -25, -24, -25, -26, -27, -28, -27, -26, -27, -28, -29, -30, -29, -28, -27, -26, -27, -26, -25, -24, -23, -22, -21, -20, -21, -22, -23, -24, -23, -24, -23, -22, -21, -20, -19, -18, -19, -20, -19, -18, -17, -16, -15, -16, -15, -14, -15, -16, -17, -16, -15, -16, -15, -14, -15, -16, -15, -16, -17, -16, -17, -18, -17, -16, -17, -16, -15, -16, -17, -18, -17, -16, -17, -16, -15, -16, -17, -16, -17, -16, -17, -16, -15, -16, -15, -14, -15, -14, -15, -14, -15, -16, -15, -16, -15, -14, -15, -16, -17, -18, -17, -16, -17, -16, -17, -16, -15, -16, -15, -14, -13, -14, -15, -16, -17, -18, -17, -18, -17, -18, -17, -18, -19, -20, -21, -20, -21, -22, -21, -20, -19, -18, -19, -20, -19, -18, -19, -18, -17, -16, -17, -16, -17, -16, -15, -14, -13, -12, -11, -10, -9, -10, -9, -8, -7, -8, -7, -8, -9, -8, -7, -6, -7, -8, -7, -6, -7, -8, -9, -10, -11, -10, -11, -12, -11, -12, -11, -10, -11, -10, -9, -10, -11, -10, -9, -8, -7, -8, -9, -8, -9, -8, -9, -10, -9, -10, -9, -10, -9, -8, -7, -6, -7, -6, -7, -8, -9, -10, -9, -8, -7, -6, -5, -6, -7, -6, -7, -8, -7, -6, -5, -4, -3, -4, -5, -4, -3, -4, -3, -4, -3, -2, -1, 0, 1, 2, 3, 2, 1, 0, 1, 0, 1, 2, 3, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0, 1, 0, 1, 0, -1, -2, -3, -4, -3, -2, -1, 0, 1, 2, 3, 2, 1, 0, -1, 0, 1, 2, 1, 0, 1, 0, 1, 2, 3, 4, 5, 4, 3, 2, 3, 2, 3, 2, 1, 0, 1, 0, -1, -2, -1, -2, -1, -2, -1, 0, -1, -2, -1, -2, -1, -2, -3, -4, -3, -4, -5, -6, -5, -4, -5, -4, -3, -2, -3, -2, -1, 0, 1, 0, -1, -2, -3, -4, -5, -4, -3, -2, -1, -2, -1, 0, 1, 0, -1, -2, -1, -2, -1, 0, 1, 0, -1, -2, -3, -4, -3, -2, -1, 0, -1, -2, -3, -4, -5, -4, -3, -4, -5, -4, -5, -4, -5, -4, -3, -4, -5, -4, -5, -6, -5, -6, -5, -6, -7, -8, -7, -8, -9, -10, -11, -10, -11, -10, -9, -10, -11, -12, -13, -12, -13, -14, -15, -16, -17, -16, -17, -18, -17, -18, -19, -20, -19, -20, -19, -18, -19, -18, -17, -16, -15, -14, -15, -16, -15, -14, -13, -14, -15, -16, -17, -16, -15, -14, -15, -16, -17, -16, -15, -14, -15, -14, -15, -14, -15, -14, -13, -12, -11, -10, -9, -10, -9, -8, -7, -6, -5, -4, -5, -6, -7, -8, -7, -6, -7, -6, -5, -4, -5, -4, -3, -4, -5, -6, -7, -6, -5, -4, -5, -6, -7, -8, -7, -8, -7, -6, -7, -8, -9, -8, -7, -8, -9, -8, -7, -6, -5, -6, -5, -4, -5, -4, -3, -2, -3, -4, -5, -4, -5, -4, -5, -6, -5, -4, -5, -6, -7, -6, -7, -8, -7, -8, -7, -8, -9, -8, -9, -8, -9, -10, -11, -10, -9, -8, -9, -8, -9, -8, -7, -6, -5, -6, -7, -6, -5, -4, -3, -4, -5, -6, -7, -8, -9, -10, -11, -10, -11, -12, -11, -10, -9, -8, -7, -6, -7, -8, -7, -8, -7, -8, -7, -6, -5, -6, -7, -6, -5, -6, -7, -8, -9, -10, -9, -8, -7, -6, -7, -6, -5, -4, -3, -2, -1, -2, -3, -2, -3, -2, -1, -2, -1, -2, -3, -2, -1, 0, 1, 0, -1, -2, -1, 0, -1, 0, -1, -2, -1, -2, -1, 0, 1, 0, -1, 0, 1, 2, 3, 2, 3, 2, 1, 2, 1, 0, -1, -2, -1, -2, -3, -2, -1, 0, -1, 0, 1, 0, 1, 0, -1, -2, -1, -2, -3, -4, -5, -4, -5, -6, -7, -6, -5, -4, -5, ...]
In [127]:
random.randint(0, 1)
Out[127]:
0
In [128]:
nsteps = 1000
In [129]:
draws = np.random.randint(0, 2, size=nsteps)
In [130]:
draws
Out[130]:
array([0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1,
1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0,
1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,
1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0,
1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1,
0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1,
0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0,
1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1,
0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1,
1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1,
1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0,
1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0,
0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,
1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1,
0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0,
0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,
1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1,
1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0,
0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1,
1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1,
1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0,
0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1,
0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0,
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1,
0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0,
0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0,
0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0,
0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0,
1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0,
1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0,
0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0,
1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0,
1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0,
1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1,
0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0,
1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1,
0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0,
0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0,
0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1,
1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0])
In [131]:
steps = np.where(draws > 0, 1, -1)
In [132]:
steps
Out[132]:
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, 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, -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, 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, 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, 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, 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, -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, -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, 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, 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, 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, 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, -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, 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, -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, -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])
In [133]:
walk = steps.cumsum()
In [134]:
walk
Out[134]:
array([ -1, -2, -3, -2, -3, -4, -5, -6, -7, -6, -7, -8, -9,
-10, -11, -12, -11, -10, -9, -8, -9, -10, -9, -8, -9, -10,
-11, -12, -11, -12, -13, -14, -15, -14, -13, -12, -11, -10, -9,
-10, -11, -10, -9, -10, -11, -12, -11, -10, -11, -12, -11, -12,
-11, -10, -11, -10, -9, -8, -7, -6, -5, -6, -5, -4, -5,
-6, -7, -8, -7, -6, -7, -6, -5, -4, -3, -4, -5, -4,
-3, -4, -3, -4, -5, -4, -5, -4, -3, -4, -3, -2, -3,
-4, -3, -2, -1, -2, -1, 0, 1, 0, -1, -2, -3, -4,
-5, -6, -5, -6, -5, -4, -5, -6, -5, -6, -5, -6, -7,
-6, -5, -4, -5, -4, -5, -6, -7, -8, -7, -6, -5, -6,
-5, -6, -7, -6, -5, -6, -7, -8, -9, -10, -9, -10, -9,
-8, -9, -10, -9, -10, -9, -8, -9, -8, -9, -10, -11, -10,
-11, -10, -11, -12, -11, -12, -11, -10, -9, -8, -7, -8, -9,
-10, -9, -8, -9, -8, -9, -10, -9, -8, -7, -8, -7, -6,
-7, -8, -7, -6, -7, -6, -7, -8, -9, -8, -9, -10, -11,
-10, -9, -8, -7, -6, -7, -8, -9, -10, -11, -10, -9, -10,
-9, -8, -7, -6, -5, -6, -5, -6, -5, -4, -5, -6, -5,
-6, -5, -4, -5, -6, -7, -8, -7, -6, -5, -6, -5, -4,
-3, -4, -3, -4, -5, -6, -5, -6, -7, -8, -9, -8, -7,
-6, -7, -8, -7, -8, -7, -6, -7, -8, -9, -10, -11, -10,
-9, -10, -11, -10, -11, -12, -13, -12, -13, -14, -15, -16, -15,
-16, -15, -16, -15, -14, -15, -16, -15, -16, -15, -16, -15, -16,
-17, -18, -19, -20, -19, -18, -17, -16, -15, -14, -13, -14, -15,
-14, -13, -12, -11, -10, -9, -8, -9, -10, -11, -12, -11, -12,
-11, -12, -13, -12, -11, -12, -11, -12, -11, -12, -13, -12, -11,
-10, -11, -10, -9, -8, -9, -8, -9, -10, -9, -8, -7, -6,
-5, -6, -5, -4, -5, -4, -3, -2, -1, -2, -1, -2, -1,
0, 1, 0, -1, -2, -1, -2, -3, -4, -3, -2, -3, -4,
-5, -4, -5, -4, -5, -4, -5, -4, -5, -6, -5, -6, -7,
-6, -7, -6, -7, -8, -7, -8, -9, -8, -7, -8, -7, -8,
-9, -10, -9, -8, -7, -8, -7, -6, -7, -6, -7, -8, -9,
-8, -9, -8, -9, -8, -7, -6, -7, -6, -5, -6, -5, -6,
-5, -6, -7, -8, -9, -8, -7, -6, -5, -4, -3, -2, -3,
-4, -5, -4, -5, -6, -5, -6, -5, -4, -3, -2, -3, -2,
-1, -2, -1, 0, 1, 2, 3, 2, 1, 2, 1, 2, 3,
2, 3, 2, 3, 2, 1, 0, 1, 0, -1, -2, -3, -4,
-3, -4, -3, -4, -5, -4, -3, -2, -1, -2, -1, 0, -1,
0, 1, 2, 3, 2, 1, 2, 3, 2, 3, 4, 5, 6,
5, 6, 7, 6, 7, 6, 7, 6, 7, 8, 9, 10, 11,
10, 9, 10, 11, 10, 9, 10, 9, 10, 11, 12, 13, 12,
13, 14, 13, 14, 15, 14, 13, 14, 13, 12, 11, 10, 9,
10, 11, 10, 11, 12, 13, 14, 15, 16, 17, 16, 15, 16,
15, 14, 13, 12, 11, 12, 11, 12, 11, 12, 11, 10, 11,
10, 11, 12, 11, 12, 13, 12, 13, 14, 13, 12, 13, 14,
13, 14, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13,
14, 15, 16, 17, 18, 17, 18, 19, 20, 19, 20, 19, 20,
19, 18, 19, 18, 19, 18, 17, 16, 17, 18, 19, 18, 17,
18, 19, 20, 19, 18, 19, 20, 19, 20, 19, 18, 17, 18,
19, 20, 19, 20, 21, 22, 23, 24, 23, 22, 23, 22, 21,
22, 23, 24, 23, 24, 23, 22, 21, 22, 21, 20, 19, 20,
21, 22, 23, 22, 21, 22, 23, 24, 25, 26, 27, 28, 27,
26, 25, 24, 25, 24, 23, 22, 21, 22, 21, 22, 21, 22,
23, 24, 23, 22, 21, 22, 21, 20, 21, 22, 23, 24, 25,
24, 23, 24, 23, 24, 25, 26, 27, 26, 25, 24, 25, 26,
27, 26, 25, 26, 27, 28, 27, 28, 27, 28, 27, 28, 29,
30, 31, 30, 29, 28, 29, 30, 31, 32, 33, 34, 33, 34,
33, 32, 33, 32, 33, 32, 33, 32, 33, 32, 31, 32, 31,
32, 31, 30, 29, 30, 31, 30, 29, 28, 27, 28, 27, 28,
27, 28, 29, 30, 29, 28, 27, 28, 29, 30, 31, 30, 29,
30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 31, 30,
29, 28, 29, 28, 29, 30, 31, 32, 31, 32, 33, 32, 33,
32, 33, 32, 31, 32, 31, 30, 29, 30, 31, 30, 29, 30,
29, 28, 29, 28, 27, 26, 27, 28, 27, 26, 25, 26, 27,
28, 29, 30, 29, 28, 29, 28, 27, 26, 27, 26, 27, 28,
27, 26, 27, 28, 27, 26, 27, 28, 29, 28, 27, 28, 29,
28, 29, 28, 27, 28, 29, 28, 29, 28, 27, 26, 27, 28,
29, 28, 29, 28, 29, 30, 29, 28, 27, 28, 29, 30, 29,
28, 29, 28, 29, 30, 29, 28, 29, 28, 27, 26, 27, 26,
27, 26, 27, 26, 25, 24, 25, 24, 23, 22, 21, 22, 23,
22, 23, 22, 21, 22, 23, 24, 25, 26, 25, 26, 25, 24,
25, 24, 23, 22, 23, 22, 21, 20, 19, 18, 17, 18, 17,
18, 19, 20, 21, 22, 21, 20, 21, 22, 21, 22, 23, 24,
23, 22, 21, 20, 21, 20, 19, 18, 17, 18, 17, 18, 19,
20, 19, 20, 21, 22, 21, 20, 19, 18, 19, 18, 17, 16,
15, 16, 15, 16, 17, 16, 17, 18, 17, 18, 19, 20, 19,
18, 19, 18, 17, 18, 19, 18, 19, 18, 19, 20, 19, 20,
21, 22, 23, 24, 25, 26, 25, 26, 25, 24, 23, 22])
In [135]:
walk.min(), walk.max()
Out[135]:
(-20, 34)
In [172]:
(np.abs(walk) >= 10).argmax()
Out[172]:
13
In [176]:
walk.ndim
Out[176]:
1
In [177]:
walk.shape
Out[177]:
(1000,)
In [175]:
# Error! 당연히 axis가 1개 밖에 없는 배열이니까
(np.abs(walk) >= 10).argmax(1)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-175-e565e1d87fee> in <module>() 1 # Error! 당연히 axis가 1개 밖에 없는 배열이니까 ----> 2 (np.abs(walk) >= 10).argmax(1) ValueError: axis(=1) out of bounds
4.7.1 한 번에 계단 오르내리기 시뮬레이션하기¶
In [137]:
nwalks = 5000
In [138]:
nsteps = 1000
In [168]:
# randint는 0부터 2까지(포함 안됨)의 숫자를 랜덤으로 생성. 즉 0과 1만 생성
# size에 넘기는 것은 행, 렬을 튜플 형태로 넘김
draws = np.random.randint(0, 2, size=(nwalks, nsteps))
In [167]:
np.random.randint(0, 2, size=(10,3))
Out[167]:
array([[0, 1, 1],
[0, 1, 0],
[1, 1, 0],
[0, 0, 0],
[0, 1, 0],
[0, 0, 1],
[0, 0, 1],
[0, 0, 0],
[1, 0, 1],
[1, 1, 0]])
In [171]:
# size에 인자 1개만 넘어갈 시 행은 1개로 고정 지정되고 1개 인자값은 컬럼값으로 설정 됨.
np.random.randint(0, 2, size=5)
Out[171]:
array([1, 1, 0, 0, 1])
In [157]:
draws.ndim
Out[157]:
2
In [158]:
draws.shape
Out[158]:
(5000, 1000)
In [140]:
steps = np.where(draws > 0, 1, -1)
In [141]:
walks = steps.cumsum(1)
In [142]:
walks
Out[142]:
array([[ -1, 0, -1, ..., 20, 19, 18],
[ -1, 0, 1, ..., -14, -13, -14],
[ 1, 2, 1, ..., 54, 55, 54],
...,
[ -1, 0, -1, ..., -32, -31, -30],
[ -1, -2, -3, ..., 12, 11, 10],
[ -1, -2, -3, ..., -62, -61, -62]])
In [143]:
walks.max(), walks.min()
Out[143]:
(122, -122)
In [144]:
hits30 = (np.abs(walks) >= 30).any(1)
In [145]:
hits30
Out[145]:
array([False, True, True, ..., True, True, True], dtype=bool)
In [146]:
len(hits30)
Out[146]:
5000
In [147]:
hits30.sum()
Out[147]:
3371
In [148]:
crossing_times = (np.abs(walks[hits30]) >= 30).argmax(1)
In [149]:
crossing_times.mean()
Out[149]:
507.19875407890834
In [150]:
steps = np.random.normal(loc=0, scale=0.25, size=(nwalks, nsteps))
In [151]:
steps
Out[151]:
array([[ 0.08726702, 0.44660757, -0.20851034, ..., -0.32885954,
-0.10377829, -0.55204768],
[ 0.28219952, -0.15124127, -0.26097055, ..., 0.21983047,
-0.01899429, 0.12845647],
[ 0.10835411, 0.16839816, -0.0588874 , ..., -0.0136134 ,
0.31643727, 0.09701192],
...,
[-0.08377433, -0.4545433 , -0.04472277, ..., -0.00461127,
-0.03111517, 0.1789901 ],
[ 0.06285865, -0.19800213, -0.28502572, ..., -0.20323394,
0.13771058, -0.11289319],
[ 0.16258237, 0.0869184 , 0.29934197, ..., -0.10236161,
-0.11827899, 0.00986353]])
In [152]:
walks
Out[152]:
array([[ -1, 0, -1, ..., 20, 19, 18],
[ -1, 0, 1, ..., -14, -13, -14],
[ 1, 2, 1, ..., 54, 55, 54],
...,
[ -1, 0, -1, ..., -32, -31, -30],
[ -1, -2, -3, ..., 12, 11, 10],
[ -1, -2, -3, ..., -62, -61, -62]])
In [155]:
walks.shape
Out[155]:
(5000, 1000)
In [156]:
walks.ndim
Out[156]:
2
In [153]:
np.abs(walks)
Out[153]:
array([[ 1, 0, 1, ..., 20, 19, 18],
[ 1, 0, 1, ..., 14, 13, 14],
[ 1, 2, 1, ..., 54, 55, 54],
...,
[ 1, 0, 1, ..., 32, 31, 30],
[ 1, 2, 3, ..., 12, 11, 10],
[ 1, 2, 3, ..., 62, 61, 62]])