Hướng dẫn list of list slicing python - danh sách danh sách cắt python

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

Hướng dẫn list of list slicing python - danh sách danh sách cắt python

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]]
3
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
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
6
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7
In [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ó.

Hướng dẫn list of list slicing python - danh sách danh sách cắt python

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]]
3
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
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
6
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7
In [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:

Hướng dẫn list of list slicing python - danh sách danh sách cắt python

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]]
3
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
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
6
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7
In [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]]
01
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
02
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7
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]]
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]]
01
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
08
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]]
01
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]]
5
Original 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]]
01
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
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]]
01
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]]
29

Output:

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]]
01
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
02
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7
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]]
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]]
01
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
08
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
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]]
01
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
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]]
01
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]]
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]]
01
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
02
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7
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]]
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]]
01
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
08
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]]
01
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]]
5
Lst[ 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]]
01
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]]
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]]
01
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]]
66
Lst[ 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]]
01
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
02
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7
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]]
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]]
08
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
05

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]]
01
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]]
05

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]]
66
Original 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]]
01
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]]
05

Output:

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]]
01
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
02
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
7
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]]
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]]
01
In [4]: A[:,:3].tolist()
Out[4]: [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
08
In [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__


Bạn có thể cắt một danh sách các danh sách trong Python khô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ó. 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.List slicing returns a new list from the existing list. If Lst is a list, then the above expression returns the portion of the list from index Initial to index End, at a step size IndexJump.

Có thể cắt có thể trong danh sách?

Định dạng cắt danh sách là [Bắt đầu: Dừng: Bước].Bắt đầu là chỉ số của danh sách nơi cắt lát bắt đầu.Dừng là chỉ số của danh sách nơi cắt kết thúc.Bước cho phép bạn chọn mục thứ n trong phạm vi bắt đầu dừng.

Danh sách cắt lát cho ví dụ là gì?

Tóm tắt video.Có thể "cắt" một danh sách trong Python.Điều này sẽ trả về một phân đoạn cụ thể của một danh sách nhất định.Ví dụ: Lệnh Mylist [2] sẽ trả về mục thứ 3 trong danh sách của bạn (hãy nhớ rằng Python bắt đầu đếm với số 0).return a specific segment of a given list. For example, the command myList[2] will return the 3rd item in your list (remember that Python begins counting with the number 0).

Danh sách cắt trong Python có nghĩa là gì?

Danh sách cắt lát đề cập đến việc truy cập một phần cụ thể hoặc một tập hợp con của danh sách cho một số hoạt động trong khi danh sách Orginal vẫn không bị ảnh hưởng.Toán tử cắt trong Python có thể lấy 3 tham số trong đó 2 là tùy chọn tùy thuộc vào yêu cầu.Cú pháp cắt danh sách: list_name [Bắt đầu: Dừng: Bước]