Zachowanie np.c_ z argumentami listy i krotki

Question

Wynik wyjściowy np.c_ różni się, gdy jego argumentami są listy lub krotki. Rozważyć wyjście z trzech następujących liniach

np.c_[[1,2]] 
np.c_[(1,2)] 
np.c_[(1,2),] 

z listą argumentów, np.c_ zwraca tablicę kolumn, jak oczekiwano. Gdy argumentem jest krotka (druga linia), zwraca wiersz 2D. Dodanie przecinka po krotce (trzecia linia) zwraca tablicę kolumn jak przy pierwszym wywołaniu.

Czy ktoś może wyjaśnić powody tego zachowania?

Answer 1

Istnieją 2 typowych przypadkach użycia np.c_:

• np.c_ może przyjmować sekwencji 1D macierzach takimi:

  In [98]: np.c_[[1,2],[3,4]] 
  Out[98]: 
  array([[1, 3], 
       [2, 4]]) 
  

• lub np.c_ może przyjąć sekwencję 2D array- polubienia:

  In [96]: np.c_[[[1,2],[3,4]], [[5,6],[7,8]]] 
  Out[96]: 
  array([[1, 2, 5, 6], 
       [3, 4, 7, 8]]) 
  

Tak więc np.c_ może być przekazywana w sposób podobny do tablic 1D lub 2D. Ale to rodzi pytanie, w jaki sposób np.c_ ma rozpoznać, czy dane wejściowe są pojedynczymi tablicami 2D (np. [[1,2], [3,4]]) lub sekwencją podobieństw tablic 1D (np. [1 , 2], [3,4])?

Deweloperzy podjęli decyzję projektową: jeśli np.c_ zostanie przekazana krotka, argument będzie traktowany jako ciąg oddzielnych podobieństw tablic. Jeśli zostanie przekazana nie-krotka (taka jak lista), wówczas obiekt ten będzie traktowany jako pojedynczy układ tablicowy.

Tak więc np.c_[[1,2], [3,4]] (co jest odpowiednikiem np.c_[([1,2], [3,4])]) będzie traktować ([1,2], [3,4]) jako dwie oddzielne tablice 1D.

In [99]: np.c_[[1,2], [3,4]] 
Out[99]: 
array([[1, 3], 
     [2, 4]]) 

Natomiast np.c_[[[1,2], [3,4]]] traktuje [[1,2], [3,4]] jako pojedynczy 2D tablicy.

In [100]: np.c_[[[1,2], [3,4]]] 
Out[100]: 
array([[1, 2], 
     [3, 4]]) 

---

Tak więc, w przykładach, opublikowanego:

np.c_[[1,2]] traktuje [1,2] jako pojedynczy 1D tablicowej, co oznacza, że ​​[1,2] w kolumnie tablicy 2D:

In [101]: np.c_[[1,2]] 
Out[101]: 
array([[1], 
     [2]]) 

np.c_[(1,2)] traktuje (1,2) 2 oddzielne array-like, tak umieszcza każdą wartość własną kolumna:

In [102]: np.c_[(1,2)] 
Out[102]: array([[1, 2]]) 

np.c_[(1,2),] traktuje krotki (1,2), (co jest równoważne ((1,2),)) w ciągu jednej tablicy podobne, tak, że tablica, jak jest traktowany jako kolumna:

In [103]: np.c_[(1,2),] 
Out[103]: 
array([[1], 
     [2]]) 

---

PS.Być może bardziej niż większość pakietów, NumPy ma historię treating lists and tuples differently. Ten link omawia sposób traktowania list i krotek w inny sposób po przekazaniu do np.array.

Answer 2

Pierwszy poziom na rozpatrywaniu argument pochodzi z interpretera, co przekłada [...] do wywołania __getitem__:

In [442]: class Foo(): 
    ...:  def __getitem__(self,args): 
    ...:   print(args) 
    ...:   
In [443]: Foo()['str'] 
str 
In [444]: Foo()[[1,2]] 
[1, 2] 
In [445]: Foo()[[1,2],] 
([1, 2],) 
In [446]: Foo()[(1,2)] 
(1, 2) 
In [447]: Foo()[(1,2),] 
((1, 2),) 

np.c_ jest wystąpienie np.lib.index_tricks.AxisConcatenator. To __getitem__

# handle matrix builder syntax 
    if isinstance(key, str): 
     .... 
     mymat = matrixlib.bmat(...) 
     return mymat 

    if not isinstance(key, tuple): 
     key = (key,) 

    .... 
    for k, item in enumerate(key): 
     .... 

Więc wyjątkiem kompatybilnym ciąg np.bmat okazuje wszystkie wejścia do krotki, a następnie dokonuje iteracji po elementach.

Każda z wersji zawierających [1,2] jest taka sama jak ([1,2],), krotka z jednym elementem. (1,2) to dwa elementy, które zostaną połączone. Tak jest ([1,2],[3,4]).

Uwaga: indeksowanie numpy rozróżnia także listy i krotki (choć z kilkoma niespójnościami).

In [455]: x=np.arange(24).reshape(2,3,4) 
In [456]: x[0,1]    # tuple - index for each dim 
Out[456]: array([4, 5, 6, 7]) 
In [457]: x[(0,1)]    # same tuple 
Out[457]: array([4, 5, 6, 7]) 
In [458]: x[[0,1]]    # list - index for one dim 
Out[458]: 
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]]]) 
In [459]: x[([0,1],)]   # same 
    ....