Câu hỏi Tạo danh sách phẳng ra khỏi danh sách các danh sách bằng Python


Tôi tự hỏi liệu có một phím tắt để thực hiện một danh sách đơn giản ra khỏi danh sách các danh sách trong Python.

Tôi có thể làm điều đó trong một vòng lặp for, nhưng có lẽ có một số mát mẻ "một lớp lót"? Tôi đã thử nó với giảmnhưng tôi gặp lỗi.

Mã số

l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
reduce(lambda x, y: x.extend(y), l)

Thông báo lỗi

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <lambda>
AttributeError: 'NoneType' object has no attribute 'extend'

2083
2018-06-04 20:30


gốc


Có một cuộc thảo luận chuyên sâu về điều này ở đây: rightfootin.blogspot.com/2006/09/more-on-python-flatten.html, thảo luận một số phương pháp làm phẳng danh sách danh sách lồng nhau tùy ý. Một điều thú vị! - RichieHindle
Một số câu trả lời khác là tốt hơn nhưng lý do của bạn không thành công là phương pháp 'mở rộng' luôn trả về Không. Đối với một danh sách có độ dài 2, nó sẽ hoạt động nhưng trả về Không. Đối với một danh sách dài hơn, nó sẽ tiêu thụ 2 arg đầu tiên, trả về None. Sau đó nó tiếp tục với None.extend (<third arg>), gây ra lỗi này - mehtunguh
@ shawn-chin giải pháp là pythonic hơn ở đây, nhưng nếu bạn cần phải bảo tồn các loại chuỗi, nói rằng bạn có một bộ tuple hơn là một danh sách các danh sách, sau đó bạn nên sử dụng giảm (operator.concat, tuple_of_tuples). Sử dụng operator.concat với tuples dường như thực hiện nhanh hơn chain.from_iterables với danh sách. - Meitham
numpy.array ([[1], [2]]). flatten (). tolist (), loại bỏ cấu trúc bên trong và trả về danh sách [1,2] - user5920660
Hiện được hỗ trợ bởi mpu: import mpu; mpu.datastructures.flatten([1, [2, 3], [4, [5, 6]]]) cho [1, 2, 3, 4, 5, 6] - Martin Thoma


Các câu trả lời:


flat_list = [item for sublist in l for item in sublist]

nghĩa là:

for sublist in l:
    for item in sublist:
        flat_list.append(item)

nhanh hơn các phím tắt được đăng cho đến thời điểm này. (l là danh sách để làm phẳng.)

Đây là một hàm tương ứng:

flatten = lambda l: [item for sublist in l for item in sublist]

Đối với bằng chứng, như mọi khi, bạn có thể sử dụng timeit mô-đun trong thư viện chuẩn:

$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' '[item for sublist in l for item in sublist]'
10000 loops, best of 3: 143 usec per loop
$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'sum(l, [])'
1000 loops, best of 3: 969 usec per loop
$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'reduce(lambda x,y: x+y,l)'
1000 loops, best of 3: 1.1 msec per loop

Giải thích: các phím tắt dựa trên + (bao gồm cả việc sử dụng ngụ ý trong sum), là cần thiết, O(L**2) khi có L danh sách con - vì danh sách kết quả trung gian tiếp tục nhận được lâu hơn, ở mỗi bước, một đối tượng danh sách kết quả trung gian mới được cấp phát và tất cả các mục trong kết quả trung gian trước đó phải được sao chép (cũng như một số mới được thêm vào) cuối cùng). Vì vậy, (để đơn giản và không mất tính tổng quát) nói rằng bạn có L danh sách con của mỗi mục I: các mục I đầu tiên được sao chép qua lại L-1 lần, mục thứ hai tôi L-2 lần, v.v. tổng số bản sao là tổng số lần x cho x từ 1 đến L bị loại trừ, tức là, I * (L**2)/2.

Việc hiểu danh sách chỉ tạo ra một danh sách, một lần và sao chép từng mục trên (từ nơi cư trú ban đầu của nó đến danh sách kết quả) cũng chính xác một lần.


