Cách nối các phần tử của danh sách trong Python

Các trường hợp cạnh dưới đây tốt hơn trong một số trường hợp, nhưng

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Kết hợp các danh sách tại chỗ trong Python

Vấn đề. Bạn có một danh sách lớn và bạn muốn thêm một danh sách nhỏ hơn vào cuối trong khi giảm thiểu việc sử dụng bộ nhớ

Trong trường hợp này, tốt nhất bạn nên thêm vào danh sách hiện có, sử dụng lại danh sách đó thay vì tạo lại danh sách mới

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Như với bất kỳ tối ưu hóa nào, bạn nên xác minh rằng điều này làm giảm sự cố bộ nhớ trong trường hợp cụ thể của bạn và tuân theo thành ngữ đơn giản

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Hãy sử dụng mô-đun

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

Trong ví dụ này, trong đó x là 3000 phần tử, phần mở rộng nhanh hơn khoảng 50 lần

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

>>> x = ["one" * 1000, "two" * 1000, "three" * 1000]
>>> y = ["four" * 1000, "five" * 1000]
>>> #This is fine
>>> z = x + y
>>> #Performance Testing [extend is slower for large elements]
>>>  setup = """\
x = ["one" * 1000, "two" * 1000, "three" * 1000]
y = ["four" * 1000, "five" * 1000]
"""
>>> timeit.timeit['x + y', setup=setup, number=1000000]
0.05397573999994165
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06511967799997365

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

Tránh chuỗi từ

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

2 cho hai danh sách

Có thể sử dụng

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Chúng tôi có thể kiểm tra hiệu suất của việc sử dụng chuỗi

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Sử dụng

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Kết hợp N Danh sách trong Python

Nếu bạn cần thêm ba hoặc thậm chí mười danh sách lại với nhau và các danh sách này được biết tĩnh, thì

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Làm phẳng một danh sách các danh sách trong Python

Tuy nhiên, nếu số lượng danh sách là động và không xác định cho đến thời gian chạy, thì

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Hiệu suất làm phẳng một danh sách các danh sách

Hiệu suất không phải lúc nào cũng quan trọng, nhưng khả năng đọc luôn quan trọng và phương pháp chuỗi là một cách đơn giản để kết hợp danh sách các danh sách. Điều đó nói rằng, hãy tạm gác khả năng đọc sang một bên và cố gắng tìm cách nhanh nhất để làm phẳng danh sách

Một lựa chọn là lặp đi lặp lại chính chúng ta

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Hãy kiểm tra hiệu suất của nó so với chuỗi

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Điều này cho thấy rằng

>>> x = ["one" * 1000, "two" * 1000, "three" * 1000]
>>> y = ["four" * 1000, "five" * 1000]
>>> #This is fine
>>> z = x + y
>>> #Performance Testing [extend is slower for large elements]
>>>  setup = """\
x = ["one" * 1000, "two" * 1000, "three" * 1000]
y = ["four" * 1000, "five" * 1000]
"""
>>> timeit.timeit['x + y', setup=setup, number=1000000]
0.05397573999994165
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06511967799997365

Làm phẳng và hợp nhất danh sách với một danh sách lớn

Điều gì về việc thêm một danh sách các danh sách vào một danh sách lớn hiện có?

Đầu tiên, chúng tôi sử dụng tiêu chuẩn của chúng tôi

>>> x = ["one" * 1000, "two" * 1000, "three" * 1000]
>>> y = ["four" * 1000, "five" * 1000]
>>> #This is fine
>>> z = x + y
>>> #Performance Testing [extend is slower for large elements]
>>>  setup = """\
x = ["one" * 1000, "two" * 1000, "three" * 1000]
y = ["four" * 1000, "five" * 1000]
"""
>>> timeit.timeit['x + y', setup=setup, number=1000000]
0.05397573999994165
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06511967799997365

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Sau đó chúng tôi kiểm tra hiệu suất của nó

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Tiếp theo, hãy thử nối bằng cách thêm mọi thứ vào danh sách dài

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Kiểm tra hiệu suất

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

Vậy là xong,

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

# Performance Check
>>> setup = """\
x = ["one","two","three"] * 1000 
y = ["four","five","six"]
"""
# x + y with large x
>>> timeit.timeit['x + y', setup=setup, number=1000000]
3.6260274310000113
# x.extend[y] with large x
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06857255800002804

Tóm lược

Đây là những biến thể chính của việc kết hợp danh sách trong python. Sử dụng bảng này để hướng dẫn bạn trong tương lai

Ngoài ra, nếu bạn đang tìm kiếm một cách hay để chuẩn hóa các quy trình xung quanh dự án python của mình – chạy thử nghiệm, cài đặt phần phụ thuộc và mã linting – hãy xem Earthly for Repeatable Builds

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]

>>> x = ["one" * 1000, "two" * 1000, "three" * 1000]
>>> y = ["four" * 1000, "five" * 1000]
>>> #This is fine
>>> z = x + y
>>> #Performance Testing [extend is slower for large elements]
>>>  setup = """\
x = ["one" * 1000, "two" * 1000, "three" * 1000]
y = ["four" * 1000, "five" * 1000]
"""
>>> timeit.timeit['x + y', setup=setup, number=1000000]
0.05397573999994165
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06511967799997365

>>> x = ["one" * 1000, "two" * 1000, "three" * 1000]
>>> y = ["four" * 1000, "five" * 1000]
>>> #This is fine
>>> z = x + y
>>> #Performance Testing [extend is slower for large elements]
>>>  setup = """\
x = ["one" * 1000, "two" * 1000, "three" * 1000]
y = ["four" * 1000, "five" * 1000]
"""
>>> timeit.timeit['x + y', setup=setup, number=1000000]
0.05397573999994165
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06511967799997365

>>> x = ["one" * 1000, "two" * 1000, "three" * 1000]
>>> y = ["four" * 1000, "five" * 1000]
>>> #This is fine
>>> z = x + y
>>> #Performance Testing [extend is slower for large elements]
>>>  setup = """\
x = ["one" * 1000, "two" * 1000, "three" * 1000]
y = ["four" * 1000, "five" * 1000]
"""
>>> timeit.timeit['x + y', setup=setup, number=1000000]
0.05397573999994165
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06511967799997365

>>> x = ["one" * 1000, "two" * 1000, "three" * 1000]
>>> y = ["four" * 1000, "five" * 1000]
>>> #This is fine
>>> z = x + y
>>> #Performance Testing [extend is slower for large elements]
>>>  setup = """\
x = ["one" * 1000, "two" * 1000, "three" * 1000]
y = ["four" * 1000, "five" * 1000]
"""
>>> timeit.timeit['x + y', setup=setup, number=1000000]
0.05397573999994165
>>> timeit.timeit['x.extend[y]', setup=setup, number=1000000]
0.06511967799997365

>>>longlist = ["one","two", "three"] * 1000
['one', 'two', 'three', 'one', 'two', 'three', .. ]
>>>shortlist = ["four","five"]
["four","five"]
>>> x.extend[y]
>>> x
['one', 'two', 'three', 'one',  ..., "four","five"]