Hai cách để tạo mảng trong Python là gì?

Khi được so sánh với Danh sách (Mảng động), Mảng Python lưu trữ loại phần tử tương tự trong đó. Trong khi Danh sách Python có thể lưu trữ các phần tử thuộc các loại dữ liệu khác nhau trong đó

Nội dung chính Show

Phương pháp 1. Sử dụng hàm for loop và Python range()
Phương pháp 2. Mô-đun Python NumPy để tạo và khởi tạo mảng
Phương pháp 3. Phương thức trực tiếp để khởi tạo một mảng Python
Phần kết luận
1) Chuyển đổi chuỗi Python thành mảng NumPy
2) Các hàm tạo mảng NumPy nội tại
Hàm tạo mảng 1 - 1D
2 - Hàm tạo mảng 2D
3 - các hàm tạo ndarray chung
3) Sao chép, nối hoặc thay đổi các mảng hiện có
4) Đọc mảng từ đĩa, từ định dạng tiêu chuẩn hoặc tùy chỉnh
Định dạng nhị phân tiêu chuẩn
Các định dạng ASCII phổ biến
5) Tạo mảng từ byte thô thông qua việc sử dụng chuỗi hoặc bộ đệm
6) Sử dụng các chức năng thư viện đặc biệt (e. g. , SciPy, Pandas và OpenCV)
Các cách khác nhau để tạo mảng trong Python là gì?
Các loại mảng trong Python là gì?
Hai loại mảng trong mã hóa là gì?
3 loại mảng là gì?

Bây giờ, chúng ta hãy xem các cách khác nhau để khởi tạo một mảng trong Python

Phương pháp 1. Sử dụng hàm for loop và Python range()

Hàm for loop và range() trong Python có thể được sử dụng cùng nhau để khởi tạo một mảng với giá trị mặc định

cú pháp

[value for element in range(num)]

Hàm range() trong Python chấp nhận một số làm đối số và trả về một dãy số bắt đầu từ 0 và kết thúc bởi số đã chỉ định, mỗi lần tăng thêm 1

Python cho vòng lặp sẽ đặt 0(giá trị mặc định) cho mọi phần tử trong mảng giữa phạm vi được chỉ định trong hàm phạm vi ()

Ví dụ

arr=[]
arr = [0 for i in range(5)] 
print(arr)

Chúng ta đã tạo một mảng — ‘arr’ và khởi tạo nó với 5 phần tử mang giá trị mặc định (0)

đầu ra

[0, 0, 0, 0, 0]

Phương pháp 2. Mô-đun Python NumPy để tạo và khởi tạo mảng

Mô-đun Python NumPy có thể được sử dụng để tạo mảng và thao tác dữ liệu trong đó một cách hiệu quả. các numpy. Hàm trống () tạo một mảng có kích thước được chỉ định với giá trị mặc định = 'Không'

cú pháp

numpy.empty(size,dtype=object)

Ví dụ

import numpy as np
arr = np.empty(10, dtype=object) 
print(arr)

đầu ra

[None None None None None None None None None None]

Phương pháp 3. Phương thức trực tiếp để khởi tạo một mảng Python

Trong khi khai báo mảng, chúng ta có thể khởi tạo giá trị dữ liệu bằng lệnh bên dưới

array-name = [default-value]*size

Ví dụ

arr_num = [0] * 5
print(arr_num)

arr_str = ['P'] * 10
print(arr_str)

Như đã thấy trong ví dụ trên, chúng tôi đã tạo hai mảng với các giá trị mặc định là '0' và 'P' cùng với kích thước được chỉ định với nó

đầu ra

________số 8_______

Phần kết luận

Đến đây, chúng ta đã đi đến cuối chủ đề này. Vui lòng bình luận bên dưới trong trường hợp, bạn gặp bất kỳ nghi ngờ nào

Bạn có thể sử dụng các phương pháp này để tạo ndarrays hoặc. Tài liệu này sẽ bao gồm các phương pháp chung để tạo ndarray

1) Chuyển đổi chuỗi Python thành mảng NumPy

