수색…


소개

N 차원 배열 또는 ndarrays 는 동일한 데이터 형식의 항목을 저장하는 데 사용되는 numpy의 핵심 개체입니다. 그것들은 일반적인 파이썬의 배열보다 우수한 효율적인 데이터 구조를 제공합니다.

비고

가능할 때마다 배열 및 벡터 연산 측면에서 데이터에 대한 연산을 표현합니다. 벡터 작업은 for 루프보다 훨씬 빠르게 실행됩니다.

배열 만들기

빈 배열

np.empty((2,3))

이 경우이 배열의 값은 설정되지 않습니다. 따라서 배열을 만드는이 방법은 코드가 나중에 배열로 채워지는 경우에만 유용합니다.

목록에서

np.array([0,1,2,3])
# Out: array([0, 1, 2, 3]) 

범위 만들기

np.arange(4)
# Out: array([0, 1, 2, 3])

0 생성

np.zeros((3,2))
# Out:
# array([[ 0.,  0.],
#        [ 0.,  0.],
#        [ 0.,  0.]])

만들기

np.ones((3,2))
# Out:
# array([[ 1.,  1.],
#        [ 1.,  1.],
#        [ 1.,  1.]])

선형으로 배열 된 배열 항목 만들기

np.linspace(0,1,21)
# Out:
# array([ 0.  ,  0.05,  0.1 ,  0.15,  0.2 ,  0.25,  0.3 ,  0.35,  0.4 ,
#         0.45,  0.5 ,  0.55,  0.6 ,  0.65,  0.7 ,  0.75,  0.8 ,  0.85,
#         0.9 ,  0.95,  1.  ])

로그 간격 배열 항목 만들기

np.logspace(-2,2,5)
# Out:
# array([  1.00000000e-02,   1.00000000e-01,   1.00000000e+00,
#          1.00000000e+01,   1.00000000e+02])

주어진 함수로부터 배열 만들기

np.fromfunction(lambda i: i**2, (5,))
# Out:
# array([  0.,   1.,   4.,   9.,  16.])
np.fromfunction(lambda i,j: i**2, (3,3))
# Out:
# array([[ 0.,  0.,  0.],
#        [ 1.,  1.,  1.],
#        [ 4.,  4.,  4.]])

배열 연산자

x = np.arange(4)
x
#Out:array([0, 1, 2, 3])

스칼라 추가 요소 현명하다

x+10
#Out: array([10, 11, 12, 13])

스칼라 곱셈은 요소 현명하다.

x*2
#Out: array([0, 2, 4, 6])

배열 추가는 요소 현명하다.

x+x
#Out: array([0, 2, 4, 6]) 

배열 곱셈은 요소 현명하다.

x*x
#Out: array([0, 1, 4, 9])

내적 (또는 더 일반적으로 행렬 곱셈)은 함수

x.dot(x)
#Out: 14

파이썬 3.5에서 @ 연산자는 행렬 곱셈을위한 중위 연산자로 추가되었습니다.

x = np.diag(np.arange(4))
print(x)
'''
   Out: array([[0, 0, 0, 0],
   [0, 1, 0, 0],
   [0, 0, 2, 0],
   [0, 0, 0, 3]])
'''
print(x@x)
print(x)
'''
   Out: array([[0, 0, 0, 0],
   [0, 1, 0, 0],
   [0, 0, 4, 0],
   [0, 0, 0, 9]])
'''

추가 . 값이 추가 된 복사본을 반환합니다. 제자리에 있지 않습니다.

#np.append(array, values_to_append, axis=None)
x = np.array([0,1,2,3,4])
np.append(x, [5,6,7,8,9])
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x
# Out: array([0, 1, 2, 3, 4])
y = np.append(x, [5,6,7,8,9])
y
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

hstack . 가로 스택입니다. (컬럼 스택)
vstack . 세로 스택. (행 스택)

