Cài đặt Numpy
Nếu bạn có Python và PIP đã được cài đặt trên một hệ thống, thì việc cài đặt Numpy là rất dễ dàng.
Cài đặt nó bằng lệnh này:
C: \ Users \ Your Name> Pip Install Numpy
Nếu lệnh này không thành công, thì hãy sử dụng phân phối Python đã được cài đặt Numpy như, Anaconda, Spyder, v.v.
Nhập khẩu Numpy
Sau khi Numpy được cài đặt, hãy nhập nó vào các ứng dụng của bạn bằng cách thêm từ khóa
>>> a = np.array[[1, 2, 3, 4, 5, 6]]26:
Bây giờ Numpy đã được nhập khẩu và sẵn sàng để sử dụng.
Numpy như NP
Numpy thường được nhập khẩu dưới bí danh
>>> a = np.array[[1, 2, 3, 4, 5, 6]]27.
Bí danh: Trong bí danh Python là một tên thay thế để đề cập đến cùng một điều. In Python alias are an alternate name for referring to the same thing.
Tạo bí danh với từ khóa
>>> a = np.array[[1, 2, 3, 4, 5, 6]]28 trong khi nhập:
Bây giờ gói numpy có thể được gọi là
>>> a = np.array[[1, 2, 3, 4, 5, 6]]27 thay vì
>>> a = np.array[[1, 2, 3, 4, 5, 6]]30.
Thí dụ
nhập khẩu NUMPY dưới dạng NP
mảng = np.array [[1, 2, 3, 4, 5]]]
in [mảng]
Hãy tự mình thử »
Kiểm tra phiên bản Numpy
Chuỗi phiên bản được lưu trữ trong thuộc tính
>>> a = np.array[[1, 2, 3, 4, 5, 6]]31.
Chào mừng bạn đến với Hướng dẫn dành cho người mới bắt đầu tuyệt đối về Numpy! Nếu bạn có ý kiến hoặc đề xuất, xin đừng ngần ngại tiếp cận!
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]]32 để có khả năng đọc mã tốt hơn bằng cách sử dụng Numpy. Đây là một quy ước được áp dụng rộng rãi mà bạn nên làm theo để bất kỳ ai làm việc với mã của bạn đều có thể dễ dàng hiểu được nó.
Đọ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]]33, bạn sẽ nhìn vào đầu vào hoặc mã mà bạn sẽ nhập. Tất cả mọi thứ không có
>>> a = np.array[[1, 2, 3, 4, 5, 6]]33 trước mặt nó là đầu ra hoặc kết quả chạy mã của bạn. Đây là kiểu bạn thấy khi bạn chạy
>>> a = np.array[[1, 2, 3, 4, 5, 6]]35 trên dòng lệnh, nhưng nếu bạn sử dụng ipython, bạn có thể thấy một kiểu khác. Lưu ý rằng nó không phải là một phần của mã và sẽ gây ra lỗi nếu được nhập hoặc dán vào vỏ Python. Nó có thể được gõ hoặc dán một cách an toàn vào vỏ ipython;
>>> a = np.array[[1, 2, 3, 4, 5, 6]]33 bị bỏ qua.input, or the code that you would enter. Everything that doesn’t have
>>> a = np.array[[1, 2, 3, 4, 5, 6]]33 in front of it is output, or the results of running your code. This is the style you see when you run
>>> a = np.array[[1, 2, 3, 4, 5, 6]]35 on the command line, but if you’re using IPython, you might see a different style. Note that it is not part of the code and will cause an error if typed or pasted into the Python shell. It can be safely typed or pasted into the IPython shell; the
>>> a = np.array[[1, 2, 3, 4, 5, 6]]33 is ignored.
Đ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ố là tất cả cùng loại, được gọi là mảng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]37.various ways. The elements are all of the same type, referred to as the array
>>> a = np.array[[1, 2, 3, 4, 5, 6]]37.
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]]38 của mảng là số lượng kích thước.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]39 của mảng là một bộ số số nguyên cho kích thước của mảng dọc theo mỗi chiều.
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]]40,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]41,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]42,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]43,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]44
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]]42 numpy được sử dụng để đại diện cho cả ma trận và vectơ. Một vectơ là một mảng có một chiều duy nhất [không có sự khác biệt giữa các vectơ hàng và cột], trong khi một ma trận đề cập đến một mảng có hai chiều. Đối với các mảng chiều 3-D trở lên, thuật ngữ tenxơ cũng thường được sử dụng.1-D, or one-dimensional array, 2-D, or two-dimensional array, and so on. The NumPy
>>> a = np.array[[1, 2, 3, 4, 5, 6]]42 class is used to represent both matrices and vectors. A vector is an array with a single dimension [there’s no difference between row and column vectors], while a matrix refers to an array with two dimensions. For 3-D or higher dimensional arrays, the term tensor is also commonly used.
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]]46,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]47,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]48,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]49,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]50,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]51,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]37
Để 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]]46.
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 ____ 154,:
>>> np.zeros[2] array[[0., 0.]]
Hoặc một mảng chứa đầy ____ 155,:
>>> 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]]56 tạo ra một mảng có nội dung ban đầu là ngẫu nhiên và phụ thuộc vào trạng thái của bộ nhớ. Lý do sử dụng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]56 trên
>>> a = np.array[[1, 2, 3, 4, 5, 6]]58 [hoặc một cái gì đó tương tự] là tốc độ - chỉ cần đảm bảo lấp đầy mọi yếu tố sau đó!
>>> # 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]]0
Bạn cũng có thể sử dụng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]51 để tạo một mảng có các giá trị được đặt cách tuyến tính trong một khoảng thời gian được chỉ định:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]1
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]]60], bạn có thể chỉ định rõ ràng kiểu dữ liệu bạn muốn sử dụng từ khóa
>>> a = np.array[[1, 2, 3, 4, 5, 6]]37.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]2
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]]62,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]63
Sắp xếp một phần tử đơn giản với
>>> a = np.array[[1, 2, 3, 4, 5, 6]]62. Bạn có thể chỉ định trục, loại và thứ tự khi bạn gọi chức năng.
Nếu bạn bắt đầu với mảng này:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]3
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]]4
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]]
65, 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]]
66, 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]]
67, 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]]
68, đó 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]]69.
Nếu bạn bắt đầu với các mảng sau:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]5
Bạn có thể kết hợp chúng với
>>> a = np.array[[1, 2, 3, 4, 5, 6]]63.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]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]]7
Bạn có thể kết hợp chúng với:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]8
Để 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]]71.
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]]72,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]73,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]74
>>> a = np.array[[1, 2, 3, 4, 5, 6]]72 sẽ cho bạn biết số lượng trục hoặc kích thước của mảng.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]73 sẽ cho bạn biết tổng số phần tử của mảng. Đây là sản phẩm của các yếu tố của hình dạng mảng.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]74 sẽ hiển thị một bộ số nguyên cho biết số lượng các phần tử được lưu trữ dọc theo mỗi chiều của mảng. Ví dụ, nếu bạn có một mảng 2 chiều với 2 hàng và 3 cột, hình dạng của mảng của bạn là
>>> a = np.array[[1, 2, 3, 4, 5, 6]]78.
Ví dụ: nếu bạn tạo mảng này:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]9
Để 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]]]0
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]]]1
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]]79
Yes!
Sử dụng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]79 sẽ đưa ra một hình dạng mới cho một mảng mà không thay đổi dữ liệu. Chỉ cần nhớ rằng khi bạn sử dụng phương pháp định hình lại, mảng bạn muốn sản xuất cần phải có cùng số lượng phần tử với mảng gốc. Nếu bạn bắt đầu với một mảng có 12 yếu tố, bạn sẽ cần đảm bảo rằng mảng mới của bạn cũng có tổng cộng 12 yếu tố.
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]]]2
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, 7, 8], [9, 10, 11, 12]]]3
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, 7, 8], [9, 10, 11, 12]]]4
>>> a = np.array[[1, 2, 3, 4, 5, 6]]65, 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]]66, 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]]67, 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]]68, đó là một loại một phần.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.
Để đọc thêm về việc sắp xếp một mảng, xem: >>> a = np.array[[1, 2, 3, 4, 5, 6]]
69..
Nếu bạn bắt đầu với các mảng sau:
Phần này bao gồm
>>> a = np.array[[1, 2, 3, 4, 5, 6]]89,
>>> a = np.array[[1, 2, 3, 4, 5, 6]]90
Bạn có thể sử dụng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]89 và
>>> a = np.array[[1, 2, 3, 4, 5, 6]]90 để tăng kích thước của mảng hiện tại của bạn.
Sử dụng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]89 sẽ tăng kích thước của mảng của bạn theo một chiều khi được sử dụng một lần. Điều này có nghĩa là một mảng 1D sẽ trở thành một mảng 2D, một mảng 2D sẽ trở thành một mảng 3D, v.v.1D array will become a 2D array, a 2D array will become a 3D array, and so on.
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]]]5
Bạn có thể sử dụng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]89 để thêm trục mới:
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]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]]89. Ví dụ: bạn có thể chuyển đổi một mảng 1D thành vectơ hàng bằng cách chèn một trục dọc theo chiều đầu tiên:
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]7
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]]]8
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 tại một vị trí được chỉ định với
>>> a = np.array[[1, 2, 3, 4, 5, 6]]90.
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]]]5
Bạn có thể sử dụng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]89 để thêm trục mới:
>>> print[a[0]] [1 2 3 4]0
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]]89. Ví dụ: bạn có thể chuyển đổi một mảng 1D thành vectơ hàng bằng cách chèn một trục dọc theo chiều đầu tiên:
>>> print[a[0]] [1 2 3 4]1
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:newaxis here and
>>> a = np.array[[1, 2, 3, 4, 5, 6]]98 at
>>> a = np.array[[1, 2, 3, 4, 5, 6]]98.
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 tại một vị trí được chỉ định với >>> a = np.array[[1, 2, 3, 4, 5, 6]]
90.
Bạn có thể sử dụng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]90 để thêm trục tại vị trí chỉ mục 1 với:
>>> print[a[0]] [1 2 3 4]2
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]]98 tại
>>> a = np.array[[1, 2, 3, 4, 5, 6]]98.
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]3
Bạn có thể sử dụng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]89 để thêm trục mới:
>>> print[a[0]] [1 2 3 4]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]]89. Ví dụ: bạn có thể chuyển đổi một mảng 1D thành vectơ hàng bằng cách chèn một trục dọc theo chiều đầu tiên:
>>> print[a[0]] [1 2 3 4]5
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]6
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 tại một vị trí được chỉ định với
>>> a = np.array[[1, 2, 3, 4, 5, 6]]90.
>>> print[a[0]] [1 2 3 4]7
Bạn có thể sử dụng
>>> a = np.array[[1, 2, 3, 4, 5, 6]]90 để thêm trục tại vị trí chỉ mục 1 với:& 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]8
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]]98 tại
>>> a = np.array[[1, 2, 3, 4, 5, 6]]98.
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]
Lập chỉ mục và cắt#
[[0., 0., 0.], [1., 1., 1.]]0
Bạn có thể lập chỉ mục và cắt các mảng numpy theo cùng một cách bạn có thể cắt danh sách Python.
Bạn có thể hình dung nó theo cách này:
[[0., 0., 0.], [1., 1., 1.]]1
Bạn có thể muốn lấy một phần của mảng hoặc các thành phần mảng cụ thể để sử dụng trong phân tích thêm hoặc các hoạt động bổ sung. Để làm điều đó, bạn sẽ cần tập hợp con, cắt và/hoặc lập chỉ mục các mảng của bạn.
[[0., 0., 0.], [1., 1., 1.]]2
Nếu bạn muốn chọn các giá trị từ mảng của bạn thực hiện một số điều kiện nhất định, thì nó sẽ đơn giản với Numpy.
[[0., 0., 0.], [1., 1., 1.]]3
Bạn có thể dễ dàng in tất cả các giá trị trong mảng nhỏ hơn 5.indexing and slicing here and here.
Bạn cũng có thể chọn, ví dụ, các số bằng hoặc lớn hơn 5 và sử dụng điều kiện đó để lập chỉ mục một mảng.
Bạn có thể chọn các phần tử chia hết cho 2:
Hoặc bạn có thể chọn các yếu tố đáp ứng hai điều kiện bằng các toán tử
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]00 và
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]01:
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.
Bạn cũng có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]02 để chọn các phần tử hoặc chỉ số từ một mảng.
[[0., 0., 0.], [1., 1., 1.]]4
Bắt đầu với mảng này:
[[0., 0., 0.], [1., 1., 1.]]5
Bạn có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]02 để in các chỉ số của các phần tử, ví dụ, ít hơn 5:
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ị.
[[0., 0., 0.], [1., 1., 1.]]6
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.]]7
Bạn cũng có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]02 để in các phần tử trong một mảng nhỏ hơn 5 với:
[[0., 0., 0.], [1., 1., 1.]]8
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ụ:
Bạn cũng có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]02 để chọn các phần tử hoặc chỉ số từ một mảng.
[[0., 0., 0.], [1., 1., 1.]]9
Bắt đầu với mảng này:
>>> import numpy as np >>> a = np.array[[1, 2, 3]]0
Bạn có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]02 để in các chỉ số của các phần tử, ví dụ, ít hơn 5:
>>> import numpy as np >>> a = np.array[[1, 2, 3]]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ụ:
Bạn cũng có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]02 để in các phần tử trong một mảng nhỏ hơn 5 với:
Hãy nói rằng bạn tạo ra mảng này:
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]
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]]]18 bằng cách cắt
>>> a = np.array[[1, 2, 3, 4, 5, 6]]83 và sửa đổi phần tử đầu tiên của
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]18. Điều này cũng sẽ sửa đổi phần tử tương ứng trong
>>> a = np.array[[1, 2, 3, 4, 5, 6]]83 là tốt!
>>> import numpy as np >>> a = np.array[[1, 2, 3]]3
Sử dụng phương thức
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]22 sẽ tạo một bản sao hoàn chỉnh của mảng và dữ liệu của nó [một bản sao sâu]. Để sử dụng điều này trên mảng của bạn, bạn có thể chạy:
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#
Phần này bao gồm bổ sung, trừ, nhân, chia, và nhiều hơn nữa
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
Bạn có thể thêm các mảng cùng với dấu cộng.
>>> import numpy as np >>> a = np.array[[1, 2, 3]]4
Tất nhiên, bạn có thể làm nhiều hơn là bổ sung!
>>> import numpy as np >>> a = np.array[[1, 2, 3]]5
Các hoạt động cơ bản rất đơn giản với Numpy. Nếu bạn muốn tìm tổng của các phần tử trong một mảng, bạn sẽ sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]23. Điều này hoạt động cho các mảng 1D, mảng 2D và mảng ở kích thước cao hơn.
>>> import numpy as np >>> a = np.array[[1, 2, 3]]6
Để thêm các hàng hoặc các cột vào một mảng 2D, bạn sẽ chỉ định trục.
Nếu bạn bắt đầu với mảng này:
>>> import numpy as np >>> a = np.array[[1, 2, 3]]7
Bạn có thể tổng hợp trên trục của hàng với:
>>> import numpy as np >>> a = np.array[[1, 2, 3]]8
Bạn có thể tổng hợp các trục của các cột với:
>>> import numpy as np >>> a = np.array[[1, 2, 3]]9
Tìm hiểu thêm về các hoạt động cơ bản ở đây..
Broadcasting#
Có những lúc bạn có thể muốn thực hiện một thao tác giữa một mảng và một số duy nhất [còn được gọi là hoạt động giữa một vectơ và vô hướng] hoặc giữa các mảng có hai kích thước khác nhau. Ví dụ: mảng của bạn [chúng tôi sẽ gọi nó là dữ liệu dữ liệu] có thể chứa thông tin về khoảng cách tính bằng dặm nhưng bạn muốn chuyển đổi thông tin thành km. Bạn có thể thực hiện thao tác này với:
>>> np.zeros[2] array[[0., 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]]]24.broadcasting. Broadcasting is a mechanism that allows NumPy to perform operations on arrays of different shapes. The dimensions of your array must be compatible, for example, when the dimensions of both arrays are equal or when one of them is 1. If the dimensions are not compatible, you will get a
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]24.
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]]]25,
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]26 và
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]27, bạn có thể dễ dàng chạy
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]28 để có được mức trung bình,
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]29 để có kết quả nhân với các yếu tố với nhau,
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]30 để có được độ lệch chuẩn, v.v.
>>> np.zeros[2] array[[0., 0.]]1
Hãy bắt đầu với mảng này, được gọi là "A"
>>> np.zeros[2] array[[0., 0.]]2
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]]]31.
>>> np.zeros[2] array[[0., 0.]]3
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.]]4
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.]]5
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.]]6
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]]]32. Để minh họa điểm này, hãy để Lôi nhìn vào một bộ dữ liệu được sửa đổi một chút:
>>> np.zeros[2] array[[0., 0.]]7
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.]]8
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.]]9
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.]]0
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]]]33 và
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]34 và lớp
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]35 để tạo số ngẫu nhiên cho điều đó. Tất cả những gì bạn cần làm là vượt qua số lượng các yếu tố bạn muốn nó tạo ra:
>>> np.ones[2] array[[1., 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]]]33,
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]34 và
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]38 để tạo mảng 2D nếu bạn cung cấp cho họ một bộ thuật mô tả kích thước của ma trận:
>>> np.ones[2] array[[1., 1.]]2
Đọc thêm về việc tạo mảng, chứa đầy ____ 154, ____ 155, 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]]]41, bạn có thể tạo các số nguyên ngẫu nhiên từ thấp [hãy nhớ rằng điều này bao gồm với Numpy] đến cao [độc quyền]. Bạn có thể đặt
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]42 để bao gồm số lượng cao.
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.]]3
Đọ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]]]43
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]]]44.
Ví dụ: nếu bạn bắt đầu với mảng này:
>>> np.ones[2] array[[1., 1.]]4
Bạn có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]44 để in các giá trị duy nhất trong mảng của mình:
>>> np.ones[2] array[[1., 1.]]5
Để 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]]]46 trong
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]43 cũng như mảng của bạn.
>>> np.ones[2] array[[1., 1.]]6
Bạn có thể vượt qua đối số
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]48 trong
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]43 cùng với mảng của bạn để có được số lượng tần số của các giá trị duy nhất trong một mảng numpy.
>>> np.ones[2] array[[1., 1.]]7
Đ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.]]8
Bạn có thể tìm thấy các giá trị duy nhất với:
>>> np.ones[2] array[[1., 1.]]9
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]]]32. Để tìm các hàng duy nhất, chỉ định
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]31 và cho các cột, chỉ định
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]52.
>>> # Create an empty array with 2 elements >>> np.empty[2] array[[3.14, 42. ]] # may vary0
Để 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 vary1
Để 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]]]53.
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]]79,
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]55,
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]56
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]]]57 cho phép bạn chuyển một ma trận.
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]]]58 có thể hữu ích. Bạn chỉ cần vượt qua các kích thước mới mà bạn muốn cho ma trận.
>>> # Create an empty array with 2 elements >>> np.empty[2] array[[3.14, 42. ]] # may vary2
Bạn cũng có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]59 để đảo ngược hoặc thay đổi trục của một mảng theo các giá trị bạn chỉ định.
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 vary3
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]]]55.
>>> # Create an empty array with 2 elements >>> np.empty[2] array[[3.14, 42. ]] # may vary4
Bạn cũng có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]56:
>>> # Create an empty array with 2 elements >>> np.empty[2] array[[3.14, 42. ]] # may vary5
Để 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]]]62 và
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]58.
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]]]64
Chức năng Numpy từ
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]64 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]]]64, chỉ định mảng bạn muốn đảo ngược và trục. Nếu bạn không chỉ định trục, Numpy sẽ đảo ngược nội dung dọc theo tất cả các trục của mảng đầu vào của bạn.
Đả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 vary6
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 vary7
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 vary8
Đả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 vary9
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]]]55.
>>> np.arange[4] array[[0, 1, 2, 3]]0
Bạn cũng có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]56:
>>> np.arange[4] array[[0, 1, 2, 3]]1
Để 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]]]62 và
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]58.
>>> np.arange[4] array[[0, 1, 2, 3]]2
Cách đảo ngược một mảng#
>>> np.arange[4] array[[0, 1, 2, 3]]3
Phần này bao gồm
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]64
>>> np.arange[4] array[[0, 1, 2, 3]]4
Chức năng Numpy từ
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]64 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]]]64, chỉ định mảng bạn muốn đảo ngược và trục. Nếu bạn không chỉ định trục, Numpy sẽ đảo ngược nội dung dọc theo tất cả các trục của mảng đầu vào của bạn.
Đả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]]5
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]]]55.
>>> np.arange[4] array[[0, 1, 2, 3]]6
Khi bạn sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]74, các thay đổi đối với mảng mới của bạn đã giành được thay đổi mảng cha mẹ.
Ví dụ:
>>> np.arange[4] array[[0, 1, 2, 3]]7
Nhưng khi bạn sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]73, những thay đổi bạn thực hiện đối với mảng mới sẽ ảnh hưởng đến mảng cha mẹ.
Ví dụ:
>>> np.arange[4] array[[0, 1, 2, 3]]8
Nhưng khi bạn sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]73, những thay đổi bạn thực hiện đối với mảng mới sẽ ảnh hưởng đến mảng cha mẹ.
Đọc thêm về >>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]
74 tại >>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]
78 và >>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]
73 tại >>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]
73.
Cách truy cập DocString để biết thêm thông tin#
Phần này bao gồm
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]81,
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]82,
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]83docstring. 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]]]81 function that can help you access this information. This means that nearly any time you need more information, you can use
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]81 to quickly find the information that you need.
Ví dụ:
>>> np.arange[4] array[[0, 1, 2, 3]]9
Nhưng khi bạn sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]73, những thay đổi bạn thực hiện đối với mảng mới sẽ ảnh hưởng đến mảng cha mẹ.
Ví dụ:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]00
Nhưng khi bạn sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]73, những thay đổi bạn thực hiện đối với mảng mới sẽ ảnh hưởng đến mảng cha mẹ.
Đọc thêm về
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]74 tại
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]78 và
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]73 tại
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]73.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]
Cách truy cập DocString để biết thêm thông tin#
>>> a = np.array[[1, 2, 3, 4, 5, 6]]02
Phần này bao gồm
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]81,
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]82,
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]83you create. Just remember to include a docstring with your function using a string literal [
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]90 or
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]91 around your documentation].
Khi nói đến hệ sinh thái khoa học dữ liệu, Python và Numpy được xây dựng với người dùng. Một trong những ví dụ tốt nhất về điều này là truy cập vào tài liệu tích hợp. Mỗi đối tượng chứa tham chiếu đến một chuỗi, được gọi là DocString. Trong hầu hết các trường hợp, tài liệu này chứa một bản tóm tắt nhanh chóng và ngắn gọn về đối tượng và cách sử dụng nó. Python có chức năng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]81 tích hợp có thể giúp bạn truy cập thông tin này. Điều này có nghĩa là gần như bất cứ lúc nào bạn cần thêm thông tin, bạn có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]81 để nhanh chóng tìm thấy thông tin mà bạn cần.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]03
Vì quyền truy cập vào thông tin bổ sung rất hữu ích, Ipython sử dụng ký tự
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]82 làm tốc ký để truy cập tài liệu này cùng với các thông tin liên quan khác. Ipython là một shell lệnh cho điện toán tương tác bằng nhiều ngôn ngữ. Bạn có thể tìm thêm thông tin về ipython ở đây.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]04
Bạn thậm chí có thể sử dụng ký hiệu này cho các phương thức đối tượng và các đối tượng.
Ví dụ:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]05
Nhưng khi bạn sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]73, những thay đổi bạn thực hiện đối với mảng mới sẽ ảnh hưởng đến mảng cha mẹ.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]06
Đọc thêm về
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]74 tại
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]78 và
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]73 tại
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]73.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]07
Cách truy cập DocString để biết thêm thông tin#
Phần này bao gồm >>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]
81, >>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]
82, >>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]
83
Khi nói đến hệ sinh thái khoa học dữ liệu, Python và Numpy được xây dựng với người dùng. Một trong những ví dụ tốt nhất về điều này là truy cập vào tài liệu tích hợp. Mỗi đối tượng chứa tham chiếu đến một chuỗi, được gọi là DocString. Trong hầu hết các trường hợp, tài liệu này chứa một bản tóm tắt nhanh chóng và ngắn gọn về đối tượng và cách sử dụng nó. Python có chức năng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]81 tích hợp có thể giúp bạn truy cập thông tin này. Điều này có nghĩa là gần như bất cứ lúc nào bạn cần thêm thông tin, bạn có thể sử dụng
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]81 để nhanh chóng tìm thấy thông tin mà bạn cần.
Vì quyền truy cập vào thông tin bổ sung rất hữu ích, Ipython sử dụng ký tự
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]82 làm tốc ký để truy cập tài liệu này cùng với các thông tin liên quan khác. Ipython là một shell lệnh cho điện toán tương tác bằng nhiều ngôn ngữ. Bạn có thể tìm thêm thông tin về ipython ở đây.
Bạn thậm chí có thể sử dụng ký hiệu này cho các phương thức đối tượng và các đối tượng.
Hãy nói rằng bạn tạo ra mảng này:
Sau đó, bạn có thể có được nhiều thông tin hữu ích [chi tiết đầu tiên về chính
>>> a = np.array[[1, 2, 3, 4, 5, 6]]83, tiếp theo là tài liệu của
>>> a = np.array[[1, 2, 3, 4, 5, 6]]42 trong đó
>>> a = np.array[[1, 2, 3, 4, 5, 6]]83 là một ví dụ]:
Đ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 chuỗi chữ [
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]90 hoặc
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]91 xung quanh tài liệu của bạn].
Ví dụ: nếu bạn tạo chức năng này:
Bạn có thể có được thông tin về chức năng:
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]]]83] cho phép bạn truy cập mã nguồn..npy file extension, and a
>>> print[a[0]] [1 2 3 4]07 function that handles NumPy files with a .npz file extension.
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]]]83 sẽ trả về thông tin giống như
>>> a = np.array[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]]82. Bạn sẽ tìm thấy điều này với rất nhiều đối tượng và loại tích hợp, ví dụ:.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.
và :
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.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]
Bạn có thể lưu nó dưới dạng tên tệp filen.npy với:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]09
Bạn có thể sử dụng
>>> print[a[0]] [1 2 3 4]12 để xây dựng lại mảng của mình.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]10
Nếu bạn muốn kiểm tra mảng của mình, bạn có thể chạy ::
>>> a = np.array[[1, 2, 3, 4, 5, 6]]11
Bạn có thể lưu một mảng numpy dưới dạng tệp văn bản đơn giản như tệp .csv hoặc .txt với
>>> print[a[0]] [1 2 3 4]00..csv or .txt file with
>>> print[a[0]] [1 2 3 4]00.
Ví dụ: nếu bạn tạo mảng này:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]12
Bạn có thể dễ dàng lưu nó dưới dạng tệp .csv có tên là New_file.csv, như thế này:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]13
Bạn có thể nhanh chóng và dễ dàng tải tệp văn bản đã lưu của mình bằng
>>> print[a[0]] [1 2 3 4]14:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]14
Các hàm
>>> print[a[0]] [1 2 3 4]15 và
>>> print[a[0]] [1 2 3 4]14 chấp nhận các tham số tùy chọn bổ sung như tiêu đề, chân trang và dấu phân cách. Mặc dù các tệp văn bản có thể dễ dàng hơn để chia sẻ, các tệp .npy và .npz nhỏ hơn và nhanh hơn để đọc. Nếu bạn cần xử lý tệp văn bản tinh vi hơn [ví dụ: nếu bạn cần làm việc với các dòng có chứa các giá trị bị thiếu], bạn sẽ muốn sử dụng hàm
>>> print[a[0]] [1 2 3 4]17.
Với
>>> print[a[0]] [1 2 3 4]04, bạn có thể chỉ định tiêu đề, chân trang, nhận xét, v.v.
Tìm hiểu thêm về các thói quen đầu vào và đầu ra ở đây.input and output routines here.
Nhập và xuất CSV#
Nó rất đơn giản để đọc trong CSV có chứa thông tin hiện có. Cách tốt nhất và dễ nhất để làm điều này là sử dụng gấu trúc.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]15
Nó rất đơn giản để sử dụng gấu trúc để xuất khẩu mảng của bạn. Nếu bạn chưa quen với Numpy, bạn có thể muốn tạo một khung dữ liệu gấu trúc từ các giá trị trong mảng của bạn và sau đó viết khung dữ liệu vào tệp CSV với gấu trúc.
Nếu bạn đã tạo ra mảng này "a"
>>> a = np.array[[1, 2, 3, 4, 5, 6]]16
Bạn có thể tạo một khung gấu dữ liệu gấu trúc
>>> a = np.array[[1, 2, 3, 4, 5, 6]]17
Bạn có thể dễ dàng lưu DataFrame của mình với:
Và đọc CSV của bạn với:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]18
Bạn cũng có thể lưu mảng của mình bằng phương pháp
>>> print[a[0]] [1 2 3 4]04 Numpy.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]19
Nếu bạn sử dụng dòng lệnh, bạn có thể đọc CSV đã lưu của mình bất cứ lúc nào bằng một lệnh như:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]20
Hoặc bạn có thể mở tệp bất cứ lúc nào với trình soạn thảo văn bản!
Nếu bạn quan tâm đến việc tìm hiểu thêm về gấu trúc, hãy xem tài liệu chính thức của gấu trúc. Tìm hiểu cách cài đặt gấu trúc với thông tin cài đặt Pandas chính thức.
Vẽ các mảng với matplotlib#
Nếu bạn cần tạo ra một lô cho các giá trị của mình, thì nó rất đơn giản với matplotlib.
Ví dụ: bạn có thể có một mảng như thế này:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]21
Nếu bạn đã cài đặt matplotlib, bạn có thể nhập nó với:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]22
Tất cả những gì bạn cần làm để vẽ các giá trị của bạn là chạy:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]23
Ví dụ: bạn có thể vẽ một mảng 1D như thế này:
>>> a = np.array[[1, 2, 3, 4, 5, 6]]24
Với matplotlib, bạn có quyền truy cập vào một số lượng lớn các tùy chọn trực quan hóa.
>>> a = np.array[[1, 2, 3, 4, 5, 6]]25
Để đọc thêm về matplotlib và những gì nó có thể làm, hãy xem tài liệu chính thức. Để biết các hướng dẫn liên quan đến việc cài đặt matplotlib, hãy xem phần Cài đặt chính thức.
Tín dụng hình ảnh: Jay Alammar //jalammar.github.io/