Hướng dẫn how to add zeros to an array in python - cách thêm số không vào một mảng trong python

Tôi muốn thêm N số không vào một mảng.

Khi mảng của bạn là X và bạn muốn thêm 3 số không ở và của một mảng mà không tạo 2 mảng:

x = np.array([1.0, 2.0, 1.0, 2.0, 7.0, 9.0, 1.0, 1.0, 3.0, 4.0, 10.0])

Tôi nghĩ rằng lệnh này sẽ hữu ích:

x = [x, np.zeros(N)]

Nhưng tôi đã nhận được 2 mảng thay vì 1 mảng lớn:

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]

Vì vậy, tôi muốn tạo loại mảng này:

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]

Bất cứ ai có thể giúp tôi với câu hỏi khá đơn giản này?

numpy.zeros (hình dạng, dtype = float, order = 'c', *, like = none)#zeros(shape, dtype=float, order='C', *, like=None)#

Trả về một mảng mới của hình dạng và loại đã cho, chứa đầy số không.

Tham sốShapeint hoặc tuple của intsshapeint or tuple of ints

Hình dạng của mảng mới, ví dụ:

x = [x, np.zeros(N)]
5 hoặc
x = [x, np.zeros(N)]
6.

kiểu Dtypedata, tùy chọndata-type, optional

Loại dữ liệu mong muốn cho mảng, ví dụ:

x = [x, np.zeros(N)]
7. Mặc định là
x = [x, np.zeros(N)]
8.

thứ tự {‘c,’ f,}, tùy chọn, mặc định: ‘c,{‘C’, ‘F’}, optional, default: ‘C’

Cho dù lưu trữ dữ liệu đa chiều trong đơn đặt hàng theo kiểu hàng (kiểu C) hoặc cột (kiểu Fortran) trong bộ nhớ.

LikeArray_Like, tùy chọnarray_like, optional

Đối tượng tham chiếu để cho phép tạo các mảng không phải là mảng không. Nếu một mảng giống như được truyền AS

x = [x, np.zeros(N)]
9 hỗ trợ giao thức
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
0, kết quả sẽ được xác định bởi nó. Trong trường hợp này, nó đảm bảo việc tạo ra một đối tượng mảng tương thích với điều đó được truyền qua thông qua đối số này.

Mới trong phiên bản 1.20.0.

Trả lại outndarrayoutndarray

Mảng số không có hình dạng, dtype và thứ tự đã cho.

Xem thêm

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
1

Trả về một mảng số không có hình dạng và loại đầu vào.

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
2

Trả lại một mảng mới không được hưởng.

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
3

Trả lại một giá trị cài đặt mảng mới cho một.

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
4

Trả về một mảng mới của hình dạng đã cho chứa đầy giá trị.

Ví dụ

>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])

>>> np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0])

>>> np.zeros((2, 1))
array([[ 0.],
       [ 0.]])

>>> s = (2,2)
>>> np.zeros(s)
array([[ 0.,  0.],
       [ 0.,  0.]])

>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
      dtype=[('x', '

Trong bài viết này, chúng tôi sẽ thảo luận về cách tạo ra một loạt các số không trong Python. Trong các mục mảng được lưu trữ tại các vị trí bộ nhớ liên tục và ở đây chúng tôi sẽ cố gắng chỉ thêm số không vào mảng với các phương thức khác nhau.

Ở đây chúng tôi sẽ bao gồm các cách tiếp cận khác nhau để tạo ra một mảng phần tử không. Các cách tiếp cận khác nhau mà chúng tôi sẽ đề cập trong bài viết này là:

  • Sử dụng phép nhân đơn giản & nbsp;
  • Sử dụng vòng lặp
  • Sử dụng danh sách hiểu
  • Sử dụng phương thức Numpy.Zeros () Phương thức trong xây dựng
  • Sử dụng hàm itertools.repeat ()

Phương pháp 1: Sử dụng phép nhân đơn giản & nbsp;

Trong ví dụ này, chúng tôi đang nhân mảng 0 thành 9. Đổi lại, chúng tôi sẽ nhận được một mảng với 9 phần tử 0 0.

Python3

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
5
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
6
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
7
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
8
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
9
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
0
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
1

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
2
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
3

Output:

[0, 0, 0, 0, 0, 0, 0, 0, 0]

Phương pháp 2: Sử dụng vòng lặp

Trong ví dụ này, chúng tôi đang tạo một mảng 0 bằng cách sử dụng vòng lặp cho phạm vi từ 0 đến 10.

Python3

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
4
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
6
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
6

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
7
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
8
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
9
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
0
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
1
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
8
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
3
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
444

>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
6
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
7
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
8
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
9

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
2
>>> np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0])
1

Output:

x = [x, np.zeros(N)]
0

Phương pháp 3: Sử dụng danh sách hiểu

Ví dụ 1: Tạo mảng 1D bằng cách sử dụng danh sách hiểu

