Hướng dẫn python list slice skip element - phần tử bỏ qua lát danh sách python

Nếu danh sách của bạn nhỏ, tôi khuyên bạn nên sử dụng phương pháp trong câu trả lời từ @Satoru.

Nếu danh sách của bạn rất lớn và bạn muốn tránh "khuấy" việc tạo và xóa các phiên bản danh sách, làm thế nào về việc sử dụng trình tạo?

import itertools as it
def skip_i(seq, i):
    return it.chain(it.islice(seq, 0, i), it.islice(seq, i+1, None))

Điều này thúc đẩy công việc bỏ qua phần tử Ith xuống vào ruột của

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

7, vì vậy điều này sẽ nhanh hơn là viết tương đương trong Python thuần túy.

Để làm điều đó trong Python thuần túy, tôi sẽ đề nghị viết một máy phát như thế này:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

Chỉnh sửa: Đây là phiên bản cải tiến của câu trả lời của tôi, nhờ @blckknght trong các bình luận bên dưới.

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

Đây là một cải tiến lớn so với câu trả lời ban đầu của tôi. Câu trả lời ban đầu của tôi chỉ hoạt động đúng về những thứ có thể lập chỉ mục như danh sách, nhưng điều này sẽ hoạt động chính xác cho bất kỳ điều gì có thể lặp lại, bao gồm cả iterators! Nó tạo ra một trình lặp rõ ràng từ ITEBLE, sau đó (trong một "chuỗi") kéo các giá trị ____38 đầu tiên và chỉ bỏ qua một giá trị duy nhất trước khi kéo tất cả các giá trị còn lại.

Cảm ơn bạn rất nhiều @blckknght!

1. Hướng dẫn Python
2. Danh sách
3. Lát cắt

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

7.23.Slice
	7.23.1.	Cắt lát để truy cập phạm vi của các yếu tố
	7.23.2.	LHS lát và các RHS có thể có bất kỳ độ dài nào
	7.23.3.	Cắt tốc độ tốc ký
	7.23.4.	Đầu tiên là bao gồm, và thứ hai là độc quyền
	7.23.5.	Cắt nhiều hơn những gì bạn có
	7.23.6.	Cắt lát từ cuối
	7.23.7.	Nếu lát cắt tiếp tục đến cuối chuỗi, bạn có thể chỉ cần bỏ chỉ mục cuối cùng
	7.23.8.	Nếu lát cắt tiếp tục bắt đầu chuỗi, bạn có thể chỉ cần bỏ chỉ mục đầu tiên
	7.23.9.	Sao chép toàn bộ chuỗi, bạn có thể bỏ qua cả hai chỉ số
	7.23.10.	Một tham số khác, bình thường là tiềm ẩn, là chiều dài bước
	7.23.11.	Kích thước bước của hai sẽ chỉ bao gồm mọi yếu tố khác của khoảng giữa bắt đầu và kết thúc:
	7.23.12.	Nếu bạn muốn mọi yếu tố thứ tư của một chuỗi, bạn chỉ phải cung cấp kích thước bước là bốn:
	7.23.13.	Kích thước bước âm
	7.23.14.	Cắt một danh sách
	7.23.15.	Kết thúc lát cắt
	7.23.16.	Lát giữa
	7.23.17.	Chỉ số tiêu cực
	7.23.18.	Revese và bỏ qua
	7.23.19.	Các chỉ số bắt đầu và kết thúc có thể vượt quá độ dài của chuỗi.

Danh sách được cho là loại hữu ích và phổ biến nhất trong Python. Một trong những lý do khiến nó rất tiện dụng là ký hiệu lát cắt Python. Nói tóm lại, cắt lát là một công cụ linh hoạt để xây dựng danh sách mới trong danh sách hiện có.

Python hỗ trợ ký hiệu lát cắt cho bất kỳ loại dữ liệu tuần tự nào như danh sách, chuỗi, bộ dữ liệu, byte, bytearrays và phạm vi. Ngoài ra, bất kỳ cấu trúc dữ liệu mới cũng có thể thêm hỗ trợ của nó. Điều này được sử dụng rất nhiều (và bị lạm dụng) trong các thư viện Numpy và Pandas, rất phổ biến trong học máy và khoa học dữ liệu. Nó là một ví dụ điển hình về việc học hỏi một lần, sử dụng ở mọi nơi.

