Nối chuỗi so với thay thế chuỗi trong Python

Trong Python, vị trí và thời điểm sử dụng nối chuỗi so với thay thế chuỗi không có tôi. Vì quá trình nối chuỗi đã chứng kiến ​​sự thúc đẩy lớn về hiệu suất, liệu đây có phải là một quyết định mang tính phong cách hơn là một quyết định thực tế?

Để có một ví dụ cụ thể, cách xử lý việc xây dựng các URI linh hoạt:

DOMAIN = 'http://stackoverflow.com'
QUESTIONS = '/questions'

def so_question_uri_sub(q_num):
    return "%s%s/%d" % (DOMAIN, QUESTIONS, q_num)

def so_question_uri_cat(q_num):
    return DOMAIN + QUESTIONS + '/' + str(q_num)

Chỉnh sửa: Cũng đã có những đề xuất về việc tham gia một danh sách các chuỗi và sử dụng sự thay thế được đặt tên. Đây là những biến thể về chủ đề trung tâm, đó là, cách nào là Cách làm đúng để thực hiện vào thời điểm đó? Cảm ơn vì những câu trả lời!

Kết nối nhanh hơn (đáng kể) theo máy của tôi. Nhưng về mặt phong cách, tôi sẵn sàng trả giá bằng sự thay thế nếu hiệu suất không quá quan trọng. Vâng, và nếu tôi cần định dạng, thậm chí không cần đặt câu hỏi ... không có lựa chọn nào khác ngoài sử dụng nội suy / tạo mẫu.

>>> import timeit
>>> def so_q_sub(n):
...  return "%s%s/%d" % (DOMAIN, QUESTIONS, n)
...
>>> so_q_sub(1000)
'http://stackoverflow.com/questions/1000'
>>> def so_q_cat(n):
...  return DOMAIN + QUESTIONS + '/' + str(n)
...
>>> so_q_cat(1000)
'http://stackoverflow.com/questions/1000'
>>> t1 = timeit.Timer('so_q_sub(1000)','from __main__ import so_q_sub')
>>> t2 = timeit.Timer('so_q_cat(1000)','from __main__ import so_q_cat')
>>> t1.timeit(number=10000000)
12.166618871951641
>>> t2.timeit(number=10000000)
5.7813972166853773
>>> t1.timeit(number=1)
1.103492206766532e-05
>>> t2.timeit(number=1)
8.5206360154188587e-06

>>> def so_q_tmp(n):
...  return "{d}{q}/{n}".format(d=DOMAIN,q=QUESTIONS,n=n)
...
>>> so_q_tmp(1000)
'http://stackoverflow.com/questions/1000'
>>> t3= timeit.Timer('so_q_tmp(1000)','from __main__ import so_q_tmp')
>>> t3.timeit(number=10000000)
14.564135316080637

>>> def so_q_join(n):
...  return ''.join([DOMAIN,QUESTIONS,'/',str(n)])
...
>>> so_q_join(1000)
'http://stackoverflow.com/questions/1000'
>>> t4= timeit.Timer('so_q_join(1000)','from __main__ import so_q_join')
>>> t4.timeit(number=10000000)
9.4431309007150048

Đừng quên về sự thay thế có tên:

def so_question_uri_namedsub(q_num):
    return "%(domain)s%(questions)s/%(q_num)d" % locals()

Hãy cảnh giác với việc nối các chuỗi trong một vòng lặp! Chi phí nối chuỗi tỷ lệ thuận với độ dài của kết quả. Vòng lặp dẫn bạn đến thẳng vùng đất N-bình phương. Một số ngôn ngữ sẽ tối ưu hóa việc ghép nối với chuỗi được phân bổ gần đây nhất, nhưng sẽ rất rủi ro khi tin tưởng vào trình biên dịch để tối ưu hóa thuật toán bậc hai của bạn xuống tuyến tính. Tốt nhất là sử dụng nguyên thủy ( join?) Lấy toàn bộ danh sách các chuỗi, thực hiện một phân bổ duy nhất và nối tất cả chúng trong một lần.

"Vì quá trình nối chuỗi đã chứng kiến ​​sự thúc đẩy lớn về hiệu suất ..."

Nếu hiệu suất quan trọng, điều này là tốt để biết.

Tuy nhiên, các vấn đề về hiệu suất mà tôi đã thấy chưa bao giờ liên quan đến các hoạt động chuỗi. Tôi thường gặp rắc rối với I / O, sắp xếp và O ( n ² ) là nút cổ chai.

Cho đến khi các hoạt động chuỗi là giới hạn hiệu suất, tôi sẽ gắn bó với những điều hiển nhiên. Hầu hết, đó là sự thay thế khi nó là một dòng hoặc ít hơn, nối khi nó có ý nghĩa và một công cụ mẫu (như Mako) khi nó lớn.

Những gì bạn muốn nối / nội suy và cách bạn muốn định dạng kết quả sẽ dẫn đến quyết định của bạn.

