Jak zainicjować tablicę dwuwymiarową w Pythonie?

Zaczynam python i próbuję użyć dwuwymiarowej listy, którą początkowo wypełniam tą samą zmienną w każdym miejscu. Wymyśliłem to:

def initialize_twodlist(foo):
    twod_list = []
    new = []
    for i in range (0, 10):
        for j in range (0, 10):
            new.append(foo)
        twod_list.append(new)
        new = []

Daje pożądany efekt, ale wydaje się obejściem. Czy jest na to łatwiejszy / krótszy / bardziej elegancki sposób?

Wzorem, który często pojawiał się w Pythonie, był

bar = []
for item in some_iterable:
    bar.append(SOME EXPRESSION)

który pomógł zmotywować wprowadzenie wyrażeń listowych, które przekonwertują ten fragment

bar = [SOME EXPRESSION for item in some_iterable]

który jest krótszy, a czasem jaśniejszy. Zwykle przyzwyczajasz się do ich rozpoznawania i często zastępujesz pętle zrozumieniem.

Twój kod jest dwa razy zgodny z tym wzorcem

twod_list = []                                       \                      
for i in range (0, 10):                               \
    new = []                  \ can be replaced        } this too
    for j in range (0, 10):    } with a list          /
        new.append(foo)       / comprehension        /
    twod_list.append(new)                           /

Możesz użyć rozumienia listy :

x = [[foo for i in range(10)] for j in range(10)]
# x is now a 10x10 array of 'foo' (which can depend on i and j if you want)

Ta metoda jest szybsza niż interpretacja listy zagnieżdżonej

[x[:] for x in [[foo] * 10] * 10]    # for immutable foo!

Oto niektóre czasy Python3 dla małych i dużych list

$python3 -m timeit '[x[:] for x in [[1] * 10] * 10]'
1000000 loops, best of 3: 1.55 usec per loop

$ python3 -m timeit '[[1 for i in range(10)] for j in range(10)]'
100000 loops, best of 3: 6.44 usec per loop

$ python3 -m timeit '[x[:] for x in [[1] * 1000] * 1000]'
100 loops, best of 3: 5.5 msec per loop

$ python3 -m timeit '[[1 for i in range(1000)] for j in range(1000)]'
10 loops, best of 3: 27 msec per loop

Wyjaśnienie:

[[foo]*10]*10tworzy listę tego samego obiektu powtarzaną 10 razy. Nie możesz tego po prostu użyć, ponieważ modyfikacja jednego elementu spowoduje zmodyfikowanie tego samego elementu w każdym wierszu!

x[:]jest równoważne, list(X)ale jest nieco bardziej wydajne, ponieważ pozwala uniknąć wyszukiwania nazw. Tak czy inaczej, tworzy płytką kopię każdego wiersza, więc teraz wszystkie elementy są niezależne.

Wszystkie elementy są tym samym fooobiektem, więc jeśli foomożna go modyfikować , nie możesz użyć tego schematu., Musisz użyć

import copy
[[copy.deepcopy(foo) for x in range(10)] for y in range(10)]

lub przyjęcie klasy (lub funkcji), Fooktóra zwraca foos

[[Foo() for x in range(10)] for y in range(10)]

Nie używaj [[v]*n]*n, to pułapka!

>>> a = [[0]*3]*3
>>> a
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> a[0][0]=1
>>> a
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]

ale

    t = [ [0]*3 for i in range(3)]

działa świetnie.

Aby zainicjować tablicę dwuwymiarową w Pythonie:

a = [[0 for x in range(columns)] for y in range(rows)]

[[foo for x in xrange(10)] for y in xrange(10)]

Zwykle, gdy potrzebujesz tablic wielowymiarowych, nie potrzebujesz listy list, a raczej tablicy numpy lub ewentualnie dyktanda.

Na przykład za pomocą numpy zrobiłbyś coś takiego

import numpy
a = numpy.empty((10, 10))
a.fill(foo)

Możesz to zrobić:

[[element] * numcols] * numrows

Na przykład:

>>> [['a'] *3] * 2
[['a', 'a', 'a'], ['a', 'a', 'a']]

Ale ma to niepożądany efekt uboczny:

>>> b = [['a']*3]*3
>>> b
[['a', 'a', 'a'], ['a', 'a', 'a'], ['a', 'a', 'a']]
>>> b[1][1]
'a'
>>> b[1][1] = 'b'
>>> b
[['a', 'b', 'a'], ['a', 'b', 'a'], ['a', 'b', 'a']]

