Tạo một danh sách trống trong python với kích thước nhất định

Tôi muốn tạo một danh sách trống (hoặc bất cứ điều gì là cách tốt nhất) có thể chứa 10 yếu tố.

Sau đó tôi muốn gán các giá trị trong danh sách đó, ví dụ: điều này được cho là hiển thị 0 đến 9:

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

print  s1

Nhưng khi tôi chạy mã này, nó sẽ phát sinh lỗi hoặc trong trường hợp khác, nó chỉ hiển thị [](trống).

Ai đó có thể giải thích tại sao?

Bạn không thể gán cho một danh sách như thế lst[i] = something, trừ khi danh sách đã được khởi tạo với ít nhất i+1các yếu tố. Bạn cần sử dụng chắp thêm để thêm các yếu tố vào cuối danh sách. lst.append(something).

(Bạn có thể sử dụng ký hiệu gán nếu bạn đang sử dụng từ điển).

Tạo một danh sách trống:

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

Gán một giá trị cho một phần tử hiện có của danh sách trên:

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

Hãy nhớ rằng một cái gì đó như l[15] = 5vẫn sẽ thất bại, vì danh sách của chúng tôi chỉ có 10 yếu tố.

phạm vi (x) tạo danh sách từ [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]

Sử dụng chức năng để tạo danh sách:

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

Hiểu danh sách (Sử dụng các ô vuông vì đối với phạm vi bạn không cần phải làm tất cả điều này, bạn chỉ có thể quay lại range(0,9)):

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

Hãy thử điều này thay thế:

lst = [None] * 10

Ở trên sẽ tạo một danh sách kích thước 10, trong đó mỗi vị trí được khởi tạo None. Sau đó, bạn có thể thêm các yếu tố vào nó:

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

Phải thừa nhận rằng, đó không phải là cách Pythonic để làm mọi việc. Tốt hơn làm điều này:

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

Hoặc thậm chí đơn giản hơn , trong Python 2.x bạn có thể làm điều này để khởi tạo danh sách với các giá trị từ 0 đến 9:

lst = range(10)

Và trong Python 3.x:

lst = list(range(10))

câu trả lời hiện đang được chấp nhận của varunl

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

Hoạt động tốt cho các loại không tham chiếu như số. Thật không may nếu bạn muốn tạo một danh sách các danh sách, bạn sẽ gặp phải các lỗi tham chiếu. Ví dụ trong Python 2.7.6:

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

Như bạn có thể thấy, mỗi phần tử đang trỏ đến cùng một đối tượng danh sách. Để giải quyết vấn đề này, bạn có thể tạo một phương thức sẽ khởi tạo mỗi vị trí thành một tham chiếu đối tượng khác nhau.

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

Có khả năng là một cách python mặc định, tích hợp sẵn để thực hiện việc này (thay vì viết một hàm), nhưng tôi không chắc nó là gì. Sẽ rất vui khi được sửa chữa!

Chỉnh sửa: Đó là [ [] for _ in range(10)]

Thí dụ :

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

Bạn có thể .append(element)vào danh sách, ví dụ : s1.append(i). Những gì bạn hiện đang cố gắng làm là truy cập một phần tử ( s1[i]) không tồn tại.

Có hai phương pháp "nhanh":

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

Nó xuất hiện [None]*xnhanh hơn:

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

Nhưng nếu bạn ổn với một phạm vi (ví dụ [0,1,2,3,...,x-1]), thì range(x)có thể là nhanh nhất:

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

Tôi ngạc nhiên không ai đề xuất cách tiếp cận đơn giản này để tạo một danh sách các danh sách trống. Đây là một chủ đề cũ, nhưng chỉ cần thêm điều này cho đầy đủ. Điều này sẽ tạo ra một danh sách 10 danh sách trống

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

(Điều này được viết dựa trên phiên bản gốc của câu hỏi.)

Tôi muốn tạo một danh sách trống (hoặc bất cứ điều gì là cách tốt nhất) có thể chứa 10 yếu tố.

Tất cả các danh sách có thể chứa nhiều yếu tố như bạn muốn, chỉ tuân theo giới hạn của bộ nhớ khả dụng. "Kích cỡ" duy nhất của danh sách quan trọng là số lượng phần tử hiện có trong danh sách .

nhưng khi tôi chạy nó, kết quả là []

