Khung dữ liệu có phải là ma trận python không?

Python cơ sở không bao gồm các cấu trúc dữ liệu được vector hóa thực sự–vectơ, ma trận và khung dữ liệu. Đối với những điều nhỏ nhặt, người ta có thể sử dụng danh sách, danh sách danh sách và hiểu danh sách. Tuy nhiên code như vậy sẽ cồng kềnh và chậm

Thiếu sót này được giải quyết bằng các thư viện bổ sung, đặc biệt là numpy và pandas. Numpy là cách chính để xử lý ma trận và vectơ trong python. Đây là cách để mô hình hóa một biến hoặc toàn bộ tập dữ liệu nên cách tiếp cận vectơ/ma trận là rất quan trọng khi làm việc với tập dữ liệu. Hơn nữa, các đối tượng này cũng mô hình hóa các vectơ/ma trận dưới dạng các đối tượng toán học. Tính toán ma trận cực kỳ quan trọng trong thống kê và do đó cũng trong học máy

biểu trưng có nhiều cục. Isabela Presedo-Floyd, CC BY-SA 4. 0, thông qua Wikimedia Commons

Numpy là thư viện python phổ biến nhất để tính toán ma trận/vector. Do sự phổ biến của python, nó cũng là một trong những thư viện hàng đầu để phân tích số và là mục tiêu thường xuyên để tính điểm chuẩn và tối ưu hóa

Điều quan trọng cần lưu ý là numpy là một thư viện riêng biệt không phải là một phần của python cơ sở. Không giống như R, python cơ sở không được vector hóa và người ta phải tải numpy (hoặc một thư viện được vector hóa khác, chẳng hạn như gấu trúc) để sử dụng các thao tác được vector hóa. Điều này cũng gây ra sự khác biệt nhất định giữa cách tiếp cận python cơ sở và cách thực hiện các thao tác vector hóa

Numpy thường được nhập dưới dạng

## array([[1, 2],
##        [3, 4]])
6

## array([[1, 2],
##        [3, 4]])
6 gần như là từ viết tắt tiêu chuẩn của numpy và được sử dụng rộng rãi trong tài liệu trực tuyến. Dưới đây, chúng tôi giả sử numpy đã được nhập dưới dạng
## array([[1, 2],
##        [3, 4]])
6

Numpy về cơ bản dựa trên mảng, cấu trúc dữ liệu N-chiều. Ở đây chúng ta chủ yếu sử dụng cấu trúc một và hai chiều (vectơ và ma trận) nhưng mảng cũng có thể có số chiều cao hơn (được gọi là tensors). Ngoài mảng, numpy còn cung cấp rất nhiều hàm hoạt động trên mảng, bao gồm toán học vector hóa và các phép toán logic

Mảng có thể được tạo bằng

## array([[1, 2],
##        [3, 4]])
9. Chẳng hạn, chúng ta có thể tạo một vectơ 1-D gồm các số từ 1 đến 4 bằng cách cung cấp danh sách các số mong muốn cho
## array([[1, 2],
##        [3, 4]])
9

## a:
##  [1 2 3 4]

Lưu ý rằng nó được in trong ngoặc dưới dạng danh sách, nhưng không giống như danh sách, nó không có dấu phẩy ngăn cách các thành phần

Nếu chúng ta muốn tạo một ma trận (mảng hai chiều), chúng ta có thể cung cấp cho

## array([[1, 2],
##        [3, 4]])
9 một danh sách các danh sách, một danh sách con cho mỗi hàng của ma trận

## b:
##  [[1 2]
##  [3 4]]

Đầu ra không có định dạng tốt nhất nhưng đủ rõ ràng

Một trong những thuộc tính cơ bản của mảng là kích thước của nó, được gọi là hình dạng trong numpy. Hình dạng là kích thước của mảng dọc theo tất cả các kích thước của nó. Điều này có thể được truy vấn bằng thuộc tính

## array([1, 2, 3, 4])
2 trả về các kích thước ở dạng

## (4,)
## (2, 2)

Ta có thể thấy rằng vectơ

## array([1, 2, 3, 4])
3 có một chiều duy nhất cỡ 4 và ma trận
## array([1, 2, 3, 4])
4 có hai chiều, cả hai đều cỡ 2 (nhớ.
## array([1, 2, 3, 4])
5 là một bộ có độ dài 1. )

Người ta cũng có thể định hình lại mảng, tôi. e. thay đổi hình dạng của chúng thành một hình dạng tương thích khác. Điều này có thể đạt được bằng phương pháp

## array([1, 2, 3, 4])
6.
## array([1, 2, 3, 4])
7 nhận một đối số, hình dạng mới (dưới dạng một bộ) của mảng. Chẳng hạn, chúng ta có thể định hình lại vectơ chiều dài 4 thành ma trận 2x2 như