twod_list = [[foo for _ in range(m)] for _ in range(n)]

dla n oznacza liczbę wierszy, a m jest liczbą kolumn, a foo jest wartością.

Jeśli jest to tablica słabo zaludniona, lepiej byłoby użyć słownika z krotką:

dict = {}
key = (a,b)
dict[key] = value
...

t = [ [0]*10 for i in [0]*10]

dla każdego elementu [0]*10zostanie utworzony nowy ..

Niepoprawne podejście: [[None * m] * n]

>>> m, n = map(int, raw_input().split())
5 5
>>> x[0][0] = 34
>>> x
[[34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None], [34, None, None, None, None]]
>>> id(x[0][0])
140416461589776
>>> id(x[3][0])
140416461589776

Dzięki takiemu podejściu python nie pozwala na tworzenie innej przestrzeni adresowej dla zewnętrznych kolumn i doprowadzi do innego niewłaściwego zachowania niż się spodziewasz.

Prawidłowe podejście, ale z wyjątkiem:

y = [[0 for i in range(m)] for j in range(n)]
>>> id(y[0][0]) == id(y[1][0])
False

Jest to dobre podejście, ale istnieje wyjątek, jeśli ustawisz wartość domyślną na None

>>> r = [[None for i in range(5)] for j in range(5)]
>>> r
[[None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None], [None, None, None, None, None]]
>>> id(r[0][0]) == id(r[2][0])
True

Więc ustaw poprawnie wartość domyślną, stosując to podejście.

Absolutnie poprawne:

Postępuj zgodnie z odpowiedzią Mike'a dotyczącą podwójnej pętli .

Matrix={}
for i in range(0,3):
  for j in range(0,3):
    Matrix[i,j] = raw_input("Enter the matrix:")

Aby zainicjować tablicę dwuwymiarową, użyj: arr = [[]*m for i in range(n)]

faktycznie arr = [[]*m]*nstworzy tablicę 2D, w której wszystkie n tablic wskaże tę samą tablicę, więc każda zmiana wartości w dowolnym elemencie zostanie odzwierciedlona na wszystkich n listach

więcej dalszych wyjaśnień na stronie: https://www.geeksforgeeks.org/python-using-2d-arrays-lists-the-right-way/

użyj najprostszej myśli, aby to stworzyć.

wtod_list = []

i dodaj rozmiar:

wtod_list = [[0 for x in xrange(10)] for x in xrange(10)]

lub jeśli chcemy najpierw zadeklarować rozmiar. używamy tylko:

   wtod_list = [[0 for x in xrange(10)] for x in xrange(10)]

Jak zauważyli @Arnab i @Mike, tablica nie jest listą. Kilka różnic to 1) tablice mają ustalony rozmiar podczas inicjalizacji 2) tablice zwykle obsługują mniejsze operacje niż lista.

Może w większości przypadków przesada, ale tutaj jest podstawowa implementacja tablicy 2d, która wykorzystuje sprzętową implementację tablicy przy użyciu ctypów python (bibliotek c)

import ctypes
class Array:
    def __init__(self,size,foo): #foo is the initial value
        self._size = size
        ArrayType = ctypes.py_object * size
        self._array = ArrayType()
        for i in range(size):
            self._array[i] = foo
    def __getitem__(self,index):
        return self._array[index]
    def __setitem__(self,index,value):
        self._array[index] = value
    def __len__(self):
        return self._size

class TwoDArray:
    def __init__(self,columns,rows,foo):
        self._2dArray = Array(rows,foo)
        for i in range(rows):
            self._2dArray[i] = Array(columns,foo)

    def numRows(self):
        return len(self._2dArray)
    def numCols(self):
        return len((self._2dArray)[0])
    def __getitem__(self,indexTuple):
        row = indexTuple[0]
        col = indexTuple[1]
        assert row >= 0 and row < self.numRows() \
               and col >=0 and col < self.numCols(),\
               "Array script out of range"
        return ((self._2dArray)[row])[col]

if(__name__ == "__main__"):
    twodArray = TwoDArray(4,5,5)#sample input
    print(twodArray[2,3])

Ważną rzeczą, którą zrozumiałem, jest: Podczas inicjowania tablicy (w dowolnym wymiarze) powinniśmy nadać domyślną wartość wszystkim pozycjom tablicy. Następnie kończy się tylko inicjalizacja. Następnie możemy zmienić lub otrzymać nowe wartości do dowolnej pozycji tablicy. Poniższy kod działał dla mnie idealnie

N=7
F=2

