Utwórz pustą listę w pythonie o określonym rozmiarze

Chcę utworzyć pustą listę (lub inną najlepszą metodę), która może zawierać 10 elementów.

Następnie chcę przypisać wartości do tej listy, na przykład powinno to wyświetlać od 0 do 9:

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

print  s1

Ale kiedy uruchamiam ten kod, generuje błąd lub w innym przypadku po prostu wyświetla [](pusty).

Czy ktoś może wyjaśnić, dlaczego?

Nie można przypisać do listy takiej jak lst[i] = something, chyba że lista jest już zainicjowana przynajmniej z i+1elementami. Musisz użyć append, aby dodać elementy na końcu listy. lst.append(something).

(Możesz użyć notacji przypisania, jeśli korzystasz ze słownika).

Tworzenie pustej listy:

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

Przypisywanie wartości do istniejącego elementu powyższej listy:

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

Pamiętaj, że coś podobnego l[15] = 5nadal zawiedzie, ponieważ nasza lista zawiera tylko 10 elementów.

zakres (x) tworzy listę z [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]

Korzystanie z funkcji do tworzenia listy:

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

Zrozumienie listy (za pomocą kwadratów, ponieważ dla zakresu nie musisz robić tego wszystkiego, możesz po prostu wrócić range(0,9)):

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

Spróbuj zamiast tego:

lst = [None] * 10

Powyższe spowoduje utworzenie listy o rozmiarze 10, w której każda pozycja jest inicjowana None. Następnie możesz dodać do niego elementy:

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

Trzeba przyznać, że nie jest to Pythoński sposób robienia rzeczy. Lepiej zrób to:

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

Lub jeszcze prościej , w Pythonie 2.x możesz to zrobić, aby zainicjować listę z wartościami od 0 do 9:

lst = range(10)

A w Python 3.x:

lst = list(range(10))

obecnie akceptowana odpowiedź varunl

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

Działa dobrze w przypadku typów innych niż odniesienia, takich jak liczby. Niestety, jeśli chcesz utworzyć listę list, napotkasz błędy odwoływania się. Przykład w Python 2.7.6:

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

Jak widać, każdy element wskazuje ten sam obiekt listy. Aby obejść ten problem, możesz utworzyć metodę, która zainicjuje każdą pozycję do innego odwołania do obiektu.

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

Prawdopodobnie jest to domyślny, wbudowany w Python sposób (zamiast pisania funkcji), ale nie jestem pewien, co to jest. Byłby szczęśliwy, gdyby został poprawiony!

Edycja: To [ [] for _ in range(10)]

Przykład:

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

Możesz .append(element)przejść do listy, np s1.append(i). : Obecnie próbujesz uzyskać dostęp do elementu ( s1[i]), który nie istnieje.

Istnieją dwie „szybkie” metody:

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

Wydaje się, że [None]*xjest szybszy:

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

Ale jeśli jesteś zadowolony z zakresu (np. [0,1,2,3,...,x-1]), To range(x)może być najszybszy:

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

Dziwię się, że nikt nie sugeruje tego prostego podejścia do tworzenia listy pustych list. To jest stary wątek, ale dodajemy go tylko dla kompletności. Spowoduje to utworzenie listy 10 pustych list

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

(Zostało napisane na podstawie oryginalnej wersji pytania).

Chcę utworzyć pustą listę (lub jakikolwiek najlepszy sposób), która może zawierać 10 elementów.

Wszystkie listy mogą zawierać dowolną liczbę elementów, z zastrzeżeniem limitu dostępnej pamięci. Jedyny „rozmiar” listy, który ma znaczenie, to liczba aktualnie znajdujących się na niej elementów .

ale kiedy go uruchomię, wynikiem jest []

print display s1nie jest poprawną składnią; na podstawie twojego opisu tego, co widzisz, zakładam, że miałeś na myśli display(s1)i wtedy print s1. Aby to s1zadziałało , musisz wcześniej zdefiniować globalny, aby przejść do funkcji.

Dzwonienie displaynie modyfikuje listy, którą przekazujesz, jak napisano. W kodzie jest napisane: „ s1to nazwa wszystkiego, co zostało przekazane do funkcji; ok, teraz pierwszą rzeczą, którą zrobimy, jest całkowite zapomnienie o tej rzeczy i s1zacznijmy odwoływać się do nowo utworzonego list. Teraz zmodyfikujemy to list„. Nie ma to wpływu na wartość, którą podałeś.

Nie ma powodu, aby podawać tutaj wartość. (Nie ma też żadnego prawdziwego powodu, aby utworzyć funkcję, ale to nie ma sensu.) Chcesz coś „stworzyć”, więc jest to wynik działania Twojej funkcji. Żadne informacje nie są wymagane do stworzenia opisywanej rzeczy, więc nie przekazuj żadnych informacji. Aby uzyskać informacje, returnto.

To dałoby ci coś takiego:

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

Następnym problemem, na który zwrócisz uwagę, jest fakt, że twoja lista będzie zawierała tylko 9 elementów, ponieważ funkcja pomija punkt końcowy range. (Jak zauważa się na marginesie, []działa tak samo dobrze list(), że średnik jest niepotrzebny, s1to zła nazwa zmiennej i tylko jeden parametr jest potrzebny, rangejeśli zaczynasz 0.)

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

Nadal jednak brakuje w tym znaku; rangeNie jest pewne magiczne słowo kluczowe, które jest częścią języka droga fori defsą, ale zamiast tego jest to funkcja. I zgadnij, co ta funkcja zwraca? Zgadza się - lista tych liczb całkowitych. Cała funkcja zapada się

def create_list():
    return range(10)

a teraz rozumiecie, dlaczego w ogóle nie musimy pisać funkcji; rangejest już funkcją, której szukamy. Chociaż znowu nie ma potrzeby ani powodu, by „wstępnie przeskalowywać” listę.

Jestem nieco zaskoczony, że najłatwiejszym sposobem utworzenia zainicjowanej listy nie jest żadna z tych odpowiedzi. Wystarczy użyć generatora w listfunkcji:

list(range(9))

Jeden prosty sposób na utworzenie macierzy 2D o rozmiarze nza pomocą zagnieżdżonych list:

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

Oto mój kod dla listy 2D w pythonie, który brzmiałby „nie”. wierszy z wejścia:

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

Natknąłem się na to pytanie SO, szukając podobnego problemu. Musiałem zbudować tablicę 2D, a następnie zastąpić niektóre elementy każdej listy (w tablicy 2D) elementami ze słownika. Potem natknąłem się na to SO pytanie, które pomogło mi, być może pomoże to innym początkującym się poruszać. Kluczową sztuczką było zainicjowanie tablicy 2D jako tablicy numpy, a następnie użycie array[i,j]zamiast array[i][j].

Dla odniesienia jest to fragment kodu, w którym musiałem użyć tego:

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)

Teraz wiem, że możemy używać listowania, ale dla uproszczenia używam zagnieżdżonej pętli for. Mam nadzieję, że pomoże to innym osobom, które natkną się na ten post.

Uczyń go bardziej użytecznym jako funkcja.

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

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

print s1

Aby utworzyć listę, użyj następujących nawiasów: „[]”

Aby dodać coś do listy, użyj list.append ()

Ten kod generuje tablicę zawierającą 10 liczb losowych.

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