Cách định hình lại hoạt động trong python

Hầu hết các tên hàm trong Python có thể được kết nối trực quan với ý nghĩa của hàm. Hàm NumPy

numpy.reshape[a, newshape, order='C']
4 không phải là ngoại lệ

Hàm

numpy.reshape[a, newshape, order='C']
4 mang một mảng thành một hình dạng khác trong khi vẫn giữ nguyên tất cả dữ liệu ban đầu. Tôi sẽ trình bày một số ví dụ đơn giản trong video hướng dẫn sau

Hướng dẫn Cơ bản về Định hình lại NumPy[] bằng Python


Xem video này trên YouTube

Để tóm tắt cách hoạt động của

numpy.reshape[a, newshape, order='C']
6

Hàm

numpy.reshape[a, newshape, order='C']
4 của NumPy lấy một mảng được định hình lại làm đối số đầu tiên và bộ hình dạng mới làm đối số thứ hai. Nó trả về một dạng xem mới trên dữ liệu hiện có—nếu có thể—hơn là tạo một bản sao đầy đủ của mảng ban đầu. Mảng trả về hoạt động như một đối tượng mới. mọi thay đổi trên một chế độ xem sẽ không ảnh hưởng đến bất kỳ chế độ xem nào khác

Dưới đây là một vài ví dụ tối thiểu

