간단한 소개

일반적인 수조는 수조에 같은 유형의 대상을 저장하는 것이다.구조화 수조는 지수 그룹에 서로 다른 대상을 저장하는 형식이다.
오늘은 NumPy 의 구조적 배열에 대해 자세히 살펴보겠습니다.

구조화된 그룹의 필드field

구조화된 수조에는 서로 다른 유형의 대상이 포함되어 있기 때문에 모든 대상 유형을field라고 부른다.
각field에는 string 형식의name, 유효한 dtype 형식의 type, 선택할 수 있는 title이 세 부분으로 구성되어 있습니다.
filed를 사용하여 dtype을 구축하는 예를 보십시오:

In [165]: np.dtype([('name', 'U10'), ('age', 'i4'), ('weight', 'f4')])
Out[165]: dtype([('name', '

위의 dtype 유형을 사용하여 새 배열을 구성할 수 있습니다.

In [166]: x = np.array([('Rex', 9, 81.0), ('Fido', 3, 27.0)],
     ...:     dtype=[('name', 'U10'), ('age', 'i4'), ('weight', 'f4')])
     ...:

In [167]: x
Out[167]:
array([('Rex', 9, 81.), ('Fido', 3, 27.)],
      dtype=[('name', '

x는 1차원 그룹으로 요소마다 세 개의 필드,name,age,weight를 포함한다.그리고 각각 그들의 데이터 형식을 지정했다.
index를 사용하여 데이터 행에 액세스할 수 있습니다.

In [168]: x[1]
Out[168]: ('Fido', 3, 27.)

name을 사용하여 다음 데이터 열에 액세스할 수도 있습니다.

In [170]: x['name']
Out[170]: array(['Rex', 'Fido'], dtype='

또한 모든 열에 값을 균일하게 지정할 수도 있습니다.

In [171]: x['age']
Out[171]: array([9, 3], dtype=int32)

In [172]: x['age'] = 10

In [173]: x
Out[173]:
array([('Rex', 10, 81.), ('Fido', 10, 27.)],
      dtype=[('name', '

구조화된 데이터 유형

위의 예는 우리로 하여금 구조화된 데이터 유형에 대해 기본적인 인식을 가지게 했다.구조화된 데이터 형식은 일련의 filed의 집합이다.

구조화된 데이터 유형 만들기

구조화된 데이터 유형은 기본 유형에서 작성되며 주로 다음과 같은 몇 가지 방법이 있습니다.

원조에서 생성

모든 모듈은 (fieldname, 데이터 type, shape) 라는 형식으로 되어 있으며, 그 중에서 shape는 선택할 수 있습니다.field name은 field title입니다.

In [174]: np.dtype([('x', 'f4'), ('y', np.float32), ('z', 'f4', (2, 2))])
Out[174]: dtype([('x', '

필드name이 빈 문자라면 f로 시작하는 형식으로 기본적으로 생성됩니다.

In [177]: np.dtype([('x', 'f4'), ('', 'i4'), ('z', 'i8')])
Out[177]: dtype([('x', '

쉼표로 분할된 dtype에서 만들기

쉼표로 분할된 dtype 유형을 선택하여 다음을 생성할 수 있습니다.

In [178]: np.dtype('i8, f4, S3')
Out[178]: dtype([('f0', '

사전에서 만들기

사전에서 만든 형식은 다음과 같습니다: {'names':......,'formats':......,'offsets':......,'titles':......,'itemsize':.....}
이 쓰기 방법은name 목록과formats 목록을 지정할 수 있습니다.
offsets는 모든 필드의byte offsets를 가리킨다.titles는 필드의 title이고 itemsize는 전체 dtype의size입니다.

In [180]: np.dtype({'names': ['col1', 'col2'], 'formats': ['i4', 'f4']})
Out[180]: dtype([('col1', '

구조화된 데이터 유형 조작

dtype의names와fields 필드를 통해 구조화된 데이터 형식의 속성에 접근할 수 있습니다.

>>> d = np.dtype([('x', 'i8'), ('y', 'f4')])
>>> d.names
('x', 'y')

>>> d.fields
mappingproxy({'x': (dtype('int64'), 0), 'y': (dtype('float32'), 8)})

Offsets 및 Alignment

구조화 형식에 대해 말하자면, 하나의 dtype에 여러 가지 데이터 형식이 포함되어 있기 때문에 기본적으로 이러한 데이터 형식은 일치하지 않는다.
다음 예제에서는 각 유형의 오프셋을 볼 수 있습니다.

>>> def print_offsets(d):
...     print("offsets:", [d.fields[name][1] for name in d.names])
...     print("itemsize:", d.itemsize)
>>> print_offsets(np.dtype('u1, u1, i4, u1, i8, u2'))
offsets: [0, 1, 2, 6, 7, 15]
itemsize: 17

dtype 형식을 만들 때 align=True를 지정하면, 이 유형들 사이는 C-struct의 구조에 따라 정렬될 수 있습니다.
정렬의 장점은 처리 효율을 높일 수 있다는 것이다.우리는 정렬된 예를 보았다.

>>> print_offsets(np.dtype('u1, u1, i4, u1, i8, u2', align=True))
offsets: [0, 1, 4, 8, 16, 24]
itemsize: 32

Field Titles

각 Filed에는 name 이외에도 title이 포함될 수 있습니다.
두 가지 방법으로 title을 지정할 수 있습니다. 첫 번째 방법은 다음과 같습니다.

In [182]: np.dtype([(('my title', 'name'), 'f4')])
Out[182]: dtype([(('my title', 'name'), '

두 번째 방법:

In [183]: np.dtype({'name': ('i4', 0, 'my title')})
Out[183]: dtype([(('my title', 'name'), '

필드의 구조를 보십시오:

In [187]: d.fields
Out[187]:
mappingproxy({'my title': (dtype('float32'), 0, 'my title'),
              'name': (dtype('float32'), 0, 'my title')})

구조화 배열

구조화된 데이터 형식에서 구조화된 그룹을 만들면 우리는 구조화된 그룹을 조작할 수 있다.

할당액

구조화된 배열에 값을 지정할 수 있습니다.

>>> x = np.array([(1, 2, 3), (4, 5, 6)], dtype='i8, f4, f8')
>>> x[1] = (7, 8, 9)
>>> x
array([(1, 2., 3.), (7, 8., 9.)],
     dtype=[('f0', '

구조화된 배열의 값을 눈금에서 지정할 수도 있습니다.

>>> x = np.zeros(2, dtype='i8, f4, ?, S1')
>>> x[:] = 3
>>> x
array([(3, 3., True, b'3'), (3, 3., True, b'3')],
      dtype=[('f0', '>> x[:] = np.arange(2)
>>> x
array([(0, 0., False, b'0'), (1, 1., True, b'1')],
      dtype=[('f0', '

구조화된 배열은 비구조화된 배열에도 값을 부여할 수 있지만 구조화된 배열에는 filed가 하나만 있어야 합니다.

>>> twofield = np.zeros(2, dtype=[('A', 'i4'), ('B', 'i4')])
>>> onefield = np.zeros(2, dtype=[('A', 'i4')])
>>> nostruct = np.zeros(2, dtype='i4')
>>> nostruct[:] = twofield
Traceback (most recent call last):
...
TypeError: Cannot cast array data from dtype([('A', '

구조화된 배열은 서로 값을 지정할 수도 있습니다.

>>> a = np.zeros(3, dtype=[('a', 'i8'), ('b', 'f4'), ('c', 'S3')])
>>> b = np.ones(3, dtype=[('x', 'f4'), ('y', 'S3'), ('z', 'O')])
>>> b[:] = a
>>> b
array([(0., b'0.0', b''), (0., b'0.0', b''), (0., b'0.0', b'')],
      dtype=[('x', '

액세스 구조화 배열

앞서 설명한 바와 같이 filed 이름을 사용하여 데이터를 액세스하고 수정할 수 있습니다.

>>> x = np.array([(1, 2), (3, 4)], dtype=[('foo', 'i8'), ('bar', 'f4')])
>>> x['foo']
array([1, 3])
>>> x['foo'] = 10
>>> x
array([(10, 2.), (10, 4.)],
      dtype=[('foo', '

되돌아오는 수치는 원시 그룹의 보기입니다. 그들은 메모리 공간을 공유하기 때문에 보기를 수정하는 동시에 원 데이터를 수정합니다.
filed가 다차원 그룹인 경우를 보십시오:

In [188]: np.zeros((2, 2), dtype=[('a', np.int32), ('b', np.float64, (3, 3))])
Out[188]:
array([[(0, [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]]),
        (0, [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]])],
       [(0, [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]]),
        (0, [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]])]],
      dtype=[('a', '

위에서 2*2의 행렬을 구축했는데 이 행렬의 첫 번째 열은 int 형식이고 두 번째 열은 3*3의float 행렬이다.
이렇게 하면 각 열의 shape 값을 볼 수 있습니다.

>>> x = np.zeros((2, 2), dtype=[('a', np.int32), ('b', np.float64, (3, 3))])
>>> x['a'].shape
(2, 2)
>>> x['b'].shape
(2, 2, 3, 3)

단일 열 액세스 외에도 한 번에 여러 열 데이터에 액세스할 수 있습니다.

>>> a = np.zeros(3, dtype=[('a', 'i4'), ('b', 'i4'), ('c', 'f4')])
>>> a[['a', 'c']]
array([(0, 0.), (0, 0.), (0, 0.)],
     dtype={'names':['a','c'], 'formats':['

여러 열에 동시에 값을 지정하려면 다음과 같이 하십시오.

>>> a[['a', 'c']] = (2, 3)
>>> a
array([(2, 0, 3.), (2, 0, 3.), (2, 0, 3.)],
      dtype=[('a', '

간단한 스왑 열 데이터:

>>> a[['a', 'c']] = a[['c', 'a']]

Record Arrays

구조화된 그룹은 index를 통해서만 접근할 수 있기 때문에 매우 불편합니다. 이 때문에 NumPy는 다차원 그룹의 하위 클래스numpy를 제공합니다.recarray, 그리고 속성을 통해 접근할 수 있습니다.
몇 가지 예를 살펴보겠습니다.

>>> recordarr = np.rec.array([(1, 2., 'Hello'), (2, 3., "World")],
...                    dtype=[('foo', 'i4'),('bar', 'f4'), ('baz', 'S10')])
>>> recordarr.bar
array([ 2.,  3.], dtype=float32)
>>> recordarr[1:2]
rec.array([(2, 3., b'World')],
      dtype=[('foo', '>> recordarr[1:2].foo
array([2], dtype=int32)
>>> recordarr.foo[1:2]
array([2], dtype=int32)
>>> recordarr[1].baz
b'World'

recarray가 되돌아오는 결과는 rec.array입니다.np를 제외하고는.rec.array 이외에view를 사용할 수 있습니다:

In [190]: arr = np.array([(1, 2., 'Hello'), (2, 3., "World")],
     ...: ...                dtype=[('foo', 'i4'),('bar', 'f4'), ('baz', 'a10')])
     ...:

In [191]: arr
Out[191]:
array([(1, 2., b'Hello'), (2, 3., b'World')],
      dtype=[('foo', '

rec.array 대상이라면, dtype 형식은np로 자동으로 변환됩니다.record 유형:

In [200]: recordarr.dtype
Out[200]: dtype((numpy.record, [('foo', '

원시적인np로 전환하고 싶습니다.ndarray 유형은 다음과 같습니다.

In [202]: recordarr.view(recordarr.dtype.fields or recordarr.dtype, np.ndarray)
Out[202]:
array([(1, 2., b'Hello'), (2, 3., b'World')],
      dtype=[('foo', '

index나field를 통해rec.array 대상의 필드에 접근하면, 필드가 구조 형식이면numpy로 되돌아옵니다.recarray, 비구조 형식이면numpy를 되돌려줍니다.ndarray:

>>> recordarr = np.rec.array([('Hello', (1, 2)), ("World", (3, 4))],
...                 dtype=[('foo', 'S6'),('bar', [('A', int), ('B', int)])])
>>> type(recordarr.foo)

>>> type(recordarr.bar)

본문은 이미 수록되었다http://www.flydean.com/05-python-structured-arrays/
가장 통속적인 해석, 가장 깊은 건조품, 가장 간결한 강좌, 당신이 모르는 많은 작은 기교를 발견할 수 있습니다!
저의 공식 번호인'프로그램 그런 것들'에 관심을 가져 주셔서 감사합니다. 기술을 알고 당신을 더 잘 알고 있습니다!