## array([[1, 2],
##        [3, 4]])

và chúng ta có thể “nắn thẳng” ma trận

## array([1, 2, 3, 4])
4 thành một vectơ với

________số 8_______

Đôi khi, việc tạo các mảng theo cách thủ công như chúng ta đã làm ở trên là thực tế, nhưng thông thường, việc tạo các mảng đó bằng tính toán sẽ quan trọng hơn nhiều. Dưới đây chúng tôi liệt kê một số tùy chọn

## array([1, 2, 3, 4])
9 tạo ra các chuỗi, khá giống với
## array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
0, nhưng kết quả sẽ là một vectơ gọn gàng. Nếu cần, chúng ta có thể định hình lại vectơ thành định dạng mong muốn

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

## array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
1 và
## array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
2 lần lượt tạo các mảng chứa các số 0 và 1

## array([0., 0., 0., 0., 0.])
## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])

Mảng có thể được kết hợp theo nhiều cách khác nhau, e. g.

## array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
3 kết hợp chúng thành cột (cạnh nhau) và
## array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
4 kết hợp chúng thành hàng (bên dưới nhau). Chẳng hạn, chúng ta có thể kết hợp một cột số một và hai cột số không như sau

## b:
##  [[1 2]
##  [3 4]]
0

Lưu ý rằng

## array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
5 mong đợi tất cả các mảng được truyền dưới dạng một bộ (hoặc danh sách)

bài tập 3. 1 Sử dụng

## array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
1,
## array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
2, các phép toán và phép nối để tạo mảng sau

## b:
##  [[1 2]
##  [3 4]]
1

Thấy

Có thể sử dụng các vòng lặp để thực hiện tính toán với các đối tượng numpy giống hệt như khi làm việc với các danh sách. Tuy nhiên, thay vào đó, người ta nên sử dụng các hoạt động được vector hóa bất cứ khi nào có thể. Các hoạt động được vector hóa dễ viết mã hơn, dễ đọc hơn và dẫn đến mã nhanh hơn

Numpy cung cấp rất nhiều hàm và toán tử được vector hóa, được gọi là hàm phổ quát. Nhiều người trong số này làm việc như mong đợi. Chẳng hạn, các phép toán. Chúng tôi tạo một ma trận, sau đó thêm "100" vào nó, sau đó tăng "2" thành lũy thừa của các giá trị

## b:
##  [[1 2]
##  [3 4]]
2_______7_______3
## b:
##  [[1 2]
##  [3 4]]
4

Cả hai phép toán này,

## array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
8 và
## array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
9 đều được thực hiện theo từng phần tử cho mọi phần tử của ma trận

bài tập 3. 2 Tạo mảng sau

## b:
##  [[1 2]
##  [3 4]]
5

Thấy

Các toán tử so sánh cũng được vector hóa

## b:
##  [[1 2]
##  [3 4]]
6
## b:
##  [[1 2]
##  [3 4]]
7

Khi các toán tử so sánh được véc tơ hóa, người ta có thể mong đợi rằng các toán tử logic khác, và, hoặc không, cũng được véc tơ hóa. Nhưng đây không phải là trường hợp. Có các toán tử logic được vector hóa, nhưng chúng khác với phiên bản python cơ sở. Các toán tử này giống với các toán tử tương ứng trong R hoặc C hơn, cụ thể là

## array([[0, 1, 2, 3, 4],
##        [5, 6, 7, 8, 9]])
0 cho logic và,
## array([[0, 1, 2, 3, 4],
##        [5, 6, 7, 8, 9]])
1 cho logic hoặc và
## array([[0, 1, 2, 3, 4],
##        [5, 6, 7, 8, 9]])
2 cho logic không

## b:
##  [[1 2]
##  [3 4]]
8
## b:
##  [[1 2]
##  [3 4]]
9
## (4,)
0

Không có so sánh đa chiều được véc tơ hóa như

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

Lập chỉ mục đề cập đến việc trích xuất các phần tử dựa trên vị trí của chúng hoặc các tiêu chí nhất định. Đây là một trong những thao tác cơ bản với mảng. Có hai cách để trích xuất các yếu tố. , và. Thật không may, điều này cũng làm cho việc lập chỉ mục hơi khó hiểu và cần một thời gian để làm quen với

Một cách tiếp cận được sử dụng cực kỳ rộng rãi là trích xuất các phần tử của một mảng dựa trên một tiêu chí logic. Về cơ bản, nó chỉ sử dụng một vectơ logic để lập chỉ mục. Vectơ phải có cùng độ dài với mảng được đề cập và kết quả chỉ chứa các phần tử tương ứng với

## array([[0, 1, 2, 3, 4],
##        [5, 6, 7, 8, 9]])
4 trong vectơ lập chỉ mục. Dưới đây là một ví dụ về cách chúng tôi có thể thực hiện việc này theo cách thủ công