#INITIALIZATION of 7 x 2 array with deafult value as 0
ar=[[0]*F for x in range(N)]

#RECEIVING NEW VALUES TO THE INITIALIZED ARRAY
for i in range(N):
    for j in range(F):
        ar[i][j]=int(input())
print(ar)

Jeśli używasz numpy , możesz łatwo tworzyć tablice 2D:

import numpy as np

row = 3
col = 5
num = 10
x = np.full((row, col), num)

x

array([[10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10]])

row=5
col=5
[[x]*col for x in [b for b in range(row)]]

Powyższe daje macierz 2D 5x5

[[0, 0, 0, 0, 0],
 [1, 1, 1, 1, 1],
 [2, 2, 2, 2, 2],
 [3, 3, 3, 3, 3],
 [4, 4, 4, 4, 4]]

Korzysta ze zrozumienia listy zagnieżdżonej. Podział jak poniżej:

[[x]*col for x in [b for b in range(row)]]

[x] * col -> końcowe wyrażenie, które jest oceniane
dla x w -> x będzie wartością podaną przez iterator
[b dla bw zakresie (wiersz)]] -> Iterator.

[b dla bw przedziale (rzędzie)]] spowoduje to ocenę do [0,1,2,3,4], ponieważ wiersz = 5,
więc teraz upraszcza się

[[x]*col for x in [0,1,2,3,4]]

Będzie to oceniać na [[0] * 5 dla x w [0,1,2,3,4]] -> przy x = 0 1. iteracja
[[1] * 5 dla x w [0,1,2, 3,4]] -> przy x = 1 2. iteracja
[[2] * 5 dla x w [0,1,2,3,4]] -> przy x = 2 3. iteracja
[[3] * 5 dla x w [0,1,2,3,4]] -> przy x = 3 4. iteracja
[[4] * 5 dla x w [0,1,2,3,4]] -> z x = 4 5. iteracja

To najlepsze, jakie znalazłem do nauczania nowych programistów i bez korzystania z dodatkowych bibliotek. Chciałbym jednak coś lepszego.

def initialize_twodlist(value):
    list=[]
    for row in range(10):
        list.append([value]*10)
    return list

Oto łatwiejszy sposób:

import numpy as np
twoD = np.array([[]*m]*n)

Do zainicjowania wszystkich komórek dowolną wartością „x” użyj:

twoD = np.array([[x]*m]*n

Często używam tego podejścia do inicjowania tablicy dwuwymiarowej

n=[[int(x) for x in input().split()] for i in range(int(input())]

Ogólny wzór dodawania wymiarów można narysować z tej serii:

x = 0
mat1 = []
for i in range(3):
    mat1.append(x)
    x+=1
print(mat1)


x=0
mat2 = []
for i in range(3):
    tmp = []
    for j in range(4):
        tmp.append(x)
        x+=1
    mat2.append(tmp)

print(mat2)


x=0
mat3 = []
for i in range(3):
    tmp = []
    for j in range(4):
        tmp2 = []
        for k in range(5):
            tmp2.append(x)
            x+=1
        tmp.append(tmp2)
    mat3.append(tmp)

print(mat3)

Możesz spróbować tego [[0] * 10] * 10. Zwróci tablicę 2d 10 wierszy i 10 kolumn o wartości 0 dla każdej komórki.

lst = [[0] * m dla i w zakresie (n)]

zainicjuj całą macierz n = wiersze im = kolumny

Innym sposobem jest użycie słownika do przechowywania tablicy dwuwymiarowej.

twoD = {}
twoD[0,0] = 0
print(twoD[0,0]) # ===> prints 0

Może to po prostu przechowywać dowolne wartości 1D, 2D i aby zainicjować tę wartość 0lub dowolną inną wartość int, użyj kolekcji .

import collections
twoD = collections.defaultdict(int)
print(twoD[0,0]) # ==> prints 0
twoD[1,1] = 1
print(twoD[1,1]) # ==> prints 1

Kod:

num_rows, num_cols = 4, 2
initial_val = 0
matrix = [[initial_val] * num_cols for _ in range(num_rows)]
print(matrix) 
# [[0, 0], [0, 0], [0, 0], [0, 0]]

initial_val musi być niezmienny.

from random import randint
l = []

for i in range(10):
    k=[]
    for j in range(10):
        a= randint(1,100)
        k.append(a)

    l.append(k)




print(l)
print(max(l[2]))

b = []
for i in range(10):
    a = l[i][5]
    b.append(a)

print(min(b))