Hướng dẫn is join faster than concatenation python? - tham gia có nhanh hơn liên kết python không?

Question

Có lẽ tất cả những người đã sử dụng Python trong một thời gian đều gặp phải gợi ý hiệu suất cổ điển này: Thay vì kết hợp nhiều chuỗi từng chuỗi, hãy tạo một chuỗi các chuỗi như vậy và sau đó tham gia với họ.

Nội dung chính Show

Bên trong mã nguồn
Sự kết luận
Chuỗi phân tách
Chia tách mà không có thông số
Điều đầu tiên cần chú ý là điều này thể hiện tính bất biến của các chuỗi trong Python: các cuộc gọi tiếp theo đến PyObject * PyUnicode_Concat(PyObject *left, PyObject *right) 4 hoạt động trên chuỗi ban đầu, không phải trong danh sách kết quả của cuộc gọi đầu tiên đến PyObject * PyUnicode_Concat(PyObject *left, PyObject *right) 4.
maxchar = PyUnicode_MAX_CHAR_VALUE(u); maxchar2 = PyUnicode_MAX_CHAR_VALUE(v); maxchar = MAX_MAXCHAR(maxchar, maxchar2); /* Concat the two Unicode strings */ w = PyUnicode_New(new_len, maxchar); 5, mặt khác, theo nghĩa đen hơn nhiều. Khi có các dấu phân cách dẫn đầu hoặc theo dõi, bạn sẽ nhận được một chuỗi trống, mà bạn có thể thấy trong các yếu tố đầu tiên và cuối cùng của danh sách kết quả.
Đầu ra của bạn phải là một danh sách các danh sách:
Kết hợp với nhà điều hành res = PyUnicode_New(sz, maxchar); 4
Hãy nhớ rằng, chuỗi là bất biến! Nếu bạn kết hợp hoặc lặp lại một chuỗi được lưu trữ trong một biến, bạn sẽ phải gán chuỗi mới cho một biến khác để giữ nó.
Đi từ danh sách đến một chuỗi trong Python với for (i = 0, res_offset = 0; i < seqlen; ++i) { [...] Py_MEMCPY(res_data, sep_data, kind * seplen); // At **row 9618** 0
Concatenation có nhanh hơn tham gia không?
Tham gia nhanh hơn trong Python?
Có phải sự kết hợp chuỗi python có chậm không?
Các chuỗi F có nhanh hơn so với cách ghép không?

Rằng nó, thay vì điều này

s = ""
for x in items:
    s += x

Voi Nó thường tốt hơn để viết một cái gì đó như thế này:

s = "".join(items)

Nhưng tại sao? Hãy để đào một chút bên trong mã nguồn Python, để tiết lộ bí ẩn.

Bên trong mã nguồn

Việc triển khai Python mà tôi đề cập đến là Cpython, trình thông dịch Python tham chiếu được phát triển bởi Guido & Co., Được viết chủ yếu bằng C, và được lưu trữ trên một kho lưu trữ công khai. Tôi sẽ nhắm mục tiêu cụ thể phiên bản 3.3.0: bạn có thể duyệt qua mã nguồn trực tuyến.

Chúng ta cần xem xét việc triển khai các chuỗi Unicode Python. Tệp Unicodectype.c: Bingo!

Chức năng thực hiện các chuỗi kết hợp với toán tử cộng với hàng ở hàng 10619:row 10619:

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

Bên trong chức năng, sau khi bỏ qua rất nhiều kiểm tra và mã thiết lập (quan trọng!)row 10653, there is the core of Python’s string concatenation:

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

Rằng nó: Mỗi khi bạn kết hợp hai chuỗi với toán tử cộng, trình thông dịch Python, phân bổ một số bộ nhớ và sao chép hai chuỗi vào đó, từng chuỗi. Nếu bạn kết hợp rất nhiều chuỗi lớn, thông dịch viên phải phân bổ bộ nhớ rất nhiều lần, đấu vật xung quanh với sự phân mảnh và như vậy. Hành vi này không làm bạn ngạc nhiên: Các đối tượng chuỗi Python, là bất biến, do đó, mỗi lần ghép tạo ra một chuỗi mới thay vì sửa đổi một chuỗi hiện có tại chỗ. Nó cũng không có gì ngạc nhiên khi nhiều chuỗi chuỗi được coi là chậm.

Điều gì về phương pháp tham gia thay thế? Tham gia là một phương thức chuỗi, vì vậy chúng ta có thể tìm thấy nó trong tệp rất giống nhau này, tại hàng 9478:row 9478:

PyObject *
PyUnicode_Join(PyObject *separator, PyObject *seq)

Hàm lặp lại hai lần trên chuỗi chuỗi. Lần lặp đầu tiên tính toán tổng chiều dài của chuỗi được nối (hàng 9568):row 9568):