Trong bài viết này, chúng tôi sẽ tập trung vào các hoạt động lập chỉ mục và cắt lát trong danh sách Python. Hầu hết các ví dụ chúng tôi sẽ thảo luận có thể được sử dụng cho bất kỳ loại dữ liệu tuần tự. Chỉ các hoạt động phân công và xóa có thể thay đổi không được áp dụng cho các loại trình tự bất biến như bộ dữ liệu, chuỗi, byte và phạm vi.

Trước khi thảo luận về ký hiệu lát cắt, chúng ta cần nắm bắt tốt việc lập chỉ mục cho các loại tuần tự.

Trong Python, danh sách giống như các mảng trong các ngôn ngữ kịch bản khác (Ruby, JavaScript, PHP). Nó cho phép bạn lưu trữ một tập hợp các mục được liệt kê ở một nơi và truy cập một mục theo vị trí của nó - chỉ mục.

Hãy để một ví dụ đơn giản:

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

Ở đây chúng tôi xác định một danh sách các màu sắc. Mỗi mục trong danh sách có một giá trị (tên màu) và một chỉ mục (vị trí của nó trong danh sách). Python sử dụng lập chỉ mục dựa trên không. Điều đó có nghĩa là, phần tử đầu tiên (giá trị ‘màu đỏ) có chỉ mục 0, phần thứ hai (giá trị‘ màu xanh lá cây) có chỉ số 1, v.v.zero-based indexing. That means, the first element(value ‘red’) has an index 0, the second(value ‘green’) has index 1, and so on.

Để truy cập một phần tử bằng chỉ mục của nó, chúng ta cần sử dụng dấu ngoặc vuông:

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']
>>> colors[0]
'red'
>>> colors[1]
'green'
>>> colors[5]
'black'

Chỉ số tiêu cực

Sử dụng lập chỉ mục, chúng ta có thể dễ dàng có được bất kỳ yếu tố nào theo vị trí của nó. Điều này rất tiện lợi nếu chúng ta sử dụng vị trí từ đầu danh sách. Nhưng điều gì sẽ xảy ra nếu chúng ta muốn lấy yếu tố cuối cùng của một danh sách? Hay yếu tố áp chót? Trong trường hợp này, chúng tôi muốn liệt kê các yếu tố từ đuôi của một danh sách.

Để giải quyết yêu cầu này có lập chỉ mục tiêu cực. Vì vậy, thay vì sử dụng các chỉ mục từ 0 trở lên, chúng ta có thể sử dụng các chỉ mục từ -1 trở xuống.

Trong hệ thống lập chỉ mục âm -1 tương ứng với phần tử cuối cùng của danh sách (giá trị ‘đen), -2 cho áp chót (giá trị‘ trắng), v.v.

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']
>>> colors[-1]
'black'
>>> colors[-2]
'white'
>>> colors[-6]
'red'

Phân công

Trước khi chúng tôi chỉ sử dụng lập chỉ mục để truy cập nội dung của ô danh sách. Nhưng nó cũng có thể thay đổi nội dung ô bằng cách sử dụng thao tác gán:

>>> basket = ['bread', 'butter', 'milk']
>>> basket[0] = 'cake'
>>> basket
['cake', 'butter', 'milk']
>>> basket[-1] = 'water'
>>> basket
['cake', 'butter', 'water']

Chúng tôi có thể tự do sử dụng lập chỉ mục tích cực hoặc tiêu cực để gán.

Xóa

Chúng tôi cũng có thể dễ dàng xóa bất kỳ phần tử nào khỏi danh sách bằng cách sử dụng câu lệnh

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

9:

________số 8

Lập chỉ mục cho các loại tuần tự khác

Hoạt động lập chỉ mục chỉ đọc hoạt động hoàn toàn tốt cho tất cả các loại tuần tự. Nhưng các hoạt động chuyển nhượng và xóa không được áp dụng cho các loại tuần tự bất biến.

Ký hiệu lát cắt

Như đã được hiển thị, việc lập chỉ mục cho phép bạn truy cập/thay đổi/xóa chỉ một ô duy nhất của danh sách. Điều gì sẽ xảy ra nếu chúng ta muốn có được một người phụ của danh sách. Hoặc chúng tôi muốn cập nhật một loạt các ô cùng một lúc? Hoặc chúng ta muốn đi trên một điên cuồng và mở rộng một danh sách với số lượng ô mới tùy ý ở bất kỳ vị trí nào?

Những và rất nhiều thủ thuật thú vị khác có thể được thực hiện với ký hiệu lát cắt. Hãy cùng nhìn vào chủ đề này.