3001
2018-06-04 20:37



Tôi đã thử một thử nghiệm với cùng một dữ liệu, sử dụng itertools.chain.from_iterable: $ python -mtimeit -s'from itertools import chain; l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'list(chain.from_iterable(l))'. Nó chạy nhanh hơn hai lần so với khả năng hiểu danh sách lồng nhau, đó là tốc độ nhanh nhất của các lựa chọn thay thế được hiển thị ở đây. - intuited
Tôi thấy cú pháp khó hiểu cho đến khi tôi nhận ra bạn có thể nghĩ về cú pháp chính xác như lồng nhau cho các vòng lặp. cho danh sách con trong l: cho mục trong danh sách con: mục lợi nhuận - Rob Crowell
@BorisChervenkov: Lưu ý rằng tôi đã thực hiện cuộc gọi list() để nhận ra trình vòng lặp vào danh sách. - intuited
[lá cho cây trong rừng cho lá trong cây] có thể dễ dàng hơn để hiểu và áp dụng. - John Mee
@ Jelel, thực sự ngày nay list(itertools.chain.from_iterable(l)) là tốt nhất - như nhận thấy trong các bình luận khác và câu trả lời của Shawn. - Alex Martelli


Bạn có thể dùng itertools.chain():

>>> import itertools
>>> list2d = [[1,2,3],[4,5,6], [7], [8,9]]
>>> merged = list(itertools.chain(*list2d))

hoặc, trên Python> = 2.6, sử dụng itertools.chain.from_iterable() không yêu cầu giải nén danh sách:

>>> import itertools
>>> list2d = [[1,2,3],[4,5,6], [7], [8,9]]
>>> merged = list(itertools.chain.from_iterable(list2d))

Cách tiếp cận này được cho là dễ đọc hơn [item for sublist in l for item in sublist] và dường như cũng nhanh hơn:

[me@home]$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99;import itertools' 'list(itertools.chain.from_iterable(l))'
10000 loops, best of 3: 24.2 usec per loop
[me@home]$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' '[item for sublist in l for item in sublist]'
10000 loops, best of 3: 45.2 usec per loop
[me@home]$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'sum(l, [])'
1000 loops, best of 3: 488 usec per loop
[me@home]$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'reduce(lambda x,y: x+y,l)'
1000 loops, best of 3: 522 usec per loop
[me@home]$ python --version
Python 2.7.3

1083
2018-06-04 21:06



@ShawnChin BTW, phần cứng bạn có khi trả lời câu hỏi này, máy trạm hiện tại của tôi nhanh gấp đôi và được 4 năm. - Manuel Gutierrez
@alexandre see docs.python.org/2/tutorial/… - Shawn Chin
Các * là điều phức tạp khiến chain ít đơn giản hơn so với việc hiểu danh sách. Bạn phải biết rằng chuỗi chỉ tham gia cùng nhau các iterables được truyền dưới dạng tham số và * làm cho danh sách cấp cao nhất được mở rộng thành các tham số, vì vậy chain tham gia cùng với tất cả các vòng lặp đó, nhưng không đi sâu hơn nữa. Tôi nghĩ điều này làm cho việc đọc hiểu dễ đọc hơn là sử dụng chuỗi trong trường hợp này. - Tim Dierks
@ TimDierks: Tôi không chắc chắn "điều này đòi hỏi bạn phải hiểu cú pháp Python" là một đối số chống lại bằng cách sử dụng một kỹ thuật nhất định trong Python. Chắc chắn, việc sử dụng phức tạp có thể gây nhầm lẫn, nhưng toán tử "splat" thường hữu ích trong nhiều trường hợp, và điều này không sử dụng nó theo cách đặc biệt tối nghĩa; từ chối tất cả các tính năng ngôn ngữ không nhất thiết phải rõ ràng đối với người dùng bắt đầu nghĩa là bạn đang buộc một tay sau lưng. Có thể cũng ném ra danh sách comprehensions quá trong khi bạn đang ở đó; người dùng từ các nền tảng khác sẽ tìm thấy for lặp đi lặp lại appendrõ ràng hơn. - ShadowRanger
Thế còn ['abcde_', ['_abcde', ['e_abcd', ['de_abc', ['cde_ab', ['bcde_a']]]]]] - Aymon Fournier


