Lấy cảm hứng từ câu trả lời tuyệt vời của @gnibbler [nhưng terse!], Chúng tôi có thể áp dụng phương pháp đó để bản đồ vào nhiều phân vùng:
from collections import defaultdict
def splitter[l, mapper]:
"""Split an iterable into multiple partitions generated by a callable mapper."""
results = defaultdict[list]
for x in l:
results[mapper[x]] += [x]
return results
Sau đó, splitter sau đó có thể được sử dụng như sau:
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
Điều này hoạt động cho hơn hai phân vùng với ánh xạ phức tạp hơn [và trên các trình lặp cũng vậy]:
>>> import math
>>> l = xrange[1, 23]
>>> split = splitter[l, lambda x: int[math.log10[x] * 5]]
>>> split.items[]
[[0, [1]],
[1, [2]],
[2, [3]],
[3, [4, 5, 6]],
[4, [7, 8, 9]],
[5, [10, 11, 12, 13, 14, 15]],
[6, [16, 17, 18, 19, 20, 21, 22]]]
Hoặc sử dụng từ điển để lập bản đồ:
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
Xem thảo luận
Cải thiện bài viết
Lưu bài viết
Xem thảo luận
Cải thiện bài viết
Lưu bài viết
Đọc
Bàn luận
Đưa ra một danh sách [có thể chứa chuỗi hoặc số], nhiệm vụ là chia danh sách theo một số giá trị thành hai danh sách. Cách tiếp cận rất đơn giản. Chia nửa đầu tiên của danh sách theo giá trị đã cho và nửa thứ hai từ cùng một giá trị. Có nhiều biến thể có thể từ hoạt động này dựa trên yêu cầu, như bỏ [các] phần tử đầu tiên/một số yếu tố trong nửa sau sau giá trị phân chia, v.v. Hãy để xem các cách khác nhau mà chúng ta có thể thực hiện nhiệm vụ này. & NBSP; & NBSP;
Phương pháp số 1: Sử dụng List Index & NBSP;
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]0
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]2
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]5
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]6
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]7
Các
['Geeks'] ['is a', 'portal', 'for Geeks']7
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
['Geeks'] ['is a', 'portal', 'for Geeks']9
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]5
['Geeks'] ['is a', 'portal', 'for Geeks']1
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]7
Các
['Geeks'] ['is a', 'portal', 'for Geeks']3
splitter2['Geeks'] ['is a', 'portal', 'for Geeks']1
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
zip[] + slicing + enumerate[]4 >>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
zip[] + slicing + enumerate[]7Đầu ra:
The original list : [1, 4, 5, 6, 4, 5, 6, 5, 4] The list after splitting by a value : [[1, 4, 5], [6, 4, 5], [6, 5], [4]]
Xem thảo luận
Cải thiện bài viết
Lưu bài viết
Xem thảo luận
Cải thiện bài viết
Lưu bài viết
Đọc
The approach is very simple.
Split the first half of list by given value, and second half from the same value. There are multiple variations possible from this operation based on the requirement, like dropping the first/some element[s] in second half after the split value etc. Let’s see the different ways we can do this task.
Bàn luận
Python3
Đưa ra một danh sách [có thể chứa chuỗi hoặc số], nhiệm vụ là chia danh sách theo một số giá trị thành hai danh sách. Cách tiếp cận rất đơn giản. Chia nửa đầu tiên của danh sách theo giá trị đã cho và nửa thứ hai từ cùng một giá trị. Có nhiều biến thể có thể từ hoạt động này dựa trên yêu cầu, như bỏ [các] phần tử đầu tiên/một số yếu tố trong nửa sau sau giá trị phân chia, v.v. Hãy để xem các cách khác nhau mà chúng ta có thể thực hiện nhiệm vụ này. & NBSP; & NBSP;
Phương pháp số 1: Sử dụng List Index & NBSP;
Is
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
Output:
['Geeks'] ['is a', 'portal', 'for Geeks']
Is
Python3
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
zip[] + slicing + enumerate[]8>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
zip[] + slicing + enumerate[]8>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
test_list 3>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
Phương pháp số 2: Sử dụng Dropwhile và Set & NBSP;
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
zip[] + slicing + enumerate[]8>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
Is
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
test_list 3>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
zip[] + slicing + enumerate[]8>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
>>> map = {'A': 1, 'X': 2, 'B': 3, 'Y': 1, 'C': 2, 'Z': 3}
>>> l = ['A', 'B', 'C', 'C', 'X', 'Y', 'Z', 'A', 'Z']
>>> split = splitter[l, map.get]
>>> split.items[]
[1, ['A', 'Y', 'A']], [2, ['C', 'C', 'X']], [3, ['B', 'Z', 'Z']]]
>>> l = [1, 2, 3, 4, 2, 3, 4, 5, 6, 4, 3, 2, 3]
>>> split = splitter[l, lambda x: x % 2 == 0] # partition l into odds and evens
>>> split.items[]
>>> [[False, [1, 3, 3, 5, 3, 3]], [True, [2, 4, 2, 4, 6, 4, 2]]]
Output:
['Geeks'] ['is a', 'portal', 'for Geeks']
Làm thế nào để bạn tách các mục trong một danh sách?
Thông thường, chúng tôi sử dụng dấu phẩy để tách ba mục trở lên trong danh sách. Tuy nhiên, nếu một hoặc nhiều trong số các mục này chứa dấu phẩy, thì bạn nên sử dụng dấu chấm phẩy, thay vì dấu phẩy, để tách các mục và tránh sự nhầm lẫn tiềm năng.if one or more of these items contain commas, then you should use a semicolon, instead of a comma, to separate the items and avoid potential confusion.
Làm thế nào để bạn chia một danh sách trong ví dụ Python?
Ví dụ 1: Sử dụng năng suất trả về các khối bằng năng suất.list_a [i: i+chunk_size] cho mỗi khối.Ví dụ: khi i = 0, các mục được bao gồm trong đoạn là i đến i + chunk_size là 0 đến [0 + 2] chỉ số th.Trong lần lặp tiếp theo, các mục được bao gồm là 2 đến 2 + 2 = 4.list_a[i:i+chunk_size] gives each chunk. For example, when i = 0 , the items included in the chunk are i to i + chunk_size which is 0 to [0 + 2]th index. In the next iteration, the items included are 2 to 2 + 2 = 4 .
Làm thế nào để bạn chia một danh sách thành hai phần bằng nhau trong Python?
Điều này có thể được thực hiện bằng các bước sau:..
Nhận độ dài của một danh sách bằng hàm Len [] ..
Nếu độ dài của các bộ phận không được đưa ra, thì hãy chia độ dài của danh sách cho 2 bằng toán tử sàn để lấy chỉ số giữa của danh sách ..
Cắt danh sách thành hai nửa bằng cách sử dụng [: middle_index] và [middle_index:].
Làm thế nào để bạn cắt một danh sách trong Python?
Để cắt tại chỗ, hãy sử dụng del trên một lát cắt;ví dụ.del listobj [-x:] sẽ xóa các phần tử x cuối cùng khỏi đối tượng danh sách.use del on a slice; e.g. del listobj[-x:] will remove the last x elements from the list object.