Ik begin met python en ik probeer een tweedimensionale lijst te gebruiken, die ik aanvankelijk overal met dezelfde variabele vul. Ik heb dit bedacht:
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 = []
Het geeft het gewenste resultaat, maar voelt als een tijdelijke oplossing. Is er een eenvoudigere/kortere/elegantere manier om dit te doen?
Antwoord 1, autoriteit 100%
Een patroon dat vaak naar voren kwam in Python was
bar = []
for item in some_iterable:
bar.append(SOME EXPRESSION)
wat hielp bij de introductie van lijstbegrippen, die dat fragment omzetten naar
bar = [SOME EXPRESSION for item in some_iterable]
die korter en soms duidelijker is. Meestal maak je er een gewoonte van om deze te herkennen en vaak loops te vervangen door begrip.
Je code volgt dit patroon twee keer
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) /
Antwoord 2, autoriteit 73%
Gebruik [[v]*n]*nniet, het is een valstrik!
>>> 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]]
maar
t = [ [0]*3 for i in range(3)]
werkt geweldig.
Antwoord 3, autoriteit 65%
U kunt een lijstbegripgebruiken:
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)
Antwoord 4, autoriteit 36%
Deze manier is snellerdan de geneste lijstbegrippen
[x[:] for x in [[foo] * 10] * 10] # for immutable foo!
Hier zijn enkele python3-timings, voor kleine en grote lijsten
$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
Uitleg:
[[foo]*10]*10maakt een lijst van hetzelfde object die 10 keer wordt herhaald. Je kunt dit niet zomaar gebruiken, want als je één element wijzigt, wordt hetzelfde element in elke rij gewijzigd!
x[:]is gelijk aan list(X)maar is iets efficiënter omdat het het opzoeken van de naam vermijdt. Hoe dan ook, het maakt een ondiepe kopie van elke rij, dus nu zijn alle elementen onafhankelijk.
Alle elementen zijn echter hetzelfde foo-object, dus als fooveranderlijk is, kun je dit schema niet gebruiken. zou moeten gebruiken
import copy
[[copy.deepcopy(foo) for x in range(10)] for y in range(10)]
of een klasse (of functie) fooaannemen die foos
retourneert
[[Foo() for x in range(10)] for y in range(10)]
Antwoord 5, autoriteit 17%
Een tweedimensionale array initialiseren in Python:
a = [[0 for x in range(columns)] for y in range(rows)]
Antwoord 6, autoriteit 8%
[[foo for x in xrange(10)] for y in xrange(10)]
Antwoord 7, autoriteit 5%
Als je multidimensionale arrays wilt, wil je meestal geen lijst met lijsten, maar eerder een numpy array of mogelijk een dictaat.
Bij numpy zou je bijvoorbeeld iets doen als
import numpy
a = numpy.empty((10, 10))
a.fill(foo)
Antwoord 8, autoriteit 3%
Je kunt precies dit doen:
[[element] * numcols] * numrows
Bijvoorbeeld:
>>> [['a'] *3] * 2
[['a', 'a', 'a'], ['a', 'a', 'a']]
Maar dit heeft een ongewenst neveneffect:
>>> 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']]
Antwoord 9, Autoriteit 2%
twod_list = [[foo for _ in range(m)] for _ in range(n)]
Voor N is het aantal rijen en M is het nummer van de kolom en FOO is de waarde.
Antwoord 10, Autoriteit 2%
Als het een dunbevolkte array is, kunt u beter afsluiten met een woordenboek met een tuple:
dict = {}
key = (a,b)
dict[key] = value
...
Antwoord 11
t = [ [0]*10 for i in [0]*10]
Voor elk element een nieuwe [0]*10wordt gemaakt.
Antwoord 12
Code:
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_valmoet onveranderlijk zijn.
Antwoord 13
Onjuiste aanpak: [[Geen * 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
Met deze aanpak staat python niet toe dat er andere adresruimte voor de buitenste kolommen wordt gemaakt en leidt dit tot ander wangedrag dan je verwacht.
Correcte aanpak maar met uitzondering:
y = [[0 for i in range(m)] for j in range(n)]
>>> id(y[0][0]) == id(y[1][0])
False
Het is een goede benadering, maar er is een uitzondering als u de standaardwaarde instelt op 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
Stel uw standaardwaarde dus correct in met deze benadering.
Absoluut correct:
Volg het antwoord van de microfoon van dubbele lus.
Antwoord 14
gebruik de eenvoudigste manier om dit te maken.
wtod_list = []
en voeg de maat toe:
wtod_list = [[0 for x in xrange(10)] for x in xrange(10)]
of als we eerst de maat willen aangeven. we gebruiken alleen:
wtod_list = [[0 for x in xrange(10)] for x in xrange(10)]
Antwoord 15
Het initialiseren van een 2D-matrix van de grootte m X n met 0
m,n = map(int,input().split())
l = [[0 for i in range(m)] for j in range(n)]
print(l)
Antwoord 16
Matrix={}
for i in range(0,3):
for j in range(0,3):
Matrix[i,j] = raw_input("Enter the matrix:")
Antwoord 17
Aan een 2-dimensionaal array initialiseren:
arr = [[]*m for i in range(n)]
eigenlijk,
arr = [[]*m]*neen 2D-array waarin alle n arrays zal verwijzen naar dezelfde array te maken, zodat wanneer de waarde in elk element wordt weerspiegeld in alle n lijsten
voor meer nadere uitleg bezoek: https: //www.geeksforgeeks.org/python-using-2d-arrays-lists-the-right-way/
Antwoord 18
Als u numpy , kunt u eenvoudig 2d arrays:
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]])
Antwoord 19
row=5
col=5
[[x]*col for x in [b for b in range(row)]]
Het bovenstaande geeft je een 5×5 2D-array
[[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]]
Het is met behulp van geneste lijst begrip.
Breakdown zoals hieronder:
[[x]*col for x in [b for b in range(row)]]
[x] * col – & gt; laatste expressie die wordt geëvalueerd
voor x in – & gt; x de waarde die de iterator zijn
[b voor b in bereik(rij)]] –> Iterator.
[b for b in range(row)]] dit zal resulteren in [0,1,2,3,4] aangezien row=5
dus nu wordt het eenvoudiger om
[[x]*col for x in [0,1,2,3,4]]
Dit evalueert tot
[[0]*5 voor x in [0,1,2,3,4]] –> met x=0 1e iteratie
[[1]*5 voor x in [0,1,2,3,4]] –> met x=1 2e iteratie
[[2]*5 voor x in [0,1,2,3,4]] –> met x=2 3e iteratie
[[3]*5 voor x in [0,1,2,3,4]] –> met x=3 4e iteratie
[[4]*5 voor x in [0,1,2,3,4]] –> met x=4 5e iteratie
Antwoord 20
Zoals @Arnab en @Mike al zeiden, is een array geen lijst. Weinig verschillen zijn 1) arrays hebben een vaste grootte tijdens initialisatie 2) arrays ondersteunen normaal gesproken minder bewerkingen dan een lijst.
Misschien een overkill in de meeste gevallen, maar hier is een eenvoudige 2D-array-implementatie die gebruikmaakt van hardwarearray-implementatie met behulp van python ctypes(c-bibliotheken)
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])
Antwoord 21
Het belangrijke ding dat ik begreep, is: tijdens het initialiseren van een array (in elke dimensie), moeten we een standaardwaarde geven aan alle array. Dan is alleen initialisatie voltooid. Daarna kunnen we nieuwe waarden wijzigen of ontvangen op elke positie van de array. De onderstaande code werkte perfect voor mij
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)
Antwoord 22
lst=[[0]*n]*m
np.array(lst)
Initialiseer alle matrix M = rijen en n = kolommen
Antwoord 23
Dit is de beste die ik heb gevonden voor het onderwijzen van nieuwe programmeurs, en zonder extra bibliotheken te gebruiken. Ik wil echter wel iets beter.
def initialize_twodlist(value):
list=[]
for row in range(10):
list.append([value]*10)
return list
Antwoord 24
Hier is een gemakkelijkere manier:
import numpy as np
twoD = np.array([[]*m]*n)
Voor het initialiseren van alle cellen met een ‘X’ -waarde-gebruik:
twoD = np.array([[x]*m]*n
Antwoord 25
Vaak gebruik ik deze benadering voor het initialiseren van een 2-dimensionale array
n=[[int(x) for x in input().split()] for i in range(int(input())]
Antwoord 26
Het algemene patroon om afmetingen toe te voegen kan uit deze serie worden getrokken:
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)
Antwoord 27
Een andere manier is om een woordenboek te gebruiken om een tweedimensionale array op te slaan.
twoD = {}
twoD[0,0] = 0
print(twoD[0,0]) # ===> prints 0
Dit kan gewoon alle 1D-, 2D-waarden bevatten en om dit te initialiseren naar 0of een andere int-waarde, gebruikt u collections.
import collections
twoD = collections.defaultdict(int)
print(twoD[0,0]) # ==> prints 0
twoD[1,1] = 1
print(twoD[1,1]) # ==> prints 1
Antwoord 28
Voor degenen die in de war zijn waarom [['']*m]*nniet goed te gebruiken is.
Python gebruikt aanroepen als referentie, dus het veranderen van één waarde in het bovenstaande geval leidt ook tot het veranderen van andere indexwaarden.
De beste manier is [['' for i in range(m)] for j in range(n)]
Dit zal alle problemen oplossen.
Voor meer opruiming
Voorbeeld:
>>> x = [['']*3]*3
[['', '', ''], ['', '', ''], ['', '', '']]
>>> x[0][0] = 1
>>> x
[[1, '', ''], [1, '', ''], [1, '', '']]
Antwoord 29
Ik gebruik het op deze manier om mXn-matrix te maken
arr = [[None]*(m) for _ in range(n)]
Antwoord 30
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))