• Nội suy chuỗi cho phép bạn dễ dàng thêm định dạng. Trên thực tế, phiên bản nội suy chuỗi của bạn không làm điều tương tự như phiên bản nối của bạn; nó thực sự thêm một dấu gạch chéo bổ sung trước q_numtham số. Để làm điều tương tự, bạn sẽ phải viết return DOMAIN + QUESTIONS + "/" + str(q_num)trong ví dụ đó.

• Nội suy giúp định dạng số dễ dàng hơn; "%d of %d (%2.2f%%)" % (current, total, total/current)sẽ khó đọc hơn nhiều ở dạng nối.

• Kết nối hữu ích khi bạn không có một số mục cố định cho chuỗi-ize.

Ngoài ra, hãy biết rằng Python 2.6 giới thiệu một phiên bản nội suy chuỗi mới, được gọi là tạo mẫu chuỗi :

def so_question_uri_template(q_num):
    return "{domain}/{questions}/{num}".format(domain=DOMAIN,
                                               questions=QUESTIONS,
                                               num=q_num)

String templating được dự kiến ​​cuối cùng sẽ thay thế% -interpolation, nhưng điều đó sẽ không xảy ra trong một thời gian khá lâu, tôi nghĩ vậy.

Tôi chỉ đang thử nghiệm tốc độ của các phương pháp nối / thay thế chuỗi khác nhau vì tò mò. Một tìm kiếm trên google về chủ đề này đã đưa tôi đến đây. Tôi nghĩ rằng tôi sẽ đăng kết quả kiểm tra của mình với hy vọng rằng nó có thể giúp ai đó quyết định.

    import timeit
    def percent_():
            return "test %s, with number %s" % (1,2)

    def format_():
            return "test {}, with number {}".format(1,2)

    def format2_():
            return "test {1}, with number {0}".format(2,1)

    def concat_():
            return "test " + str(1) + ", with number " + str(2)

    def dotimers(func_list):
            # runs a single test for all functions in the list
            for func in func_list:
                    tmr = timeit.Timer(func)
                    res = tmr.timeit()
                    print "test " + func.func_name + ": " + str(res)

    def runtests(func_list, runs=5):
            # runs multiple tests for all functions in the list
            for i in range(runs):
                    print "----------- TEST #" + str(i + 1)
                    dotimers(func_list)

... Sau khi chạy runtests((percent_, format_, format2_, concat_), runs=5), tôi thấy rằng phương thức% nhanh gấp đôi so với các phương thức khác trên các chuỗi nhỏ này. Phương thức concat luôn là chậm nhất (hầu như không). Có sự khác biệt rất nhỏ khi chuyển đổi vị trí trongformat() phương pháp, nhưng chuyển đổi vị trí luôn chậm hơn ít nhất 0,01 so với phương pháp định dạng thông thường.

Mẫu kết quả kiểm tra:

    test concat_()  : 0.62  (0.61 to 0.63)
    test format_()  : 0.56  (consistently 0.56)
    test format2_() : 0.58  (0.57 to 0.59)
    test percent_() : 0.34  (0.33 to 0.35)

Tôi đã chạy những điều này bởi vì tôi sử dụng nối chuỗi trong các tập lệnh của mình và tôi đã tự hỏi chi phí là bao nhiêu. Tôi đã chạy chúng theo các thứ tự khác nhau để đảm bảo không có gì can thiệp hoặc đạt được hiệu suất tốt hơn dù là đầu tiên hay cuối cùng. Một lưu ý nhỏ, tôi đã đưa vào một số trình tạo chuỗi dài hơn vào các hàm như vậy "%s" + ("a" * 1024)và concat thông thường nhanh hơn gần 3 lần (1.1 so với 2.8) so với sử dụng các phương thức formatvà %. Tôi đoán nó phụ thuộc vào các chuỗi, và những gì bạn đang cố gắng đạt được. Nếu hiệu suất thực sự quan trọng, tốt hơn là bạn nên thử những thứ khác nhau và kiểm tra chúng. Tôi có xu hướng chọn khả năng đọc hơn tốc độ, trừ khi tốc độ trở thành vấn đề, nhưng đó chỉ là tôi. VẬY không thích sao chép / dán của tôi, tôi phải đặt 8 khoảng trắng trên mọi thứ để làm cho nó trông đúng. Tôi thường sử dụng 4.

Hãy nhớ rằng, các quyết định theo phong cách là những quyết định thực tế, nếu bạn có kế hoạch duy trì hoặc gỡ lỗi mã của mình :-) Có một câu nói nổi tiếng từ Knuth (có thể là trích dẫn Hoare?): "Chúng ta nên quên đi những hiệu quả nhỏ, hãy nói khoảng 97% thời gian: tối ưu hóa quá sớm là gốc rễ của mọi điều ác. "

Miễn là bạn cẩn thận không (nói) biến một nhiệm vụ O (n) thành một nhiệm vụ O (n ² ), tôi sẽ chọn cách nào bạn thấy dễ hiểu nhất ..

Tôi sử dụng thay thế bất cứ nơi nào tôi có thể. Tôi chỉ sử dụng phép nối nếu tôi đang xây dựng một chuỗi trong vòng lặp for.

Trên thực tế, điều chính xác cần làm, trong trường hợp này (xây dựng đường dẫn) là sử dụng os.path.join. Không phải nối chuỗi hoặc nội suy