Hướng dẫn what is 2d numpy array in python? - mảng numpy 2d trong python là gì?

Chào mừng bạn đến với Numpy!#

Numpy (Python số) là một thư viện Python nguồn mở mà sử dụng trong hầu hết các lĩnh vực khoa học và kỹ thuật. Nó có tiêu chuẩn phổ quát để làm việc với dữ liệu số trong Python, và nó là cốt lõi của hệ sinh thái Python và Pydata khoa học. Người dùng Numpy bao gồm tất cả mọi người từ các lập trình viên bắt đầu đến các nhà nghiên cứu có kinh nghiệm làm nghiên cứu và phát triển khoa học và công nghiệp tiên tiến. API numpy được sử dụng rộng rãi trong gấu trúc, scipy, matplotlib, scikit-learn, scikit-hình ảnh và hầu hết các gói khoa học dữ liệu khác và các gói python khoa học.Numerical Python) is an open source Python library that’s used in almost every field of science and engineering. It’s the universal standard for working with numerical data in Python, and it’s at the core of the scientific Python and PyData ecosystems. NumPy users include everyone from beginning coders to experienced researchers doing state-of-the-art scientific and industrial research and development. The NumPy API is used extensively in Pandas, SciPy, Matplotlib, scikit-learn, scikit-image and most other data science and scientific Python packages.

Thư viện Numpy chứa các cấu trúc dữ liệu mảng và ma trận đa chiều (bạn sẽ tìm thấy thêm thông tin về điều này trong các phần sau). Nó cung cấp ndarray, một đối tượng mảng N chiều đồng nhất, với các phương pháp để hoạt động hiệu quả trên nó. Numpy có thể được sử dụng để thực hiện nhiều hoạt động toán học trên các mảng. Nó bổ sung các cấu trúc dữ liệu mạnh mẽ vào Python đảm bảo các tính toán hiệu quả với các mảng và ma trận và nó cung cấp một thư viện khổng lồ các chức năng toán học cấp cao hoạt động trên các mảng và ma trận này.ndarray, a homogeneous n-dimensional array object, with methods to efficiently operate on it. NumPy can be used to perform a wide variety of mathematical operations on arrays. It adds powerful data structures to Python that guarantee efficient calculations with arrays and matrices and it supplies an enormous library of high-level mathematical functions that operate on these arrays and matrices.

Tìm hiểu thêm về Numpy ở đây!NumPy here!

Cài đặt Numpy#

Để cài đặt Numpy, chúng tôi thực sự khuyên bạn nên sử dụng phân phối Python khoa học. Nếu bạn đang tìm kiếm các hướng dẫn đầy đủ để cài đặt Numpy trên hệ điều hành của mình, hãy xem Cài đặt Numpy.

Nếu bạn đã có Python, bạn có thể cài đặt Numpy với:

hoặc

Nếu bạn không có Python, bạn có thể muốn xem xét sử dụng Anaconda. Nó là cách dễ nhất để bắt đầu. Điều tốt khi nhận được phân phối này là thực tế là bạn không cần phải lo lắng quá nhiều về việc cài đặt riêng biệt hoặc bất kỳ gói chính nào mà bạn sẽ sử dụng cho các phân tích dữ liệu của mình, như gấu trúc, scikit-learn, v.v.

Cách nhập Numpy#

Để truy cập Numpy và các chức năng của nó nhập nó vào mã Python của bạn như sau:

Chúng tôi rút ngắn tên đã nhập xuống

>>> a = np.array([1, 2, 3, 4, 5, 6])

Đọc mã ví dụ#

Nếu bạn đã không thoải mái với việc đọc các hướng dẫn có chứa nhiều mã, bạn có thể không biết cách diễn giải một khối mã trông như thế này:

>>> a = np.arange(6)
>>> a2 = a[np.newaxis, :]
>>> a2.shape
(1, 6)

Nếu bạn không quen thuộc với phong cách này, nó rất dễ hiểu. Nếu bạn thấy

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Điều gì khác biệt giữa một danh sách Python và một mảng numpy?##