for (i = 0; i < seqlen; i++)
    [..
    sz += PyUnicode_GET_LENGTH(item);   // At row 9580

Sau đó, tại ROW & NBSP; 9597, hàm phân bổ không gian cho chuỗi được nối:row 9597, the function allocates the space for the joined string:

res = PyUnicode_New(sz, maxchar);

Cuối cùng, có một lần lặp thứ hai sao chép mọi chuỗi trong chuỗi bên trong chuỗi mới được phân bổ (xem tại ROW & NBSP; 9612):row 9612):

for (i = 0, res_offset = 0; i < seqlen; ++i) {
    [...]
    Py_MEMCPY(res_data,
        sep_data,
        kind * seplen);  // At **row 9618**

Sự kết luận

Khi sử dụng phương thức tham gia, Python phân bổ bộ nhớ cho chuỗi được nối chỉ một lần; Nếu bạn nối các chuỗi liên tiếp, thay vào đó, Python phải phân bổ bộ nhớ mới cho mỗi lần ghép. Đoán xem những gì nhanh hơn? 😉

Có một vài đảm bảo trong cuộc sống: cái chết, thuế và lập trình viên cần phải đối phó với các chuỗi. Chuỗi có thể có nhiều hình thức. Chúng có thể là văn bản không cấu trúc, tên người dùng, mô tả sản phẩm, tên cột cơ sở dữ liệu hoặc thực sự bất cứ điều gì khác mà chúng tôi mô tả bằng ngôn ngữ.

Với sự gần như của dữ liệu chuỗi, điều quan trọng là phải thành thạo các công cụ của giao dịch khi nói đến chuỗi. May mắn thay, Python làm cho thao tác chuỗi rất đơn giản, đặc biệt là khi so sánh với các ngôn ngữ khác và thậm chí các phiên bản cũ của Python.

Trong bài viết này, bạn sẽ tìm hiểu một số hoạt động chuỗi cơ bản nhất: chia tách, nối và tham gia. Bạn không chỉ học cách sử dụng các công cụ này, mà bạn sẽ bỏ đi với sự hiểu biết sâu sắc hơn về cách chúng hoạt động dưới mui xe. Not only will you learn how to use these tools, but you will walk away with a deeper understanding of how they work under the hood.

Chuỗi phân tách

Trong Python, các chuỗi được biểu diễn dưới dạng các đối tượng

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

3, điều này là bất biến: điều này có nghĩa là đối tượng được biểu thị trong bộ nhớ không thể được thay đổi trực tiếp. Hai sự thật này có thể giúp bạn học (và sau đó nhớ) cách sử dụng

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4.immutable: this means that the object as represented in memory can not be directly altered. These two facts can help you learn (and then remember) how to use

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4.

Bạn đã đoán làm thế nào hai tính năng của chuỗi liên quan đến chức năng phân tách trong Python? Nếu bạn đoán rằng

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 là một phương thức thể hiện vì chuỗi là một loại đặc biệt, bạn sẽ đúng! Trong một số ngôn ngữ khác (như Perl), chuỗi gốc đóng vai trò là đầu vào cho hàm

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 độc lập chứ không phải là một phương thức được gọi trên chính chuỗi.instance method because strings are a special type, you would be correct! In some other languages (like Perl), the original string serves as an input to a standalone

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 function rather than a method called on the string itself.

Điều gì về tính bất biến chuỗi? Điều này sẽ nhắc nhở bạn rằng các phương thức chuỗi không phải là hoạt động tại chỗ, nhưng chúng trả về một đối tượng mới trong bộ nhớ.in-place operations, but they return a new object in memory.

Chia tách mà không có thông số

Trước khi đi sâu hơn, hãy để Lôi nhìn vào một ví dụ đơn giản:

>>>

>>> 'this is my string'.split()
['this', 'is', 'my', 'string']

Đây thực sự là một trường hợp đặc biệt của một cuộc gọi

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 mà tôi đã chọn cho sự đơn giản của nó. Không có bất kỳ bộ phân cách nào được chỉ định,

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 sẽ đếm bất kỳ khoảng trắng nào làm dấu phân cách.

Một tính năng khác của cuộc gọi trần tới

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 là nó tự động cắt bỏ khoảng trắng hàng đầu và kéo dài, cũng như khoảng trắng liên tiếp. So sánh cuộc gọi

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 trên chuỗi sau mà không có tham số phân tách và với

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

1 làm tham số phân tách:

>>>

>>> s = ' this   is  my string '
>>> s.split()
['this', 'is', 'my', 'string']
>>> s.split(' ')
['', 'this', '', '', 'is', '', 'my', 'string', '']

Đây thực sự là một trường hợp đặc biệt của một cuộc gọi

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 mà tôi đã chọn cho sự đơn giản của nó. Không có bất kỳ bộ phân cách nào được chỉ định,

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 sẽ đếm bất kỳ khoảng trắng nào làm dấu phân cách.

Một tính năng khác của cuộc gọi trần tới

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 là nó tự động cắt bỏ khoảng trắng hàng đầu và kéo dài, cũng như khoảng trắng liên tiếp. So sánh cuộc gọi

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 trên chuỗi sau mà không có tham số phân tách và với

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

1 làm tham số phân tách:

Điều đầu tiên cần chú ý là điều này thể hiện tính bất biến của các chuỗi trong Python: các cuộc gọi tiếp theo đến PyObject * PyUnicode_Concat(PyObject left, PyObject right) 4 hoạt động trên chuỗi ban đầu, không phải trong danh sách kết quả của cuộc gọi đầu tiên đến PyObject * PyUnicode_Concat(PyObject left, PyObject right) 4.

Cái thứ hai và thứ chính mà bạn nên thấy là cuộc gọi trần

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 sẽ trích xuất các từ trong câu và loại bỏ bất kỳ khoảng trắng nào.

Chỉ định phân tách

maxchar = PyUnicode_MAX_CHAR_VALUE(u); maxchar2 = PyUnicode_MAX_CHAR_VALUE(v); maxchar = MAX_MAXCHAR(maxchar, maxchar2); /* Concat the two Unicode strings */ w = PyUnicode_New(new_len, maxchar); 5, mặt khác, theo nghĩa đen hơn nhiều. Khi có các dấu phân cách dẫn đầu hoặc theo dõi, bạn sẽ nhận được một chuỗi trống, mà bạn có thể thấy trong các yếu tố đầu tiên và cuối cùng của danh sách kết quả.

Trường hợp có nhiều bộ phân cách liên tiếp (chẳng hạn như giữa các trò chơi này và và là một trong những người đầu tiên và giữa đó như dây trống.

>>>

s = "".join(items)

0

Đây thực sự là một trường hợp đặc biệt của một cuộc gọi

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 mà tôi đã chọn cho sự đơn giản của nó. Không có bất kỳ bộ phân cách nào được chỉ định,

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 sẽ đếm bất kỳ khoảng trắng nào làm dấu phân cách.

Một tính năng khác của cuộc gọi trần tới

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 là nó tự động cắt bỏ khoảng trắng hàng đầu và kéo dài, cũng như khoảng trắng liên tiếp. So sánh cuộc gọi

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 trên chuỗi sau mà không có tham số phân tách và với

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

1 làm tham số phân tách:

Điều đầu tiên cần chú ý là điều này thể hiện tính bất biến của các chuỗi trong Python: các cuộc gọi tiếp theo đến

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 hoạt động trên chuỗi ban đầu, không phải trong danh sách kết quả của cuộc gọi đầu tiên đến

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4.

Cái thứ hai và thứ chính mà bạn nên thấy là cuộc gọi trần

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 sẽ trích xuất các từ trong câu và loại bỏ bất kỳ khoảng trắng nào.

Chỉ định phân tách

s = "".join(items)

1

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

5, mặt khác, theo nghĩa đen hơn nhiều. Khi có các dấu phân cách dẫn đầu hoặc theo dõi, bạn sẽ nhận được một chuỗi trống, mà bạn có thể thấy trong các yếu tố đầu tiên và cuối cùng của danh sách kết quả.

s = "".join(items)

2

Trường hợp có nhiều bộ phân cách liên tiếp (chẳng hạn như giữa các trò chơi này và và là một trong những người đầu tiên và giữa đó như dây trống.

Hạn chế chia tách với MaxSplit

s = "".join(items)

3

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 có một tham số tùy chọn khác được gọi là

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

7. Theo mặc định,

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 sẽ thực hiện tất cả các chia tách có thể khi được gọi. Tuy nhiên, khi bạn đưa ra một giá trị cho

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

7, chỉ có số lượng chia tách đã cho. Sử dụng chuỗi ví dụ trước của chúng tôi, chúng ta có thể thấy

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

7 trong hành động:

Như bạn thấy ở trên, nếu bạn đặt

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

7 thành

PyObject *
PyUnicode_Join(PyObject *separator, PyObject *seq)

2, vùng trắng đầu tiên được sử dụng làm dấu phân cách và phần còn lại bị bỏ qua. Hãy cùng làm một số bài tập để kiểm tra mọi thứ chúng tôi đã học được cho đến nay.newline character.

Điều gì xảy ra khi bạn đưa ra một số âm dưới dạng tham số

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

7?

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4 sẽ phân chia chuỗi của bạn trên tất cả các dấu phân cách có sẵn, đây cũng là hành vi mặc định khi

maxchar = PyUnicode_MAX_CHAR_VALUE(u);
maxchar2 = PyUnicode_MAX_CHAR_VALUE(v);
maxchar = MAX_MAXCHAR(maxchar, maxchar2);

/* Concat the two Unicode strings */
w = PyUnicode_New(new_len, maxchar);

7 được đặt.

Gần đây bạn đã được trao một tệp giá trị phân tách dấu phẩy (CSV) được định dạng khủng khiếp. Công việc của bạn là trích xuất từng hàng vào một danh sách, với mỗi yếu tố của danh sách đó đại diện cho các cột của tệp đó. Điều gì làm cho nó được định dạng xấu? Trường địa chỉ trên mạng bao gồm nhiều dấu phẩy nhưng cần được thể hiện trong danh sách dưới dạng một yếu tố duy nhất!

Giả sử rằng tệp của bạn đã được tải vào bộ nhớ dưới dạng chuỗi đa dòng sau:

Đầu ra của bạn phải là một danh sách các danh sách:

Hoạt động chuỗi cơ bản khác trái ngược với các chuỗi phân tách: nối chuỗi. Nếu bạn thiên đường nhìn thấy từ này, đừng lo lắng. Nó chỉ là một cách lạ mắt để nói về việc dán mắt nhau.concatenation. If you haven’t seen this word, don’t worry. It’s just a fancy way of saying “gluing together.”

Kết hợp với nhà điều hành res = PyUnicode_New(sz, maxchar); 4

Có một vài cách để làm điều này, tùy thuộc vào những gì bạn đang cố gắng đạt được. Phương pháp đơn giản nhất và phổ biến nhất là sử dụng ký hiệu cộng (

res = PyUnicode_New(sz, maxchar);

4) để thêm nhiều chuỗi lại với nhau. Chỉ cần đặt một

res = PyUnicode_New(sz, maxchar);

4 giữa nhiều chuỗi như bạn muốn tham gia cùng nhau:

>>>

s = "".join(items)

4

Để phù hợp với chủ đề toán học, bạn cũng có thể nhân một chuỗi để lặp lại nó:

Hãy nhớ rằng, chuỗi là bất biến! Nếu bạn kết hợp hoặc lặp lại một chuỗi được lưu trữ trong một biến, bạn sẽ phải gán chuỗi mới cho một biến khác để giữ nó.

>>>

s = "".join(items)

5

Để phù hợp với chủ đề toán học, bạn cũng có thể nhân một chuỗi để lặp lại nó:

Hãy nhớ rằng, chuỗi là bất biến! Nếu bạn kết hợp hoặc lặp lại một chuỗi được lưu trữ trong một biến, bạn sẽ phải gán chuỗi mới cho một biến khác để giữ nó.

>>>

s = "".join(items)

6

Để phù hợp với chủ đề toán học, bạn cũng có thể nhân một chuỗi để lặp lại nó:

Hãy nhớ rằng, chuỗi là bất biến! Nếu bạn kết hợp hoặc lặp lại một chuỗi được lưu trữ trong một biến, bạn sẽ phải gán chuỗi mới cho một biến khác để giữ nó.

Nếu chúng tôi không có chuỗi bất biến,

res = PyUnicode_New(sz, maxchar);

7 thay vào đó sẽ xuất ra

res = PyUnicode_New(sz, maxchar);

8.

Một lưu ý khác là Python không thực hiện chuyển đổi chuỗi ngầm. Nếu bạn cố gắng kết hợp một chuỗi với loại không chuỗi, Python sẽ tăng

res = PyUnicode_New(sz, maxchar);

9:

Điều này là do bạn chỉ có thể nối các chuỗi với các chuỗi khác, có thể là hành vi mới đối với bạn nếu bạn đến từ một ngôn ngữ như JavaScript, cố gắng thực hiện chuyển đổi loại ngầm.

>>>

s = "".join(items)

7

Để phù hợp với chủ đề toán học, bạn cũng có thể nhân một chuỗi để lặp lại nó:

Hãy nhớ rằng, chuỗi là bất biến! Nếu bạn kết hợp hoặc lặp lại một chuỗi được lưu trữ trong một biến, bạn sẽ phải gán chuỗi mới cho một biến khác để giữ nó.

Nếu chúng tôi không có chuỗi bất biến,

res = PyUnicode_New(sz, maxchar);

7 thay vào đó sẽ xuất ra

res = PyUnicode_New(sz, maxchar);

8.

>>>

s = "".join(items)

8

Để phù hợp với chủ đề toán học, bạn cũng có thể nhân một chuỗi để lặp lại nó:

Hãy nhớ rằng, chuỗi là bất biến! Nếu bạn kết hợp hoặc lặp lại một chuỗi được lưu trữ trong một biến, bạn sẽ phải gán chuỗi mới cho một biến khác để giữ nó.

>>>

s = "".join(items)

9

Để phù hợp với chủ đề toán học, bạn cũng có thể nhân một chuỗi để lặp lại nó:

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

0

Hãy nhớ rằng, chuỗi là bất biến! Nếu bạn kết hợp hoặc lặp lại một chuỗi được lưu trữ trong một biến, bạn sẽ phải gán chuỗi mới cho một biến khác để giữ nó.

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

1

Nếu chúng tôi không có chuỗi bất biến,

res = PyUnicode_New(sz, maxchar);

7 thay vào đó sẽ xuất ra

res = PyUnicode_New(sz, maxchar);

8.

Một lưu ý khác là Python không thực hiện chuyển đổi chuỗi ngầm. Nếu bạn cố gắng kết hợp một chuỗi với loại không chuỗi, Python sẽ tăng

res = PyUnicode_New(sz, maxchar);

9:

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

2

Điều này là do bạn chỉ có thể nối các chuỗi với các chuỗi khác, có thể là hành vi mới đối với bạn nếu bạn đến từ một ngôn ngữ như JavaScript, cố gắng thực hiện chuyển đổi loại ngầm.

Đi từ danh sách đến một chuỗi trong Python với for (i = 0, res_offset = 0; i < seqlen; ++i) { [...] Py_MEMCPY(res_data, sep_data, kind * seplen); // At row 9618 0

Có một cách khác, mạnh mẽ hơn, để tham gia các chuỗi với nhau. Bạn có thể đi từ danh sách đến một chuỗi trong Python với phương thức

for (i = 0, res_offset = 0; i < seqlen; ++i) {
    [...]
    Py_MEMCPY(res_data,
        sep_data,
        kind * seplen);  // At **row 9618**

1.

Trường hợp sử dụng phổ biến ở đây là khi bạn có một trò chơi có thể điều chỉnh được như một danh sách mà các chuỗi đã tạo ra và bạn muốn kết hợp các chuỗi đó thành một chuỗi. Giống như

PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)

4,

for (i = 0, res_offset = 0; i < seqlen; ++i) {
    [...]
    Py_MEMCPY(res_data,
        sep_data,
        kind * seplen);  // At **row 9618**

0 là phương thức thể hiện chuỗi. Nếu tất cả các chuỗi của bạn đều ở trong một điều có thể, bạn gọi cái nào

for (i = 0, res_offset = 0; i < seqlen; ++i) {
    [...]
    Py_MEMCPY(res_data,
        sep_data,
        kind * seplen);  // At **row 9618**

0?

Đây là một chút câu hỏi lừa. Hãy nhớ rằng khi bạn sử dụng
```
PyObject *
PyUnicode_Concat(PyObject *left, PyObject *right)
```
4, bạn gọi nó trên chuỗi hoặc ký tự bạn muốn chia tay. Hoạt động ngược lại là
```
for (i = 0, res_offset = 0; i < seqlen; ++i) {
    [...]
    Py_MEMCPY(res_data,
        sep_data,
        kind * seplen);  // At **row 9618**
```
0, vì vậy bạn gọi nó trên chuỗi hoặc ký tự bạn muốn sử dụng để kết hợp với các chuỗi có thể lặp lại với nhau:

Tại đây, chúng tôi tham gia từng yếu tố của danh sách

for (i = 0, res_offset = 0; i < seqlen; ++i) {
    [...]
    Py_MEMCPY(res_data,
        sep_data,
        kind * seplen);  // At **row 9618**

7 với dấu phẩy (

res = PyUnicode_New(sz, maxchar);

1) và gọi

for (i = 0, res_offset = 0; i < seqlen; ++i) {
    [...]
    Py_MEMCPY(res_data,
        sep_data,
        kind * seplen);  // At **row 9618**

0 trên nó thay vì danh sách

for (i = 0, res_offset = 0; i < seqlen; ++i) {
    [...]
    Py_MEMCPY(res_data,
        sep_data,
        kind * seplen);  // At **row 9618**

7.

Làm thế nào bạn có thể làm cho văn bản đầu ra dễ đọc hơn?

Concatenation có nhanh hơn tham gia không?

Thực hiện n Concatenations yêu cầu tạo n chuỗi mới trong quá trình.Tham gia (), mặt khác, chỉ phải tạo một chuỗi duy nhất (kết quả cuối cùng) và do đó hoạt động nhanh hơn nhiều.join() , on the other hand, only has to create a single string (the final result) and thus works much faster.

Tham gia nhanh hơn trong Python?

Sử dụng phương thức tham gia () có thể nhanh hơn 4 lần so với sử dụng + để tham gia các chuỗi trong danh sách. to join the strings in the list.

Có phải sự kết hợp chuỗi python có chậm không?

Hành vi này không làm bạn ngạc nhiên: Các đối tượng chuỗi của Python là bất biến, do đó, mỗi lần ghép tạo ra một chuỗi mới thay vì sửa đổi một chuỗi hiện có tại chỗ.Cũng không có gì ngạc nhiên khi nhiều chuỗi chuỗi được coi là chậm.multiple string concatenations are considered slow.

Các chuỗi F có nhanh hơn so với cách ghép không?

Tóm tắt: Sử dụng toán tử nối chuỗi nhanh hơn một chút so với việc sử dụng các chuỗi chữ số định dạng.Trừ khi bạn đang thực hiện hàng trăm ngàn lần ghép chuỗi và cần chúng được thực hiện rất nhanh, việc thực hiện được chọn không có khả năng tạo ra sự khác biệt.Using the string concatenation operator is slightly faster than using format string literals. Unless you are performing many hundreds of thousands of string concatenations and need them done very quickly, the implementation chosen is unlikely to make a difference.

programming python Python string join

Hướng dẫn is join faster than concatenation python? - tham gia có nhanh hơn liên kết python không?

Bên trong mã nguồn

Sự kết luận

Chuỗi phân tách

Chia tách mà không có thông số

Đầu ra của bạn phải là một danh sách các danh sách:

Kết hợp với nhà điều hành res = PyUnicode_New(sz, maxchar); 4

Hãy nhớ rằng, chuỗi là bất biến! Nếu bạn kết hợp hoặc lặp lại một chuỗi được lưu trữ trong một biến, bạn sẽ phải gán chuỗi mới cho một biến khác để giữ nó.

Đi từ danh sách đến một chuỗi trong Python với for (i = 0, res_offset = 0; i < seqlen; ++i) { [...] Py_MEMCPY(res_data, sep_data, kind * seplen); // At **row 9618** 0

Concatenation có nhanh hơn tham gia không?

Tham gia nhanh hơn trong Python?

Có phải sự kết hợp chuỗi python có chậm không?

Các chuỗi F có nhanh hơn so với cách ghép không?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

Đi từ danh sách đến một chuỗi trong Python với for (i = 0, res_offset = 0; i < seqlen; ++i) { [...] Py_MEMCPY(res_data, sep_data, kind * seplen); // At row 9618 0