Các mảng NumPy có thể được xác định bằng cách sử dụng các chuỗi Python như danh sách và bộ dữ liệu. Danh sách và bộ dữ liệu được xác định lần lượt bằng cách sử dụng

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

8 và

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

9. Danh sách và bộ dữ liệu có thể xác định việc tạo ndarray

một danh sách các số sẽ tạo ra một mảng 1D,
một danh sách các danh sách sẽ tạo ra một mảng 2D,
các danh sách lồng nhau hơn nữa sẽ tạo ra các mảng có chiều cao hơn. Nói chung, bất kỳ đối tượng mảng nào được gọi là ndarray trong NumPy

>>> a1D = np.array([1, 2, 3, 4])
>>> a2D = np.array([[1, 2], [3, 4]])
>>> a3D = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

Khi bạn sử dụng để xác định một mảng mới, bạn nên xem xét dtype của các phần tử trong mảng, có thể được chỉ định rõ ràng. Tính năng này cung cấp cho bạn nhiều quyền kiểm soát hơn đối với các cấu trúc dữ liệu cơ bản và cách các phần tử được xử lý trong các hàm C/C++. Nếu bạn không cẩn thận với các nhiệm vụ của

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

1, bạn có thể bị tràn không mong muốn, như vậy

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

Số nguyên có dấu 8 bit biểu thị các số nguyên từ -128 đến 127. Việc gán mảng

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

2 cho các số nguyên bên ngoài phạm vi này sẽ dẫn đến tràn. Tính năng này thường có thể bị hiểu lầm. Nếu bạn thực hiện các phép tính với sự không phù hợp của

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

3, bạn có thể nhận được kết quả không mong muốn, chẳng hạn

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

Lưu ý khi bạn thực hiện thao tác với hai mảng giống nhau

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

5, mảng kết quả là cùng loại. Khi bạn thực hiện các thao tác với các

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

1 khác nhau, NumPy sẽ chỉ định một loại mới đáp ứng tất cả các phần tử mảng liên quan đến phép tính, ở đây cả

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

5 và

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

8 đều có thể được biểu diễn dưới dạng

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

Hành vi NumPy mặc định là tạo các mảng theo số nguyên có chữ ký 32 hoặc 64 bit (phụ thuộc vào nền tảng và khớp với kích thước int C) hoặc số dấu phẩy động chính xác kép, tương ứng là int32/int64 và float. Nếu bạn muốn các mảng số nguyên của mình là một kiểu cụ thể, thì bạn cần chỉ định kiểu dữ liệu trong khi tạo mảng

2) Các hàm tạo mảng NumPy nội tại

NumPy có hơn 40 chức năng tích hợp để tạo mảng như được trình bày trong. Các hàm này có thể được chia thành khoảng ba loại, dựa trên kích thước của mảng mà chúng tạo

mảng 1D
mảng 2D
ndarrays

Hàm tạo mảng 1 - 1D

Các hàm tạo mảng 1D e. g. và thường cần ít nhất hai đầu vào,