Numpy cung cấp cho bạn một loạt các cách nhanh chóng và hiệu quả để tạo mảng và thao tác dữ liệu số bên trong chúng. Mặc dù một danh sách Python có thể chứa các loại dữ liệu khác nhau trong một danh sách duy nhất, tất cả các yếu tố trong một mảng numpy nên đồng nhất. Các hoạt động toán học có nghĩa là được thực hiện trên các mảng sẽ cực kỳ kém hiệu quả nếu các mảng weren đồng nhất.

Tại sao sử dụng Numpy?

Các mảng Numpy nhanh hơn và nhỏ gọn hơn danh sách Python. Một mảng tiêu thụ ít bộ nhớ hơn và thuận tiện để sử dụng. Numpy sử dụng ít bộ nhớ hơn để lưu trữ dữ liệu và nó cung cấp một cơ chế chỉ định các loại dữ liệu. Điều này cho phép mã được tối ưu hóa hơn nữa.

Mảng là gì?#

Một mảng là một cấu trúc dữ liệu trung tâm của thư viện Numpy. Một mảng là một lưới các giá trị và nó chứa thông tin về dữ liệu thô, cách định vị một phần tử và cách giải thích một phần tử. Nó có một lưới các yếu tố có thể được lập chỉ mục theo nhiều cách khác nhau. Các yếu tố đều giống nhau, được gọi là mảng

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Một mảng có thể được lập chỉ mục bởi một bộ số nguyên không âm, bởi booleans, bởi một mảng khác hoặc bởi các số nguyên.

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Một cách chúng ta có thể khởi tạo các mảng numpy là từ danh sách Python, sử dụng danh sách lồng nhau cho dữ liệu hai hoặc chiều cao hơn.

Ví dụ:

>>> a = np.array([1, 2, 3, 4, 5, 6])

or:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Chúng ta có thể truy cập các phần tử trong mảng bằng dấu ngoặc vuông. Khi bạn truy cập các phần tử, hãy nhớ rằng việc lập chỉ mục trong Numpy bắt đầu từ 0. Điều đó có nghĩa là nếu bạn muốn truy cập phần tử đầu tiên trong mảng của mình, bạn sẽ truy cập phần tử.

>>> print(a[0])
[1 2 3 4]

Thêm thông tin về mảng#

Phần này bao gồm

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Thỉnh thoảng bạn có thể nghe thấy một mảng được gọi là một Ndarray, đó là cách viết tắt của mảng N-dimensional. Một mảng n chiều chỉ đơn giản là một mảng với bất kỳ số lượng kích thước nào. Bạn cũng có thể nghe thấy mảng 1-D, hoặc một chiều, mảng 2-D hoặc hai chiều, v.v. Lớp

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Các thuộc tính của một mảng là gì?

Một mảng thường là một thùng chứa có kích thước cố định của các vật phẩm cùng loại và kích thước. Số lượng kích thước và vật phẩm trong một mảng được xác định bởi hình dạng của nó. Hình dạng của một mảng là một bộ phận của các số nguyên không âm chỉ xác định kích thước của từng chiều.

Trong Numpy, kích thước được gọi là trục. Điều này có nghĩa là nếu bạn có một mảng 2D trông như thế này:axes. This means that if you have a 2D array that looks like this:

[[0., 0., 0.],
 [1., 1., 1.]]

Mảng của bạn có 2 trục. Trục đầu tiên có chiều dài 2 và trục thứ hai có chiều dài 3.

Giống như trong các đối tượng container Python khác, nội dung của một mảng có thể được truy cập và sửa đổi bằng cách lập chỉ mục hoặc cắt mảng. Không giống như các đối tượng container thông thường, các mảng khác nhau có thể chia sẻ cùng một dữ liệu, do đó các thay đổi được thực hiện trên một mảng có thể được hiển thị trong một mảng khác.

Các thuộc tính mảng phản ánh thông tin nội tại cho chính mảng. Nếu bạn cần có, hoặc thậm chí đặt, các thuộc tính của một mảng mà không tạo ra một mảng mới, bạn thường có thể truy cập một mảng thông qua các thuộc tính của nó.attributes reflect information intrinsic to the array itself. If you need to get, or even set, properties of an array without creating a new array, you can often access an array through its attributes.

Đọc thêm về các thuộc tính mảng ở đây và tìm hiểu về các đối tượng mảng ở đây. and learn about array objects here.

Cách tạo một mảng cơ bản#

Phần này bao gồm

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Để tạo một mảng numpy, bạn có thể sử dụng chức năng

