Łączenie łańcuchów a zastępowanie łańcuchów w Pythonie

Nie zapomnij o podmianie nazw:

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

Uważaj na łączenie strun w pętlę! koszt połączenia łańcuchów jest proporcjonalny do długości wyniku. Zapętlenie prowadzi cię prosto do krainy N-squared. Niektóre języki zoptymalizują konkatenację do ostatnio przydzielonego ciągu znaków, ale ryzykowne jest liczenie na to, że kompilator zoptymalizuje algorytm kwadratowy do liniowego. Najlepiej użyć prymitywnego (join?), który pobiera całą listę ciągów, wykonuje pojedynczą alokację i łączy je wszystkie w raz.

" jako, że konkatenacja strun odnotowała duże zwiększenie wydajności..."

Jeśli wydajność ma znaczenie, dobrze o tym wiedzieć.

Jednak problemy z wydajnością, które widziałem, nigdy nie sprowadzały się do operacji ciągów. Ogólnie mam problemy z I / O, sortowaniem i o (n²) operacje są wąskimi gardłami.

Dopóki operacje ciągów nie będą ogranicznikami wydajności, będę trzymał się rzeczy, które są oczywiste. Najczęściej jest to substytucja, gdy jest to jedna linia lub mniej, konkatenacja, gdy ma to sens, i narzędzie szablonu (jak Mako), gdy jest duże.

To, co chcesz połączyć/interpolować i jak chcesz sformatować wynik, powinno napędzać twoją decyzję.

• Interpolacja łańcuchów umożliwia łatwe dodawanie formatowania. W rzeczywistości, twoja wersja interpolacji łańcuchów nie robi tego samego co wersja konkatenacji; w rzeczywistości dodaje dodatkowy ukośnik przed parametrem q_num. Aby zrobić to samo, musisz napisać return DOMAIN + QUESTIONS + "/" + str(q_num) w tym przykładzie.

• Interpolacja ułatwia formatowanie cyfry; "%d of %d (%2.2f%%)" % (current, total, total/current) byłyby znacznie mniej czytelne w formie konkatenacji.

• Konkatenacja jest przydatna, gdy nie ma ustalonej liczby elementów do String-ize.

Wiedz również, że Python 2.6 wprowadza nową wersję interpolacji łańcuchów, zwaną string template:

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

String template ma w końcu zastąpić % - interpolację, ale myślę, że to nie nastąpi przez dłuższy czas.

Z ciekawości testowałem szybkość różnych metod łączenia/zastępowania łańcuchów. Wyszukiwarka Google na ten temat mnie tu przywiozła. Pomyślałem, że opublikuję wyniki badań w nadziei, że to pomoże komuś zdecydować.

    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)

...Po uruchomieniu runtests((percent_, format_, format2_, concat_), runs=5), odkryłem, że metoda % była około dwa razy szybsza niż pozostałe na tych małych strunach. Metoda concat była zawsze najwolniejsza (ledwo). Były bardzo małe różnice podczas przełączania pozycji w format() metoda, ale zmiana pozycji była zawsze co najmniej .01 wolniejszy od zwykłej metody formatowania.

Przykładowe wyniki badań:

    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)

Uruchomiłem je, ponieważ używam konkatenacji łańcuchów w moich skryptach i zastanawiałem się, jaki był koszt. Sprawdzałem je w różnych kolejnościach, aby upewnić się, że nic nie przeszkadzało, lub uzyskiwałem lepsze wyniki jako pierwszy lub ostatni. Na marginesie dodałem do tych funkcji jakieś dłuższe Generatory strun jak "%s" + ("a" * 1024) i zwykły concat był prawie 3 razy tak szybko (1,1 vs 2,8) jak przy użyciu metod format i %. Myślę, że to zależy od strun i tego, co próbujesz osiągnąć. Jeśli wydajność naprawdę ma znaczenie, może lepiej wypróbować różne rzeczy i przetestować je. Mam tendencję do wyboru czytelności nad prędkością, chyba że prędkość staje się problemem, ale to tylko ja. Więc nie podoba mi się mój kopiuj / wklej, musiałem umieścić 8 spacji na wszystko, aby wyglądało dobrze. Zwykle używam 4.

Pamiętaj, decyzje stylistyczne są decyzjami praktycznymi, jeśli kiedykolwiek planujesz utrzymać lub debugować swój kod :-) jest słynny cytat z Knutha (może cytując Hoare?): "Powinniśmy zapomnieć o małej wydajności, powiedzmy około 97% czasu: przedwczesna optymalizacja jest korzeniem wszelkiego zła."

Dopóki jesteś ostrożny, aby (powiedzieć) nie zamienić zadania O (n) W O (n²) zadanie, wybrałbym to, co jest dla Ciebie najłatwiejsze do zrozumienia..

Używam substytucji, gdzie tylko mogę. Używam konkatenacji tylko wtedy, gdy buduję ciąg w pętli typu for.

Właściwie właściwą rzeczą do zrobienia ,w tym przypadku (budowanie ścieżek) jest użycie os.path.join. Nie concatenation string lub interpolation