Sử dụng cơ bản của lát cắt

Hãy để tạo ra một danh sách cơ bản:

>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]

Điều gì sẽ xảy ra nếu chúng ta muốn lấy một người phụ từ danh sách

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

0? Đây là một snap khi sử dụng lát cắt:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

0

Vì vậy, đây là ví dụ đầu tiên của chúng tôi về một lát: 2: 7. Cú pháp đầy đủ là: Bắt đầu: Dừng: Bước.

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1 đề cập đến chỉ số của phần tử được sử dụng như là một khởi đầu của lát cắt của chúng tôi.

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2 đề cập đến chỉ số của phần tử chúng ta nên dừng ngay trước đó để hoàn thành lát cắt của mình.

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3 cho phép bạn lấy từng phần tử thứ n trong phạm vi bắt đầu: Dừng.

Trong ví dụ của chúng tôi

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1 bằng

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

5, do đó, lát cắt của chúng tôi bắt đầu từ giá trị

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

6.

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2 là

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

8, do đó, phần tử cuối cùng của lát cắt là

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

9 với Index

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']
>>> colors[0]
'red'
>>> colors[1]
'green'
>>> colors[5]
'black'

0. Cuối cùng, Slice tạo ra một danh sách mới (chúng tôi đặt tên là

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']
>>> colors[0]
'red'
>>> colors[1]
'green'
>>> colors[5]
'black'

1) với các phần tử được chọn.

Chúng tôi đã không sử dụng

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3 trong lát cắt của chúng tôi, vì vậy chúng tôi đã bỏ qua bất kỳ yếu tố nào và có được tất cả các giá trị trong phạm vi.

Với các lát, chúng tôi có thể trích xuất một phần tùy ý của danh sách, ví dụ:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

1

Ở đây chúng tôi bắt đầu từ phần tử đầu tiên (INDEX

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']
>>> colors[0]
'red'
>>> colors[1]
'green'
>>> colors[5]
'black'

3) và lấy danh sách cho đến khi phần tử có chỉ mục

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']
>>> colors[0]
'red'
>>> colors[1]
'green'
>>> colors[5]
'black'

4.

Lấy n yếu tố đầu tiên của một danh sách

Ký hiệu lát cắt cho phép bạn bỏ qua bất kỳ yếu tố nào của cú pháp đầy đủ. Nếu chúng ta bỏ qua số

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1 thì nó bắt đầu từ

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']
>>> colors[0]
'red'
>>> colors[1]
'green'
>>> colors[5]
'black'

3 Index:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

2

Vì vậy, NUMS [: 5] tương đương với NUMS [0: 5]. Sự kết hợp này là một lối tắt tiện dụng để lấy n yếu tố đầu tiên của một danh sách.

Lấy n các yếu tố cuối cùng của một danh sách

Các chỉ mục tiêu cực cho phép chúng tôi dễ dàng lấy các yếu tố N-Last của danh sách:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

3

Ở đây, tham số

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2 được bỏ qua. Điều đó có nghĩa là bạn lấy từ vị trí

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1, cho đến khi kết thúc danh sách. Chúng tôi bắt đầu từ phần tử thứ ba từ cuối (giá trị

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

9 với INDEX

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']
>>> colors[-1]
'black'
>>> colors[-2]
'white'
>>> colors[-6]
'red'

0) và đưa mọi thứ đến cùng.

Chúng ta có thể tự do trộn các chỉ số tiêu cực và tích cực ở vị trí

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1 và

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

4

Lấy tất cả trừ n các yếu tố cuối cùng của một danh sách

Một cách sử dụng tốt khác của các chỉ số tiêu cực:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

5

Chúng tôi lấy tất cả trừ hai yếu tố cuối cùng của danh sách ban đầu.

Lấy mọi yếu tố thứ n của một danh sách

Điều gì sẽ xảy ra nếu chúng ta chỉ muốn có mỗi yếu tố 2-ND của

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

0? Đây là nơi tham số

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3 phát huy tác dụng:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

6

Ở đây chúng tôi bỏ qua ________ 41/________ 42 tham số và chỉ sử dụng

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3. Bằng cách cung cấp

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1, chúng tôi có thể bỏ qua một số yếu tố:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

7

Và nếu chúng tôi không muốn bao gồm một số yếu tố ở cuối, chúng tôi cũng có thể thêm tham số

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

8