>>> a = np.array([1, 2, 3, 4, 5, 6])

Tất cả những gì bạn cần làm để tạo một mảng đơn giản là truyền một danh sách cho nó. Nếu bạn chọn, bạn cũng có thể chỉ định loại dữ liệu trong danh sách của mình. Bạn có thể tìm thêm thông tin về các loại dữ liệu ở đây.You can find more information about data types here.

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Bạn có thể trực quan hóa mảng của bạn theo cách này:

Xin lưu ý rằng những hình ảnh trực quan này có nghĩa là để đơn giản hóa các ý tưởng và cung cấp cho bạn một sự hiểu biết cơ bản về các khái niệm và cơ học numpy. Các mảng và hoạt động mảng phức tạp hơn nhiều so với được ghi lại ở đây!

Bên cạnh việc tạo một mảng từ một chuỗi các phần tử, bạn có thể dễ dàng tạo một mảng chứa đầy ____ 148 148:

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

Hoặc một mảng chứa đầy ____ 149,:

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

Hoặc thậm chí là một mảng trống! Hàm

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Bạn có thể tạo một mảng với một loạt các yếu tố:

>>> np.arange(4)
array([0, 1, 2, 3])

Và thậm chí một mảng chứa một loạt các khoảng cách đều nhau. Để làm điều này, bạn sẽ chỉ định số đầu tiên, số cuối cùng và kích thước bước.first number, last number, and the step size.

>>> a = np.array([1, 2, 3, 4, 5, 6])

Bạn cũng có thể sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Chỉ định kiểu dữ liệu của bạn

