Maak een lege lijst in Python met een bepaalde grootte

Ik wil een lege lijst maken (of wat de beste manier is) die 10 elementen kan bevatten.

Daarna wil ik waarden toewijzen in die lijst, dit zou bijvoorbeeld 0 tot 9 moeten weergeven:

s1 = list();
for i in range(0,9):
   s1[i] = i
print s1

Maar als ik deze code uitvoer, wordt er een fout gegenereerd of in een ander geval wordt gewoon [](leeg) weergegeven.

Kan iemand uitleggen waarom?

Antwoord 1, autoriteit 100%

Je kunt niet toewijzen aan een lijst zoals lst[i] = something, tenzij de lijst al is geïnitialiseerd met ten minste i+1elementen. U moet append gebruiken om elementen aan het einde van de lijst toe te voegen. lst.append(something).

(Je zou de opdrachtnotatie kunnen gebruiken als je een woordenboek zou gebruiken).

Een lege lijst maken:

>>> l = [None] * 10
>>> l
[None, None, None, None, None, None, None, None, None, None]

Een waarde toewijzen aan een bestaand element van de bovenstaande lijst:

>>> l[1] = 5
>>> l
[None, 5, None, None, None, None, None, None, None, None]

Houd er rekening mee dat iets als l[15] = 5nog steeds zou mislukken, aangezien onze lijst maar 10 elementen heeft.

range(x) maakt een lijst van [0, 1, 2, … x-1]

# 2.X only. Use list(range(10)) in 3.X.
>>> l = range(10)
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Een functie gebruiken om een lijst te maken:

>>> def display():
...     s1 = []
...     for i in range(9): # This is just to tell you how to create a list.
...         s1.append(i)
...     return s1
... 
>>> print display()
[0, 1, 2, 3, 4, 5, 6, 7, 8]

Lijstbegrip (gebruik de vierkanten, want voor bereik hoef je dit niet allemaal te doen, je kunt gewoon range(0,9)retourneren):

>>> def display():
...     return [x**2 for x in range(9)]
... 
>>> print display()
[0, 1, 4, 9, 16, 25, 36, 49, 64]

Antwoord 2, autoriteit 14%

Probeer dit in plaats daarvan:

lst = [None] * 10

Het bovenstaande creëert een lijst van maat 10, waarbij elke positie wordt geïnitialiseerd op None. Daarna kun je er elementen aan toevoegen:

lst = [None] * 10
for i in range(10):
    lst[i] = i

Toegegeven, dat is niet de Python-manier om dingen te doen. Doe dit beter:

lst = []
for i in range(10):
    lst.append(i)

Of nog eenvoudiger, in Python 2.x kun je dit doen om een lijst te initialiseren met waarden van 0 tot 9:

lst = range(10)

En in Python 3.x:

lst = list(range(10))

Antwoord 3, autoriteit 11%

varunl’s momenteel geaccepteerde antwoord

>>> l = [None] * 10
 >>> l
 [None, None, None, None, None, None, None, None, None, None]

Werkt goed voor niet-referentietypen zoals getallen. Als u een lijst met lijsten wilt maken, zult u helaas te maken krijgen met verwijzingsfouten. Voorbeeld in Python 2.7.6:

>>> a = [[]]*10
>>> a
[[], [], [], [], [], [], [], [], [], []]
>>> a[0].append(0)
>>> a
[[0], [0], [0], [0], [0], [0], [0], [0], [0], [0]]
>>> 

Zoals je kunt zien, verwijst elk element naar hetzelfde lijstobject. Om dit te omzeilen, kun je een methode maken die elke positie initialiseert naar een andere objectreferentie.

def init_list_of_objects(size):
    list_of_objects = list()
    for i in range(0,size):
        list_of_objects.append( list() ) #different object reference each time
    return list_of_objects
>>> a = init_list_of_objects(10)
>>> a
[[], [], [], [], [], [], [], [], [], []]
>>> a[0].append(0)
>>> a
[[0], [], [], [], [], [], [], [], [], []]
>>> 

Er is waarschijnlijk een standaard ingebouwde Python-manier om dit te doen (in plaats van een functie te schrijven), maar ik weet niet zeker wat het is. Zou graag gecorrigeerd worden!