Ghi chú từ tác giả: Điều này không hiệu quả. Nhưng vui vẻ, bởi vì monads là tuyệt vời. Nó không thích hợp để sản xuất mã Python.

>>> sum(l, [])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Điều này chỉ tổng hợp các phần tử của iterable được truyền trong đối số đầu tiên, xử lý đối số thứ hai làm giá trị ban đầu của tổng (nếu không được đưa ra, 0 được sử dụng thay thế và trường hợp này sẽ cho bạn một lỗi).

Bởi vì bạn đang tổng hợp danh sách lồng nhau, bạn thực sự nhận được [1,3]+[2,4] la kêt quả của sum([[1,3],[2,4]],[]), bằng với [1,3,2,4].

Lưu ý rằng chỉ hoạt động trên danh sách các danh sách. Đối với danh sách danh sách các danh sách, bạn sẽ cần một giải pháp khác.


638
2018-06-04 20:35



đó là khá gọn gàng và thông minh nhưng tôi sẽ không sử dụng nó bởi vì nó khó hiểu để đọc. - andrewrk
Đây là thuật toán Shlemiel của họa sĩ joelonsoftware.com/articles/fog0000000319.html - không cần thiết không hiệu quả cũng như không cần thiết xấu xí. - Mike Graham
Hoạt động nối thêm trên danh sách tạo thành Monoid, đó là một trong những cách trừu tượng thuận tiện nhất để suy nghĩ về + hoạt động theo nghĩa chung (không chỉ giới hạn ở các số). Vì vậy, câu trả lời này xứng đáng được +1 từ tôi để xử lý các danh sách như một monoid (chính xác). Hiệu suất là liên quan mặc dù ... - ulidtko
@andrewrk Vâng, một số người nghĩ rằng đây là cách sạch nhất để làm điều đó: youtube.com/watch?v=IOiZatlZtGU những người không nhận được lý do tại sao điều này là mát mẻ chỉ cần chờ một vài thập kỷ cho đến khi mọi người làm theo cách này :) hãy sử dụng ngôn ngữ lập trình (và trừu tượng) được phát hiện và không phát minh ra, Monoid được phát hiện. - jhegedus
đây là một cách rất không hiệu quả vì khía cạnh bậc hai của tổng. - Jean-François Fabre


Tôi đã thử nghiệm hầu hết các giải pháp được đề xuất với perfplot (một dự án thú cưng của tôi, về cơ bản là một gói bao quanh timeit), và tìm thấy

list(itertools.chain.from_iterable(a))

là giải pháp nhanh nhất (nếu có nhiều hơn 10 danh sách được nối).

enter image description here


Mã để tái tạo cốt truyện:

import functools
import itertools
import numpy
import operator
import perfplot


def forfor(a):
    return [item for sublist in a for item in sublist]


def sum_brackets(a):
    return sum(a, [])


def functools_reduce(a):
    return functools.reduce(operator.concat, a)


def itertools_chain(a):
    return list(itertools.chain.from_iterable(a))


def numpy_flat(a):
    return list(numpy.array(a).flat)


def numpy_concatenate(a):
    return list(numpy.concatenate(a))


perfplot.show(
    setup=lambda n: [list(range(10))] * n,
    kernels=[
        forfor, sum_brackets, functools_reduce, itertools_chain, numpy_flat,
        numpy_concatenate
        ],
    n_range=[2**k for k in range(16)],
    logx=True,
    logy=True,
    xlabel='num lists'
    )

131
2017-07-26 09:38





from functools import reduce #python 3