Sử dụng bước tiêu cực và danh sách đảo ngược

Chúng ta có thể sử dụng

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3 âm để có được danh sách đảo ngược:

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

9

Tiêu cực

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3 thay đổi một cách, ký hiệu lát cắt hoạt động. Nó làm cho lát cắt được xây dựng từ đuôi của danh sách. Vì vậy, nó đi từ phần tử cuối cùng sang phần tử đầu tiên. Đó là lý do tại sao chúng tôi nhận được một danh sách đảo ngược với một bước tiêu cực.

Do tính đặc thù này,

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1 và

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2 cũng nên được cung cấp từ phải sang trái. Ví dụ: nếu bạn muốn có một danh sách đảo ngược bắt đầu từ

>>> basket = ['bread', 'butter', 'milk']
>>> basket[0] = 'cake'
>>> basket
['cake', 'butter', 'milk']
>>> basket[-1] = 'water'
>>> basket
['cake', 'butter', 'water']

4:

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

0

Vì vậy, chúng tôi bắt đầu từ phần tử

>>> basket = ['bread', 'butter', 'milk']
>>> basket[0] = 'cake'
>>> basket
['cake', 'butter', 'milk']
>>> basket[-1] = 'water'
>>> basket
['cake', 'butter', 'water']

5 (giá trị

>>> basket = ['bread', 'butter', 'milk']
>>> basket[0] = 'cake'
>>> basket
['cake', 'butter', 'milk']
>>> basket[-1] = 'water'
>>> basket
['cake', 'butter', 'water']

4) và đi từ phải sang trái thu thập tất cả các phần tử trong một danh sách đảo ngược.

Chúng ta có thể sử dụng giá trị

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2 để ngừng thực hiện trước một số yếu tố. Ví dụ: hãy để Lôi không bao gồm các giá trị

>>> basket = ['bread', 'butter', 'milk']
>>> basket[0] = 'cake'
>>> basket
['cake', 'butter', 'milk']
>>> basket[-1] = 'water'
>>> basket
['cake', 'butter', 'water']

8 và

>>> basket = ['bread', 'butter', 'milk']
>>> basket[0] = 'cake'
>>> basket
['cake', 'butter', 'milk']
>>> basket[-1] = 'water'
>>> basket
['cake', 'butter', 'water']

9:

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

1

Chúng tôi sử dụng

>>> basket = ['bread', 'butter', 'milk']
>>> del basket[0]
>>> basket
['butter', 'milk']
>>> del basket[1]
>>> basket
['butter']

0 cho chỉ số

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2, là phần tử có giá trị

>>> basket = ['bread', 'butter', 'milk']
>>> basket[0] = 'cake'
>>> basket
['cake', 'butter', 'milk']
>>> basket[-1] = 'water'
>>> basket
['cake', 'butter', 'water']

8. Vì vậy, chúng tôi đi từ 80 đến 30, không bao gồm giá trị

>>> basket = ['bread', 'butter', 'milk']
>>> basket[0] = 'cake'
>>> basket
['cake', 'butter', 'milk']
>>> basket[-1] = 'water'
>>> basket
['cake', 'butter', 'water']

8.

Nó có một chút khó khăn rằng với

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3 âm, chỉ số

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2 được đặt trước

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1. Tiêu cực

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3 làm đảo lộn mọi thứ.

Tất nhiên, chúng ta có thể sử dụng một tiêu cực tùy ý

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3:

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

2

Cắt lát và sao chép

Một điều quan trọng cần chú ý - đó là Danh sách Slice tạo ra một bản sao nông của danh sách ban đầu. Điều đó có nghĩa là, chúng tôi có thể sửa đổi một cách an toàn danh sách mới và nó sẽ không ảnh hưởng đến danh sách ban đầu:

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

3

Mặc dù chúng tôi đột biến phần tử trong Index

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

5, nhưng nó không ảnh hưởng đến danh sách

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

0, bởi vì danh sách

>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]

1 - là một bản sao một phần của danh sách

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

0.

Có hình thức ngắn nhất của ký hiệu lát cắt - chỉ là colons nums [:].

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

4

Nó tạo ra một bản sao nông của toàn bộ danh sách và là một tốc ký tốt khi bạn cần một bản sao của danh sách gốc.

Đối tượng cắt lát

Nhưng điều gì sẽ xảy ra nếu chúng ta muốn sử dụng cùng một lát cắt nhiều lần. Có cách nào để tạo một đối tượng lát cắt thay vì chỉ sử dụng dạng cú pháp không?