Mặc dù kiểu dữ liệu mặc định là điểm nổi (

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Tìm hiểu thêm về việc tạo mảng ở đây

Thêm, loại bỏ và sắp xếp các yếu tố#

Phần này bao gồm

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Sắp xếp một phần tử là đơn giản với

>>> a = np.array([1, 2, 3, 4, 5, 6])

Nếu bạn bắt đầu với mảng này:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Bạn có thể nhanh chóng sắp xếp các số theo thứ tự tăng dần với:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Ngoài việc sắp xếp, trả về một bản sao được sắp xếp của một mảng, bạn có thể sử dụng:

• >>> a = np.array([1, 2, 3, 4, 5, 6])
  

  59, là một loại gián tiếp dọc theo một trục được chỉ định,

• >>> a = np.array([1, 2, 3, 4, 5, 6])
  

  60, là một loại ổn định gián tiếp trên nhiều phím,

• >>> a = np.array([1, 2, 3, 4, 5, 6])
  

  61, sẽ tìm thấy các yếu tố trong một mảng được sắp xếp và

• >>> a = np.array([1, 2, 3, 4, 5, 6])
  

  62, đó là một loại một phần.

Để đọc thêm về việc sắp xếp một mảng, xem:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Nếu bạn bắt đầu với các mảng sau:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Bạn có thể kết hợp chúng với

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Hoặc, nếu bạn bắt đầu với các mảng sau:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Bạn có thể kết hợp chúng với:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Để loại bỏ các phần tử khỏi một mảng, nó rất đơn giản để sử dụng lập chỉ mục để chọn các phần tử mà bạn muốn giữ.

Để đọc thêm về Concatenate, xem:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Làm thế nào để bạn biết hình dạng và kích thước của một mảng?#

Phần này bao gồm

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Ví dụ: nếu bạn tạo mảng này:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Để tìm số lượng kích thước của mảng, hãy chạy:

Để tìm tổng số phần tử trong mảng, hãy chạy:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Và để tìm hình dạng của mảng của bạn, hãy chạy:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể định hình lại một mảng không?#

Phần này bao gồm

>>> a = np.array([1, 2, 3, 4, 5, 6])

Yes!

Sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

Nếu bạn bắt đầu với mảng này:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Với

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Nếu bạn muốn tìm hiểu thêm về thứ tự C và Fortran, bạn có thể đọc thêm về tổ chức nội bộ của các mảng numpy ở đây. Về cơ bản, các đơn đặt hàng C và Fortran có liên quan đến cách các chỉ số tương ứng với thứ tự mảng được lưu trữ trong bộ nhớ. Trong Fortran, khi di chuyển qua các phần tử của một mảng hai chiều vì nó được lưu trữ trong bộ nhớ, chỉ số đầu tiên là chỉ số khác nhau nhanh nhất. Khi chỉ mục đầu tiên di chuyển sang hàng tiếp theo khi nó thay đổi, ma trận được lưu trữ một cột tại một thời điểm. Đây là lý do tại sao Fortran được coi là một ngôn ngữ chính cột. Mặt khác, chỉ số cuối cùng thay đổi nhanh nhất. Ma trận được lưu trữ bởi các hàng, làm cho nó trở thành một ngôn ngữ lớn. Những gì bạn làm cho C hoặc Fortran phụ thuộc vào việc nó có quan trọng hơn để bảo tồn quy ước lập chỉ mục hay không sắp xếp lại dữ liệu.read more about the internal organization of NumPy arrays here. Essentially, C and Fortran orders have to do with how indices correspond to the order the array is stored in memory. In Fortran, when moving through the elements of a two-dimensional array as it is stored in memory, the first index is the most rapidly varying index. As the first index moves to the next row as it changes, the matrix is stored one column at a time. This is why Fortran is thought of as a Column-major language. In C on the other hand, the last index changes the most rapidly. The matrix is stored by rows, making it a Row-major language. What you do for C or Fortran depends on whether it’s more important to preserve the indexing convention or not reorder the data.

Tìm hiểu thêm về thao tác hình dạng ở đây..

Cách chuyển đổi mảng 1D thành mảng 2D (cách thêm trục mới vào mảng)#

Phần này bao gồm

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Bạn có thể sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

Ví dụ: nếu bạn bắt đầu với mảng này:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể chuyển đổi rõ ràng một mảng 1D với một vectơ hàng hoặc vectơ cột bằng cách sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Hoặc, đối với một vectơ cột, bạn có thể chèn một trục dọc theo chiều thứ hai:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn cũng có thể mở rộng một mảng bằng cách chèn một trục mới ở một vị trí được chỉ định với

>>> a = np.array([1, 2, 3, 4, 5, 6])

Ví dụ: nếu bạn bắt đầu với mảng này:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

Bạn có thể chuyển đổi rõ ràng một mảng 1D với một vectơ hàng hoặc vectơ cột bằng cách sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

Hoặc, đối với một vectơ cột, bạn có thể chèn một trục dọc theo chiều thứ hai:

>>> print(a[0])
[1 2 3 4]

Bạn cũng có thể mở rộng một mảng bằng cách chèn một trục mới ở một vị trí được chỉ định với

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Bạn có thể sử dụng >>> a = np.array([1, 2, 3, 4, 5, 6]) 84 để thêm trục tại vị trí chỉ mục 1 với:

>>> print(a[0])
[1 2 3 4]

>>> print(a[0])
[1 2 3 4]

Bạn có thể thêm một trục tại vị trí chỉ mục 0 với:

Tìm thêm thông tin về Newaxis tại đây và

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Lập chỉ mục và cắt#

Ví dụ: nếu bạn bắt đầu với mảng này:

>>> print(a[0])
[1 2 3 4]

Bạn có thể sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> print(a[0])
[1 2 3 4]

Bạn có thể chuyển đổi rõ ràng một mảng 1D với một vectơ hàng hoặc vectơ cột bằng cách sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> print(a[0])
[1 2 3 4]

Bạn có thể chọn các phần tử chia hết cho 2:

>>> print(a[0])
[1 2 3 4]

Hoặc bạn có thể chọn các yếu tố đáp ứng hai điều kiện bằng cách sử dụng các toán tử

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> print(a[0])
[1 2 3 4]

Bạn cũng có thể sử dụng các toán tử logic & và | Để trả về các giá trị boolean xác định xem các giá trị trong một mảng có đáp ứng một điều kiện nhất định hay không. Điều này có thể hữu ích với các mảng có chứa tên hoặc các giá trị phân loại khác.& and | in order to return boolean values that specify whether or not the values in an array fulfill a certain condition. This can be useful with arrays that contain names or other categorical values.

>>> print(a[0])
[1 2 3 4]

Bạn cũng có thể sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

Bắt đầu với mảng này:

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

[[0., 0., 0.],
 [1., 1., 1.]]

Trong ví dụ này, một bộ mảng đã được trả về: một cho mỗi chiều. Mảng thứ nhất biểu thị các chỉ số hàng nơi các giá trị này được tìm thấy và mảng thứ hai biểu thị các chỉ số cột nơi tìm thấy các giá trị.

Nếu bạn muốn tạo một danh sách các tọa độ nơi các yếu tố tồn tại, bạn có thể zip các mảng, lặp lại danh sách tọa độ và in chúng. Ví dụ:

[[0., 0., 0.],
 [1., 1., 1.]]

Bạn cũng có thể sử dụng

>>> a = np.array([1, 2, 3, 4, 5, 6])

[[0., 0., 0.],
 [1., 1., 1.]]

Nếu phần tử mà bạn đang tìm kiếm không tồn tại trong mảng, thì mảng các chỉ số được trả về sẽ trống. Ví dụ:

[[0., 0., 0.],
 [1., 1., 1.]]

Tìm hiểu thêm về lập chỉ mục và cắt lát ở đây và đây.indexing and slicing here and here.

Đọc thêm về việc sử dụng hàm khác không tại:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Cách tạo một mảng từ dữ liệu hiện có#

Phần này bao gồm

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể dễ dàng tạo một mảng mới từ một phần của một mảng hiện có.

Hãy nói rằng bạn có mảng này:

[[0., 0., 0.],
 [1., 1., 1.]]

Bạn có thể tạo một mảng mới từ một phần của mảng của bạn bất cứ lúc nào bằng cách chỉ định nơi bạn muốn cắt mảng của bạn.

[[0., 0., 0.],
 [1., 1., 1.]]

Tại đây, bạn đã lấy một phần của mảng của bạn từ vị trí chỉ mục 3 đến vị trí chỉ mục 8.

Bạn cũng có thể xếp hai mảng hiện có, cả theo chiều dọc và chiều ngang. Hãy nói rằng bạn có hai mảng,

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

[[0., 0., 0.],
 [1., 1., 1.]]

Bạn có thể xếp chúng theo chiều dọc với

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

[[0., 0., 0.],
 [1., 1., 1.]]

Hoặc xếp chúng theo chiều ngang với

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

[[0., 0., 0.],
 [1., 1., 1.]]

Bạn có thể chia một mảng thành một số mảng nhỏ hơn bằng cách sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Hãy nói rằng bạn có mảng này:

[[0., 0., 0.],
 [1., 1., 1.]]

Bạn có thể tạo một mảng mới từ một phần của mảng của bạn bất cứ lúc nào bằng cách chỉ định nơi bạn muốn cắt mảng của bạn.

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Tại đây, bạn đã lấy một phần của mảng của bạn từ vị trí chỉ mục 3 đến vị trí chỉ mục 8.

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Bạn cũng có thể xếp hai mảng hiện có, cả theo chiều dọc và chiều ngang. Hãy nói rằng bạn có hai mảng,

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể xếp chúng theo chiều dọc với

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Hoặc xếp chúng theo chiều ngang với

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

[[0., 0., 0.],
 [1., 1., 1.]]

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể chia một mảng thành một số mảng nhỏ hơn bằng cách sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Nếu bạn muốn chia mảng này thành ba mảng có hình tương đương, bạn sẽ chạy:

Nếu bạn muốn phân chia mảng của mình sau cột thứ ba và thứ tư, bạn sẽ chạy:.

Tìm hiểu thêm về các mảng xếp chồng và chia tách ở đây.

Bạn có thể sử dụng phương thức

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Quan điểm là một khái niệm kỳ quặc quan trọng! Các chức năng Numpy, cũng như các hoạt động như lập chỉ mục và cắt, sẽ trả về chế độ xem bất cứ khi nào có thể. Điều này lưu bộ nhớ và nhanh hơn (không có bản sao của dữ liệu). Tuy nhiên, điều quan trọng là phải nhận thức được điều này - sửa đổi dữ liệu trong chế độ xem cũng sửa đổi mảng gốc!

Hãy nói rằng bạn tạo ra mảng này:

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Bây giờ chúng tôi tạo một mảng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Sử dụng phương thức

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Tìm hiểu thêm về các bản sao và quan điểm ở đây.

Hoạt động mảng cơ bản#

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Phần này bao gồm bổ sung, trừ, nhân, chia, và nhiều hơn nữa

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Khi bạn đã tạo ra mảng của mình, bạn có thể bắt đầu làm việc với họ. Ví dụ, hãy nói rằng, bạn đã tạo ra hai mảng, một người được gọi là dữ liệu và một cái gọi là những người có tên là Ones Ones

>>> import numpy as np
>>> a = np.array([1, 2, 3])

Bạn có thể thêm các mảng cùng với dấu cộng..

Broadcasting#

Tất nhiên, bạn có thể làm nhiều hơn là bổ sung!

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

Numpy hiểu rằng sự nhân lên sẽ xảy ra với mỗi ô. Khái niệm đó được gọi là phát sóng. Phát sóng là một cơ chế cho phép Numpy thực hiện các hoạt động trên các mảng có các hình dạng khác nhau. Kích thước của mảng của bạn phải tương thích, ví dụ, khi kích thước của cả hai mảng bằng hoặc khi một trong số chúng là 1. Nếu kích thước không tương thích, bạn sẽ nhận được

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Tìm hiểu thêm về phát sóng ở đây..

Các hoạt động mảng hữu ích hơn#

Phần này bao gồm tối đa, tối thiểu, tổng, trung bình, sản phẩm, độ lệch chuẩn, và nhiều hơn nữa

Numpy cũng thực hiện các chức năng tổng hợp. Ngoài

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

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

Hãy bắt đầu với mảng này, được gọi là "A"

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

Nó rất phổ biến để muốn tổng hợp dọc theo một hàng hoặc cột. Theo mặc định, mọi hàm tổng hợp Numpy sẽ trả về tổng hợp của toàn bộ mảng. Để tìm tổng hoặc tối thiểu của các phần tử trong mảng của bạn, hãy chạy:

Or:

Bạn có thể chỉ định trên trục nào bạn muốn chức năng tổng hợp được tính toán. Ví dụ: bạn có thể tìm thấy giá trị tối thiểu trong mỗi cột bằng cách chỉ định

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

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

Bốn giá trị được liệt kê ở trên tương ứng với số lượng cột trong mảng của bạn. Với một mảng bốn cột, bạn sẽ nhận được bốn giá trị là kết quả của mình.

Đọc thêm về các phương thức mảng ở đây.array methods here.

Tạo ma trận#

Bạn có thể vượt qua danh sách danh sách Python để tạo một mảng 2 chiều (hoặc ma trận ma trận) để thể hiện chúng trong Numpy.

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

Các hoạt động lập chỉ mục và cắt lát rất hữu ích khi bạn điều khiển ma trận:

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

Bạn có thể tổng hợp các ma trận giống như cách bạn tổng hợp các vectơ:

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

Bạn có thể tổng hợp tất cả các giá trị trong một ma trận và bạn có thể tổng hợp chúng trên các cột hoặc hàng bằng tham số

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

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

Khi bạn đã tạo ra ma trận của mình, bạn có thể thêm và nhân chúng bằng toán tử số học nếu bạn có hai ma trận có cùng kích thước.

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

Bạn có thể thực hiện các hoạt động số học này trên các ma trận có kích thước khác nhau, nhưng chỉ khi một ma trận chỉ có một cột hoặc một hàng. Trong trường hợp này, Numpy sẽ sử dụng các quy tắc phát sóng cho hoạt động.

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

Xin lưu ý rằng khi Numpy in các mảng N chiều, trục cuối cùng được lặp qua nhanh nhất trong khi trục đầu tiên là chậm nhất. Ví dụ:

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

Thường có những trường hợp chúng tôi muốn Numpy khởi tạo các giá trị của một mảng. Numpy cung cấp các chức năng như

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

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

Bạn cũng có thể sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

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

Tìm hiểu thêm về việc tạo mảng, chứa đầy ____ 148, ____ 149, các giá trị khác hoặc không được cung cấp, tại các thói quen tạo mảng.array creation routines.

Tạo số ngẫu nhiên#

Việc sử dụng tạo số ngẫu nhiên là một phần quan trọng của cấu hình và đánh giá nhiều thuật toán học và học máy. Cho dù bạn cần khởi tạo ngẫu nhiên các trọng số trong mạng thần kinh nhân tạo, chia dữ liệu thành các bộ ngẫu nhiên hoặc xáo trộn ngẫu nhiên bộ dữ liệu của bạn, có thể tạo ra các số ngẫu nhiên (thực tế, các số giả ngẫu nhiên lặp lại) là điều cần thiết.

Với

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể tạo một mảng 2 x 4 của các số nguyên ngẫu nhiên trong khoảng từ 0 đến 4 với:

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

Đọc thêm về tạo số ngẫu nhiên ở đây..

Cách nhận các mặt hàng độc đáo và đếm#

Phần này bao gồm

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể tìm thấy các yếu tố duy nhất trong một mảng một cách dễ dàng với

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Ví dụ: nếu bạn bắt đầu với mảng này:

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

Bạn có thể sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

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

Để có được các chỉ số của các giá trị duy nhất trong một mảng numpy (một mảng các vị trí chỉ mục đầu tiên của các giá trị duy nhất trong mảng), chỉ cần chuyển đối số

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

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

Bạn có thể vượt qua đối số

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

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

Điều này cũng hoạt động với mảng 2D! Nếu bạn bắt đầu với mảng này:

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

Bạn có thể tìm thấy các giá trị duy nhất với:

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

Nếu đối số trục được thông qua, mảng 2D của bạn sẽ bị san phẳng.

Nếu bạn muốn có được các hàng hoặc cột duy nhất, hãy đảm bảo vượt qua đối số

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Để có được các hàng, vị trí chỉ mục và số lượng xuất hiện duy nhất, bạn có thể sử dụng:

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Để tìm hiểu thêm về việc tìm kiếm các yếu tố độc đáo trong một mảng, hãy xem

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Chuyển đổi và định hình lại một ma trận#

Phần này bao gồm

>>> a = np.array([1, 2, 3, 4, 5, 6])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Nó phổ biến cần phải chuyển đổi ma trận của bạn. Các mảng Numpy có thuộc tính

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn cũng có thể cần chuyển đổi kích thước của ma trận. Điều này có thể xảy ra khi, ví dụ, bạn có một mô hình mong đợi một hình dạng đầu vào nhất định khác với bộ dữ liệu của bạn. Đây là nơi phương thức

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Bạn cũng có thể sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Nếu bạn bắt đầu với mảng này:

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Bạn có thể chuyển đổi mảng của bạn với

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Bạn cũng có thể sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Để tìm hiểu thêm về việc chuyển đổi và định hình lại các mảng, hãy xem

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Cách đảo ngược một mảng#

Phần này bao gồm

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Chức năng Numpy từ ____258 cho phép bạn lật hoặc đảo ngược, nội dung của một mảng dọc theo một trục. Khi sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Đảo ngược một mảng 1D

Nếu bạn bắt đầu với một mảng 1D như thế này:

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Bạn có thể đảo ngược nó với:

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Nếu bạn muốn in mảng đảo ngược của mình, bạn có thể chạy:

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Đảo ngược một mảng 2D

Một mảng 2D hoạt động giống nhau theo cùng một cách.

Nếu bạn bắt đầu với mảng này:

>>> # Create an empty array with 2 elements
>>> np.empty(2) 
array([3.14, 42.  ])  # may vary

Bạn có thể chuyển đổi mảng của bạn với

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> np.arange(4)
array([0, 1, 2, 3])

Bạn cũng có thể sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> np.arange(4)
array([0, 1, 2, 3])

Để tìm hiểu thêm về việc chuyển đổi và định hình lại các mảng, hãy xem

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> np.arange(4)
array([0, 1, 2, 3])

Cách đảo ngược một mảng#

>>> np.arange(4)
array([0, 1, 2, 3])

Phần này bao gồm

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> np.arange(4)
array([0, 1, 2, 3])

Chức năng Numpy từ ____258 cho phép bạn lật hoặc đảo ngược, nội dung của một mảng dọc theo một trục. Khi sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Đảo ngược một mảng 1D

Nếu bạn bắt đầu với một mảng 1D như thế này:

Bạn có thể đảo ngược nó với:

Nếu bạn bắt đầu với mảng này:

>>> np.arange(4)
array([0, 1, 2, 3])

Bạn có thể chuyển đổi mảng của bạn với

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> np.arange(4)
array([0, 1, 2, 3])

Bạn cũng có thể sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Để tìm hiểu thêm về việc chuyển đổi và định hình lại các mảng, hãy xem

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> np.arange(4)
array([0, 1, 2, 3])

Cách đảo ngược một mảng#

Để tìm hiểu thêm về việc chuyển đổi và định hình lại các mảng, hãy xem

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> np.arange(4)
array([0, 1, 2, 3])

Cách đảo ngược một mảng#

Phần này bao gồm >>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) 58