>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(2, 10, dtype=float)
array([2., 3., 4., 5., 6., 7., 8., 9.])
>>> np.arange(2, 3, 0.1)
array([2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

2 và

>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(2, 10, dtype=float)
array([2., 3., 4., 5., 6., 7., 8., 9.])
>>> np.arange(2, 3, 0.1)
array([2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

tạo các mảng với các giá trị tăng đều đặn. Kiểm tra tài liệu để biết thông tin và ví dụ đầy đủ. Một vài ví dụ được hiển thị

>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(2, 10, dtype=float)
array([2., 3., 4., 5., 6., 7., 8., 9.])
>>> np.arange(2, 3, 0.1)
array([2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

Ghi chú. cách thực hành tốt nhất là sử dụng các giá trị số nguyên bắt đầu, kết thúc và bước. Có một số điểm tinh tế liên quan đến

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

1. Trong ví dụ thứ hai,

>>> a = np.array([2, 3, 4], dtype=np.uint32)
>>> b = np.array([5, 6, 7], dtype=np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

1 được định nghĩa. Trong ví dụ thứ ba, mảng là

>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(2, 10, dtype=float)
array([2., 3., 4., 5., 6., 7., 8., 9.])
>>> np.arange(2, 3, 0.1)
array([2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

8 để phù hợp với kích thước bước của

>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(2, 10, dtype=float)
array([2., 3., 4., 5., 6., 7., 8., 9.])
>>> np.arange(2, 3, 0.1)
array([2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

9. Do lỗi làm tròn, giá trị

>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(2, 10, dtype=float)
array([2., 3., 4., 5., 6., 7., 8., 9.])
>>> np.arange(2, 3, 0.1)
array([2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

3 đôi khi được đưa vào

sẽ tạo các mảng với một số phần tử được chỉ định và cách đều nhau giữa các giá trị đầu và cuối được chỉ định. Ví dụ

>>> np.linspace(1., 4., 6)
array([1. ,  1.6,  2.2,  2.8,  3.4,  4. ])

Ưu điểm của hàm tạo này là bạn đảm bảo số lượng phần tử và điểm đầu và điểm cuối.

>>> np.linspace(1., 4., 6)
array([1. ,  1.6,  2.2,  2.8,  3.4,  4. ])

2 trước đó sẽ không bao gồm giá trị

>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(2, 10, dtype=float)
array([2., 3., 4., 5., 6., 7., 8., 9.])
>>> np.arange(2, 3, 0.1)
array([2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

2 - Hàm tạo mảng 2D

Các hàm tạo mảng 2D e. g. , và xác định các thuộc tính của ma trận đặc biệt được biểu diễn dưới dạng mảng 2D

>>> np.linspace(1., 4., 6)
array([1. ,  1.6,  2.2,  2.8,  3.4,  4. ])

7 xác định ma trận nhận dạng 2D. Các phần tử trong đó i=j (chỉ số hàng và chỉ số cột bằng nhau) là 1 và phần còn lại là 0, như vậy

>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(3, 5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.]])

có thể xác định mảng 2D hình vuông với các giá trị đã cho dọc theo đường chéo hoặc nếu được cung cấp mảng 2D trả về mảng 1D chỉ có các phần tử đường chéo. Hai hàm tạo mảng có thể hữu ích khi thực hiện đại số tuyến tính, như vậy

>>> np.diag([1, 2, 3])
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
>>> np.diag([1, 2, 3], 1)
array([[0, 1, 0, 0],
       [0, 0, 2, 0],
       [0, 0, 0, 3],
       [0, 0, 0, 0]])
>>> a = np.array([[1, 2], [3, 4]])
>>> np.diag(a)
array([1, 4])

>>> np.linspace(1., 4., 6)
array([1. ,  1.6,  2.2,  2.8,  3.4,  4. ])

9 định nghĩa ma trận Vandermonde là mảng 2D NumPy. Mỗi cột của ma trận Vandermonde là lũy thừa giảm dần của mảng 1D đầu vào hoặc danh sách hoặc bộ,

>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(3, 5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.]])

0 trong đó bậc đa thức cao nhất là

>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(3, 5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.]])

1. Quy trình tạo mảng này rất hữu ích trong việc tạo các mô hình bình phương nhỏ nhất tuyến tính, như vậy

>>> np.vander(np.linspace(0, 2, 5), 2)
array([[0. , 1. ],
      [0.5, 1. ],
      [1. , 1. ],
      [1.5, 1. ],
      [2. , 1. ]])
>>> np.vander([1, 2, 3, 4], 2)
array([[1, 1],
       [2, 1],
       [3, 1],
       [4, 1]])
>>> np.vander((1, 2, 3, 4), 4)
array([[ 1,  1,  1,  1],
       [ 8,  4,  2,  1],
       [27,  9,  3,  1],
       [64, 16,  4,  1]])

3 - các hàm tạo ndarray chung

Các hàm tạo ndarray e. g. , và xác định mảng dựa trên hình dạng mong muốn. Các hàm tạo ndarray có thể tạo các mảng với bất kỳ kích thước nào bằng cách chỉ định có bao nhiêu kích thước và độ dài dọc theo kích thước đó trong một bộ hoặc danh sách

sẽ tạo một mảng chứa đầy các giá trị 0 với hình dạng đã chỉ định. dtype mặc định là

>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(3, 5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.]])

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

       [[0., 0.],
        [0., 0.],
        [0., 0.]]])

sẽ tạo một mảng chứa đầy 1 giá trị. Nó giống hệt với

>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(3, 5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.]])

8 ở tất cả các khía cạnh khác như vậy

>>> np.ones((2, 3))
array([[1., 1., 1.],
       [1., 1., 1.]])
>>> np.ones((2, 3, 2))
array([[[1., 1.],
        [1., 1.],
        [1., 1.]],

       [[1., 1.],
        [1., 1.],
        [1., 1.]]])

Phương thức của kết quả của

>>> np.diag([1, 2, 3])
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
>>> np.diag([1, 2, 3], 1)
array([[0, 1, 0, 0],
       [0, 0, 2, 0],
       [0, 0, 0, 3],
       [0, 0, 0, 0]])
>>> a = np.array([[1, 2], [3, 4]])
>>> np.diag(a)
array([1, 4])

0 sẽ tạo ra một mảng chứa đầy các giá trị ngẫu nhiên trong khoảng từ 0 đến 1. Nó được bao gồm trong thư viện. Dưới đây, hai mảng được tạo với hình dạng (2,3) và (2,3,2) tương ứng. Hạt giống được đặt thành 42 để bạn có thể sao chép các số giả ngẫu nhiên này

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

sẽ tạo một tập hợp các mảng (được xếp chồng lên nhau dưới dạng mảng có một chiều cao hơn), mỗi mảng một chiều với mỗi biến thể biểu thị trong chiều đó

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

Điều này đặc biệt hữu ích để đánh giá các chức năng của nhiều thứ nguyên trên lưới thông thường

3) Sao chép, nối hoặc thay đổi các mảng hiện có

Khi bạn đã tạo các mảng, bạn có thể sao chép, nối hoặc thay đổi các mảng hiện có đó để tạo các mảng mới. Khi bạn gán một mảng hoặc các phần tử của nó cho một biến mới, bạn phải tường minh mảng đó, nếu không thì biến đó là một dạng nhìn vào mảng ban đầu. Xem xét ví dụ sau

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

Trong ví dụ này, bạn không tạo một mảng mới. Bạn đã tạo một biến,

>>> np.diag([1, 2, 3])
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
>>> np.diag([1, 2, 3], 1)
array([[0, 1, 0, 0],
       [0, 0, 2, 0],
       [0, 0, 0, 3],
       [0, 0, 0, 0]])
>>> a = np.array([[1, 2], [3, 4]])
>>> np.diag(a)
array([1, 4])

4 đã xem 2 phần tử đầu tiên của

>>> np.diag([1, 2, 3])
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
>>> np.diag([1, 2, 3], 1)
array([[0, 1, 0, 0],
       [0, 0, 2, 0],
       [0, 0, 0, 3],
       [0, 0, 0, 0]])
>>> a = np.array([[1, 2], [3, 4]])
>>> np.diag(a)
array([1, 4])

5. Khi bạn thêm 1 vào

>>> np.diag([1, 2, 3])
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
>>> np.diag([1, 2, 3], 1)
array([[0, 1, 0, 0],
       [0, 0, 2, 0],
       [0, 0, 0, 3],
       [0, 0, 0, 0]])
>>> a = np.array([[1, 2], [3, 4]])
>>> np.diag(a)
array([1, 4])

4, bạn sẽ nhận được kết quả tương tự bằng cách thêm 1 vào

>>> np.diag([1, 2, 3])
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
>>> np.diag([1, 2, 3], 1)
array([[0, 1, 0, 0],
       [0, 0, 2, 0],
       [0, 0, 0, 3],
       [0, 0, 0, 0]])
>>> a = np.array([[1, 2], [3, 4]])
>>> np.diag(a)
array([1, 4])

7. Nếu bạn muốn tạo một mảng mới, hãy sử dụng quy trình tạo mảng như vậy

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

Để biết thêm thông tin và ví dụ nhìn vào

Có một số thủ tục để tham gia các mảng hiện có e. g. , , Và. Dưới đây là một ví dụ về việc nối bốn mảng 2 nhân 2 thành một mảng 4 nhân 4 bằng cách sử dụng

>>> np.vander(np.linspace(0, 2, 5), 2)
array([[0. , 1. ],
      [0.5, 1. ],
      [1. , 1. ],
      [1.5, 1. ],
      [2. , 1. ]])
>>> np.vander([1, 2, 3, 4], 2)
array([[1, 1],
       [2, 1],
       [3, 1],
       [4, 1]])
>>> np.vander((1, 2, 3, 4), 4)
array([[ 1,  1,  1,  1],
       [ 8,  4,  2,  1],
       [27,  9,  3,  1],
       [64, 16,  4,  1]])

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

Các thói quen khác sử dụng cú pháp tương tự để tham gia ndarrays. Kiểm tra tài liệu của quy trình để biết thêm các ví dụ và cú pháp

4) Đọc mảng từ đĩa, từ định dạng tiêu chuẩn hoặc tùy chỉnh

Đây là trường hợp phổ biến nhất của việc tạo mảng lớn. Các chi tiết phụ thuộc rất lớn vào định dạng của dữ liệu trên đĩa. Phần này đưa ra các gợi ý chung về cách xử lý các định dạng khác nhau. Để biết thêm các ví dụ chi tiết về IO, hãy xem

Định dạng nhị phân tiêu chuẩn

Các trường khác nhau có định dạng chuẩn cho dữ liệu mảng. Phần sau liệt kê những cái có thư viện Python đã biết để đọc chúng và trả về mảng NumPy (có thể có những cái khác có thể đọc và chuyển đổi thành mảng NumPy, vì vậy hãy kiểm tra cả phần cuối cùng)

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

Ví dụ về các định dạng không thể đọc trực tiếp nhưng không khó để chuyển đổi là những định dạng được các thư viện hỗ trợ như PIL (có thể đọc và ghi nhiều định dạng hình ảnh như jpg, png, v.v.)

Các định dạng ASCII phổ biến

Các tệp được phân tách như tệp giá trị được phân tách bằng dấu phẩy (csv) và tệp giá trị được phân tách bằng tab (tsv) được sử dụng cho các chương trình như Excel và LabView. Các hàm Python có thể đọc và phân tích các tệp này theo từng dòng. NumPy có hai quy trình tiêu chuẩn để nhập tệp có dữ liệu được phân tách và. Các chức năng này có nhiều trường hợp sử dụng liên quan hơn trong Đọc và ghi tệp . Một ví dụ đơn giản cho một

>>> np.vander(np.linspace(0, 2, 5), 2)
array([[0. , 1. ],
      [0.5, 1. ],
      [1. , 1. ],
      [1.5, 1. ],
      [2. , 1. ]])
>>> np.vander([1, 2, 3, 4], 2)
array([[1, 1],
       [2, 1],
       [3, 1],
       [4, 1]])
>>> np.vander((1, 2, 3, 4), 4)
array([[ 1,  1,  1,  1],
       [ 8,  4,  2,  1],
       [27,  9,  3,  1],
       [64, 16,  4,  1]])

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

Việc nhập

>>> np.vander(np.linspace(0, 2, 5), 2)
array([[0. , 1. ],
      [0.5, 1. ],
      [1. , 1. ],
      [1.5, 1. ],
      [2. , 1. ]])
>>> np.vander([1, 2, 3, 4], 2)
array([[1, 1],
       [2, 1],
       [3, 1],
       [4, 1]])
>>> np.vander((1, 2, 3, 4), 4)
array([[ 1,  1,  1,  1],
       [ 8,  4,  2,  1],
       [27,  9,  3,  1],
       [64, 16,  4,  1]])

5 được thực hiện bằng cách sử dụng

>>> np.vander(np.linspace(0, 2, 5), 2)
array([[0. , 1. ],
      [0.5, 1. ],
      [1. , 1. ],
      [1.5, 1. ],
      [2. , 1. ]])
>>> np.vander([1, 2, 3, 4], 2)
array([[1, 1],
       [2, 1],
       [3, 1],
       [4, 1]])
>>> np.vander((1, 2, 3, 4), 4)
array([[ 1,  1,  1,  1],
       [ 8,  4,  2,  1],
       [27,  9,  3,  1],
       [64, 16,  4,  1]])

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

Có thể đọc các tệp ASCII chung hơn bằng cách sử dụng và Pandas

5) Tạo mảng từ byte thô thông qua việc sử dụng chuỗi hoặc bộ đệm