>>> l = [[1,2,3],[4,5,6], [7], [8,9]]
>>> reduce(lambda x,y: x+y,l)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Các extend() phương pháp trong ví dụ của bạn sửa đổi x thay vì trả về một giá trị hữu ích (mà reduce() mong đợi).

Cách nhanh hơn để thực hiện reduce phiên bản sẽ là

>>> import operator
>>> l = [[1,2,3],[4,5,6], [7], [8,9]]
>>> reduce(operator.concat, l)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

100
2018-06-04 20:35



reduce(operator.add, l) sẽ là cách chính xác để thực hiện reduce phiên bản. Built-in nhanh hơn lambdas. - agf
@agf đây là cách thực hiện: * timeit.timeit('reduce(operator.add, l)', 'import operator; l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]', number=10000)  0,017956018447875977   * timeit.timeit('reduce(lambda x, y: x+y, l)', 'import operator; l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]', number=10000)  0,025218963623046875 - lukmdo
Đây là một thuật toán Shlemiel của họa sĩ joelonsoftware.com/articles/fog0000000319.html - Mike Graham
điều này chỉ có thể sử dụng cho integers. Nhưng nếu danh sách chứa string? - Freddy
@Freddy: The operator.add chức năng hoạt động tốt cho cả hai danh sách các số nguyên và danh sách các chuỗi. - Greg Hewgill


Đây là một cách tiếp cận chung áp dụng cho số, dây, lồng nhau danh sách và hỗn hợp hộp đựng.

Mã số

from collections import Iterable


def flatten(items):
    """Yield items from any nested iterable; see Reference."""
    for x in items:
        if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
            for sub_x in flatten(x):
                yield sub_x
        else:
            yield x

Lưu ý: trong Python 3, yield from flatten(x) có thể thay thế for sub_x in flatten(x): yield sub_x

Bản giới thiệu

lst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(flatten(lst))                                         # nested lists
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

mixed = [[1, [2]], (3, 4, {5, 6}, 7), 8, "9"]              # numbers, strs, nested & mixed
list(flatten(mixed))
# [1, 2, 3, 4, 5, 6, 7, 8, '9']

Tài liệu tham khảo

  • Giải pháp này được sửa đổi từ một công thức trong Beazley, D. và B. Jones. Công thức 4.14, Python Cookbook 3rd Ed., O'Reilly Media Inc. Sebastopol, CA: 2013.
  • Tìm thấy sớm hơn SO bài đăng, có thể là bản trình diễn gốc.

55
2017-11-29 04:14



Tôi chỉ viết khá nhiều như nhau, bởi vì tôi không thấy giải pháp của bạn ... đây là những gì tôi tìm kiếm "đệ quy san phẳng hoàn thành nhiều danh sách" ... (+1) - Martin Thoma
@MartinThoma Nhiều đánh giá cao. FYI, nếu làm phẳng vòng lặp lồng nhau là một thực tế phổ biến cho bạn, có một số gói của bên thứ ba xử lý tốt. Điều này có thể tiết kiệm từ việc phát minh lại bánh xe. Tôi đã đề cập more_itertools trong số những người khác được thảo luận trong bài đăng này. Chúc mừng. - pylang
Nice - chỉ tự hỏi về một yield from loại xây dựng trên trăn sau khi tìm hiểu về yield * trong năm 2015. - Triptych
thay thế bởi if isinstance(el, collections.Iterable) and not isinstance(el, (str, bytes)): để hỗ trợ chuỗi. - Jorge Leitão
Chính xác. Công thức nấu ăn ban đầu thực sự cho thấy cách hỗ trợ chuỗi và byte. Nếu đã chỉnh sửa nó để phản ánh sự hỗ trợ này. - pylang


Tôi lấy lại lời tuyên bố của tôi. tổng không phải là người chiến thắng. Mặc dù nó nhanh hơn khi danh sách nhỏ. Nhưng hiệu suất giảm đáng kể với các danh sách lớn hơn. 

>>> timeit.Timer(
        '[item for sublist in l for item in sublist]',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10000'
    ).timeit(100)
