Crie uma lista vazia em python com determinado tamanho

Eu quero criar uma lista vazia (ou qualquer que seja a melhor maneira) que possa conter 10 elementos.

Depois disso, quero atribuir valores nessa lista, por exemplo, isso deve exibir de 0 a 9:

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

print  s1

Mas quando executo esse código, ele gera um erro ou, em outro caso, apenas exibe [](vazio).

Alguém pode explicar o porquê?

Você não pode atribuir a uma lista como lst[i] = something, a menos que a lista já esteja inicializada com pelo menos i+1elementos. Você precisa usar o acréscimo para adicionar elementos ao final da lista. lst.append(something).

(Você pode usar a notação de atribuição se estiver usando um dicionário).

Criando uma lista vazia:

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

Atribuindo um valor a um elemento existente da lista acima:

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

Lembre-se de que algo como l[15] = 5ainda falharia, pois nossa lista possui apenas 10 elementos.

o intervalo (x) cria uma lista de [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]

Usando uma função para criar uma lista:

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

Compreensão da lista (usando os quadrados porque, para o intervalo, você não precisa fazer tudo isso, basta retornar range(0,9)):

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

Tente isso:

lst = [None] * 10

O acima criará uma lista de tamanho 10, onde cada posição é inicializada None. Depois disso, você pode adicionar elementos a ele:

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

É certo que essa não é a maneira pitônica de fazer as coisas. Melhor fazer isso:

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

Ou ainda mais simples , no Python 2.x, você pode fazer isso para inicializar uma lista com valores de 0 a 9:

lst = range(10)

E no Python 3.x:

lst = list(range(10))

resposta atualmente aceita de varunl

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

Funciona bem para tipos sem referência, como números. Infelizmente, se você deseja criar uma lista de listas, encontrará erros de referência. Exemplo no Python 2.7.6:

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

Como você pode ver, cada elemento está apontando para o mesmo objeto de lista. Para contornar isso, você pode criar um método que inicialize cada posição em uma referência de objeto diferente.

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

Provavelmente, existe uma maneira python interna padrão de fazer isso (em vez de escrever uma função), mas não tenho certeza do que é. Ficaria feliz em ser corrigido!

Edit: É [ [] for _ in range(10)]

Exemplo:

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

Pode .append(element)à lista, por exemplo: s1.append(i). O que você está atualmente tentando fazer é acessar um elemento ( s1[i]) que não existe.

Existem dois métodos "rápidos":

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

Parece que [None]*xé mais rápido:

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

Mas se você estiver de acordo com um intervalo (por exemplo [0,1,2,3,...,x-1]), range(x)poderá ser o mais rápido:

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

Estou surpreso que ninguém sugira essa abordagem simples para criar uma lista de listas vazias. Este é um tópico antigo, mas basta adicioná-lo para completar. Isso criará uma lista de 10 listas vazias

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

(Isso foi escrito com base na versão original da pergunta.)

Eu quero criar uma lista vazia (ou qualquer que seja a melhor maneira) pode conter 10 elementos.

Todas as listas podem conter quantos elementos você quiser, sujeitos apenas ao limite de memória disponível. O único "tamanho" de uma lista que importa é o número de elementos atualmente nela.

mas quando eu o executo, o resultado é []

print display s1não é uma sintaxe válida; com base na sua descrição do que você está vendo, suponho que você quis dizer display(s1)e então print s1. Para que isso seja executado, você deve ter definido anteriormente um globals1 para passar para a função.

A chamada displaynão modifica a lista pela qual você passa, conforme escrito. Seu código diz " s1é um nome para qualquer coisa que foi passada para a função; ok, agora a primeira coisa que faremos é esquecer completamente essa coisa e s1começar a nos referir a um recém-criadolist . Agora vamos modificar isso list" Isso não afeta o valor que você passou.

Não há razão para passar um valor aqui. (Também não há motivo real para criar uma função, mas isso não vem ao caso.) Você deseja "criar" algo, para que seja o resultado da sua função. Nenhuma informação é necessária para criar o que você descreve; portanto, não passe nenhuma informação. Para obter informações,return .

Isso lhe daria algo como:

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

O próximo problema que você notará é que sua lista terá apenas 9 elementos, porque o ponto final é ignorado pela rangefunção. (Como notas laterais, []funciona tão bem quanto list(), o ponto-e-vírgula é desnecessário, s1é um nome ruim para a variável e somente um parâmetro é necessário rangese você estiver começando 0.) Então você acaba com

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

No entanto, isso ainda está faltando a marca; rangenão é uma palavra-chave mágica que é parte da linguagem do caminho fore defsão, mas em vez disso é uma função. E adivinhe o que essa função retorna? Isso mesmo - uma lista desses números inteiros. Portanto, a função inteira entra em colapso para

def create_list():
    return range(10)

e agora você vê por que não precisamos escrever uma função; rangejá é a função que estamos procurando. Embora, novamente, não haja necessidade ou motivo para "pré-dimensionar" a lista.

Uma maneira simples de criar uma matriz de tamanho 2D nusando compreensão de lista aninhada:

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

Estou um pouco surpreso que a maneira mais fácil de criar uma lista inicializada não esteja em nenhuma dessas respostas. Basta usar um gerador na listfunção:

list(range(9))

Aqui está o meu código para a lista 2D em python, que iria ler não. de linhas da entrada:

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

A resposta aceita tem algumas dicas. Por exemplo:

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

Portanto, cada dicionário se refere ao mesmo objeto. O mesmo vale se você inicializar com matrizes ou objetos.

Você poderia fazer isso:

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

Me deparei com essa pergunta SO enquanto procurava por um problema semelhante. Eu tive que construir uma matriz 2D e, em seguida, substituir alguns elementos de cada lista (na matriz 2D) por elementos de um ditado. Eu me deparei com essa questão do SO que me ajudou, talvez isso ajude outros iniciantes a se locomover. O truque principal era inicializar a matriz 2D como uma matriz numpy e depois usar em array[i,j]vez dearray[i][j] .

Para referência, este é o pedaço de código em que eu tive que usar isso:

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)

Agora eu sei que podemos usar a compreensão de lista, mas por uma questão de simplicidade, estou usando um loop for aninhado. Espero que isso ajude outras pessoas que se deparam com este post.

Torne-o mais reutilizável como uma função.

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

Para criar uma lista, basta usar estes colchetes: "[]"

Para adicionar algo a uma lista, use list.append ()

Este código gera uma matriz que contém 10 números aleatórios.

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