[Python] 2-2) Jupyter Numpy

 

 

 

 

 8일차 (23.03.22)

 

 

 

팬시인덱스 : 정수배열 인덱스

인덱스 배열의 원소 각각이 원래 ndarray 객체 원소 하나를 가리키는 인덱스 정수여야함

a= np.array([11,12,13,14,15,16,17,18,19])
idx = np.array([0,2,4,6,8])
a[idx]

 

array([11, 13, 15, 17, 19])

 

idx = np.array([0,1,0,0,2,2,8])
a[idx]

 

array([11, 12, 11, 11, 13, 13, 19])

 

매칭되는 인덱스 값을 집어 넣음 위치에 있는 값을 출력하겠다

 

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
a

 

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

 

 

a[:, [True, False, False, True]]

 

array([[ 1,  4],
       [ 5,  8],
       [ 9, 12]])

 

슬라이싱과 다르게 부분적인 요소를 출력할 수 있음

 

a[[2, 0, 1], :]

 

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

 

순서에 맞게 [2,0,1] 출력해줌

 

arr = np.empty((8,4))
for i in range(8):
    arr[i] = i

arr

 

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

 

arr[[4,3,0,6]]

 

arr[[4,3,0,6]]
arr[[4,3,0,6]]
array([[4., 4., 4., 4.],
       [3., 3., 3., 3.],
       [0., 0., 0., 0.],
       [6., 6., 6., 6.]])

 

4행 3행 0행 6행 [4,3,0,6]행에 맞게 출력

 

arr[[-3, -1, -5]]

 

array([[5., 5., 5., 5.],
       [7., 7., 7., 7.],
       [3., 3., 3., 3.]])

 

[-3, -1, -5] 뒤에서부터 -숫자 출력

 

---

 

배열 크기 변환

arr=np.arange(32).reshape((8,4))
arr

 

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

 

만든 개수와 2차원 배열 개수를 맞게 해 줌

 

arr.reshape(4,-1)

 

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개의 데이터니까 => (4,-1) 행만 정해주면 뒤(-1)부분은 알아서 계산 됨

행,열 중 하나가 정해지면 다른것은 -1로 작성 가능

 

arr.reshape(2,4,-1)

 

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

 

[2,4,-1] = 4핼 4열 짜리가 2개

 

arr.flatten()

 

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

 

다시 1차원으로 변경할때

 

a = arr[[1,5,7,2],[0,3,1,2]]
a

 

array([ 4, 23, 29, 10])

 

(1,0)(5,3)(7,1)(2,2), 팬시인덱스 결과는 항상 1차원

팬시인덱스는 슬라이싱과 달리 선택된 데이터를 새로운 배열로 복사

행 - 1,5,7,2 / 열 - 0,3,1,2 : 짝궁(1,0)(5,3)(7,1)(2,2)

 

arr

 

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

 

 

arr[[1,5,7,2]][:,[0,3,1,2]]

 

array([[ 4,  7,  5,  6],
       [20, 23, 21, 22],
       [28, 31, 29, 30],
       [ 8, 11,  9, 10]])

 

위 코드와 같지만 열 한줄의 값을 다 가져오고 싶을때 (:) 추가

 

arr

 

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

 

arr은 계속 같은 값 상태를 유지 중

 

---

 

배열 전치와 축 바꾸기

 

arr=np.arange(15).reshape((3,5))
arr

 

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

 

arr.T 

 

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

 

행,열을 바꿔줌 (0,1) => (1,0)

 

arr.transpose()

 

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

 

값을 뒤로 안넘겨줘도 알아서 행과열을 서로 바꿔줌 T축변환과 같음

(0,1) = 행 열 (1,0) = 열,행

 

arr = np.arange(16).reshape((2,2,4))
arr

 

array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

 

arr.transpose((1,0,2))

 

array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],

       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])

 

인덱스 원래[0,1,2] => [1,0,2]로 치환