2.0440959930419922

Phiên bản tổng số vẫn chạy trong hơn một phút và chưa xử lý xong!

Đối với danh sách trung bình:

>>> timeit.Timer(
        '[item for sublist in l for item in sublist]',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10'
    ).timeit()
20.126545906066895
>>> timeit.Timer(
        'reduce(lambda x,y: x+y,l)',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10'
    ).timeit()
22.242258071899414
>>> timeit.Timer(
        'sum(l, [])',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10'
    ).timeit()
16.449732065200806

Sử dụng danh sách nhỏ và thời gian chờ: số = 1000000

>>> timeit.Timer(
        '[item for sublist in l for item in sublist]',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]'
    ).timeit()
2.4598159790039062
>>> timeit.Timer(
        'reduce(lambda x,y: x+y,l)',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]'
    ).timeit()
1.5289170742034912
>>> timeit.Timer(
        'sum(l, [])',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]'
    ).timeit()
1.0598428249359131

31
2018-06-04 20:46



cho một danh sách rất nhỏ gọn, ví dụ: một với 3 danh sách con, có thể - nhưng vì hiệu suất của tổng đi với O (N ** 2) trong khi danh sách hiểu được đi với O (N), chỉ cần tăng danh sách đầu vào một chút sẽ đảo ngược mọi thứ - thực sự LC sẽ là " vô hạn nhanh hơn "tổng số tại giới hạn khi N tăng lên. Tôi chịu trách nhiệm thiết kế tổng hợp và thực hiện lần đầu tiên trong thời gian chạy Python, và tôi vẫn ước tôi đã tìm ra cách để hạn chế hiệu quả số tổng hợp (những gì nó thực sự tốt) và chặn "phiền toái hấp dẫn" mà nó cung cấp cho mọi người những người muốn "tổng hợp" danh sách ;-). - Alex Martelli


Tại sao bạn sử dụng mở rộng?

reduce(lambda x, y: x+y, l)

Điều này sẽ làm việc tốt.


25
2018-06-04 20:38



Điều này có thể tạo ra nhiều, nhiều, danh sách trung gian. - Reut Sharabani
cho python3 from functools import reduce - andorov
Xin lỗi, thật chậm khi thấy phần còn lại của câu trả lời - Mr_and_Mrs_D


Dường như có sự nhầm lẫn với operator.add! Khi bạn thêm hai danh sách cùng nhau, cụm từ chính xác cho danh sách đó là concat, không thêm. operator.concat là những gì bạn cần sử dụng.

Nếu bạn đang suy nghĩ chức năng, nó là dễ dàng như thế này ::

>>> list2d = ((1,2,3),(4,5,6), (7,), (8,9))
>>> reduce(operator.concat, list2d)
(1, 2, 3, 4, 5, 6, 7, 8, 9)

Bạn thấy giảm sự tôn trọng kiểu chuỗi, vì vậy khi bạn cung cấp một bộ dữ liệu, bạn lấy lại một bộ dữ liệu. hãy thử với một danh sách ::

>>> list2d = [[1,2,3],[4,5,6], [7], [8,9]]
>>> reduce(operator.concat, list2d)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Aha, bạn lấy lại một danh sách.

Làm thế nào về hiệu suất ::

>>> list2d = [[1,2,3],[4,5,6], [7], [8,9]]
>>> %timeit list(itertools.chain.from_iterable(list2d))
1000000 loops, best of 3: 1.36 µs per loop

from_iterable là khá nhanh! Nhưng nó không so sánh để giảm với concat.

>>> list2d = ((1,2,3),(4,5,6), (7,), (8,9))
>>> %timeit reduce(operator.concat, list2d)
1000000 loops, best of 3: 492 ns per loop

19
2017-09-14 15:09



Hmm để được công bằng ví dụ thứ hai nên được danh sách cũng (hoặc đầu tiên tuple?) - Mr_and_Mrs_D