## (4,)
1

Điều quan trọng là bạn hiểu những gì đang xảy ra ở đây. mảng

## array([1, 2, 3, 4])
3 và
## array([[0, 1, 2, 3, 4],
##        [5, 6, 7, 8, 9]])
6 sẽ được “khớp”, vì vậy mỗi phần tử của
## array([1, 2, 3, 4])
3 sẽ có “khớp” của nó trong
## array([[0, 1, 2, 3, 4],
##        [5, 6, 7, 8, 9]])
6. Tiếp theo, chỉ những phần tử của
## array([1, 2, 3, 4])
3 khớp với
## array([[0, 1, 2, 3, 4],
##        [5, 6, 7, 8, 9]])
4 được trích xuất, trong trường hợp này chỉ là 1 và 7

Ví dụ trước–việc tạo thủ công một vectơ chỉ mục logic của giá trị đúng và giá trị sai hầu như không hữu ích. Hầu như chúng ta luôn sử dụng các phép toán logic để thay thế. Chẳng hạn, chúng ta có thể trích xuất tất cả các phần tử của

## array([1, 2, 3, 4])
3 lớn hơn 5

## (4,)
2
## (4,)
3

Điều này thường được viết theo cách nhỏ gọn hơn bằng cách bỏ qua vectơ logic rõ ràng

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

## (4,)
3

Những người dùng mới của numpy (và các ngôn ngữ khác hỗ trợ lập chỉ mục logic) đôi khi quên rằng điều kiện logic không nhất thiết phải liên quan đến cùng một mảng mà chúng ta đang cố trích xuất. Chẳng hạn, chúng ta có thể trích xuất tất cả kết quả cho một người nhất định

## (4,)
5

Ở đây vectơ chỉ số chỉ dựa trên biến

## array([0., 0., 0., 0., 0.])
3 và không liên quan trực tiếp đến
## array([0., 0., 0., 0., 0.])
4. Tuy nhiên, chúng tôi sử dụng nó để trích xuất các giá trị từ cái sau

Cuối cùng, chúng ta cũng có thể trích xuất các hàng (hoặc cột) từ một mảng 2 chiều theo cách khá giống nhau

## (4,)
6
## (4,)
7

Kết quả là hàng thứ hai của mảng 2-D

## array([0., 0., 0., 0., 0.])
4, tương ứng với tên “Darius”

Lập chỉ mục logic cũng có thể được sử dụng ở phía bên trái của biểu thức, để thay thế các phần tử. Dưới đây là một ví dụ trong đó chúng tôi thay thế tất cả các phần tử âm của

## array([1, 2, 3, 4])
3 bằng không

## (4,)
8
## (4,)
9

Khi thay thế các phần tử theo kiểu như vậy thì chúng ta cần cung cấp vectơ thay thế có độ dài bằng 1 (tất cả các phần tử được thay thế bằng “0” trong ví dụ trên) hoặc cách khác, chúng ta nên cung cấp một vectơ thay thế có độ dài chính xác. Chẳng hạn, chúng ta có thể thay thế các số dương còn lại trong

## array([1, 2, 3, 4])
3 bằng 1, 2, 3

## (2, 2)
0

bài tập 3. 4 xét hai vectơ

Thực hiện các thao tác sau bằng cách sử dụng thao tác vector hóa một dòng

  • Trích xuất tất cả các điểm kiểm tra nhỏ hơn 130
  • Trích xuất tất cả các điểm kiểm tra bằng Statira
  • Thêm 10 điểm vào điểm số của Roxana. (Bạn cần giải nén nó trước. )

Thấy

Numpy cung cấp một bộ lớn các trình tạo số ngẫu nhiên. Chúng có thể được gọi là

## array([0., 0., 0., 0., 0.])
8generator
## array([0., 0., 0., 0., 0.])
9params
## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])
0. Chẳng hạn,
## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])
1 có thể được sử dụng để tạo các số ngẫu nhiên từ 0 đến \(N-1\).
## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])
2 xác định hình dạng của đối tượng kết quả

Đối số là kích thước, không phải hình dạng, mặc dù nó xác định hình dạng đầu ra

Dưới đây là một ví dụ để mô phỏng tung xúc xắc 5 lần

## (2, 2)
1

Nhưng có lẽ chúng tôi không muốn dán nhãn kết quả là 0. 5 mà 1. 6. Vì vậy, chúng tôi chỉ có thể thêm một vào kết quả. Dưới đây là một ví dụ tạo mảng 2-D của các cuộn khuôn

## (2, 2)
2

Numpy cung cấp một tập hợp lớn các giá trị ngẫu nhiên khác nhau. Ở đây chúng tôi liệt kê thêm một số

## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])
3 cũng có thể trích xuất các phần tử ngẫu nhiên từ danh sách

