De code uitvoeren
listoflists = []
list = []
for i in range(0,10):
list.append(i)
if len(list)>3:
list.remove(list[0])
listoflists.append((list, list[0]))
print listoflists
retouren
[([7, 8, 9], 0), ([7, 8, 9], 0), ([7, 8, 9], 0), ([7, 8, 9], 1), ([7, 8, 9], 2), ([7, 8, 9], 3), ([7, 8, 9], 4), ([7, 8, 9], 5), ([7, 8, 9], 6), ([7, 8, 9], 7)]
dus op de een of andere manier wordt het eerste argument van elke tuple (lijst) elke keer bijgewerkt in de lijst met lijsten, maar de tweede argumentlijst[0] niet. Kan iemand uitleggen wat hier aan de hand is en een manier voorstellen om dit op te lossen? Ik wil graag uitvoeren
[([0],0), ([0,1],0), ...
Antwoord 1, autoriteit 100%
Lijsten zijn een veranderlijk type – om een kopie te maken (in plaats van alleen dezelfde lijst rond te sturen), moet je dit expliciet doen:
listoflists.append((list[:], list[0]))
list is echter al de naam van een ingebouwde Python – het is beter om die naam niet te gebruiken voor uw variabele. Hier is een versie die list niet als variabelenaam gebruikt en een kopie maakt:
listoflists = []
a_list = []
for i in range(0,10):
a_list.append(i)
if len(a_list)>3:
a_list.remove(a_list[0])
listoflists.append((list(a_list), a_list[0]))
print listoflists
Merk op dat ik hierboven twee verschillende manieren heb laten zien om een kopie van een lijst te maken: [:] en list().
De eerste, [:], is het maken van een slice (normaal vaak gebruikt om slechts een deel van een lijst te krijgen), die toevallig de hele lijst bevat, en is dus in feite een kopie van de lijst.
De tweede, list(), gebruikt de feitelijke list type constructor om een nieuwe lijst te maken met een inhoud die gelijk is aan de eerste lijst. (Ik heb het in het eerste voorbeeld niet gebruikt omdat je die naam in je code overschreef – wat een goed voorbeeld is van waarom je dat niet wilt doen!)
Antwoord 2, autoriteit 42%
Ik kwam hier omdat ik nieuw ben met python en lui ben, dus ik was op zoek naar een voorbeeld om een lijst van 2 lijsten te maken, maar na een tijdje realiseerde ik me dat het onderwerp hier verkeerd zou kunnen zijn…
dit is een code om een lijst met lijsten te maken:
listoflists = []
for i in range(0,2):
sublist = []
for j in range(0,10)
sublist.append((i,j))
listoflists.append(sublist)
print listoflists
dit is de uitvoer
[
[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), ( 0, 8), (0, 9)],
[(1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), ( 1, 8), (1, 9)]
]
Het probleem met je code lijkt te zijn dat je een tupel maakt met je lijst en je krijgt de verwijzing naar de lijst in plaats van een kopie. Dat zou volgens mij onder een tuple-onderwerp moeten vallen…
Antwoord 3, autoriteit 25%
Ten eerste raad ik u ten zeerste aan om uw variabele list te hernoemen naar iets anders. list is de naam van de ingebouwde lijstconstructor en je verbergt zijn normale functie. Ik zal de naam van list in het volgende wijzigen in a.
Pythonnamen zijn verwijzingen die aan objecten zijn gebonden. Dat betekent dat, tenzij u meer dan één lijst maakt, wanneer u a gebruikt, het verwijst naar hetzelfde werkelijke lijstobject als de vorige keer. Dus als je belt
listoflists.append((a, a[0]))
je kunt later a wijzigen en het verandert waar het eerste element van die tuple naar verwijst. Dit gebeurt niet met a[0] omdat het object (dat een geheel getal is) waarnaar wordt verwezen door a[0] niet verandert (hoewel a[0] wijst naar verschillende objecten tijdens de uitvoering van uw code).
U kunt een kopie van de hele lijst a maken met behulp van de list-constructor:
listoflists.append((list(a), a[0]))
Of u kunt de slice-notatie gebruiken om een kopie te maken:
listoflists.append((a[:], a[0]))
Antwoord 4, autoriteit 6%
De variabele list (die ik zou aanraden om te hernoemen naar iets zinnigers) is een verwijzing naar een lijstobject, dat kan worden gewijzigd.
Aan de lijn
listoflists.append((list, list[0]))
Je voegt eigenlijk alleen een verwijzing toe aan de objectverwijzing door de lijstvariabele. Je hebt meerdere mogelijkheden om een kopie van de lijst te maken, dus listoflists bevat de waarden zoals je lijkt te verwachten:
Gebruik de kopieerbibliotheek
import copy
listoflists.append((copy.copy(list), list[0]))
gebruik de plaknotatie
listoflists.append((list[:], list[0]))
Antwoord 5, autoriteit 6%
Als je de code uitvoert
listoflists.append((list, list[0]))
Je voegt niet (zoals ik denk dat je verwacht) een kopie van list toe aan het einde van listoflists. Wat je doet is een verwijzing naar list toevoegen aan het einde van listoflists. Dus elke keer dat u list bijwerkt, wordt elke verwijzing naar list bijgewerkt, wat in dit geval elk item in listoflists
is.
Wat u in plaats daarvan zou kunnen doen, is zoiets als dit:
listoflists = []
for i in range(1, 10):
listoflists.append((range(i), 0))
Antwoord 6, autoriteit 4%
Je krijgt ook niet de uitvoer waar je op hoopt zolang je alleen binnen de if-clausule toevoegt aan listoflists.
Probeer in plaats daarvan iets als dit:
import copy
listoflists = []
list = []
for i in range(0,10):
list.append(i)
if len(list)>3:
list.remove(list[0])
listoflists.append((copy.copy(list), copy.copy(list[0])))
print(listoflists)
Antwoord 7, autoriteit 4%
Tijdreiziger hier
List_of_list =[([z for z in range(x-2,x+1) if z >= 0],y) for y in range(10) for x in range(10)]
Dit zou voldoende moeten zijn. En de output is dit:
[([0], 0), ([0, 1], 0), ([0, 1, 2], 0), ([1, 2, 3], 0), ([2, 3, 4], 0), ([3, 4, 5], 0), ([4, 5, 6], 0), ([5, 6, 7], 0), ([6, 7, 8], 0), ([7, 8, 9], 0), ([0], 1), ([0, 1], 1), ([0, 1, 2], 1), ([1, 2, 3], 1), ([2, 3, 4], 1), ([3, 4, 5], 1), ([4, 5, 6], 1), ([5, 6, 7], 1), ([6, 7, 8], 1), ([7, 8, 9], 1), ([0], 2), ([0, 1], 2), ([0, 1, 2], 2), ([1, 2, 3], 2), ([2, 3, 4], 2), ([3, 4, 5], 2), ([4, 5, 6], 2), ([5, 6, 7], 2), ([6, 7, 8], 2), ([7, 8, 9], 2), ([0], 3), ([0, 1], 3), ([0, 1, 2], 3), ([1, 2, 3], 3), ([2, 3, 4], 3), ([3, 4, 5], 3), ([4, 5, 6], 3), ([5, 6, 7], 3), ([6, 7, 8], 3), ([7, 8, 9], 3), ([0], 4), ([0, 1], 4), ([0, 1, 2], 4), ([1, 2, 3], 4), ([2, 3, 4], 4), ([3, 4, 5], 4), ([4, 5, 6], 4), ([5, 6, 7], 4), ([6, 7, 8], 4), ([7, 8, 9], 4), ([0], 5), ([0, 1], 5), ([0, 1, 2], 5), ([1, 2, 3], 5), ([2, 3, 4], 5), ([3, 4, 5], 5), ([4, 5, 6], 5), ([5, 6, 7], 5), ([6, 7, 8], 5), ([7, 8, 9], 5), ([0], 6), ([0, 1], 6), ([0, 1, 2], 6), ([1, 2, 3], 6), ([2, 3, 4], 6), ([3, 4, 5], 6), ([4, 5, 6], 6), ([5, 6, 7], 6), ([6, 7, 8], 6), ([7, 8, 9], 6), ([0], 7), ([0, 1], 7), ([0, 1, 2], 7), ([1, 2, 3], 7), ([2, 3, 4], 7), ([3, 4, 5], 7), ([4, 5, 6], 7), ([5, 6, 7], 7), ([6, 7, 8], 7), ([7, 8, 9], 7), ([0], 8), ([0, 1], 8), ([0, 1, 2], 8), ([1, 2, 3], 8), ([2, 3, 4], 8), ([3, 4, 5], 8), ([4, 5, 6], 8), ([5, 6, 7], 8), ([6, 7, 8], 8), ([7, 8, 9], 8), ([0], 9), ([0, 1], 9), ([0, 1, 2], 9), ([1, 2, 3], 9), ([2, 3, 4], 9), ([3, 4, 5], 9), ([4, 5, 6], 9), ([5, 6, 7], 9), ([6, 7, 8], 9), ([7, 8, 9], 9)]
Dit wordt gedaan door lijstbegrip (waardoor elementen in een lijst via één regelcode kunnen worden herhaald). De logica achter deze éénregelige code is de volgende:
(1) voor x in bereik (10) en voor y in bereik (10) worden gebruikt voor twee onafhankelijke lussen in een lijst
(2) (een lijst, y) is de algemene term van de lus, daarom wordt deze voor twee for’s in (1) geplaatst
(3) de lengte van de lijst in (2) mag niet langer zijn dan 3, en de lijst is afhankelijk van x, dus
[z for z in range(x-2,x+1)]
wordt gebruikt
(4) omdat z begint bij nul maar bereik(x-2,x+1) begint bij -2, wat niet is wat we willen, dus een voorwaardelijke instructie als z >= 0 wordt aan het einde van de lijst in (2)
[z for z in range(x-2,x+1) if z >= 0]