>>> import numpy as np
>>> a = np.array[[1, 2, 3, 4, 5, 6]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
>>> np.reshape[a, [3,2]]
array[[[1, 2],
       [3, 4],
       [5, 6]]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]

Trước khi chúng tôi đi sâu vào giải thích thêm về hình dạng và các đặc điểm liên quan, hãy xem nhanh các tham số và cú pháp tiếp theo

Tham số và cú pháp

numpy.reshape[a, newshape, order='C']
ParameterTypeDescription
numpy.reshape[a, newshape, order='C']
8
numpy.reshape[a, newshape, order='C']
9Mảng được định hình lại.
import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
0
import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
1 hoặc bộ số nguyên Hình dạng mới và hình dạng ban đầu phải tương thích.

Nếu hình dạng mới là số nguyên
import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
2, mảng được định hình lại sẽ là mảng 1-D có độ dài
import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
2.

Nếu hình dạng mới là một bộ, mỗi phần tử bộ sẽ chỉ định hình dạng của một chiều. Một kích thước hình dạng có thể là
import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
4 trong trường hợp đó, giá trị được suy ra từ chiều dài mảng và các kích thước còn lại.
import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
5
import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
6, tùy chọn, mặc định
import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
7Nếu được chỉ định, đọc và đặt các phần tử của
numpy.reshape[a, newshape, order='C']
8 theo thứ tự chỉ mục này.

import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
7. đọc hoặc ghi các phần tử sao cho chỉ số trục cuối cùng thay đổi nhanh nhất, quay lại chỉ số trục đầu tiên thay đổi chậm nhất.
numpy.reshape[a, newshape, order='C']
80. đọc hoặc ghi các phần tử sao cho chỉ mục đầu tiên thay đổi nhanh nhất và chỉ mục cuối cùng thay đổi chậm nhất.
– ‘A’. đọc hoặc ghi các phần tử theo thứ tự
numpy.reshape[a, newshape, order='C']
80 nếu a là Fortran liền kề trong bộ nhớ và theo thứ tự
import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
7 nếu không. nguồn

Giá trị trả về. Đầu ra của hàm

numpy.reshape[a, newshape, order='C']
6 là
numpy.reshape[a, newshape, order='C']
84 được định hình lại thành một đối tượng mới nếu có thể

Thuộc tính hình dạng của một mảng NumPy

Trước khi tập trung vào hàm

numpy.reshape[a, newshape, order='C']
4, chúng ta cần hiểu một số khái niệm NumPy cơ bản

Giả sử rằng chúng ta có một tập dữ liệu lớn và việc đếm số lượng mục nhập sẽ là một nhiệm vụ bất khả thi. Chúng ta có thể sử dụng thuộc tính

numpy.reshape[a, newshape, order='C']
86 để tìm số phần tử dọc theo mỗi chiều của mảng này

🛑 Chú ý. Hãy cẩn thận để nhớ rằng ______186isan thuộc tính và không phải là một chức năng. Các thuộc tính không có dấu ngoặc đơn theo sau chúng

Thuộc tính

numpy.reshape[a, newshape, order='C']
86 luôn trả về một bộ cho chúng ta biết độ dài của mỗi chiều

Mảng một chiều [1D] là một vectơ hàng và hình dạng của nó là một giá trị duy nhất có thể lặp lại, theo sau là dấu phẩy. Mảng một chiều không có hàng và cột nên thuộc tính shape trả về một bộ giá trị duy nhất

Hãy xem một ví dụ

________số 8

Đoạn mã cũng sử dụng hàm NumPy

numpy.reshape[a, newshape, order='C']
89 để tạo một mảng ban đầu gồm các giá trị tiếp theo trong khoảng từ 0 đến 9

💡 Tham khảo. Vui lòng tìm phần thảo luận chi tiết về hàm NumPy

numpy.reshape[a, newshape, order='C']
90 trong bài viết blog Finxter này

Thuộc tính

numpy.reshape[a, newshape, order='C']
86 của mảng hai chiều [2D], còn được gọi là ma trận, cho chúng ta một bộ. Thuộc tính
numpy.reshape[a, newshape, order='C']
86 trả về số phần tử dọc theo mỗi chiều, là số hàng và cột trong mảng hai chiều

numpy.reshape[a, newshape, order='C']
8

Ví dụ sau đây dành cho hình dạng của mảng ba chiều [3D]

numpy.reshape[a, newshape, order='C']
9

Cần một số thực hành để hiểu bộ dữ liệu

numpy.reshape[a, newshape, order='C']
86 cho mảng nhiều chiều

Các kích thước được đại diện bởi một bộ dữ liệu được đọc từ ngoài vào trong

Nếu bạn quan sát các dấu ngoặc, thì dấu ngoặc ngoài cùng là một phần của cú pháp cơ bản cho toàn bộ mảng. Trong hình, bộ 2 đại diện cho bộ dấu ngoặc thứ hai. Nếu bạn đếm chúng, bạn sẽ thấy rằng có 2 yếu tố trong chiều này

phần tử thứ nhất

numpy.reshape[a, newshape, order='C']
94

phần tử thứ 2

numpy.reshape[a, newshape, order='C']
95

Mỗi phần tử chứa thêm ba phần tử trong chiều thứ hai. Nếu bạn nghĩ về danh sách lồng nhau, bạn có thể rút ra phép loại suy

Những yếu tố này là

phần tử thứ nhất

numpy.reshape[a, newshape, order='C']
96

phần tử thứ 2

numpy.reshape[a, newshape, order='C']
97

phần tử thứ 3

numpy.reshape[a, newshape, order='C']
98

Cuối cùng, số

numpy.reshape[a, newshape, order='C']
99 đại diện cho số phần tử trong chiều thứ ba. Đó là những yếu tố bên trong. Ví dụ 0, 11, 15 và 16

Chức năng reshape[] trong NumPy là gì?

Làm cách nào để chúng tôi liên kết thuộc tính NumPy's

numpy.reshape[a, newshape, order='C']
86 với hàm NumPy
numpy.reshape[a, newshape, order='C']
4?

cú pháp

>>> import numpy as np
>>> a = np.array[[1, 2, 3, 4, 5, 6]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
>>> np.reshape[a, [3,2]]
array[[[1, 2],
       [3, 4],
       [5, 6]]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
32

ở đâu

  • >>> import numpy as np
    >>> a = np.array[[1, 2, 3, 4, 5, 6]]
    >>> np.reshape[a, [2,3]]
    array[[[1, 2, 3],
           [4, 5, 6]]]
    >>> np.reshape[a, [3,2]]
    array[[[1, 2],
           [3, 4],
           [5, 6]]]
    >>> np.reshape[a, [2,3]]
    array[[[1, 2, 3],
           [4, 5, 6]]]
    33 là mảng chúng tôi muốn định hình lại,
  • import numpy as np
    
    # 1D NumPy array
    arr = np.arange[10]
    
    print[arr]
    # [0 1 2 3 4 5 6 7 8 9]
    
    print[arr.shape]
    # [10, ]
    
    0 là một số nguyên cho mảng một chiều và bộ số nguyên cho nhiều chiều, và
  • import numpy as np
    
    # 1D NumPy array
    arr = np.arange[10]
    
    print[arr]
    # [0 1 2 3 4 5 6 7 8 9]
    
    print[arr.shape]
    # [10, ]
    
    5 là một đối số tùy chọn mà chúng tôi sẽ không tham gia vào hướng dẫn này

Định hình lại một mảng có thể hữu ích khi làm sạch dữ liệu hoặc nếu có một số tính toán phần tử đơn giản cần được thực hiện

Một trong những lợi thế mà mảng NumPy có trên danh sách Python là khả năng thực hiện các thao tác vector hóa dễ dàng hơn. Hơn nữa, định hình lại các mảng là phổ biến trong học máy

Hãy nhớ rằng tất cả các phần tử trong mảng NumPy phải cùng loại

Định hình lại mảng NumPy 1D thành 2D

Nhiều cột

Giả sử rằng chúng ta đang đo nhiệt độ bên ngoài 3 ngày liên tiếp, cả bằng độ C và độ F

Chúng tôi đã ghi lại phép đo của mình dưới dạng vectơ một chiều [1D] trong đó tất cả các chỉ số chẵn biểu thị nhiệt độ được viết bằng độ C và tất cả các chỉ số lẻ biểu thị nhiệt độ được viết bằng độ F

>>> import numpy as np
>>> a = np.array[[1, 2, 3, 4, 5, 6]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
>>> np.reshape[a, [3,2]]
array[[[1, 2],
       [3, 4],
       [5, 6]]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
3

Có 6 phần tử được ghi trong một hàng

Để định hình lại mảng một chiều

>>> import numpy as np
>>> a = np.array[[1, 2, 3, 4, 5, 6]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
>>> np.reshape[a, [3,2]]
array[[[1, 2],
       [3, 4],
       [5, 6]]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
36 thành mảng hai chiều, chúng ta cần truyền một bộ có số hàng và cột cho hàm
>>> import numpy as np
>>> a = np.array[[1, 2, 3, 4, 5, 6]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
>>> np.reshape[a, [3,2]]
array[[[1, 2],
       [3, 4],
       [5, 6]]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
37

Cụ thể, bộ dữ liệu này sẽ bao gồm hai số, hãy gọi chúng là

>>> import numpy as np
>>> a = np.array[[1, 2, 3, 4, 5, 6]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
>>> np.reshape[a, [3,2]]
array[[[1, 2],
       [3, 4],
       [5, 6]]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
38 và
>>> import numpy as np
>>> a = np.array[[1, 2, 3, 4, 5, 6]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
>>> np.reshape[a, [3,2]]
array[[[1, 2],
       [3, 4],
       [5, 6]]]
>>> np.reshape[a, [2,3]]
array[[[1, 2, 3],
       [4, 5, 6]]]
39, trong đó số đầu tiên là số hàng và số thứ hai là số cột

💡 Lưu ý.

numpy.reshape[a, newshape, order='C']
20, số hàng nhân với số cột, phải bằng số phần tử trong mảng ban đầu. Trong ví dụ này, số phần tử trong mảng ban đầu là 6*1=6

Vì vậy, chúng ta chỉ có hai lựa chọn cho mảng hai chiều, 2 hàng và 3 cột hoặc 3 cột và 2 hàng

numpy.reshape[a, newshape, order='C']
2

Dữ liệu không thay đổi; . Chúng được sắp xếp lại thành hai hàng và ba cột

Một cột

Trong phần nói về thuộc tính

numpy.reshape[a, newshape, order='C']
86, chúng ta đã nói rằng hình dạng của mảng một chiều được cho bởi một bộ chứa một số nguyên theo sau bởi dấu phẩy. Sau đó, chúng tôi đã giải thích rằng vectơ này không chứa hàng hoặc cột

Điều gì sẽ xảy ra nếu chúng ta muốn vectơ này có một cột và nhiều hàng bằng số phần tử?

Chúng ta có thể làm điều này bằng cách sử dụng ______04. Mặc dù chỉ có một cột nhưng mảng này sẽ có hai chiều

numpy.reshape[a, newshape, order='C']
6

Định hình lại mảng NumPy 2D thành 1D

Giả sử chúng ta đang thu thập dữ liệu từ một cuộc thi chạy trong nhà của trường đại học cho nội dung chạy 200 mét dành cho nữ

  • Trong lần gặp đầu tiên, chúng tôi ghi lại ba lần đẹp nhất 23. 09 giây, 23. 41 giây, 24. 01 giây
  • Trong lần gặp thứ hai, chúng tôi ghi ba lần tốt nhất 22. 55 giây, 23. 05 giây và 23. 09 giây

Chúng tôi ghi lại điều này trong một mảng hai chiều. Nhưng một khi chúng tôi bắt đầu phân tích dữ liệu, chúng tôi cần kết quả nằm trong một hàng. Chúng tôi làm như sau để định hình lại ma trận

numpy.reshape[a, newshape, order='C']
7

Định hình lại NumPy [mảng, -1]

Bây giờ, chúng ta có nhiều khả năng gặp phải tình huống có hàng nghìn mục nhập trong dữ liệu của mình

Giả sử rằng chúng ta đã thu thập dữ liệu từ cuộc thi chạy trong nhà của trường đại học cho nội dung chạy 200 mét dành cho nữ trong 3 năm qua

Thật dễ dàng để đếm số mục khi chúng tôi chỉ có sáu mục, nhưng bây giờ chúng tôi có hàng ngàn mục. Thay vì thực hiện nhiệm vụ khó khăn là đếm số lượng mục nhập, chúng ta có thể chuyển -1 trong đối số

import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
0

Chúng ta có thể chỉ ra điều này trong ví dụ sau

numpy.reshape[a, newshape, order='C']
9

Sử dụng

import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
4 cho
import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
0 có thể hữu ích trong các mảng đa chiều. Chúng tôi sẽ trở lại với nó trong phần tiếp theo

Định hình lại mảng NumPy 3D thành 2D

Đôi khi dữ liệu chúng tôi thu thập sẽ lộn xộn và trước khi bắt đầu phân tích, chúng tôi cần dọn dẹp nó

Giả sử chúng ta có một mảng NumPy ba chiều trông như thế này

numpy.reshape[a, newshape, order='C']
0

Khi chúng tôi kiểm tra dữ liệu kỹ hơn, chúng tôi có thể thấy rằng sẽ hợp lý hơn nếu lưu trữ dữ liệu dưới dạng ma trận hai chiều

Chúng ta có thể đếm số “cặp” mà chúng ta muốn có. Một cách để làm điều này là

numpy.reshape[a, newshape, order='C']
1

NumPy định hình lại [-1, m] và định hình lại [n, -1]

Phương pháp định hình lại mảng ba chiều [3D] thành mảng hai chiều [2D] ở trên hoạt động nếu chúng ta không có nhiều mục nhập

Tuy nhiên, nếu chúng tôi có hàng nghìn mục, điều này có thể phức tạp. Trong trường hợp này, chúng tôi có thể sử dụng

import numpy as np

# 1D NumPy array
arr = np.arange[10]

print[arr]
# [0 1 2 3 4 5 6 7 8 9]

print[arr.shape]
# [10, ]
4 cho một chiều và nếu có thể, dữ liệu sẽ được định hình lại cho chúng tôi

Sử dụng ví dụ trên

numpy.reshape[a, newshape, order='C']
2

np. định hình lại vs. np. trục mới

Khi chúng ta muốn thực hiện các thao tác trên mảng thì chúng cần tương thích với nhau

Yếu tố khôn ngoan, kích thước của các mảng cần phải bằng nhau trong một chiều. Tuy nhiên, chúng không nhất thiết phải có cùng số chiều. Nếu kích thước không bằng nhau, NumPy sẽ báo lỗi

Khi các mảng có kích thước khác nhau, một cách để thêm kích thước là sử dụng hàm

numpy.reshape[a, newshape, order='C']
4

Một cách khác là sử dụng ______528biểu thức

Lợi thế của_______528trên

numpy.reshape[a, newshape, order='C']
4là bạn không cần phải biết số thứ nguyên cần được thêm vào. Biểu thức ____528 tăng kích thước để mảng một chiều trở thành mảng hai chiều, mảng hai chiều trở thành mảng ba chiều, v.v.

Cách thức hoạt động của nó là “cắt” một mảng bằng cách thêm một thứ nguyên. Nếu chúng ta nhìn vào mảng nhiệt độ ban đầu từ trước đó trong hướng dẫn

numpy.reshape[a, newshape, order='C']
3

Ghi công

Bài viết này được đóng góp bởi người dùng Finxter Milica Cvetkovic. Milica cũng là một nhà văn trên Medium — hãy xem Hồ sơ trên Medium của cô ấy

Đi đâu từ đây?

Hiểu biết thấu đáo về những điều cơ bản của NumPy là một phần quan trọng trong quá trình học tập của bất kỳ nhà khoa học dữ liệu nào. NumPy là trung tâm của nhiều thư viện khoa học dữ liệu và máy học tiên tiến như Pandas, TensorFlow và Scikit-learning

Nếu bạn gặp khó khăn với thư viện NumPy — đừng sợ. Trở thành một chuyên gia NumPy ngay lập tức với cuốn sách viết mã mới của chúng tôi “Coffee Break NumPy”. Đây không chỉ là phần giới thiệu kỹ lưỡng về thư viện NumPy mà sẽ làm tăng giá trị của bạn trên thị trường. Thật thú vị khi xem qua bộ sưu tập lớn các câu đố mã trong cuốn sách

Nhận Coffee Break của bạn NumPy

Chris

Trong khi làm việc với tư cách là một nhà nghiên cứu trong các hệ thống phân tán, Dr. Christian Mayer tìm thấy tình yêu của mình với việc dạy sinh viên khoa học máy tính

Để giúp sinh viên đạt được mức độ thành công Python cao hơn, anh ấy đã thành lập trang web giáo dục lập trình Finxter. com. Ông là tác giả của cuốn sách lập trình nổi tiếng Python One-Liners [NoStarch 2020], đồng tác giả của loạt sách tự xuất bản Coffee Break Python, người đam mê khoa học máy tính, cộng tác viên tự do và chủ sở hữu của một trong 10 blog Python lớn nhất thế giới

Niềm đam mê của anh ấy là viết, đọc và mã hóa. Nhưng niềm đam mê lớn nhất của anh ấy là phục vụ các lập trình viên đầy tham vọng thông qua Finxter và giúp họ nâng cao kỹ năng của mình. Bạn có thể tham gia học viện email miễn phí của anh ấy tại đây

Định hình lại được sử dụng để làm gì trong Python?

Định hình lại có nghĩa là thay đổi hình dạng của một mảng . Hình dạng của một mảng là số phần tử trong mỗi chiều. Bằng cách định hình lại, chúng tôi có thể thêm hoặc xóa kích thước hoặc thay đổi số lượng phần tử trong mỗi kích thước.

Định hình lại trong NumPy hoạt động như thế nào?

Hàm reshape[] được dùng để tạo hình dạng mới cho mảng mà không làm thay đổi dữ liệu của mảng . Mảng được định hình lại. Hình dạng mới phải tương thích với hình dạng ban đầu. Nếu là một số nguyên, thì kết quả sẽ là một mảng 1-D có độ dài đó.

Công dụng của lệnh Reshape là gì?

định hình lại chuyển đổi dữ liệu từ dạng rộng sang dạng dài và ngược lại .

Đâu là sự khác biệt giữa reshape[] và resize[] ?

reshape[] và gọn gàng. phương thức resize[] được sử dụng để thay đổi kích thước của mảng NumPy. Sự khác biệt giữa chúng là phương thức reshape[] không thay đổi mảng ban đầu mà chỉ trả về mảng đã thay đổi, trong khi phương thức resize[] không trả về gì cả và trực tiếp thay đổi mảng ban đầu.

Chủ Đề