ex)101 = 011 / 013 = 103

 

arr.transpose((2,0,1))

 

array([[[ 0,  4],
        [ 8, 12]],

       [[ 1,  5],
        [ 9, 13]],

       [[ 2,  6],
        [10, 14]],

       [[ 3,  7],
        [11, 15]]])

 

2차원 (행,열)

3차원 (층,행,열)

arr

 

array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

 

arr.swapaxes(1,2) 

 

arr.swapaxes(1,2) 
arr.swapaxes(1,2) 
array([[[ 0,  4],
        [ 1,  5],
        [ 2,  6],
        [ 3,  7]],

       [[ 8, 12],
        [ 9, 13],
        [10, 14],
        [11, 15]]])

 

swapaxes 2,3차원이던 뭐든 스와핑은 2개의 인자값만 받음

3차원 0층,1행,2열

(2,1) => 열과 행을 바꿔줌 (0,2,1)

 

트랜스는 순서 그대로 인자값에 맞게 적어주고

스와핑은 바꿀 인자값 2개만 적어주면 됨

arr

 

array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

 

 

 

 

배열연결

 

a1 = np.ones((2,3))
a1

 

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

 

b1 = np.zeros((2,2))
b1

 

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

 

a1 b1 붙이기 - 열의 개수가 달라서 밑으로는 못 붙임 인덱스가 맞는 행2로 붙어야 함

 

np.hstack([a1,b1])

 

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

 

 

a2 = np.ones((2,3))
a2

 

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

 

b2 = np.zeros((3,3))
b2

 

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

 

이번엔 열로 붙여주기

np.vstack([a2, b2])

 

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

 

c1 = np.ones((2,3))
c1

 

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

 

 

c2 = np.zeros((2,3))
c2

 

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

 

2층 3행 3열

 

np.dstack([c1, c2])

 

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

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

 

c= np.stack([c1,c2])
c

 

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

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

 

 

c.shape

 

(2, 2, 3)

 

c = np.stack([c1, c2], axis=1)
c

 

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

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

 

c.shape

 

(2, 2, 3)

 

 

a= np.array([[0,1,2],[3,4,5]])
np.tile(a,2)

 

a= np.array([[0,1,2],[3,4,5]])
np.tile(a,2)

 

동일한 배열 반복 연결

np.tile(a, (3, 2))

 

array([[0, 1, 2, 0, 1, 2],
       [3, 4, 5, 3, 4, 5],
       [0, 1, 2, 0, 1, 2],
       [3, 4, 5, 3, 4, 5],
       [0, 1, 2, 0, 1, 2],
       [3, 4, 5, 3, 4, 5]])

 

a가 2행 3열로 복시 붙여넣기

 

 

---

연습문제)

 

대표사진 삭제

사진 설명을 입력하세요.

zeros = np.zeros([3,3])
ones = np.ones([3,2])
numbers = np.reshape(np.arange(10,160,10), (3,-1))
res = np.tile(np.vstack([np.hstack([zeros, ones]), numbers]), (2, 1))
res

 

array([[  0.,   0.,   0.,   1.,   1.],
       [  0.,   0.,   0.,   1.,   1.],
       [  0.,   0.,   0.,   1.,   1.],
       [ 10.,  20.,  30.,  40.,  50.],
       [ 60.,  70.,  80.,  90., 100.],
       [110., 120., 130., 140., 150.],
       [  0.,   0.,   0.,   1.,   1.],
       [  0.,   0.,   0.,   1.,   1.],
       [  0.,   0.,   0.,   1.,   1.],
       [ 10.,  20.,  30.,  40.,  50.],
       [ 60.,  70.,  80.,  90., 100.],
       [110., 120., 130., 140., 150.]])

 

가로로 붙이기 hsack arnage를 이용해 3핼5열 ㅏ리 만들고 vsack으로 붙이기 마지막

