วิธีการเริ่มต้นอาร์เรย์สองมิติใน Python ได้อย่างไร

ฉันเริ่มต้นไพ ธ อนและฉันพยายามใช้รายการสองมิติซึ่งตอนแรกฉันเติมตัวแปรตัวเดียวกันในทุกที่ ฉันมากับสิ่งนี้:

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

มันให้ผลลัพธ์ที่ต้องการ แต่ให้ความรู้สึกเหมือนเป็นวิธีแก้ปัญหา มีวิธีที่ง่ายกว่า / สั้นกว่า / สวยงามกว่านี้หรือไม่?

รูปแบบที่พบบ่อยใน Python คือ

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

ซึ่งช่วยกระตุ้นการเปิดตัวรายการความเข้าใจซึ่งแปลงส่วนย่อยนั้นเป็น

bar = [SOME EXPRESSION for item in some_iterable]

ซึ่งสั้นกว่าและบางครั้งก็ชัดเจนขึ้น โดยปกติคุณจะติดนิสัยในการจดจำสิ่งเหล่านี้และมักจะแทนที่การวนซ้ำด้วยความเข้าใจ

รหัสของคุณเป็นไปตามรูปแบบนี้สองครั้ง

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

คุณสามารถใช้list comprehension :

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)

วิธีนี้เร็วกว่าความเข้าใจในรายการซ้อน

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

นี่คือการกำหนดเวลา python3 บางรายการสำหรับรายการขนาดเล็กและขนาดใหญ่

$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

คำอธิบาย:

[[foo]*10]*10สร้างรายการของวัตถุเดียวกันซ้ำแล้วซ้ำอีก 10 ครั้ง คุณไม่สามารถใช้สิ่งนี้เพราะการแก้ไของค์ประกอบหนึ่งจะแก้ไของค์ประกอบเดียวกันในแต่ละแถว!

x[:]เทียบเท่ากับlist(X)แต่มีประสิทธิภาพมากกว่านี้เล็กน้อยเนื่องจากไม่ต้องค้นหาชื่อ ไม่ว่าจะด้วยวิธีใดก็สร้างสำเนาตื้นของแต่ละแถวดังนั้นตอนนี้องค์ประกอบทั้งหมดจึงเป็นอิสระ

องค์ประกอบทั้งหมดเป็นfooวัตถุเดียวกันแม้ว่าดังนั้นหากfooไม่แน่นอนคุณไม่สามารถใช้รูปแบบนี้ได้คุณต้องใช้

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

หรือสมมติคลาส (หรือฟังก์ชัน) Fooที่ส่งคืนfoos

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

อย่าใช้[[v]*n]*nมันเป็นกับดัก!

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

แต่

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

ใช้งานได้ดี

ในการเริ่มต้นอาร์เรย์สองมิติใน Python:

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

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

โดยปกติเมื่อคุณต้องการอาร์เรย์หลายมิติคุณไม่ต้องการรายการของรายการ แต่เป็นอาร์เรย์ numpy หรือ dict

ตัวอย่างเช่นด้วย numpy คุณจะทำอะไรเช่น

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

คุณสามารถทำสิ่งนี้:

[[element] * numcols] * numrows

ตัวอย่างเช่น:

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

แต่สิ่งนี้มีผลข้างเคียงที่ไม่พึงประสงค์:

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

สำหรับ n คือจำนวนแถวและ m คือจำนวนคอลัมน์และ foo คือค่า

หากเป็นอาเรย์ที่มีประชากรเบาบางคุณอาจจะดีกว่าถ้าใช้พจนานุกรมที่มี tuple

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

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

สำหรับแต่ละองค์ประกอบ[0]*10จะมีการสร้างใหม่ ..

วิธีการที่ไม่ถูกต้อง: [[ไม่มี * 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

ด้วยวิธีการนี้ python ไม่อนุญาตให้สร้างพื้นที่ที่อยู่ที่แตกต่างกันสำหรับคอลัมน์ด้านนอกและจะนำไปสู่พฤติกรรมที่ไม่เหมาะสมมากกว่าที่คุณคาดหวัง

วิธีการที่ถูกต้อง แต่มีข้อยกเว้น:

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

มันเป็นวิธีการที่ดี แต่มีข้อยกเว้นหากคุณตั้งค่าเริ่มต้นเป็น 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

ดังนั้นตั้งค่าเริ่มต้นของคุณอย่างถูกต้องโดยใช้วิธีนี้

ถูกต้องทั้งหมด:

ติดตามการตอบกลับไมค์ของสองวง

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

ในการเริ่มต้นใช้อาร์เรย์แบบสองมิติ: arr = [[]*m for i in range(n)]

จริง ๆ แล้ว arr = [[]*m]*nจะสร้างอาร์เรย์ 2 มิติซึ่ง n อาร์เรย์ทั้งหมดจะชี้ไปยังอาร์เรย์เดียวกันดังนั้นการเปลี่ยนแปลงค่าใด ๆ ในองค์ประกอบใด ๆ จะปรากฏในรายการ n ทั้งหมด

สำหรับคำอธิบายเพิ่มเติมเพิ่มเติมได้ที่: https://www.geeksforgeeks.org/python-using-2d-arrays-lists-the-right-way/

ใช้ความคิดที่ง่ายที่สุดในการสร้างสิ่งนี้

wtod_list = []

และเพิ่มขนาด:

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

หรือถ้าเราต้องการประกาศขนาดแรก เราใช้เท่านั้น:

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

เนื่องจาก @Arnab และ @Mike ชี้ให้เห็นว่าอาร์เรย์ไม่ใช่รายการ ความแตกต่างเล็กน้อยคือ 1) อาร์เรย์มีขนาดคงที่ในระหว่างการเริ่มต้น 2) อาร์เรย์โดยปกติจะสนับสนุนการดำเนินการที่น้อยกว่ารายการ