Có nhiều cách tiếp cận khác nhau mà người ta có thể sử dụng. Nếu tệp có định dạng tương đối đơn giản thì người ta có thể viết một thư viện I/O đơn giản và sử dụng hàm NumPy

>>> np.vander(np.linspace(0, 2, 5), 2)
array([[0. , 1. ],
      [0.5, 1. ],
      [1. , 1. ],
      [1.5, 1. ],
      [2. , 1. ]])
>>> np.vander([1, 2, 3, 4], 2)
array([[1, 1],
       [2, 1],
       [3, 1],
       [4, 1]])
>>> np.vander((1, 2, 3, 4), 4)
array([[ 1,  1,  1,  1],
       [ 8,  4,  2,  1],
       [27,  9,  3,  1],
       [64, 16,  4,  1]])

9 và phương thức

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

       [[0., 0.],
        [0., 0.],
        [0., 0.]]])

0 để đọc và ghi trực tiếp các mảng NumPy (hãy nhớ thứ tự byte của bạn. ) Nếu tồn tại một thư viện C hoặc C++ tốt để đọc dữ liệu, người ta có thể bọc thư viện đó bằng nhiều kỹ thuật khác nhau mặc dù điều đó chắc chắn sẽ hiệu quả hơn nhiều và đòi hỏi kiến thức nâng cao hơn đáng kể để giao tiếp với C hoặc C++