# np.hstack(tup), np.vstack(tup)
x = np.array([0,0,0])
y = np.array([1,1,1])
z = np.array([2,2,2])
np.hstack(x,y,z)
# Out: array([0, 0, 0, 1, 1, 1, 2, 2, 2])
np.vstack(x,y,z)
# Out: array([[0, 0, 0],
#             [1, 1, 1],
#             [2, 2, 2]])

배열 액세스

슬라이스 구문은 i:j:k 이고 i 는 시작 색인 (포함)이고 j 는 중단 색인 (제외)이며 k 는 단계 크기입니다. 다른 파이썬 데이터 구조와 마찬가지로 첫 번째 요소의 인덱스는 0입니다.

x = np.arange(10)
x[0]
# Out: 0

x[0:4]
# Out: array([0, 1, 2, 3])

x[0:4:2]
# Out:array([0, 2])

음수 값은 배열의 끝에서부터 계산됩니다. 따라서 -1 은 배열의 마지막 요소에 액세스합니다.

x[-1]
# Out: 9
x[-1:0:-1]
# Out: array([9, 8, 7, 6, 5, 4, 3, 2, 1])

다차원 배열은 각 차원을 쉼표로 구분하여 지정하여 액세스 할 수 있습니다. 이전의 모든 규칙이 적용됩니다.

x = np.arange(16).reshape((4,4))
x
# Out: 
#     array([[ 0,  1,  2,  3],
#            [ 4,  5,  6,  7],
#            [ 8,  9, 10, 11],
#            [12, 13, 14, 15]])

x[1,1]
# Out: 5

x[0:3,0]
# Out: array([0, 4, 8])

x[0:3, 0:3]
# Out: 
#     array([[ 0,  1,  2],
#            [ 4,  5,  6],
#            [ 8,  9, 10]])

x[0:3:2, 0:3:2]
# Out: 
#     array([[ 0,  2],
#            [ 8, 10]])

배열 전치

arr = np.arange(10).reshape(2, 5)

.transpose 메소드 사용 :

arr.transpose()
# Out:  
#      array([[0, 5],
#            [1, 6],
#            [2, 7],
#            [3, 8],
#            [4, 9]])

.T 방법 :

arr.T
# Out: 
#     array([[0, 5],
#            [1, 6],
#            [2, 7],
#            [3, 8],
#            [4, 9]])

또는 np.transpose :

np.transpose(arr)
# Out:
#     array([[0, 5],
#            [1, 6],
#            [2, 7],
#            [3, 8],
#            [4, 9]])

2 차원 배열의 경우 이것은 표준 행렬 전치와 같습니다 (위 그림 참조). n 차원의 경우 배열 축의 순열을 지정할 수 있습니다. 기본적 array.shape 되돌 array.shape .

a = np.arange(12).reshape((3,2,2))
a.transpose() # equivalent to a.transpose(2,1,0)
# Out:
#   array([[[ 0,  4,  8],
#           [ 2,  6, 10]],
#
#          [[ 1,  5,  9],
#           [ 3,  7, 11]]])

그러나 축 인덱스의 모든 순열이 가능합니다.

a.transpose(2,0,1)
# Out:
#    array([[[ 0,  2],
#            [ 4,  6],
#            [ 8, 10]],
#    
#           [[ 1,  3],
#            [ 5,  7],
#            [ 9, 11]]])

a = np.arange(24).reshape((2,3,4))  # shape (2,3,4)
a.transpose(2,0,1).shape
# Out:
#    (4, 2, 3)

부울 색인 생성

arr = np.arange(7)
print(arr)
# Out: array([0, 1, 2, 3, 4, 5, 6])

스칼라와 비교하면 부울 배열이 반환됩니다.

arr > 4
# Out: array([False, False, False, False, False,  True,  True], dtype=bool)

이 배열은 4보다 큰 숫자 만 선택하기 위해 색인 생성에 사용할 수 있습니다.