tile로 복사 붙여 넣기 인자값 2 하나만 적으면 옆으로 붙임 (2,1)로 붙여야 밑으로 붙음

 

 

---

 

 

2차원 그리드 포인드 생성

 

변수가 2개인 2차원 함수의 그래프를 그리거나 표를 작성하려면 2차원 영역에 대한 (x,y) 좌표값

쌍 필요 그리드 포인트를 생성하여 각 좌표에 대한 함수 값을 계산 (격자)

x = np.arange(3)
x

 

array([0, 1, 2])

 

y = np.arange(5)
y

 

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

 

X, Y = np.meshgrid(x, y)
X
Y

 

X
array([[0, 1, 2],
       [0, 1, 2],
       [0, 1, 2],
       [0, 1, 2],
       [0, 1, 2]])

 

Y
array([[0, 0, 0],
       [1, 1, 1],
       [2, 2, 2],
       [3, 3, 3],
       [4, 4, 4]])

 

[list(zip(x, y)) for x, y in zip(X, Y)]

 

[[(0, 0), (1, 0), (2, 0)],
 [(0, 1), (1, 1), (2, 1)],
 [(0, 2), (1, 2), (2, 2)],
 [(0, 3), (1, 3), (2, 3)],
 [(0, 4), (1, 4), (2, 4)]]

 

---

 

브로드캐스팅

 

넘파이에서는 서로 다른 크기를 가진 두 배열의 사칙 연산도 지원

작은 배열을 자동으로 반복확장히여 크기가 큰 배열에 맞추는 방법

갯수가 안맞아서 수학적 계산을 못하지만 갯수를 늘려서 넣어주기

 

x = np.arange(5)
x

 

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

 

y = np.ones_like(x)
y

 

array([1, 1, 1, 1, 1])

 

onse_like : 뒤에 오는 인자값과 크기를 채우는데 1로 채워라

 

x + y

 

array([1, 2, 3, 4, 5])

 

x + 1

 

array([1, 2, 3, 4, 5])

 

원래는 안되지만 자동으로 행열에 계산을 도와줌

 

 

대표사진 삭제

사진 설명을 입력하세요.

x = np.array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]])
x

 

array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]])

 

y = np.arange(5)[:, np.newaxis] # np.newaxis: 1을 추가해줌, (5,1) 앞에있으면 (1,5)
y

 

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

 

np.newaxis: 1을 추가해줌, (5,1) 앞에있으면 (1,5) - 행1열이 만들어짐

x + y

 

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

 

y = np.arange(3)
y

 

array([0, 1, 2])

 

x + y

 

array([[0, 2, 4],
       [1, 3, 5],
       [2, 4, 6],
       [3, 5, 7],
       [4, 6, 8]])

 

---

 

차원 축소 : 1차원 백터로 나오는 것

 

최대/축소 : min, max,argmin,argmax

통계 : sum, mean, median, std,var

불리언: all,any

 

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

 

array([1, 2, 3, 4])

 

np.sum(x)

 

결과 => 10

x.sum()

 

결과 => 10

x.min()

 

결과 => 1

x.max()

 

결과 => 4

x.argmin()

 

결과 => 0 min값을 가지고 잇는 인덱스값을 출력

x = np.array([1, 2, 3, 1])
x.mean()

 

결과 => 1.75

np.all([True, True, False])

 

결과 => False

np.any([True, True, False])

 

결과 => True

x = np.array([[1, 1], [2, 2]])
x

 

array([[1, 1],
       [2, 2]])

 

x.sum()

 

결과=>6

x.sum(axis=0)

 

array([3, 3])

 

열 함계 구하기

 

축에 다가 입력할 때

0 = 열

1 = 행

 

 

x.sum(axis=1)

 

array([2, 4])

 

행 갑계 구하기

 

 

---

대표사진 삭제

사진 설명을 입력하세요.

x = np.random.randn(30).reshape(5,6)

 

1

x.max()

 

3.000302720497015

 

2