อาจจะ overkill ในกรณีส่วนใหญ่ แต่นี่คือการใช้งานอาร์เรย์ 2d ขั้นพื้นฐานที่ใช้ประโยชน์จากการใช้งานอาร์เรย์ฮาร์ดแวร์โดยใช้ python ctypes (ไลบรารี 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])

สิ่งสำคัญที่ฉันเข้าใจคือ: ในขณะที่เริ่มต้นอาร์เรย์ (ในมิติใด ๆ ) เราควรให้ค่าเริ่มต้นกับทุกตำแหน่งของอาร์เรย์ จากนั้นการเริ่มต้นเท่านั้นจะเสร็จสมบูรณ์ หลังจากนั้นเราสามารถเปลี่ยนหรือรับค่าใหม่ไปยังตำแหน่งใด ๆ ของอาร์เรย์ รหัสด้านล่างทำงานให้ฉันอย่างสมบูรณ์แบบ

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)

หากคุณใช้numpyคุณสามารถสร้างอาร์เรย์ 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)]]

ด้านบนจะให้อาเรย์ 5x5 2D แก่คุณ

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

มันใช้ความเข้าใจในรายการซ้อน รายละเอียดดังต่อไปนี้:

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

[x] * col -> นิพจน์สุดท้ายที่ประเมิน
สำหรับ x in -> x จะเป็นค่าที่กำหนดโดย iterator
[b สำหรับ b ในช่วง (แถว)]] -> Iterator

[b สำหรับ b อยู่ในช่วง (แถว)]] สิ่งนี้จะประเมินเป็น [0,1,2,3,4] ตั้งแต่แถว = 5
ดังนั้นตอนนี้มันจะทำให้

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

สิ่งนี้จะประเมินเป็น [[0] * 5 สำหรับ x ใน [0,1,2,3,4]] -> โดย x = 0 การวนซ้ำครั้งที่ 1
[[1] * 5 สำหรับ x ใน [0,1,2, 3,4]] -> ด้วย x = 1 ซ้ำ 2
[[2] * 5 สำหรับ x ใน [0,1,2,3,4]] -> กับ x = 2 ซ้ำ 3
[[3] * 5 สำหรับ x ใน [0,1,2,3,4]] -> กับ x = 3 ซ้ำ 4
[[4] * 5 สำหรับ x ใน [0,1,2,3,4]] -> ด้วย x = 4 ซ้ำ 5

นี่คือสิ่งที่ดีที่สุดที่ฉันพบสำหรับการสอนโปรแกรมเมอร์ใหม่และไม่ต้องใช้ห้องสมุดเพิ่มเติม ฉันต้องการบางสิ่งที่ดีกว่า

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

นี่เป็นวิธีที่ง่ายกว่า:

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

สำหรับการเริ่มต้นเซลล์ทั้งหมดด้วยการใช้ค่า 'x':

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

บ่อยครั้งที่ฉันใช้วิธีนี้ในการเริ่มต้นอาร์เรย์ 2 มิติ

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

รูปแบบทั่วไปเพื่อเพิ่มมิติสามารถดึงมาจากซีรี่ส์นี้:

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)

คุณสามารถลอง [[0] * 10] * 10 นี่จะส่งคืนอาร์เรย์ 2d ของ 10 แถวและ 10 คอลัมน์ที่มีค่า 0 สำหรับแต่ละเซลล์

lst = [[0] * m สำหรับ i อยู่ในช่วง (n)]

เริ่มต้นเมทริกซ์ทั้งหมด n = แถวและ m = คอลัมน์

อีกวิธีคือใช้พจนานุกรมเพื่อเก็บอาเรย์สองมิติ

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

เพียงแค่นี้ก็สามารถถือใด ๆ ค่า 1D, 2D และการเริ่มต้นนี้0หรือค่า int อื่น ๆ ใช้งานคอลเลกชัน

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

รหัส:

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 จะต้องไม่เปลี่ยนรูป

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