Điều này có thể được thực hiện bằng hàm

>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]

3:

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

5

Hàm

>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]

3 chấp nhận các đối số theo cùng thứ tự như trong ký hiệu lát cắt và nếu bạn cần bỏ qua một số yếu tố, chỉ cần sử dụng

>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]

5:

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

6

Phân công lát cắt

Python hỗ trợ hoạt động gán lát cắt, cho phép chúng tôi thực hiện một loạt các hoạt động gọn gàng trong một danh sách hiện có. Không giống như các hoạt động lát cắt trước đó, những điều này làm biến đổi đối tượng ban đầu tại chỗ. Đó là lý do tại sao chúng không áp dụng cho các loại tuần tự bất biến.

Thay thế một phần của danh sách

Phân công cắt cho phép bạn cập nhật một phần của danh sách với các giá trị mới:

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

7

Ở đây chúng tôi không thay đổi số lượng các yếu tố trong danh sách. Chỉ một số giá trị danh sách được cập nhật.

Thay thế và thay đổi kích thước một phần của danh sách

Thay vào đó, chúng ta có thể thay thế một phần của danh sách bằng một đoạn lớn hơn: thay vào đó:

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

8

Trong trường hợp này, chúng tôi mở rộng danh sách ban đầu.

Nó cũng có thể thay thế một đoạn lớn hơn bằng một số lượng nhỏ hơn các mặt hàng:

import itertools as it
def skip_i(iterable, i):
    itr = iter(iterable)
    return it.chain(it.islice(itr, 0, i), it.islice(itr, 1, None))

9

Thay thế mọi phần tử n-th

Thêm

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3 cho phép thay thế từng phần tử N-th bằng một giá trị mới:

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

0

Sử dụng gán lát cắt với

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3 đặt giới hạn trong danh sách chúng tôi cung cấp cho bài tập. Danh sách được cung cấp nên khớp chính xác với số lượng các yếu tố để thay thế. Nếu độ dài không khớp, Python ném ngoại lệ:

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

1

Chúng ta cũng có thể sử dụng âm

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3:

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

2

Bằng cách cung cấp các giá trị

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1 và

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2, chúng ta có thể thu hẹp khu vực thay thế:

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

3

Xóa cắt lát

Chúng tôi cũng có thể sử dụng câu lệnh

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

9 để loại bỏ một lát ra khỏi danh sách:

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

4

Ở đây, chúng tôi đã loại bỏ một loạt các yếu tố trong danh sách

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

0.

Chúng tôi cũng có thể cung cấp tham số

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']

3 để cắt và loại bỏ từng phần tử n-th:

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

5

Với cú pháp đầy đủ, chúng ta có thể đặt ranh giới cho các yếu tố được xóa:

s = 'abcdefgh'
print s[::-1]            # think of it as 'reverse'
print s[::2]             # think of it as skipping by 2

6

Vì vậy, chúng tôi bắt đầu xóa từ 20 (chỉ số 1) và loại bỏ từng phần tử 2-ND cho đến giá trị 80 (chỉ số 7).

Và bởi vì việc xóa lát cắt làm biến đổi đối tượng cơ bản, nó không áp dụng cho các loại tuần tự bất biến.

Bản tóm tắt

Chúng tôi đã thảo luận về hai hoạt động danh sách chính: lập chỉ mục và cắt. Cả hai khái niệm đều rất quan trọng để sử dụng Python hiệu quả.

Bài viết này đã chuẩn bị nền để giải quyết việc lập chỉ mục và cắt trong

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

04

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

05 và

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

06

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

07 và

def gen_skip_i(seq, i):
    for j, x in enumerate(seq):
        if i != j:
            yield x

08 đối tượng. Có rất nhiều điểm tương đồng giữa các cấu trúc này, nhưng cũng có rất nhiều sự khác biệt tinh tế và gotchas sẽ được thảo luận trong các bài viết sắp tới dành riêng cho các kỹ thuật học máy mà nhóm Railsware sử dụng.

Nếu bạn vẫn là người mới bắt đầu, đây là danh sách các thư viện và công cụ có thể giúp bạn bắt đầu với việc học máy và AI.

Bạn có thể cắt một danh sách trong Python không?

Có cắt một danh sách tạo ra một đối tượng mới?

Việc cắt có làm đột biến một danh sách?

Là cắt lát bao gồm trong Python?