6) Sử dụng các chức năng thư viện đặc biệt (e. g. , SciPy, Pandas và OpenCV)

NumPy là thư viện cơ bản cho các bộ chứa mảng trong ngăn xếp Máy tính khoa học Python. Nhiều thư viện Python, bao gồm SciPy, Pandas và OpenCV, sử dụng ndarray NumPy làm định dạng phổ biến để trao đổi dữ liệu, Các thư viện này có thể tạo, vận hành và làm việc với mảng NumPy

Các cách khác nhau để tạo mảng trong Python là gì?

Có ba cách khác nhau để tạo mảng Numpy. .

Sử dụng các hàm Numpy

Chuyển đổi từ các cấu trúc Python khác như danh sách

Sử dụng các chức năng thư viện đặc biệt

Các loại mảng trong Python là gì?

Mảng Python và cách sử dụng mảng trong Python [Có ví dụ] .

Mảng lập chỉ mục

Mảng cắt lát

Mảng lặp

Hai loại mảng trong mã hóa là gì?

Mảng trong C có hai loại; . Single dimensional arrays and Multidimensional arrays.

3 loại mảng là gì?

Mảng nhiều chiều .

Mảng hai chiều

Mảng ba chiều

programming python

Hai cách để tạo mảng trong Python là gì?

Phương pháp 1. Sử dụng hàm for loop và Python range()

Phương pháp 2. Mô-đun Python NumPy để tạo và khởi tạo mảng

Phương pháp 3. Phương thức trực tiếp để khởi tạo một mảng Python

Phần kết luận

1) Chuyển đổi chuỗi Python thành mảng NumPy

2) Các hàm tạo mảng NumPy nội tại

Hàm tạo mảng 1 - 1D

2 - Hàm tạo mảng 2D

3 - các hàm tạo ndarray chung

3) Sao chép, nối hoặc thay đổi các mảng hiện có

4) Đọc mảng từ đĩa, từ định dạng tiêu chuẩn hoặc tùy chỉnh

Định dạng nhị phân tiêu chuẩn

Các định dạng ASCII phổ biến

5) Tạo mảng từ byte thô thông qua việc sử dụng chuỗi hoặc bộ đệm

6) Sử dụng các chức năng thư viện đặc biệt (e. g. , SciPy, Pandas và OpenCV)

Các cách khác nhau để tạo mảng trong Python là gì?

Các loại mảng trong Python là gì?

Hai loại mảng trong mã hóa là gì?

3 loại mảng là gì?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội