Với Numpy, nó rất đơn giản - bạn chỉ có thể thực hiện lát cắt:
In [1]: import numpy as np
In [2]: A = np.array[[[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5]]]
In [3]: A[:,:3]
Out[3]:
array[[[1, 2, 3],
[1, 2, 3],
[1, 2, 3]]]
Tất nhiên, bạn có thể chuyển đổi
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
1 trở lại In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
2:In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
Trong Python, việc cắt danh sách là một thực tế phổ biến và nó là kỹ thuật được sử dụng nhiều nhất để các lập trình viên giải quyết các vấn đề hiệu quả. Hãy xem xét một danh sách Python, theo đơn đặt hàng để truy cập vào một loạt các yếu tố trong danh sách, bạn cần cắt một danh sách. Một cách để làm điều này là sử dụng toán tử cắt lát đơn giản, tức là đại tràng [:]
Với toán tử này, người ta có thể chỉ định nơi bắt đầu cắt lát, nơi kết thúc và chỉ định bước. Danh sách cắt giảm trả về một danh sách mới từ danh sách hiện có.
Syntax:
Lst[ Initial : End : IndexJump ]
Nếu LST là một danh sách, thì biểu thức ở trên sẽ trả về phần của danh sách từ chỉ mục ban đầu đến cuối chỉ mục, ở một kích thước bước chỉ mục.
Lập chỉ mục
1. Chỉ số tích cực
Dưới đây là một chương trình đơn giản, để hiển thị toàn bộ danh sách bằng cách sử dụng cắt lát.
Python3
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
3In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
4 In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
5In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
6In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
8__[50, 70, 30, 20, 90, 10, 50]0
[50, 70, 30, 20, 90, 10, 50]1
Output:
[50, 70, 30, 20, 90, 10, 50]
Sơ đồ trên minh họa một danh sách LST với các giá trị và phần tử chỉ mục của nó.
2. Các chỉ số tiêu cực
Bây giờ, chúng ta hãy nhìn vào sơ đồ dưới đây minh họa một danh sách cùng với các chỉ mục tiêu cực của nó.
Index -1 đại diện cho phần tử cuối cùng và -n đại diện cho phần tử đầu tiên của danh sách [coi n là độ dài của danh sách]. Danh sách cũng có thể được thao tác bằng cách sử dụng các chỉ mục tiêu cực.
Python3
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
3In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
4 In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
5In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
6In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
8__[50, 70, 30, 20, 90, 10, 50]0
[70, 30, 20, 90]0
[70, 30, 20, 90]1
[70, 30, 20, 90]2
[70, 30, 20, 90]3
[70, 30, 20, 90]4
[70, 30, 20, 90]5
Output:
[50, 70, 30, 20, 90, 10, 50]
Chương trình trên hiển thị toàn bộ danh sách bằng cách sử dụng chỉ số tiêu cực trong cắt danh sách.
3. Cắt lát
Như đã đề cập cắt giảm danh sách trước đó là một thực tế phổ biến trong Python và có thể được sử dụng cả hai với các chỉ số tích cực cũng như các chỉ số tiêu cực. Sơ đồ dưới đây minh họa kỹ thuật cắt danh sách:
Chương trình dưới đây chuyển đổi minh họa trên thành mã Python:
Python3
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
3In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
4 In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
5In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
6In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
8__[50, 70, 30, 20, 90, 10, 50]0
[70, 30, 20, 90]0
[70, 30, 20, 90]4
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']6
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']7
[70, 30, 20, 90]5
Output:
[70, 30, 20, 90]
Dưới đây là một số ví dụ mô tả việc sử dụng danh sách cắt trong Python:
Ví dụ 1:
Python3
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
4 In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
5[70, 30, 20, 90]4
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7__844[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
02In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
08In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
5Original List: [-999, 'G4G', 1706256, '^_^', 3.1496] Sliced Lists: [] [] [] []6
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']6
Original List: [-999, 'G4G', 1706256, 3.1496, '^_^'] Sliced Lists: [-999, 'G4G', 'Geeks', 'for', 'Geeks', '!', '^_^'] ['^_^']8
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']6
Original List: [-999, 'G4G', 1706256, '^_^', 3.1496] Sliced Lists: [] [] [] []4
[70, 30, 20, 90]5
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
23Original List: [-999, 'G4G', 1706256, '^_^', 3.1496] Sliced Lists: [] [] [] []4
[70, 30, 20, 90]5
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
29Output:
Original List: [1, 2, 3, 4, 5, 6, 7, 8, 9] Sliced Lists: [4, 6, 8] [1, 3, 5, 7, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9]
Để lại bất kỳ đối số nào như trống ban đầu, đầu hoặc chỉ mục sẽ dẫn đến việc sử dụng các giá trị mặc định, tức là 0 là độ dài ban đầu, độ dài của danh sách là kết thúc và 1 là indexJump.
Ví dụ 2:
Python3
Is
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
02In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
08In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05[50, 70, 30, 20, 90, 10, 50]0____101
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
23[70, 30, 20, 90]1
[70, 30, 20, 90]4__
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
23[70, 30, 20, 90]1
Original List: [-999, 'G4G', 1706256, '^_^', 3.1496] Sliced Lists: [] [] [] []6
[70, 30, 20, 90]5
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
66[70, 30, 20, 90]4
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']6
[70, 30, 20, 90]1
Original List: [-999, 'G4G', 1706256, '^_^', 3.1496] Sliced Lists: [] [] [] []4
[70, 30, 20, 90]5
Output:
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']
Một danh sách đảo ngược có thể được tạo bằng cách sử dụng số nguyên âm làm đối số IndexJump. Để lại cái đầu và kết thúc như trống. Chúng ta cần chọn giá trị ban đầu và kết thúc theo danh sách đảo ngược nếu giá trị IndexJump là âm. & NBSP;
Ví dụ 3:
Python3
Is
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
02In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
08In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
5Lst[ Initial : End : IndexJump ]6
[70, 30, 20, 90]3
Original List: [-999, 'G4G', 1706256, '^_^', 3.1496] Sliced Lists: [] [] [] []4
[70, 30, 20, 90]5
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
5[70, 30, 20, 90]4
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']6
[70, 30, 20, 90]4
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']6
[70, 30, 20, 90]4
[70, 30, 20, 90]5
Các
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
66Lst[ Initial : End : IndexJump ]31
Lst[ Initial : End : IndexJump ]32
Output:
Original List: [-999, 'G4G', 1706256, '^_^', 3.1496] Sliced Lists: [] [] [] []
Nếu một số biểu thức cắt được thực hiện không có ý nghĩa hoặc không thể tính được thì danh sách trống được tạo ra.
Ví dụ 4:
Python3
Is
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
02In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05[50, 70, 30, 20, 90, 10, 50]0____101
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
08In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05Các
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
66Original List: [-999, 'G4G', 1706256, 3.1496, '^_^'] Sliced Lists: [-999, 'G4G', 'Geeks', 'for', 'Geeks', '!', '^_^'] ['^_^']2.
[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05Output:
Original List: [-999, 'G4G', 1706256, 3.1496, '^_^'] Sliced Lists: [-999, 'G4G', 'Geeks', 'for', 'Geeks', '!', '^_^'] ['^_^']
Danh sách cắt có thể được sử dụng để sửa đổi danh sách hoặc thậm chí xóa các yếu tố khỏi danh sách.
Ví dụ 5:
Python3
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
4 In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
5[70, 30, 20, 90]4
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7__844[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
02In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05[50, 70, 30, 20, 90, 10, 50]0
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
01In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
08In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05Để lại bất kỳ đối số nào như trống ban đầu, đầu hoặc chỉ mục sẽ dẫn đến việc sử dụng các giá trị mặc định, tức là 0 là độ dài ban đầu, độ dài của danh sách là kết thúc và 1 là indexJump.
[50, 70, 30, 20, 90, 10, 50]0
[50, 70, 30, 20, 90, 10, 50]30
Ví dụ 2:
Is
Output:
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
0[50, 70, 30, 20, 90, 10, 50]0____101
Original List: ['Geeks', 4, 'geeks !'] Sliced Lists: ['geeks !', 4, 'Geeks'] ['geeks !'] ['geeks !']9
In [4]: A[:,:3].tolist[]
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
23[70, 30, 20, 90]1
[70, 30, 20, 90]4__