Nếu bạn muốn làm phẳng cấu trúc dữ liệu mà bạn không biết nó lồng vào nhau sâu đến mức nào, bạn có thể sử dụng iteration_utilities.deepflatten1

>>> from iteration_utilities import deepflatten

>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> list(deepflatten(l, depth=1))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> l = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
>>> list(deepflatten(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Đó là một máy phát điện, do đó bạn cần phải đưa kết quả vào list hoặc lặp lại một cách rõ ràng.


Để làm phẳng chỉ một cấp và nếu mỗi mục trong số đó có thể lặp lại, bạn cũng có thể sử dụng iteration_utilities.flatten mà chính nó chỉ là một bao bọc mỏng xung quanh itertools.chain.from_iterable:

>>> from iteration_utilities import flatten
>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> list(flatten(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Chỉ cần thêm một số timings (dựa trên câu trả lời Nico Schlömer không bao gồm hàm được trình bày trong câu trả lời này):

enter image description here

Đó là một âm mưu log-log để phù hợp với phạm vi rộng lớn của các giá trị kéo dài. Đối với lý luận định tính: Hạ thấp hơn.

Kết quả cho thấy rằng nếu iterable chỉ chứa một vài iterables bên trong thì sum sẽ nhanh nhất, tuy nhiên đối với các lần lặp lại dài thì chỉ itertools.chain.from_iterable, iteration_utilities.deepflatten hoặc hiểu được lồng nhau có hiệu suất hợp lý với itertools.chain.from_iterable là nhanh nhất (như đã được nhận thấy bởi Nico Schlömer).

from itertools import chain
from functools import reduce
from collections import Iterable  # or from collections.abc import Iterable
import operator
from iteration_utilities import deepflatten

def nested_list_comprehension(lsts):
    return [item for sublist in lsts for item in sublist]

def itertools_chain_from_iterable(lsts):
    return list(chain.from_iterable(lsts))

def pythons_sum(lsts):
    return sum(lsts, [])

def reduce_add(lsts):
    return reduce(lambda x, y: x + y, lsts)

def pylangs_flatten(lsts):
    return list(flatten(lsts))

def flatten(items):
    """Yield items from any nested iterable; see REF."""
    for x in items:
        if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
            yield from flatten(x)
        else:
            yield x

def reduce_concat(lsts):
    return reduce(operator.concat, lsts)

def iteration_utilities_deepflatten(lsts):
    return list(deepflatten(lsts, depth=1))


from simple_benchmark import benchmark

b = benchmark(
    [nested_list_comprehension, itertools_chain_from_iterable, pythons_sum, reduce_add,
     pylangs_flatten, reduce_concat, iteration_utilities_deepflatten],
    arguments={2**i: [[0]*5]*(2**i) for i in range(1, 13)},
    argument_name='number of inner lists'
)

b.plot()

1 Tuyên bố từ chối trách nhiệm: Tôi là tác giả của thư viện đó


17
2017-11-26 00:20



sum không còn hoạt động trên các chuỗi tùy ý khi nó bắt đầu bằng 0, chế tạo functools.reduce(operator.add, sequences) sự thay thế (chúng tôi không vui vì họ đã xóa reduce từ nội trang?). Khi các loại được biết, nó có thể nhanh hơn để sử dụng type.__add__. - Yann Vernier
@YannVernier Cảm ơn thông tin. Tôi nghĩ rằng tôi đã chạy các điểm chuẩn này trên Python 3.6 và nó đã làm việc với sum. Bạn có biết được phiên bản Python nào ngừng hoạt động không? - MSeifert
Tôi đã phần nào nhầm lẫn. 0 chỉ là giá trị bắt đầu mặc định, do đó, nó hoạt động nếu một giá trị sử dụng bắt đầu lập luận để bắt đầu với một danh sách trống ... nhưng nó vẫn là các trường hợp đặc biệt và yêu cầu tôi sử dụng phép nối. Nó đang thực hiện foldl thay vì foldl1. Vấn đề tương tự bật lên ở 2.7. - Yann Vernier