Bewerken: het is [ [] for _ in range(10)]

Voorbeeld:

>>> [ [random.random() for _ in range(2) ] for _ in range(5)]
>>> [[0.7528051908943816, 0.4325669600055032], [0.510983236521753, 0.7789949902294716], [0.09475179523690558, 0.30216475640534635], [0.3996890132468158, 0.6374322093017013], [0.3374204010027543, 0.4514925173253973]]

Antwoord 4, autoriteit 2%

Je kunt .append(element)toevoegen aan de lijst, bijvoorbeeld: s1.append(i). Wat u momenteel probeert te doen, is toegang te krijgen tot een element (s1[i]) dat niet bestaat.

Antwoord 5, autoriteit 2%

Er zijn twee “snelle” methoden:

x = length_of_your_list
a = [None]*x
# or
a = [None for _ in xrange(x)]

Het lijkt erop dat [None]*xsneller is:

>>> from timeit import timeit
>>> timeit("[None]*100",number=10000)
0.023542165756225586
>>> timeit("[None for _ in xrange(100)]",number=10000)
0.07616496086120605

Maar als je akkoord gaat met een bereik (bijv. [0,1,2,3,...,x-1]), dan range(x)misschien wel het snelst:

>>> timeit("range(100)",number=10000)
0.012513160705566406

Antwoord 6, autoriteit 2%

Het verbaast me dat niemand deze eenvoudige benadering voorstelt om een lijst met lege lijsten te maken. Dit is een oud topic, maar voor de volledigheid even toegevoegd. Dit maakt een lijst van 10 lege lijsten

x = [[] for i in range(10)]

Antwoord 7

Het geaccepteerde antwoord heeft enkele problemen. Bijvoorbeeld:

>>> a = [{}] * 3
>>> a
[{}, {}, {}]
>>> a[0]['hello'] = 5
>>> a
[{'hello': 5}, {'hello': 5}, {'hello': 5}]
>>> 

Dus elk woordenboek verwijst naar hetzelfde object. Hetzelfde geldt als je initialiseert met arrays of objecten.

Je zou in plaats daarvan dit kunnen doen:

>>> b = [{} for i in range(0, 3)]
>>> b
[{}, {}, {}]
>>> b[0]['hello'] = 6
>>> b
[{'hello': 6}, {}, {}]
>>> 

Antwoord 8

(Dit is geschreven op basis van de originele versie van de vraag.)

Ik wil een lege lijst maken (of wat de beste manier is) die 10 elementen kan bevatten.

Alle lijsten kunnen zoveel elementen bevatten als u wilt, alleen met de limiet van het beschikbare geheugen. De enige “grootte” van een lijst die er toe doet, is het aantal elementen dat er momenteelin staat.

maar als ik het uitvoer, is het resultaat []

print display s1is geen geldige syntaxis; op basis van je beschrijving van wat je ziet, neem ik aan dat je display(s1)bedoelde en vervolgens print s1. Om dat te laten werken, moet u eerder een globale s1hebben gedefinieerd om door te gaan naar de functie.

Het aanroepen van displayheeft geen invloed op de lijst die u doorgeeft, zoals geschreven. Uw code zegt: “s1is een naam voor wat er ook aan de functie is doorgegeven; ok, het eerste wat we nu zullen doen is dat ding volledig vergeten en s1in plaats daarvan verwijzen naar een nieuw aangemaakte list. Nu gaan we die listaanpassen”. Dit heeft geen effect op de waarde die je hebt doorgegeven.

Er is geen reden om hier een waarde door te geven. (Er is ook geen echte reden om een functie te creëren, maar daar gaat het niet om.) Je wilt iets “creëren”, dus dat is de output van je functie. Er is geen informatie vereist om het ding dat u beschrijft te maken, dus geef geen informatie door. Om informatie eruit te krijgen, returnhet.

Dat zou je zoiets geven als:

def display():
    s1 = list();
    for i in range(0, 9):
        s1[i] = i
    return s1

Het volgende probleem dat u zult opmerken, is dat uw lijst in feite slechts 9 elementen zal hebben, omdat het eindpunt wordt overgeslagen door de functie range. (Als kanttekening werkt []net zo goed als list(), de puntkomma is niet nodig, s1is een slechte naam voor de variabele , en er is maar één parameter nodig voor rangeals je begint bij 0.) Dus dan krijg je