print display s1không phải là cú pháp hợp lệ; dựa trên mô tả của bạn về những gì bạn đang thấy, tôi cho rằng bạn có ý display(s1)đó và sau đó print s1. Để chạy nó, trước đây bạn phải xác định toàn cầu s1để truyền vào hàm.

Gọi displaykhông sửa đổi danh sách bạn chuyển qua, như được viết. Mã của bạn nói " s1là tên của bất cứ thứ gì được truyền vào hàm; ok, bây giờ điều đầu tiên chúng ta sẽ làm là quên hoàn toàn thứ đó và s1thay vào đó hãy bắt đầu tham chiếu đến một thứ mới được tạo list. Bây giờ chúng ta sẽ sửa đổi list". Điều này không ảnh hưởng đến giá trị bạn truyền vào.

Không có lý do để vượt qua trong một giá trị ở đây. (Không có lý do thực sự để tạo một chức năng, nhưng đó là bên cạnh điểm.) Bạn muốn "tạo" một cái gì đó, vì vậy đó là đầu ra của chức năng của bạn. Không có thông tin được yêu cầu để tạo ra thứ bạn mô tả, vì vậy đừng chuyển bất kỳ thông tin nào vào. Để lấy thông tin ra, returnnó sẽ được cung cấp.

Điều đó sẽ cung cấp cho bạn một cái gì đó như:

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

Vấn đề tiếp theo bạn sẽ lưu ý là danh sách của bạn thực sự sẽ chỉ có 9 phần tử, vì điểm cuối bị bỏ qua bởi rangehàm. (Như ghi chú bên cạnh, []hoạt động cũng như list(), dấu chấm phẩy là không cần thiết, s1là một tên kém cho biến và chỉ cần một tham số cho rangenếu bạn bắt đầu từ đó 0.) Vì vậy, bạn kết thúc với

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

Tuy nhiên, điều này vẫn còn thiếu dấu hiệu; rangekhông phải là một số từ khóa kỳ diệu, đó là một phần của ngôn ngữ, forvà defthay vào đó là một chức năng. Và đoán xem hàm đó trả về cái gì? Điều đó đúng - một danh sách các số nguyên đó. Vì vậy, toàn bộ chức năng sụp đổ để

def create_list():
    return range(10)

và bây giờ bạn thấy tại sao chúng ta không cần phải tự viết một hàm; rangeđã là chức năng chúng tôi đang tìm kiếm. Mặc dù, một lần nữa, không có nhu cầu hoặc lý do để "kích thước trước" danh sách.

Tôi hơi ngạc nhiên rằng cách dễ nhất để tạo một danh sách khởi tạo không nằm trong bất kỳ câu trả lời nào trong số này. Chỉ cần sử dụng một trình tạo trong listchức năng:

list(range(9))

Một cách đơn giản để tạo ma trận 2D có kích thước nbằng cách hiểu danh sách lồng nhau:

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

Đây là mã của tôi cho danh sách 2D trong python sẽ không đọc. của các hàng từ đầu vào:

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

Câu trả lời được chấp nhận có một số vấn đề. Ví dụ:

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

Vì vậy, mỗi từ điển đề cập đến cùng một đối tượng. Điều tương tự cũng đúng nếu bạn khởi tạo với mảng hoặc đối tượng.

Bạn có thể làm điều này thay vào đó:

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

Tôi đã gặp câu hỏi SO này trong khi tìm kiếm một vấn đề tương tự. Tôi đã phải xây dựng một mảng 2D và sau đó thay thế một số thành phần của mỗi danh sách (trong mảng 2D) bằng các thành phần từ một lệnh. Sau đó tôi đi qua này câu hỏi SO đó giúp tôi, có lẽ điều này sẽ giúp người mới bắt đầu khác để có được xung quanh. Thủ thuật chính là khởi tạo mảng 2D thành một mảng gọn gàng và sau đó sử dụng array[i,j]thay vì array[i][j].

Để tham khảo, đây là đoạn mã mà tôi phải sử dụng:

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)

Bây giờ tôi biết chúng ta có thể sử dụng hiểu danh sách nhưng để đơn giản, tôi đang sử dụng một vòng lặp lồng nhau. Hy vọng điều này sẽ giúp những người khác đi qua bài viết này.

Làm cho nó tái sử dụng nhiều hơn như là một chức năng.

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

Để tạo danh sách, chỉ cần sử dụng các dấu ngoặc này: "[]"

Để thêm một cái gì đó vào danh sách, hãy sử dụng list.append ()

Mã này tạo ra một mảng chứa 10 số ngẫu nhiên.

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