programming python

Chuyển đổi mảng thành vector Python

Trong hướng dẫn này, chúng ta sẽ tìm hiểu cách chúng ta có thể tạo một vectơ bằng thư viện Numpy. Chúng ta cũng sẽ tìm hiểu phép toán cơ bản của vectơ như thực hiện cộng hai vectơ, trừ hai vectơ, chia hai vectơ, nhân hai vectơ, tích vectơ và tích vô hướng vectơ

Vectơ là gì?

Một vectơ được gọi là một mảng một chiều. Trong Python, vectơ là một mảng danh sách một chiều và hoạt động giống như danh sách Python. Theo Google, vectơ biểu thị hướng cũng như độ lớn;

Các vectơ rất quan trọng trong Học máy vì chúng có độ lớn và cả các tính năng hướng. Hãy hiểu cách chúng ta có thể tạo vectơ trong Python

Tạo vectơ trong Python

Mô-đun Python Numpy cung cấp numpy. phương thức array[] tạo mảng một chiều i. e. một véc tơ. Một vectơ có thể nằm ngang hoặc dọc

cú pháp

Phương thức trên chấp nhận một danh sách làm đối số và trả về numpy. ndarray

Hãy hiểu ví dụ sau -

Ví dụ 1. Véc Tơ Ngang

đầu ra

We create a vector from a list:
[10 20 30 40 50]

Ví dụ - 2. Véc Tơ Dọc

đầu ra

We create a vector from a list:
[[12]
 [40]
 [ 6]
 [10]]

Hoạt động cơ bản của vector Python

Sau khi tạo xong véc tơ, bây giờ chúng ta sẽ thực hiện các phép tính số học trên véc tơ

Dưới đây là danh sách các thao tác cơ bản mà chúng ta có thể thực hiện trong vector

  • Môn số học
  • phép trừ
  • Phép nhân
  • Phân công
  • chấm sản phẩm
  • phép nhân vô hướng

Phép cộng hai vectơ

Trong phép cộng vectơ, nó diễn ra theo cách khôn ngoan, có nghĩa là phép cộng sẽ xảy ra từng phần tử và độ dài sẽ giống như của hai vectơ cộng

cú pháp

Hãy hiểu ví dụ sau

Thí dụ -

đầu ra

We create vector from a list 1:
[10 20 30 40 50]
We create vector from a list 2:
[11 12 13 14 15]
Addition of two vectors:  [21 32 43 54 65]

Phép trừ hai vectơ

Phép trừ thực hiện giống như phép cộng, nó tuân theo cách tiếp cận theo từng phần tử và các phần tử vectơ 2 sẽ bị trừ khỏi vectơ 1. Hãy hiểu ví dụ sau

Thí dụ -

đầu ra

We create vector from a list 1:
[10 20 30 40 50]
We create vector from a list 2:
[5 2 4 3 1]
Subtraction of two vectors:  [5 18 26 37 49]

Nhân hai vectơ

Các phần tử vectơ 1 được nhân với vectơ 2 và trả về các vectơ có cùng độ dài như các vectơ nhân. Hãy hiểu ví dụ sau

Thí dụ -

đầu ra

We create vector from a list 1:
[10 20 30 40 50]
We create vector from a list 2:
[5 2 4 3 1]
Multiplication of two vectors:  [ 50  40 120 120  50]

Phép nhân được thực hiện như sau

vct[0] = x[0] * y[0]
vct[1] = x[1] * y[1]

Phần tử đầu tiên của vectơ 1 được nhân với phần tử đầu tiên của vectơ 2 tương ứng, v.v.

Phép chia hai vectơ

Trong phép chia, vectơ kết quả chứa giá trị thương nhận được từ phép chia hai phần tử của vectơ

Hãy hiểu ví dụ sau

Thí dụ -

đầu ra

We create vector from a list 1:
[10 20 30 40 50]
We create vector from a list 2:
[5 2 4 3 1]
Division of two vectors:  [ 2.   10.          7.5        13.33333333        50.        ]

Như chúng ta có thể thấy trong đầu ra ở trên, phép chia đã trả về giá trị thương của các phần tử

Vector Chấm Sản Phẩm

Tích vectơ chấm thực hiện giữa hai vectơ tuần tự có cùng độ dài và trả về tích chấm đơn. chúng tôi sẽ sử dụng. phương thức dot[] để thực hiện tích vô hướng. Nó sẽ xảy ra như dưới đây

Hãy hiểu ví dụ sau

Thí dụ -

đầu ra

We create vector from a list 1:
[10 20 30 40 50]
We create vector from a list 2:
[5 2 4 3 1]
Dot product of two vectors:  380

Phép nhân vectơ-vô hướng

Trong phép toán nhân vô hướng; . Hãy hiểu ví dụ sau

Thí dụ -

đầu ra

________số 8_______

Trong đoạn mã trên, giá trị vô hướng được nhân với từng phần tử của vectơ theo cách s * v = [s * v1, s * v2, s * v3]

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
1. 
>>> 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
9

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

  1. mảng 1D

  2. mảng 2D

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

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

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 hoặc danh sách hoặc bộ 1D đầu vào, 
>>> 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.]]]
6

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

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

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

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