def create_list():
    result = list()
    for i in range(10):
        result[i] = i
    return result

Dit schiet echter nog tekort; rangeis niet een magisch sleutelwoord dat deel uitmaakt van de taal zoals foren defzijn, maar in plaats daarvan is het een functie. En raad eens wat die functie teruggeeft? Dat klopt – een lijst van die gehele getallen. Dus de hele functie stort in tot

def create_list():
    return range(10)

en nu begrijp je waarom we helemaal geen functie hoeven te schrijven; rangeis al de functie die we zoeken. Hoewel, nogmaals, er is geen noodzaak of reden om de lijst te “pre-sizen”.

Antwoord 9

Een eenvoudige manier om een 2D-matrix van de grootte nte maken met behulp van geneste lijstbegrippen:

m = [[None for _ in range(n)] for _ in range(n)]

Antwoord 10

Het verbaast me een beetje dat de gemakkelijkste manier om een geïnitialiseerde lijst te maken niet in een van deze antwoorden staat. Gebruik gewoon een generator in de functie list:

list(range(9))

Antwoord 11

Hier is mijn code voor 2D-lijst in python, die zou luiden als nr. van rijen van de invoer :

empty = []
row = int(input())
for i in range(row):
    temp = list(map(int, input().split()))
    empty.append(temp)
for i in empty:
    for j in i:
        print(j, end=' ')
    print('')

Antwoord 12

Technisch gezien geen lijst, maar qua functionaliteit vergelijkbaar met een lijst en een vaste lengte

from collections import deque
my_deque_size_10 = deque(maxlen=10)

Als het vol is, dwz 10 items heeft en dan nog een item toevoegt, wordt item @index 0 verwijderd. FIFO..maar je kunt ook in beide richtingen toevoegen.
Gebruikt in zeg

• een voortschrijdend gemiddelde van statistieken
• een lijst er doorheen laten lopen, oftewel een venster over een lijst schuiven totdat je een match krijgt met een ander deque-object.

Als je een lijst nodig hebt, gebruik dan gewoon list(deque object)

Antwoord 13

Ik kwam deze SO-vraag tegen toen ik op zoek was naar een soortgelijk probleem. Ik moest een 2D-array bouwen en vervolgens enkele elementen van elke lijst (in 2D-array) vervangen door elementen uit een dictaat.
Toen kwam ik dezeSO-vraag tegen die me hielp , misschien helpt dit andere beginners om zich te verplaatsen.
De belangrijkste truc was om de 2D-array te initialiseren als een numpy-array en vervolgens array[i,j]te gebruiken in plaats van array[i][j].

Ter referentie, dit is het stukje code waar ik dit moest gebruiken:

nd_array = []
for i in range(30):
    nd_array.append(np.zeros(shape = (32,1)))
new_array = []
for i in range(len(lines)):
    new_array.append(nd_array)
new_array = np.asarray(new_array)
for i in range(len(lines)):
    splits = lines[i].split(' ')
    for j in range(len(splits)):
        #print(new_array[i][j])
        new_array[i,j] = final_embeddings[dictionary[str(splits[j])]-1].reshape(32,1)

Nu weet ik dat we lijstbegrip kunnen gebruiken, maar voor de eenvoud gebruik ik een geneste for-lus. Ik hoop dat dit anderen helpt die dit bericht tegenkomen.

Antwoord 14

s1 = []
for i in range(11):
   s1.append(i)
print s1

Gebruik deze haakjes om een lijst te maken: “[]”

Om iets aan een lijst toe te voegen, gebruik list.append()

Antwoord 15

Maak het meer herbruikbaar als een functie.

def createEmptyList(length,fill=None):
    '''
    return a (empty) list of a given length
    Example:
        print createEmptyList(3,-1)
        >> [-1, -1, -1]
        print createEmptyList(4)
        >> [None, None, None, None]
    '''
    return [fill] * length

Antwoord 16

Deze code genereert een array die 10 willekeurige getallen bevat.

import random
numrand=[]
for i in range(0,10):
   a = random.randint(1,50)
   numrand.append(a)
   print(a,i)
print(numrand)