## (2, 2)
3

Như ví dụ minh họa,

## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])
3 chọn các phần tử ngẫu nhiên có thay thế (sử dụng tùy chọn
## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])
5 để thay đổi hành vi này)

## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])
6 tạo các số ngẫu nhiên có phân phối chuẩn. Phân phối được tập trung tại loc và phương sai của nó là tỷ lệ

## (2, 2)
4

## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])
7 tạo các nhị thức ngẫu nhiên trong đó xác suất thành công là p và cỡ mẫu là n

## (2, 2)
5

bài tập 3. 5 Chúng ta có thể mô tả việc tung đồng xu là Nhị thức (1, 0. 5) trong đó 1 đề cập đến thực tế là chúng ta tung một đồng xu và 0. 5 có nghĩa là nó có xác suất 0. 5 sắp tới. Vì vậy, các biến ngẫu nhiên như vậy là chuỗi các số không và một. Nhưng làm thế nào chúng ta có thể nhận được một chuỗi -1 và 1 thay thế?

Thấy

## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])
8 tạo các số ngẫu nhiên phân bố đều trong khoảng [thấp, cao]

## (2, 2)
6

Các số ngẫu nhiên thường được gọi là giả ngẫu nhiên vì chúng không thực sự ngẫu nhiên – chúng được tính toán dựa trên một thuật toán được xác định rõ ràng, vì vậy khi cung cấp các giá trị ban đầu giống nhau cho thuật toán, người ta luôn nhận được các số ngẫu nhiên giống nhau. Tuy nhiên, thông thường các giá trị ban đầu được lấy từ một số tham số khó kiểm soát nhất định bên ngoài điều khiển chương trình, chẳng hạn như thời gian tính bằng micro giây và số sê-ri của đĩa cứng, vì vậy trong thực tế không thể sao chép cùng một trình tự

Tuy nhiên, nếu bạn cần sao chép chính xác kết quả của mình, bạn phải đặt các giá trị ban đầu một cách rõ ràng bằng cách sử dụng

## array([[1., 1., 1., 1.],
##        [1., 1., 1., 1.]])
9. Điều này khởi tạo lại RNG-s về trạng thái ban đầu đã cho

## (2, 2)
7_______10_______8
## (2, 2)
7

Numpy cung cấp một tập hợp các hàm thống kê cơ bản, bao gồm tổng, giá trị trung bình và độ lệch chuẩn std. Chúng có thể được áp dụng cho toàn bộ mảng hoặc riêng cho các hàng hoặc cột. Trong trường hợp sau, người ta phải chỉ định đối số

## b:
##  [[1 2]
##  [3 4]]
00, trong đó giá trị 0 có nghĩa là áp dụng thao tác theo hàng (và giữ nguyên cột) và
## b:
##  [[1 2]
##  [3 4]]
01 có nghĩa là áp dụng thao tác theo cột (và giữ nguyên hàng). Đây là một ví dụ

## array([[1, 2],
##        [3, 4]])
0
## array([[1, 2],
##        [3, 4]])
1
## array([[1, 2],
##        [3, 4]])
2
## array([[1, 2],
##        [3, 4]])
3

Các chức năng có hai dạng. dưới dạng một phương thức

## b:
##  [[1 2]
##  [3 4]]
02 và dưới dạng một hàm riêng biệt
## b:
##  [[1 2]
##  [3 4]]
03. Hai cách này tương đối giống nhau

DataFrame có phải là ma trận không?

Khung dữ liệu và ma trận đại diện cho loại dữ liệu 'hình chữ nhật' , nghĩa là chúng được sử dụng để lưu trữ dữ liệu dạng bảng, có hàng và cột. Sự khác biệt chính là ma trận chỉ có thể chứa một lớp dữ liệu duy nhất, trong khi khung dữ liệu có thể bao gồm nhiều lớp dữ liệu khác nhau.

DataFrame có phải là một mảng không?

Nếu Sê-ri là dạng tương tự của mảng một chiều có chỉ số linh hoạt, thì DataFrame là dạng tương tự của mảng hai chiều có cả chỉ số hàng linh hoạt và tên cột linh hoạt . .

DataFrame có phải là một mảng NumPy không?

Bây giờ, bạn có thể thấy rằng các bản ghi DataFrame của bạn được ghi lại trong một cấu trúc mảng và có thể xác nhận rằng đó là một mảng NumPy . Hãy xem xét một số ví dụ phức tạp hơn về việc chuyển đổi DataFrames của gấu trúc thành mảng NumPy.

Khung dữ liệu có thể chuyển đổi thành ma trận không?

Hàm matrix() trong Ngôn ngữ R được sử dụng để tạo ma trận bằng cách chuyển đổi tất cả các giá trị của Khung dữ liệu thành chế độ số và sau đó liên kết chúng dưới dạng ma trận .