Chức năng Numpy từ ____258 cho phép bạn lật hoặc đảo ngược, nội dung của một mảng dọc theo một trục. Khi sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Đảo ngược một mảng 1Ddocstring. In most cases, this docstring contains a quick and concise summary of the object and how to use it. Python has a built-in

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Để tìm hiểu thêm về việc chuyển đổi và định hình lại các mảng, hãy xem

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> np.arange(4)
array([0, 1, 2, 3])

Cách đảo ngược một mảng#

Để tìm hiểu thêm về việc chuyển đổi và định hình lại các mảng, hãy xem

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Cách đảo ngược một mảng#

Phần này bao gồm

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Chức năng Numpy từ ____258 cho phép bạn lật hoặc đảo ngược, nội dung của một mảng dọc theo một trục. Khi sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([1, 2, 3, 4, 5, 6])

Điều này cũng hoạt động cho các chức năng và các đối tượng khác mà bạn tạo. Chỉ cần nhớ bao gồm một tài liệu với chức năng của bạn bằng cách sử dụng một chuỗi chữ (

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Ví dụ: nếu bạn tạo chức năng này:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Bạn có thể có được thông tin về chức năng:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Bạn có thể đạt được một cấp thông tin khác bằng cách đọc mã nguồn của đối tượng mà bạn quan tâm. Sử dụng dấu câu hỏi kép (

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Ví dụ:

>>> a = np.array([1, 2, 3, 4, 5, 6])

Nếu đối tượng trong câu hỏi được biên dịch bằng ngôn ngữ khác ngoài Python, sử dụng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([1, 2, 3, 4, 5, 6])

và :

>>> a = np.array([1, 2, 3, 4, 5, 6])

Có cùng đầu ra vì chúng được biên dịch bằng ngôn ngữ lập trình khác với Python.

Làm việc với các công thức toán học#

Sự dễ dàng thực hiện các công thức toán học hoạt động trên các mảng là một trong những điều khiến cho sự vô cùng được sử dụng rộng rãi trong cộng đồng Python khoa học.

Ví dụ, đây là công thức lỗi trung bình bình phương (một công thức trung tâm được sử dụng trong các mô hình học máy được giám sát liên quan đến hồi quy):

Việc thực hiện công thức này rất đơn giản và đơn giản trong Numpy:

Điều làm cho công việc này trở nên tốt đẹp là

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Bạn có thể hình dung nó theo cách này:

Trong ví dụ này, cả hai dự đoán và nhãn vectơ đều chứa ba giá trị, có nghĩa là

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Cách lưu và tải các đối tượng Numpy#

Phần này bao gồm

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Đến một lúc nào đó, bạn sẽ muốn lưu các mảng của bạn vào đĩa và tải chúng lại mà không cần phải chạy lại mã. May mắn thay, có một số cách để lưu và tải các đối tượng với Numpy. Các đối tượng ndarray có thể được lưu và tải từ các tệp đĩa với các chức năng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> print(a[0])
[1 2 3 4]

>>> print(a[0])
[1 2 3 4]

Các tệp .npy và .npz lưu trữ dữ liệu, hình dạng, dtype và các thông tin khác cần thiết để xây dựng lại ndarray theo cách cho phép mảng được truy xuất chính xác, ngay cả khi tệp trên một máy khác có kiến ​​trúc khác..npy and .npz files store data, shape, dtype, and other information required to reconstruct the ndarray in a way that allows the array to be correctly retrieved, even when the file is on another machine with different architecture.

Nếu bạn muốn lưu trữ một đối tượng ndarray duy nhất, hãy lưu trữ nó dưới dạng tệp .npy bằng

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

>>> print(a[0])
[1 2 3 4]

Nó rất dễ để lưu và tải và mảng với

>>> print(a[0])
[1 2 3 4]

>>> a = np.array([1, 2, 3, 4, 5, 6])