Bagaimana cara menginisialisasi array dua dimensi dengan Python?

Saya mulai python dan saya mencoba menggunakan daftar dua dimensi, yang awalnya saya isi dengan variabel yang sama di setiap tempat. Saya datang dengan ini:

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 = []

Ini memberikan hasil yang diinginkan, tetapi terasa seperti solusi. Apakah ada cara yang lebih mudah / lebih pendek / lebih elegan untuk melakukan ini?

Pola yang sering muncul dalam Python adalah

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

yang membantu memotivasi pengenalan daftar, yang mengubah cuplikan itu menjadi

bar = [SOME EXPRESSION for item in some_iterable]

yang lebih pendek dan terkadang lebih jelas. Biasanya Anda terbiasa mengenali ini dan sering mengganti loop dengan pemahaman.

Kode Anda mengikuti pola ini dua kali

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)                           /

Anda dapat menggunakan pemahaman daftar :

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)

Jangan gunakan [[v]*n]*n, itu jebakan!

>>> 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]]

tapi

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

bekerja dengan baik.

Cara ini lebih cepat daripada pemahaman daftar bersarang

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

Berikut adalah beberapa timing python3, untuk daftar kecil dan besar

$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

Penjelasan:

[[foo]*10]*10membuat daftar objek yang sama diulang 10 kali. Anda tidak bisa hanya menggunakan ini, karena memodifikasi satu elemen akan mengubah elemen yang sama di setiap baris!

x[:]setara dengan list(X)tetapi sedikit lebih efisien karena menghindari pencarian nama. Either way, itu membuat salinan dangkal setiap baris, jadi sekarang semua elemen independen.

Semua elemen adalah fooobjek yang sama , jadi jika foobisa berubah , Anda tidak dapat menggunakan skema ini., Anda harus menggunakannya

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

atau dengan asumsi kelas (atau fungsi) Fooyang mengembalikan foos

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

Untuk menginisialisasi array dua dimensi dengan Python:

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

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

Biasanya ketika Anda ingin array multidimensi Anda tidak ingin daftar daftar, melainkan array numpy atau mungkin dict.

Misalnya, dengan numpy Anda akan melakukan sesuatu seperti

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

Anda dapat melakukan ini:

[[element] * numcols] * numrows

Sebagai contoh:

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

Tetapi ini memiliki efek samping yang tidak diinginkan:

>>> 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)]

untuk n adalah jumlah baris, dan m adalah jumlah kolom, dan foo adalah nilainya.

Jika array ini jarang diisi, Anda mungkin lebih baik menggunakan kamus yang dikunci dengan tuple:

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

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

untuk setiap elemen baru [0]*10akan dibuat ..

Pendekatan Salah: [[Tidak Ada * 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

Dengan pendekatan ini, python tidak mengizinkan pembuatan ruang alamat yang berbeda untuk kolom luar dan akan menyebabkan berbagai kesalahan perilaku daripada yang Anda harapkan.

Pendekatan yang Benar tetapi dengan pengecualian:

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

Ini adalah pendekatan yang baik tetapi ada pengecualian jika Anda menetapkan nilai default 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

Jadi atur nilai default Anda dengan benar menggunakan pendekatan ini.

Benar sekali:

Ikuti balasan mike dari loop ganda .

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

Untuk menginisialisasi penggunaan array 2 dimensi: arr = [[]*m for i in range(n)]

sebenarnya, arr = [[]*m]*nakan membuat array 2D di mana semua n array akan menunjuk ke array yang sama, sehingga setiap perubahan nilai dalam elemen apa pun akan tercermin di semua daftar n

untuk penjelasan lebih lanjut, kunjungi: https://www.geeksforgeeks.org/python-using-2d-arrays-lists-the-right-way/

gunakan pemikiran paling sederhana untuk membuat ini.

wtod_list = []

dan tambahkan ukuran:

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

atau jika kita ingin mendeklarasikan ukurannya terlebih dahulu. kami hanya menggunakan:

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

Seperti yang ditunjukkan oleh @Arnab dan @Mike, array bukanlah daftar. Beberapa perbedaan adalah 1) array ukuran tetap selama inisialisasi 2) array biasanya mendukung operasi yang lebih rendah daripada daftar.

Mungkin berlebihan dalam banyak kasus, tapi di sini adalah implementasi array 2d dasar yang memanfaatkan implementasi array perangkat keras menggunakan python ctypes (c libraries)

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])

Yang penting saya mengerti adalah: Ketika menginisialisasi array (dalam dimensi apa pun), kita harus memberikan nilai default untuk semua posisi array. Maka hanya inisialisasi yang selesai. Setelah itu, kami dapat mengubah atau menerima nilai baru ke posisi array apa pun. Kode di bawah ini berfungsi dengan baik untuk saya

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)

Jika Anda menggunakan numpy , Anda dapat dengan mudah membuat array 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)]]

Di atas akan memberi Anda array 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]]

Ini menggunakan pemahaman daftar bersarang. Breakdown seperti di bawah ini:

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

[x] * col -> ekspresi akhir yang dievaluasi
untuk x in -> x akan menjadi nilai yang diberikan oleh iterator
[b untuk b dalam rentang (baris)]] -> Iterator.

[b untuk b dalam rentang (baris)]] ini akan dievaluasi menjadi [0,1,2,3,4] karena baris = 5
jadi sekarang ia disederhanakan menjadi

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

Ini akan mengevaluasi ke [[0] * 5 untuk x di [0,1,2,3,4]] -> dengan x = 0 iterasi pertama
[[1] * 5 untuk x di [0,1,2, 3,4]] -> dengan x = 1 iterasi ke 2
[[2] * 5 untuk x di [0,1,2,3,4]] -> dengan x = 2 iterasi ke-3
[[3] * 5 untuk x dalam [0,1,2,3,4]] -> dengan x = 3 iterasi ke 4
[[4] * 5 untuk x dalam [0,1,2,3,4]] -> dengan x = 4 iterasi ke-5

Ini adalah yang terbaik yang saya temukan untuk mengajar programmer baru, dan tanpa menggunakan perpustakaan tambahan. Saya ingin sesuatu yang lebih baik.

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

Ini cara yang lebih mudah:

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

Untuk menginisialisasi semua sel dengan menggunakan nilai 'x':

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

Seringkali saya menggunakan pendekatan ini untuk menginisialisasi array 2 dimensi

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

Pola umum untuk menambahkan dimensi dapat diambil dari seri ini:

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)

Anda dapat mencoba ini [[0] * 10] * 10. Ini akan mengembalikan array 2d dari 10 baris dan 10 kolom dengan nilai 0 untuk setiap sel.

lst = [[0] * m untuk saya dalam kisaran (n)]

inisialisasi semua matriks n = baris dan m = kolom

Cara lain adalah dengan menggunakan kamus untuk memegang array dua dimensi.

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

Ini hanya dapat menampung 1D, nilai 2D dan untuk menginisialisasi ini ke 0atau nilai int lainnya, gunakan koleksi .

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

Kode:

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 harus kekal.

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))