arr[arr>4]
# Out: array([5, 6])

부울 색인 생성은 여러 배열 (예 : 관련 병렬 배열)간에 사용할 수 있습니다.

# Two related arrays of same length, i.e. parallel arrays
idxs = np.arange(10)
sqrs = idxs**2

# Retrieve elements from one array using a condition on the other
my_sqrs = sqrs[idxs % 2 == 0]
print(my_sqrs)
# Out: array([0, 4, 16, 36, 64])

배열 모양 변경하기

numpy.reshape (동일 numpy.ndarray.reshape ) 방법은 동일한 전체 크기의 배열을 반환하지만, 새로운 형상 :

print(np.arange(10).reshape((2, 5)))   
# [[0 1 2 3 4]
#  [5 6 7 8 9]]

새 배열을 반환하고 제 위치에서 작동하지 않습니다.

a = np.arange(12)
a.reshape((3, 4))
print(a)
# [ 0  1  2  3  4  5  6  7  8  9 10 11]

그러나, 덮어 쓰기 할 수있다 shape 의 AN 속성 ndarray :

a = np.arange(12)
a.shape = (3, 4)
print(a)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

이 동작은 처음에는 놀라운 일이지만 ndarray 는 연속적인 메모리 블록에 저장되며 그 shape 은이 데이터 스트림을 다차원 객체로 해석해야하는 방법 만 지정합니다.

shape 튜플의 한 축까지는 -1 값을 가질 수 있습니다. 그러면 numpy 가이 축의 길이를 추측합니다.

a = np.arange(12)
print(a.reshape((3, -1)))
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

또는:

a = np.arange(12)
print(a.reshape((3, 2, -1)))

# [[[ 0  1]
#   [ 2  3]]

#  [[ 4  5]
#   [ 6  7]]

#  [[ 8  9]
#   [10 11]]]

a.reshape((3, -1, -1)) 와 같은 여러 개의 지정되지 않은 차원은 허용되지 않으며 ValueError 시킵니다.

브로드 캐스팅 배열 작업

산술 연산은 Numpy 배열에서 요소 단위로 수행됩니다. 동일한 모양의 배열의 경우, 이는 해당 색인의 요소간에 연산이 수행됨을 의미합니다.

# Create two arrays of the same size
a = np.arange(6).reshape(2, 3)
b = np.ones(6).reshape(2, 3)

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

# a + b: a and b are added elementwise
a + b
# array([1, 2, 3],
#       [4, 5, 6])

산술 연산은 Numpy 방송 을 통해 다른 모양의 배열에서도 실행될 수 있습니다. 일반적으로 하나의 배열은 다른 요소 위에 "브로드 캐스팅"되므로 요소 모양 작업은 일치하는 모양의 하위 배열에서 수행됩니다.

# Create arrays of shapes (1, 5) and (13, 1) respectively
a = np.arange(5).reshape(1, 5)
a
# array([[0, 1, 2, 3, 4]])
b = np.arange(4).reshape(4, 1)
b
# array([0],
#       [1],
#       [2],
#       [3])

# When multiplying a * b, slices with the same dimensions are multiplied
# elementwise. In the case of a * b, the one and only row of a is multiplied
# with each scalar down the one and only column of b.
a*b
# array([[ 0,  0,  0,  0,  0],
#        [ 0,  1,  2,  3,  4],
#        [ 0,  2,  4,  6,  8],
#        [ 0,  3,  6,  9, 12]])

이를 더 설명하기 위해, 2D 및 3D 배열과 부합하는 하위 차원의 곱셈을 고려하십시오.

# Create arrays of shapes (2, 2, 3) and (2, 3) respectively
a = np.arange(12).reshape(2, 2, 3)
a
# array([[[ 0  1  2]
#         [ 3  4  5]]
#
#        [[ 6  7  8]
#         [ 9 10 11]]])
b = np.arange(6).reshape(2, 3)
# array([[0, 1, 2],
#        [3, 4, 5]])

