Matrix Зеркальное в питона

Question

У меня есть матрица чисел:

[[a, b, c] 
[d, e, f] 
[g, h, i]] 

, что я хотел бы отражал соответственно:

[[g, h, i] 
[d, e, f] 
[a, b, c] 
[d, e, f] 
[g, h, i]] 

И затем снова выход:

[[i, h, g, h, i] 
[f, e, d, e, f] 
[c, b, a, b, c] 
[f, e, d, e, f] 
[i, h, g, h, i]] 

Я хотел бы придерживаться базовых пакетов Python, таких как numpy. Заранее благодарю за любую помощь!!

Answer 1

Это может быть достигнуто с помощью простой вспомогательной функции в чистом питоне:

def mirror(seq): 
    output = list(seq[::-1]) 
    output.extend(seq[1:]) 
    return output 

inputs = [ 
    ['a', 'b', 'c'], 
    ['d', 'e', 'f'], 
    ['g', 'h', 'i'], 
] 
print(mirror([mirror(sublist) for sublist in inputs])) 

Очевидно, что после того, как зеркальная список будет создан, вы можете использовать его, чтобы создать Numpy массив или любой другой ...

Answer 2

Это помечено numpy, так что я буду считать вашу матрицу является 2d массив

In [937]: A=np.arange(9).reshape(3,3) 
In [938]: A 
Out[938]: 
array([[0, 1, 2], 
     [3, 4, 5], 
     [6, 7, 8]]) 

листать его на строки:

In [939]: A[::-1,:] 
Out[939]: 
array([[6, 7, 8], 
     [3, 4, 5], 
     [0, 1, 2]]) 

конкатенации вертикально

In [940]: np.concatenate((A[::-1,:],A), axis=0) 
Out[940]: 
array([[6, 7, 8], 
     [3, 4, 5], 
     [0, 1, 2], 
     [0, 1, 2], 
     [3, 4, 5], 
     [6, 7, 8]]) 

удаление дубликат первая строка

In [941]: np.concatenate((A[::-1,:],A[1:,:]), axis=0) 
Out[941]: 
array([[6, 7, 8], 
     [3, 4, 5], 
     [0, 1, 2], 
     [3, 4, 5], 
     [6, 7, 8]]) 

Как вы думаете, вы можете сделать то же самое с горизонтальной (колонкой) разворота и конкатенацией (ось = 1)?

Answer 3

И здесь не является NumPy решение:

a = [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']] 
b = list(reversed(a[1:])) + a # vertical mirror 
c = list(zip(*b)) # transpose 
d = list(reversed(c[1:])) + C# another vertical mirror 
e = list(zip(*d)) # transpose again 

Answer 4

Предположим, у вас есть

from numpy import array, concatenate 
m = array([[1, 2, 3], 
      [4, 5, 6], 
      [7, 8, 9]]) 

Вы можете инвертировать это вдоль первой (вертикальной) оси с помощью

>>> m[::-1, ...] 
array([[7, 8, 9], 
     [4, 5, 6], 
     [1, 2, 3]]) 

, где ::-1 выбирает строки от последнего до первого с шагом -1.

Чтобы опустить последнюю строку, явно задать для выбора немедленно остановиться перед 0:

>>> m[:0:-1, ...] 
array([[7, 8, 9], 
     [4, 5, 6]]) 

Это может быть сцеплены вдоль первой оси

p = concatenate([m[:0:-1, ...], m], axis=0) 

в форме:

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

Это можно повторить и по другой оси:

q = concatenate([p[..., :0:-1], p], axis=1) 

получая

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

Answer 5

import numpy as np 

X= [[1, 2, 3], 
    [4, 5, 6], 
    [7, 8, 9]] 

A = np.asanyarray(X) 
B= np.flipud(A) 
C= np.concatenate((B, A[1:]), axis=0) 
D = C[:,1:] 
F = np.fliplr(C) 
E = np.concatenate((F, D), axis=1) 

print(E) 

Я добавил шаг за шагом трансформации. flipud и flipud refrence

выход

[[9 8 7 8 9] 
[6 5 4 5 6] 
[3 2 1 2 3] 
[6 5 4 5 6] 
[9 8 7 8 9]] 

Answer 6

m = [['a', 'b', 'c'], 
    ['d', 'e', 'f'], 
    ['g', 'h', 'i']] 

m_m = [[m[abs(i)][abs(j)] 
     for j in range(-len(m)+1, len(m))] 
     for i in range(-len(m)+1, len(m))] 

Или с помощью NumPy

m = array([['a', 'b', 'c'], 
      ['d', 'e', 'f'], 
      ['g', 'h', 'i']]) 

m_m = m.T[meshgrid(*2*[abs(arange(-len(m) + 1, len(m)))])] 

Answer 7

Использование numpy.lib.pad с 'reflect'

m = [['a', 'b', 'c'], 
    ['d', 'e', 'f'], 
    ['g', 'h', 'i']] 

n=np.lib.pad(m,((2,0),(2,0)),'reflect') 

n 
Out[8]: 
array([['i', 'h', 'g', 'h', 'i'], 
     ['f', 'e', 'd', 'e', 'f'], 
     ['c', 'b', 'a', 'b', 'c'], 
     ['f', 'e', 'd', 'e', 'f'], 
     ['i', 'h', 'g', 'h', 'i']], 
     dtype='<U1')