x.sum(axis=1)

 

array([ 2.74119601,  0.16890114, -2.23898929,  0.34915588,  1.49343524])

 

3

x.max(axis=1)

 

array([1.23482548, 1.44734225, 0.37577339, 3.00030272, 1.21649682])

 

4

x.sum(axis=0)

 

array([-2.79076618,  1.45832455,  3.5047505 , -0.24879264,  1.67379308,
       -1.08361032])

 

5

x.min(axis=0)

 

array([-2.35880481, -0.12958668, -1.08993151, -0.66011264, -0.60081522,
       -2.02672315])

 

---

 

 

기술통계

 

 

데이터의 개수(count)

평균(mean, average)

분산(variance)

표준 편차(standard deviation)

최댓값(maximum)

최솟값(minimum)

중앙값(median)

사분위수(quartile)

x=np.random.randn(8)
y=np.random.randn(8)
x
y

 

array([-0.38723899,  0.90012105, -0.69132379, -1.18086909, -1.10513922,
       -1.18035284,  0.16191994,  0.38015772])
array([ 1.32339135, -1.22645664,  0.34500828, -0.07155646, -0.27691623,
       -0.87365978, -0.33442238,  1.66500728])

 

np.maximum(x,y)

 

array([ 0.15818062,  1.21087863,  0.95451006, -0.42300185,  0.1001897 ,
       -0.35398344,  0.16191994,  0.38015772])

 

arr= np.random.randn(7) *5
arr

 

array([ 4.46278792,  1.94472383, -1.05415424,  2.82930699,  3.78036114,
        0.5898475 ,  4.85233983])

 

remainder, whole_port = np.modf(arr)
remainder

 

array([ 0.46278792,  0.94472383, -0.05415424,  0.82930699,  0.78036114,
        0.5898475 ,  0.85233983])

 

 

whole_port

 

array([ 4.,  1., -1.,  2.,  3.,  0.,  4.])

 

arr

 

array([-0.98955495, -3.50119697, -4.87125258,  1.53577108,  0.88053038,
        1.66236278,  2.32760319])

 

result = [(x if c else y)
         for x,y,c in zip(xarr, yarr, cond)]

result

 

[1.1, 2.2, 1.3, 1.4, 2.5]

 

result = np.where(cond, xarr, yarr)
result

 

array([1.1, 2.2, 1.3, 1.4, 2.5])

 

cond = 조건 작성

arr = np.random.randn(4,4)
arr

 

array([[-2.0462457 ,  1.33494483,  0.00836136, -0.16099447],
       [-0.62617579,  0.38743985, -0.06120312,  1.11114927],
       [-0.6871594 , -0.0557534 , -0.59527726,  0.63203097],
       [ 0.87855077,  0.18659704,  0.38085208, -1.87886488]])

 

arr>0

 

array([[False, False,  True, False],
       [False, False, False,  True],
       [False,  True,  True, False],
       [False,  True,  True,  True]])

 

np.where(arr>0, 2, -2)

 

array([[-2, -2,  2, -2],
       [-2, -2, -2,  2],
       [-2,  2,  2, -2],
       [-2,  2,  2,  2]])

 

np.where(arr>0, 2, arr)

 

array([[-0.67521875, -0.08514805,  2.        , -0.82986534],
       [-2.33868009, -0.30821989, -0.0459476 ,  2.        ],
       [-0.69726012,  2.        ,  2.        , -3.07181991],
       [-0.24116463,  2.        ,  2.        ,  2.        ]])

 

arr=np.random.randn(5,4)
arr

 

array([[ 0.50707889,  0.91046747, -0.1337737 , -0.60073523],
       [ 1.44126266,  0.6432464 ,  1.77975847,  0.09442149],
       [ 0.02483896,  1.44813588, -0.98439559,  0.74986602],
       [-0.04902824,  0.67113584,  0.55764603,  0.10788369],
       [-1.72491155,  0.11486899, -1.51907641, -0.36065142]])

 

