Dwuwymiarowa uporządkowana tablica - python-2.7, numpy, tablica strukturalna

Próbuję zbudować structured array w Pythonie, do którego można uzyskać dostęp poprzez nazwy kolumn i wierszy. Czy to możliwe z structured array metoda numpy?

Przykład: Moja tablica powinna mieć mniej więcej taką postać:

My_array =        A B C
E 1 2 3
F 4 5 6
G 7 8 9

I chcę mieć możliwość wykonania następujących czynności:

My_array["A"]["E"] = 1
My_array["C"]["F"] = 6

Czy można to zrobić za pomocą pythona? structured arrays czy istnieje inny rodzaj struktury, który jest bardziej odpowiedni do takiego zadania?

Odpowiedzi:

1 dla odpowiedzi № 1

Dzięki ponownemu zapisowi możesz uzyskać dostęp do kolumn za pomocą kropkinotację lub ze szczególnym odniesieniem do nazwy kolumny. W przypadku wierszy są one dostępne po numerze wiersza. Nie widziałem dostępu do nich przez nazwę rzędu, na przykład:

>>> import numpy as np
>>> a = np.arange(1,10,1).reshape(3,3)
>>> dt = np.dtype([("A","int"),("B","int"),("C","int")])
>>> a.dtype = dt
>>> r = a.view(type=np.recarray)
>>> r
rec.array([[(1, 2, 3)],
[(4, 5, 6)],
[(7, 8, 9)]],
dtype=[("A", "<i4"), ("B", "<i4"), ("C", "<i4")])
>>> r.A
array([[1],
[4],
[7]])
>>> r["A"]
array([[1],
[4],
[7]])
>>> r.A[0]
array([1])
>>> a["A"][0]
array([1])
>>> # now for the row
>>> >>> r[0]
rec.array([(1, 2, 3)],
dtype=[("A", "<i4"), ("B", "<i4"), ("C", "<i4")])
>>>

Możesz podać typ dtype i typ w tym samym czasie

>>> a = np.ones((3,3))
>>> b = a.view(dtype= [("A","<f8"), ("B","<f8"),("C", "<f8")], type = np.recarray)
>>> b
rec.array([[(1.0, 1.0, 1.0)],
[(1.0, 1.0, 1.0)],
[(1.0, 1.0, 1.0)]],
dtype=[("A", "<f8"), ("B", "<f8"), ("C", "<f8")])
>>> b.A
array([[ 1.],
[ 1.],
[ 1.]])
>>> b.A[0]
array([ 1.])

---

1 dla odpowiedzi nr 2

Podstawowa tablica strukturalna daje coś, co można zaindeksować jedną nazwą:

In [276]: dt=np.dtype([("A",int),("B",int),("C",int)])
In [277]: x=np.arange(9).reshape(3,3).view(dtype=dt)
In [278]: x
Out[278]:
array([[(0, 1, 2)],
[(3, 4, 5)],
[(6, 7, 8)]],
dtype=[("A", "<i4"), ("B", "<i4"), ("C", "<i4")])

In [279]: x["B"]   # index by field name
Out[279]:
array([[1],
[4],
[7]])

In [280]: x[1]    # index by row (array element)
Out[280]:
array([(3, 4, 5)],
dtype=[("A", "<i4"), ("B", "<i4"), ("C", "<i4")])

In [281]: x["B"][1]
Out[281]: array([4])

In [282]: x.shape    # could be reshaped to (3,)
Out[282]: (3, 1)

Podejście widoku tworzy tablicę 2D, ale z jedną kolumną. Typowe kolumny są zastępowane polami dtype. To 2d, ale z niespodzianką view bufor danych pozostaje niezmieniony; dtype zapewnia tylko inny sposób dostępu do tych "kolumn". dtype pola z technicznego punktu widzenia nie są wymiarem. Nie rejestrują się ani w .shape lub .ndim tablicy. Również nie możesz tego użyć x[0,"A"].

recarray robi to samo, ale dodaje opcję dostępu do pól jako atrybutów, np. x.B jest taki sam jak x["B"].

rows nadal musi być dostępny według numeru indeksu.

Innym sposobem konstruowania tablicy strukturalnej jest zdefiniowanie wartości jako listy krotek.

In [283]: x1 = np.arange(9).reshape(3,3)
In [284]: x2=np.array([tuple(i) for i in x1],dtype=dt)
In [285]: x2
Out[285]:
array([(0, 1, 2), (3, 4, 5), (6, 7, 8)],
dtype=[("A", "<i4"), ("B", "<i4"), ("C", "<i4")])
In [286]: x2.shape
Out[286]: (3,)

ones, zeros, empty również skonstruuj podstawowe uporządkowane tablice

In [287]: np.ones((3,),dtype=dt)
Out[287]:
array([(1, 1, 1), (1, 1, 1), (1, 1, 1)],
dtype=[("A", "<i4"), ("B", "<i4"), ("C", "<i4")])

Mogę zbudować tablicę, która jest indeksowana 2 nazwami pól, poprzez zagnieżdżanie dtypów:

In [294]: dt1=np.dtype([("D",int),("E",int),("F",int)])

In [295]: dt2=np.dtype([("A",dt1),("B",dt1),("C",dt1)])

In [296]: y=np.ones((),dtype=dt2)

In [297]: y
Out[297]:
array(((1, 1, 1), (1, 1, 1), (1, 1, 1)),
dtype=[("A", [("D", "<i4"), ("E", "<i4"), ("F", "<i4")]), ("B", [("D", "<i4"), ("E", "<i4"), ("F", "<i4")]), ("C", [("D", "<i4"), ("E", "<i4"), ("F", "<i4")])])

In [298]: y["A"]["F"]
Out[298]: array(1)

Ale szczerze mówiąc, jest to raczej zawiłe. Nie wiedziałem nawet, jak ustawić elementy arange(9) (bez powtarzania nazw pól).

Strukturyzowane tablice są najczęściej produkowane przez czytanie csv pliki z np.genfromtxt (lub loadtxt). Wynikiem jest nazwane pole dla każdej kolumny z etykietą i numerowany "wiersz" dla każdej linii w pliku.

---