Như bạn đã khám phá, In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
8 cố gắng tạo một mảng 2D khi được cung cấp một cái gì đó như A = np.array([[1,2],[3,4]],dtype=object)
Bạn đã áp dụng một số thủ thuật để vượt qua hành vi mặc định này. Một là làm cho những người con thay đổi theo chiều dài. Nó không thể tạo ra một mảng 2D từ những thứ này, vì vậy nó dùng đến mảng đối tượng: In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
Và sau đó bạn có thể nối các giá trị vào từng danh sách đó: In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
9 cũng tạo ra một mảng đối tượng:In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
Nhưng sau đó bạn phải cẩn thận cách bạn thay đổi các yếu tố thành danh sách. In [53]: B=[[]]*3
In [54]: B
Out[54]: [[], [], []]
In [55]: for i in B: i.append(34)
In [56]: B
Out[56]: [[34, 34, 34], [34, 34, 34], [34, 34, 34]]
0 đang hấp dẫn, nhưng có vấn đề:In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
Hóa ra In [53]: B=[[]]*3
In [54]: B
Out[54]: [[], [], []]
In [55]: for i in B: i.append(34)
In [56]: B
Out[56]: [[34, 34, 34], [34, 34, 34], [34, 34, 34]]
1 đặt cùng một danh sách trong tất cả các vị trí, do đó, việc sửa đổi một sửa đổi tất cả các loại khác. Bạn có thể gặp vấn đề tương tự với danh sách danh sách:In [53]: B=[[]]*3
In [54]: B
Out[54]: [[], [], []]
In [55]: for i in B: i.append(34)
In [56]: B
Out[56]: [[34, 34, 34], [34, 34, 34], [34, 34, 34]]
Cách thích hợp để ban đầu In [53]: B=[[]]*3
In [54]: B
Out[54]: [[], [], []]
In [55]: for i in B: i.append(34)
In [56]: B
Out[56]: [[34, 34, 34], [34, 34, 34], [34, 34, 34]]
2 In [53]: B=[[]]*3
In [54]: B
Out[54]: [[], [], []]
In [55]: for i in B: i.append(34)
In [56]: B
Out[56]: [[34, 34, 34], [34, 34, 34], [34, 34, 34]]
3 là với một lần lặp, ví dụ:In [65]: A=np.empty((3,),dtype=object)
In [66]: for i,v in enumerate(A): A[i]=[v,i]
In [67]: A
Out[67]: array([[None, 0], [None, 1], [None, 2]], dtype=object)
In [68]: for v in A: v.append(34)
In [69]: A
Out[69]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34]], dtype=object)
Không rõ ràng từ câu hỏi và nhận xét cho dù bạn muốn nối vào danh sách hoặc nối lại danh sách vào mảng. Tôi vừa chứng minh việc thêm vào danh sách. Có một chức năng In [53]: B=[[]]*3
In [54]: B
Out[54]: [[], [], []]
In [55]: for i in B: i.append(34)
In [56]: B
Out[56]: [[34, 34, 34], [34, 34, 34], [34, 34, 34]]
4, mà người dùng mới thường lạm dụng. Nó không phải là một sự thay thế cho danh sách phụ lục. Đó là một mặt trước đến In [53]: B=[[]]*3
In [54]: B
Out[54]: [[], [], []]
In [55]: for i in B: i.append(34)
In [56]: B
Out[56]: [[34, 34, 34], [34, 34, 34], [34, 34, 34]]
5. Nó không phải là một hoạt động tại chỗ; Nó trả về một mảng mới.Ngoài ra, việc xác định một danh sách để thêm với nó có thể là khó khăn: In [72]: np.append(A,[[1,23]])
Out[72]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34], 1, 23], dtype=object)
Bạn cần xây dựng một mảng đối tượng khác để kết hợp với bản gốc, ví dụ: In [76]: np.append(A,np.empty((1,),dtype=object))
Out[76]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34], None], dtype=object)
Trong tất cả những điều này, một loạt các danh sách khó xây dựng hơn một danh sách các danh sách, và không dễ dàng hơn, hoặc nhanh hơn, để thao túng. Bạn phải biến nó thành một loạt các danh sách 2D để có được một số lợi ích. In [78]: A[:,None]
Out[78]:
array([[[None, 0, 34]],
[[None, 1, 34]],
[[None, 2, 34]]], dtype=object)
Bạn có thể định hình lại, chuyển vị, vv một mảng đối tượng, trong đó tạo ra và điều khiển một danh sách các danh sách danh sách trở nên phức tạp hơn. In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
0=== Như được hiển thị trong https://stackoverflow.com/a/57364472/901925, In [53]: B=[[]]*3
In [54]: B
Out[54]: [[], [], []]
In [55]: for i in B: i.append(34)
In [56]: B
Out[56]: [[34, 34, 34], [34, 34, 34], [34, 34, 34]]
6 là một công cụ tốt để tạo một mảng các đối tượng.In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
1 Cách tạo mảng danh sách#In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
2Từ danh sách Python#Nếu bạn có một bộ sưu tập các danh sách Python, cách dễ nhất để biến chúng thành một mảng khó xử là chuyển chúng cho trình xây dựng AK.Array, công nhận một sự khác biệt không phải là DICT, không có năng suất và gọi AK.From_ITER. In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
3In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
4In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
5In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
6Danh sách các danh sách có thể tùy ý sâu sắc.
In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
7In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
8In [43]: A=np.array([[1,2],[],[1,2,3,4]])
In [44]: A
Out[44]: array([[1, 2], [], [1, 2, 3, 4]], dtype=object)
5In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
0Các ____ ____57, trong chuỗi loại biểu thị các mức danh sách có độ dài thay đổi. Đây là một loạt các danh sách danh sách danh sách các số nguyên. Ưu điểm của mảng khó xử là dữ liệu số hiện đang nằm trong một bộ đệm và tính toán được vector hóa trên mảng, chẳng hạn như các hàm phổ quát.
In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
1Không giống như danh sách Python, các mảng bao gồm một loại đồng nhất. Một danh sách Python sẽ không thông báo nếu dữ liệu số được đưa ra ở hai cấp độ khác nhau của việc làm tổ, nhưng đó là một sự khác biệt lớn đối với một mảng khó xử. In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
2In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
3Trong ví dụ này, loại dữ liệu là một liên minh của hai cấp độ sâu và ba cấp độ sâu. In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
4Một số hoạt động có thể với các mảng công đoàn, nhưng không phải tất cả. (Lặp lại trong numba là một ví dụ như vậy.) Từ mảng numpy#Trình xây dựng AK.Array tải các mảng numpy khác với danh sách Python. Kích thước bên trong của một mảng numpy được đảm bảo có cùng độ dài, vì vậy chúng được hiểu là loại danh sách có độ dài cố định. In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
5In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
6In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
7In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
8Loại trong trường hợp này không có In [53]: B=[[]]*3
In [54]: B
Out[54]: [[], [], []]
In [55]: for i in B: i.append(34)
In [56]: B
Out[56]: [[34, 34, 34], [34, 34, 34], [34, 34, 34]]
7, trong đó, chỉ có ____ ____59, ____, ____, và ____. Nó có một mảng chiều dài 2 danh sách dài 3 chứa danh sách dài 5 của số nguyên.Hơn nữa, nếu các mảng numpy được lồng trong danh sách Python (hoặc các vòng lặp khác), chúng sẽ được coi là độ dài thay đổi ( cùng hình dạng. In [45]: for i in A: i.append(34)
In [46]: A
Out[46]: array([[1, 2, 34], [34], [1, 2, 3, 4, 34]], dtype=object)
9In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
0In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
1In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
2Cả In [65]: A=np.empty((3,),dtype=object)
In [66]: for i,v in enumerate(A): A[i]=[v,i]
In [67]: A
Out[67]: array([[None, 0], [None, 1], [None, 2]], dtype=object)
In [68]: for v in A: v.append(34)
In [69]: A
Out[69]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34]], dtype=object)
3 và In [65]: A=np.empty((3,),dtype=object)
In [66]: for i,v in enumerate(A): A[i]=[v,i]
In [67]: A
Out[67]: array([[None, 0], [None, 1], [None, 2]], dtype=object)
In [68]: for v in A: v.append(34)
In [69]: A
Out[69]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34]], dtype=object)
4 đều có cùng giá trị dữ liệu:In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
3Nhưng họ có các loại khác nhau: In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
4In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
5Điều này có thể tạo ra sự khác biệt trong một số hoạt động, chẳng hạn như phát sóng.broadcasting. Nếu bạn muốn kiểm soát nhiều hơn về điều này, hãy sử dụng các hàm AK.from_iter và ak.from_numpy rõ ràng thay vì hàm tạo AK.array có mục đích chung. Unflattening#Một sự khác biệt khác giữa ak.from_iter và ak.from_numpy là việc lặp lại trên danh sách python là chậm và nhất thiết phải sao chép dữ liệu, trong khi việc nhập một mảng numpy là không sao. (Bạn có thể thấy rằng nó không sao chép bằng cách thay đổi dữ liệu tại chỗ.) Trong một số trường hợp, lập danh sách có thể được vector hóa. Nếu bạn có một mảng dữ liệu phẳng và một mảng đếm số đếm cộng với độ dài của dữ liệu, thì bạn có thể ak.unflatted nó. In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
6In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
7Danh sách đầu tiên có độ dài In [65]: A=np.empty((3,),dtype=object)
In [66]: for i,v in enumerate(A): A[i]=[v,i]
In [67]: A
Out[67]: array([[None, 0], [None, 1], [None, 2]], dtype=object)
In [68]: for v in A: v.append(34)
In [69]: A
Out[69]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34]], dtype=object)
5, thứ hai có độ dài In [65]: A=np.empty((3,),dtype=object)
In [66]: for i,v in enumerate(A): A[i]=[v,i]
In [67]: A
Out[67]: array([[None, 0], [None, 1], [None, 2]], dtype=object)
In [68]: for v in A: v.append(34)
In [69]: A
Out[69]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34]], dtype=object)
6, thứ ba có độ dài In [65]: A=np.empty((3,),dtype=object)
In [66]: for i,v in enumerate(A): A[i]=[v,i]
In [67]: A
Out[67]: array([[None, 0], [None, 1], [None, 2]], dtype=object)
In [68]: for v in A: v.append(34)
In [69]: A
Out[69]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34]], dtype=object)
7 và cuối cùng có độ dài In [65]: A=np.empty((3,),dtype=object)
In [66]: for i,v in enumerate(A): A[i]=[v,i]
In [67]: A
Out[67]: array([[None, 0], [None, 1], [None, 2]], dtype=object)
In [68]: for v in A: v.append(34)
In [69]: A
Out[69]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34]], dtype=object)
8. Điều này gần với biểu diễn bên trong của Array Array của các danh sách có độ dài thay đổi, vì vậy nó có thể được thực hiện nhanh chóng.Hàm này được đặt tên là ak.unflatten vì nó có tác dụng ngược lại như ak.flatten và ak.num: In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
8In [47]: A=np.empty((3,),dtype=object)
In [48]: A
Out[48]: array([None, None, None], dtype=object)
9
Với ArrayBuilder#AK.ArrayBuilder được mô tả chi tiết hơn trong hướng dẫn này, nhưng bạn cũng có thể xây dựng các mảng danh sách bằng các phương thức ________ 69/________ 70 hoặc Trình quản lý bối cảnh In [72]: np.append(A,[[1,23]])
Out[72]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34], 1, 23], dtype=object)
1.in this tutorial, but you can also construct arrays of lists using the
In [65]: A=np.empty((3,),dtype=object)
In [66]: for i,v in enumerate(A): A[i]=[v,i]
In [67]: A
Out[67]: array([[None, 0], [None, 1], [None, 2]], dtype=object)
In [68]: for v in A: v.append(34)
In [69]: A
Out[69]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34]], dtype=object)
9/In [72]: np.append(A,[[1,23]])
Out[72]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34], 1, 23], dtype=object)
0 methods or the In [72]: np.append(A,[[1,23]])
Out[72]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34], 1, 23], dtype=object)
1 context manager.(Đây là những gì ak.from_iter sử dụng nội bộ để tích lũy danh sách.) In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
0In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
1In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
2In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
1Trong numba#Các chức năng mà Numba chỉ trong thời gian (JIT) biên dịch có thể sử dụng AK.ArrayBuilder hoặc xây dựng dữ liệu phẳng và các mảng đếm số của AK cho ak.unflatten. . Bối cảnh. Tương tự, các chức năng In [72]: np.append(A,[[1,23]])
Out[72]: array([[None, 0, 34], [None, 1, 34], [None, 2, 34], 1, 23], dtype=object)
4 như ak.unflatten không thể được gọi bên trong hàm được biên dịch JIT, nhưng có thể ở bên ngoài.)In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
4In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
1In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
6In [49]: A.fill([])
In [50]: A
Out[50]: array([[], [], []], dtype=object)
In [51]: for i in A: i.append(34)
In [52]: A
Out[52]: array([[34, 34, 34], [34, 34, 34], [34, 34, 34]], dtype=object)
1
Bạn có thể lập một danh sách các danh sách trong Python không?
Python cung cấp một tùy chọn tạo danh sách trong danh sách. Nếu đặt đơn giản, đó là một danh sách lồng nhau nhưng với một hoặc nhiều danh sách bên trong dưới dạng một yếu tố. Ở đây, [a, b], [c, d] và [e, f] là các danh sách riêng biệt được truyền dưới dạng các yếu tố để tạo một danh sách mới. Đây là danh sách các danh sách.. If put simply, it is a nested list but with one or more lists inside as an element. Here, [a,b], [c,d], and [e,f] are separate lists which are passed as elements to make a new list. This is a list of lists.
Bạn có thể có một danh sách các mảng?
ArrayList of Arrays có thể được tạo giống như bất kỳ đối tượng nào khác sử dụng trình xây dựng ArrayList..
Là các mảng danh sách Python hoặc danh sách?
Vậy sự khác biệt là gì?.. Mảng cần được khai báo.Danh sách không, vì chúng được xây dựng thành Python..... Mảng có thể lưu trữ dữ liệu rất nhỏ gọn và hiệu quả hơn để lưu trữ lượng dữ liệu lớn .. Mảng là tuyệt vời cho các hoạt động số;Danh sách không thể xử lý trực tiếp các hoạt động toán học .. Numpy Arrays có thể lưu trữ danh sách không?
Các mảng Numpy được sử dụng để lưu trữ danh sách dữ liệu số và để đại diện cho các vectơ, ma trận và thậm chí cả tenxơ.Các mảng Numpy được thiết kế để xử lý các bộ dữ liệu lớn một cách hiệu quả và với tối thiểu ồn ào.Thư viện Numpy có một bộ lớn các thói quen để tạo, thao tác và biến đổi các mảng numpy. and to represent vectors, matrices, and even tensors. NumPy arrays are designed to handle large data sets efficiently and with a minimum of fuss. The NumPy library has a large set of routines for creating, manipulating, and transforming NumPy arrays. |