Để 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]]]
2

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

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

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

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

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

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

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

Làm cách nào để chuyển đổi mảng thành vectơ trong Python?

Để tạo một vectơ, chúng tôi sử dụng np. phương thức mảng . Ghi chú. Chúng ta cũng có thể tạo vectơ bằng phương thức khác, trả về mảng numpy 1-D, ví dụ np. sắp xếp [10], np.

định hình lại là gì [

Định hình lại dữ liệu của bạn bằng cách sử dụng mảng. định hình lại[-1, 1] nếu dữ liệu của bạn có một đối tượng duy nhất hoặc mảng. định hình lại [1, -1] nếu nó chứa một mẫu duy nhất. Chúng tôi có thể thay đổi Sê-ri của mình thành một mảng NumPy và sau đó định hình lại nó để có hai chiều.

Làm cách nào để chuyển đổi mảng 1 chiều thành mảng 2 chiều trong Python?

chuyển mảng 1 chiều thành mảng 2 chiều bằng cách thêm trục mới . a=np. mảng[[10,20,30,40,50,60]] b=a[. ,np. newaxis]--nó sẽ chuyển đổi nó thành hai chiều.

Các vectơ và mảng có giống nhau trong Python không?

Vectơ trong một thuật ngữ đơn giản có thể được coi là một mảng một chiều. Đối với Python, vector là mảng một chiều gồm các danh sách . Nó chiếm các phần tử theo cách tương tự như danh sách Python.

Bài Viết Liên Quan

Tam giác xanh trong ô Excel
Tùy chỉnh báo cáo pytest-html
Thợ làm bánh Mayfield có phải là Đại lý miễn phí vào năm 2023 không?
PHP lấy tên trang hiện tại
Phiên bản Bootstrap nào tốt hơn
5.4 inch là bao nhiêu cm
Nhập nhiều tệp csv vào bàn làm việc của MySQL
Đọc tệp RTF Python
Hình ảnh không hiển thị trong html trình duyệt di động
Không có trong mysql
Làm cách nào để lấy ngày từ datetime trong Python?
Động cơ BMW X5 2023
Danh sách chủ đề hội thảo python
Viết tập tin theo dòng python
Python song song cho đa xử lý vòng lặp
Làm thế nào để bạn truy cập các lớp học trong python?
Làm cách nào để chuyển đổi chuỗi ngày giờ thành ngày trong Python?
Làm thế nào để xin thị thực Hajj 2023?
Làm cách nào để lấy lại ngày 30 ngày trong PHP?
Không thể tìm thấy trình điều khiển Laravel 8

Toplist mới

#1
Top 7 tết mậu thân năm 1968 đã diễn ra sự kiện gì ở miền nam nước ta 2023
6 tháng trước
#2
Top 13 luyện từ và câu: dấu gạch ngang lớp 4 trang 45 2023
6 tháng trước
#3
Top 6 trong mặt phẳng oxy ảnh của đường thẳng d 3x y 4=0 2023
6 tháng trước
#4
Top 6 thử thách thần chết thuyết minh phần 2 2023
6 tháng trước
#5
Top 4 vở bài tập tiếng việt lớp 3 tập 2 chính tả trang 15 2023
6 tháng trước
#6
Top 5 áo khoác nam quảng châu cao cấp 2023
6 tháng trước
#7
Top 4 nội dung nào sau đây không phải là trách nhiệm của đơn vị đầu mối cung cấp thông tin 2023
6 tháng trước
#8
Top 9 mẫu đồng phục công sở đẹp 2022 2023
6 tháng trước
#9
Top 5 ốp lưng iphone 13 pro bảo vệ camera 2023
6 tháng trước

Bài mới nhất

Cải làm dưa chua là cải gì năm 2024
Trưởng ban dân vận tỉnh ủy tiếng anh là gì năm 2024
Chữ c trên công tơ điện là gì năm 2024
Cua sốt trứng muối tiếng anh là gì năm 2024
Hùng vương tên thật là gì năm 2024
Giải vở bài tập toán lớp 5 bài 168 năm 2024
Tập làm văn kiểm tra viết trang 45 năm 2024
Cách khắc phục lỗi máy tính bị màn hình xanh năm 2024
Bài tập tiếng việt cuối tuần 11 lớp 1 năm 2024
Các trường của 1 đối tượng là gì năm 2024

Chủ Đề

programming Hỏi Đáp Là gì Mẹo Hay Toplist Địa Điểm Hay Học Tốt mẹo hay Công Nghệ Nghĩa của từ Bao nhiêu Khỏe Đẹp đánh giá Tiếng anh Top List bao nhieu bao nhiêu hướng dẫn Món Ngon So Sánh Bài tập So sánh Xây Đựng Sản phẩm tốt Ngôn ngữ Bài Tập javascript Ở đâu Thế nào Hướng dẫn Dịch Tại sao Máy tính Đại học