arr.mean()

 

결과 => 0.18390193207360644

np.mean(arr)

 

결과 => 0.16969096390631594

arr.sum()

 

결과값 => 3.393819278126319

arr.mean(axis=1)

 

arr.mean(axis=1)

 

arr.mean(axis=1)

 

array([ 0.40948234, -1.56131484,  3.42471346,  1.12093831])

 

array([ 0.40948234, -1.56131484,  3.42471346,  1.12093831])

 

arr.cumsum()

 

array([ 0,  1,  3,  6, 10, 15, 21, 28], dtype=int32)

 

arr=np.array([[0,1,2],[3,4,5],[6,7,8]])
arr

 

array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

 

arr.cumsum(axis=1)

 

array([[ 0,  1,  3],
       [ 3,  7, 12],
       [ 6, 13, 21]], dtype=int32)

 

누적합

 

arr.cumprod(axis=1)

 

array([[  0,   0,   0],
       [  3,  12,  60],
       [  6,  42, 336]], dtype=int32)

 

arr=np.random.randn(100

 

(arr>0).sum()

 

결과 값 => 55

bools = np.array([False, False, True, False])
bools.any()

 

결과 값 => True

bools.all()

 

결과 => False

 

 

---

 

집합관련 함수

 

names = np.array( ['bob','joe','will','bob','will','joe','joe'])
np.unique(names) 

 

array(['bob', 'joe', 'will'], dtype='<U4')

 

중복 원소 제거

ints = np.array([3,3,2,5,3,1,1,2])
np.unique(ints)

 

array([1, 2, 3, 5])

 

a = np.array(['a', 'b', 'b', 'c', 'a'])
index, count = np.unique(a, return_counts=True)

index

 

array(['a', 'b', 'c'], dtype='<U1')

 

count

 

array([2, 2, 1], dtype=int64)

 

np.bincount([1, 1, 2, 2, 2, 3], minlength=6)

 

np.bincount([1, 1, 2, 2, 2, 3], minlength=6)

 

bincount는 없는 값도 수를 세고 싶을때는 count 말고 bincount 사용

 

---

 

난수 생성

 

np.random.seed(0)
np.random.rand(5)

 

array([0.5488135 , 0.71518937, 0.60276338, 0.54488318, 0.4236548 ])

 

시드(시작숫자) 설정, 0과 같거나 큰 정수넣음

()안의 횟수만큼 0과 1사이의 난수를 발생

np.random.seed(0)

 

재설정

 

x = np.arange(10)
x

 

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

 

데이터 순서 바꾸기

 

np.random.shuffle(x)
x

 

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

 

 

---

데이터 샘플링 :무작위 선택

 

numpy.random.choice(a, size=None, replace=True, p=None)

a : 배열이면 원래의 데이터, 정수이면 arange(a) 명령으로 데이터 생성

size : 정수. 샘플 숫자

replace : 불리언. True이면 한번 선택한 데이터를 다시 선택 가능

p : 배열. 각 데이터가 선택될 수 있는 확률

 

choice(,) - choice(범위, 개수)

np.random.choice(5, 5, replace=False)

 

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

 

replace: 중복 없애기

 

np.random.choice(5, 3, replace=False)

 

array([4, 2, 3])

 

np.random.choice(5, 10)

 

array([0, 2, 4, 3, 3, 2, 4, 2, 0, 0])

 

np.random.choice(5, 10, p=[0.1, 0, 0.3, 0.6, 0])

 

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

 

확률 높이기

---

난수 생성

 

rand: 0부터 1사이의 균일 분포

randn: 표준 정규 분포

randint: 균일 분포의 정수 난수

 

np.random.rand(10)

 

array([0.65314004, 0.17090959, 0.35815217, 0.75068614, 0.60783067,
       0.32504723, 0.03842543, 0.63427406, 0.95894927, 0.65279032])

 

np.random.rand(3, 5)

 

array([[0.63505887, 0.99529957, 0.58185033, 0.41436859, 0.4746975 ],
       [0.6235101 , 0.33800761, 0.67475232, 0.31720174, 0.77834548],
       [0.94957105, 0.66252687, 0.01357164, 0.6228461 , 0.67365963]])

 

np.random.randn(10)

 

array([-0.68658948,  0.01487332, -0.3756659 , -0.03822364,  0.36797447,
       -0.0447237 , -0.30237513, -2.2244036 ,  0.72400636,  0.35900276])

 

np.random.randn(3, 5)

 

array([[ 1.07612104,  0.19214083,  0.85292596,  0.01835718,  0.42830357],
       [ 0.99627783, -0.49114966,  0.71267817,  1.11334035, -2.15367459],
       [-0.41611148, -1.07089699,  0.22113881, -1.12305712, -1.05075796]])

 

np.random.randint(10, size=10)

 

array([0, 8, 8, 3, 8, 2, 8, 4, 3, 0])

 

np.random.randint(10, 20, size=10)

 

array([14, 13, 16, 19, 18, 10, 18, 15, 19, 10])

 

np.random.randint(10, 20, size=(3, 5))

 

array([[19, 16, 15, 13, 11],
       [18, 10, 14, 19, 16],
       [15, 17, 18, 18, 19]])

 

---

 

 

정렬

arr=np.random.randn(6)
arr

 

array([ 0.74997817, -0.24893485,  0.93003547, -2.12457281,  0.84904169,
        0.62872693])

 

arr.sort()
arr

 

array([-2.12457281, -0.24893485,  0.62872693,  0.74997817,  0.84904169,
        0.93003547])

 

오름차순 정렬

arr=np.random.randn(5,3)
arr

 

array([[-1.39733677, -0.21429748, -0.16801566],
       [-1.46098868, -1.08393052,  0.09936394],
       [ 0.83380232, -0.47930716,  0.20256948],
       [-0.42734122, -0.69751512, -2.32488515],
       [ 0.28760674, -1.28986794, -1.64678759]])

 

arr.sort(1)
arr

 

array([[-1.39733677, -0.21429748, -0.16801566],
       [-1.46098868, -1.08393052,  0.09936394],
       [-0.47930716,  0.20256948,  0.83380232],
       [-2.32488515, -0.69751512, -0.42734122],
       [-1.64678759, -1.28986794,  0.28760674]])

 

행정렬

arr.sort(0)
arr

 

array([[-2.32488515, -1.28986794, -0.42734122],
       [-1.64678759, -1.08393052, -0.16801566],
       [-1.46098868, -0.69751512,  0.09936394],
       [-1.39733677, -0.21429748,  0.28760674],
       [-0.47930716,  0.20256948,  0.83380232]])

 

열정렬

sort 메서드는 해당 객체의 자료 자체가 변화하는 자체변화(in-place) 메서드이므로 사용할 때 주의

 

a = np.array([42, 38, 12, 25])
j = np.argsort(a)
j

 

array([2, 3, 1, 0], dtype=int64)

 

np.argsort(a) - 순서만 알고싶을때

arg - 값이 아닌 인덱스 주소를 알려줌

a[j]

 

array([12, 25, 38, 42])

 

np.sort(a)

 

array([12, 25, 38, 42])

 

a의 자체 값을 변경 잘 사용 바람

array([42, 38, 12, 25])

 

a.sort()
a

 

array([12, 25, 38, 42])

 

---

연습문제)

대표사진 삭제

사진 설명을 입력하세요.

x= np.array([[ 1, 2, 3, 4],
[ 46, 99, 100, 71],
[ 81, 59, 90, 100]])
x1_argsort = np.argsort(x[1])
x = x[:,x1_argsort]
x

 

array([[  1,   4,   2,   3],
       [ 46,  71,  99, 100],
       [ 81, 100,  59,  90]])