Như chúng ta đã biết ở đây cho Loop sẽ tạo ra một danh sách như vậy và chúng tôi lặp lại số 0 trong danh sách cho đến phạm vi đã cho.

Python3

>>> np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0])
2
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
6
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
7
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
8
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
7
>>> np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0])
7
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
9

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
2
>>> np.zeros((2, 1))
array([[ 0.],
       [ 0.]])
4

Output:

x = [x, np.zeros(N)]
1

Ví dụ 2: Tạo mảng 2D bằng cách sử dụng danh sách hiểu

Trong ví dụ này, chúng tôi đang tạo một mảng 2 chiều bằng cách sử dụng danh sách hiểu trong Python để tạo 0 0 của 5 hàng và 10 cột.

Python3

>>> np.zeros((2, 1))
array([[ 0.],
       [ 0.]])
5
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
6
>>> np.zeros((2, 1))
array([[ 0.],
       [ 0.]])
7
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
8
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
7
>>> s = (2,2)
>>> np.zeros(s)
array([[ 0.,  0.],
       [ 0.,  0.]])
0__

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
2
>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
      dtype=[('x', '
4

Output:

x = [x, np.zeros(N)]
2

Phương pháp 4: Sử dụng phương thức Numpy.zeros () Phương thức trong xây dựng

Trong ví dụ này, chúng tôi đang tạo ra một mảng numpy với số 0 là hàm numpy.zeros () được sử dụng để trả về một mảng mới có hình dạng và loại đã cho, với số không. & NBSP;numpy.zeros()function is used which returns a new array of given shape and type, with zeros. 

Python3

>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
      dtype=[('x', '
5
>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
      dtype=[('x', '
6

>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
      dtype=[('x', '
7
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
6
>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
      dtype=[('x', '
9__900991____9090991__949599

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
2
x = [x, np.zeros(N)]
07

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
2
x = [x, np.zeros(N)]
09

Output:

Trong đầu ra, i4 chỉ định 4 byte của kiểu dữ liệu số nguyên, trong khi F8 chỉ định 8 byte của kiểu dữ liệu float.i4 specifies 4 bytes of integer data type, whereas f8 specifies 8 bytes of float data type.

x = [x, np.zeros(N)]
3

Phương pháp 5: Sử dụng & nbsp; itertools.repeat () hàm

Mô-đun ITERTOOLS là một công cụ tiết kiệm bộ nhớ được sử dụng bởi chính nó hoặc kết hợp để tạo thành đại số iterator. & NBSP;

Ở đây chúng tôi tạo một trình lặp bằng cách sử dụng hàm lặp lại (), hàm này lấy giá trị làm đối số đầu tiên của nó, và sau đó đối số thứ hai lấy số lần lặp lại của các giá trị. & NBSP;

Bên dưới ví dụ, chúng tôi lấy 0 làm giá trị và tham số thứ hai 5 là số lần lặp lại và sau đó chuyển đổi TEMP_VAR thành danh sách.

Python3

>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
      dtype=[('x', '
5
x = [x, np.zeros(N)]
11

x = [x, np.zeros(N)]
12
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
6
x = [x, np.zeros(N)]
14
[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10.]),
 array([ 0.,  0.,  0.,  0.])]
8
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
3
>>> np.zeros((2, 1))
array([[ 0.],
       [ 0.]])
1
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
9

[array([  1.,   2.,   1.,   2.,   7.,   9.,   1.,   1.,   3.,   4.,  10., 0.,  0.,  0.,  0.])]
2
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
1
x = [x, np.zeros(N)]
21
x = [x, np.zeros(N)]
22

Output:

x = [x, np.zeros(N)]
1

Làm thế nào để bạn thêm 0 vào một mảng?

Bạn có thể sử dụng numpy.pad, các miếng đệm mặc định 0 cho cả hai đầu của mảng trong khi ở chế độ không đổi, chỉ định pad_width = (0, n) sẽ pad n zeros ở bên phải và không có gì ở bên trái: n = 4 np.pad (x, (0, n), 'hằng số') #Array ([1., 2., 1., 2., 7., 9., 1., 1., 3., 4., 10., # 0., 0., 0., 0.])use numpy. pad , which pads default 0 to both ends of the array while in constant mode, specify the pad_width = (0, N) will pad N zeros to the right and nothing to the left: N = 4 np. pad(x, (0, N), 'constant') #array([ 1., 2., 1., 2., 7., 9., 1., 1., 3., 4., 10., # 0., 0., 0., 0.])

Việc sử dụng hàm zeros () trong mảng numpy trong Python là gì?

Hàm Zeros () được sử dụng để có được một mảng mới có hình dạng và loại đã cho, chứa đầy số không.Hình dạng của mảng mới, ví dụ: (2, 3) hoặc 2. Loại dữ liệu mong muốn cho mảng, ví dụ: Numpy.int8.