# Executing a*b broadcasts b to each (2, 3) slice of a,
# multiplying elementwise.
a*b
# array([[[ 0,  1,  4],
#         [ 9, 16, 25]],
#
#        [[ 0,  7, 16],
#         [27, 40, 55]]])

# Executing b*a gives the same result, i.e. the smaller
# array is broadcast over the other.

배열 방송은 언제 적용됩니까?

방송은 두 배열이 호환 가능한 모양을 가질 때 발생합니다.

도형은 구성 요소별로 후행 구성 요소와 비교됩니다. 두 치수가 동일하거나 둘 중 하나가 1 경우 두 치수가 호환됩니다. 한 모양의 치수가 다른 모양보다 높으면 초과되는 구성 요소는 비교되지 않습니다.

호환되는 모양의 몇 가지 예 :

(7, 5, 3)    # compatible because dimensions are the same
(7, 5, 3)


(7, 5, 3)    # compatible because second dimension is 1  
(7, 1, 3)

(7, 5, 3, 5) # compatible because exceeding dimensions are not compared
      (3, 5)

(3, 4, 5)    # incompatible 
   (5, 5) 

(3, 4, 5)    # compatible 
   (1, 5) 

배열 방송 에 대한 공식 문서는 다음과 같습니다.

배열에 CSV 파일의 내용 채우기

filePath = "file.csv"
data = np.genfromtxt(filePath)

많은 옵션이 지원됩니다. 전체 목록은 공식 문서 를 참조하십시오.

data = np.genfromtxt(filePath, dtype='float', delimiter=';', skip_header=1, usecols=(0,1,3) )

Numpy n 차원 배열 : ndarray

numpy의 핵심 데이터 구조는 ndarray ( n- 차원 배열의 약자)입니다. ndarray 은 다음과 같습니다.

  • 균질 (즉, 동일한 데이터 유형의 항목을 포함합니다)
  • 고정 된 크기의 항목을 포함합니다 ( 모양 , 각 차원의 크기를 지정하는 n 개의 양의 정수로 구성된 튜플로 나타남)

1 차원 배열 :

x = np.arange(15)
# array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
x.shape
# (15,)

2 차원 배열 :

x = np.asarray([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
x
# array([[ 0, 1, 2, 3, 4],
# [ 5, 6, 7, 8, 9],
# [10, 11, 12, 13, 14]])
x.shape
# (3, 5)

3 차원 :

np.arange(12).reshape([2,3,2])

내용을 지정하지 않고 배열을 초기화하려면 다음을 사용하십시오.

x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])

데이터 유형 추측 및 자동 캐스팅

데이터 유형은 기본적으로 부동으로 설정됩니다.

x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])

x.dtype
# dtype('float64')

일부 데이터가 제공되면 numpy는 데이터 유형을 추측합니다.

x = np.asarray([[1, 2], [3, 4]])
x.dtype
# dtype('int32')

할당을 할 때 numpy는 ndarray 의 데이터 유형에 맞게 값을 자동으로 캐스팅하려고 시도합니다

x[1, 1] = 1.5 # assign a float value
x[1, 1]
# 1 
# value has been casted to int
x[1, 1] = 'z' # value cannot be casted, resulting in a ValueError

배열 방송

브로드 캐스팅 배열 작업을 참조하십시오.

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

행렬 용어로는 2x2 행렬과 1x2 행 벡터가 있습니다. 여전히 우리는 합계를 할 수 있습니다.

# x + y
array([[ 6, 8],
       [ 8, 10]])

이는 배열 y 가 다음과 같이 " 확장 "되기 때문입니다.

array([[5, 6],
       [5, 6]])

x 의 모양에 맞게.

자원:



Modified text is an extract of the original Stack Overflow Documentation
아래 라이선스 CC BY-SA 3.0
와 제휴하지 않음 Stack Overflow