한 개만 연결 문자열을 문자열으로 진실이며당신이 참조입니다 경우, 특별한 경우에는 다른 및끝 스피통 확장 및 하면 이제 이 문자열에 파일배치.

결과적으로 해당 작업이 상각 O (n).

예:

s = ""
for i in range(n):
    s+=str(i)

그러나 지금은 used to be O (n ^ 2), O (n).

소스에서 (브리트솝ject.c):

<! - 언어: c - &gt.

void
PyBytes_ConcatAndDel(register PyObject **pv, register PyObject *w)
{
    PyBytes_Concat(pv, w);
    Py_XDECREF(w);
}

/* The following function breaks the notion that strings are immutable:
   it changes the size of a string.  We get away with this only if there
   is only one module referencing the object.  You can also think of it
   as creating a new string object and destroying the old one, only
   more efficiently.  In any case, don't use this if the string may
   already be known to some other part of the code...
   Note that if there's not enough memory to resize the string, the original
   string object at *pv is deallocated, *pv is set to NULL, an "out of
   memory" exception is set, and -1 is returned.  Else (on success) 0 is
   returned, and the value in *pv may or may not be the same as on input.
   As always, an extra byte is allocated for a trailing \0 byte (newsize
   does *not* include that), and a trailing \0 byte is stored.
*/

int
_PyBytes_Resize(PyObject **pv, Py_ssize_t newsize)
{
    register PyObject *v;
    register PyBytesObject *sv;
    v = *pv;
    if (!PyBytes_Check(v) || Py_REFCNT(v) != 1 || newsize < 0) {
        *pv = 0;
        Py_DECREF(v);
        PyErr_BadInternalCall();
        return -1;
    }
    /* XXX UNREF/NEWREF interface should be more symmetrical */
    _Py_DEC_REFTOTAL;
    _Py_ForgetReference(v);
    *pv = (PyObject *)
        PyObject_REALLOC((char *)v, PyBytesObject_SIZE + newsize);
    if (*pv == NULL) {
        PyObject_Del(v);
        PyErr_NoMemory();
        return -1;
    }
    _Py_NewReference(*pv);
    sv = (PyBytesObject *) *pv;
    Py_SIZE(sv) = newsize;
    sv->ob_sval[newsize] = '\0';
    sv->ob_shash = -1;          /* invalidate cached hash value */
    return 0;
}

39 의 it& 쉽게 확인할 수 있을 만큼 경험적으로.

&lt pre>; $ & # 39, & # 39 m, s = s&quot 파이썬 - 티마이트 "; & # 39 의 &quot, 내가 그레인지 :s+ a& # 39 (10) = ";; 1 000 000 루프, 최고의 3: 마이크로 초 1.85 루프당 $ & # 39, & # 39 m, s = s&quot 파이썬 - 티마이트 "; & # 39 의 &quot, 내가 그레인지 :s+ a& # 39 (100) = ";; 10000mb 루프, 최고의 3: 마이크로 초 루프당 16.8 $ & # 39, & # 39 m, s = s&quot 파이썬 - 티마이트 "; 내가 그레인지 &quot, 의 (1000년), a& # 39, & # 39 :s+ = &quot. 10000mb 루프, 최고의 3: 마이크로 초 루프당 158 $ & # 39, & # 39 m, s = s&quot 파이썬 - 티마이트 "; & # 39 의 &quot, 내가 그레인지 :s+ a& # 39 (10000mb) = ";; 1000년 루프, 최고의 3: 루프당 1.71 밀리초 $ & # 39, & # 39 m, s = s&quot 파이썬 - 티마이트 "; & # 39 의 &quot, 내가 그레인지 :s+ a& # 39 (100000) = ";; 10 루프, 최고의 3: 14.6 밀리초 루프당 $ & # 39, & # 39 m, s = s&quot 파이썬 - 티마이트 "; & # 39 의 &quot, 내가 그레인지 :s+ a& # 39 (1 000 000) = ";; 10 루프, 최고의 3: 루프당 17.3cm 밀리초 &lt /pre>;

, 하지만 이는 It& # 39 의 중요한 부분을 isn& # 39 를 최적화, 파이썬, s # 39 만 t 의 spec. It& 스피통 구축상의 내린 것으로 알고 있다. 예를 들어 같은 pypy 에서 테스트하는 경험적 또는 자이썬 (i/o n ) 성능을 tfsnap 표시할 수 있습니다.

&lt pre>; $ & # 39, & # 39 m, s = s&quot pypy - 티마이트 "; & # 39 의 &quot, 내가 그레인지 :s+ a& # 39 (10) = ";; 10000mb 루프, 최고의 3: 마이크로 초 90.8 루프당 $ & # 39, & # 39 m, s = s&quot pypy - 티마이트 "; & # 39 의 &quot, 내가 그레인지 :s+ a& # 39 (100) = ";; 1000년 루프, 최고의 3: 896 루프당 마이크로 초 $ & # 39, & # 39 m, s = s&quot pypy - 티마이트 "; 내가 그레인지 &quot, 의 (1000년), a& # 39, & # 39 :s+ = &quot. 100 루프, 최고의 3: 루프당 9.03 밀리초 $ & # 39, & # 39 m, s = s&quot pypy - 티마이트 "; & # 39 의 &quot, 내가 그레인지 :s+ a& # 39 (10000mb) = ";; 10 루프, 최고의 3: 루프당 89.5 밀리초 &lt /pre>;

그런데, so far, so good

&lt pre>; $ & # 39, & # 39 m, s = s&quot pypy - 티마이트 "; & # 39 의 &quot, 내가 그레인지 :s+ a& # 39 (100000) = ";; 10 루프, 최고의 3: 루프당 12.8 초 &lt /pre>;

그렇지만 춘향아 fopen 밑구녕만도 이차. 그래서 잘 어울리는 파선-짧은 문장열 하지만 pypy 뭔가 잘못 대규모 써줬지 향상합니다

39, 중간에 최적화합니다 don& 없다. # 39 의 there& reason to believe 없으면 그냥 치중한다는 '+' 와 '스피드 연결 문자열을 다음 인한 병목 현상을 + =':

s  = 'foo'
s += 'bar'
s += 'baz'

즉, 만약 you& # 39, re 는 스트라이베이더 의 표준 파이썬 관용구, 뭔가 노리는 Java& # 39 와 같은 항목을 추가할 수 끝에 다음 목록 및 그들 모두 '연결' 스트리요린.

l = []
l.append('foo')
l.append('bar')
l.append('baz')

s = ''.join(l)

39, don& 없다.

즉, 대부분의 경우 생성 문자열 전체가 한 후 오히려 더 나은 오프하도록 덧붙이기 검색하기를 기존 구체화하십시오.

예를 들어, don& # 39, t 도: 'obj1.name + &quot :"; str (obj1.count) '+

대신: '&quot 사용하여 %s:%d"; % (obj1.name, obj1.count) '

쉽게 읽을 수 있는 것으로, 보다 효율적인.

str1 = "Hello"
str2 = "World"
newstr = " ".join((str1, str2))

Space) 과 함께 결합하여 str1 및 str2 구분. 할 수도 있습니다. (str1, str2.) ',' &quot &quot 스타인. '스트리요린 ()' 는 이트레이블 도왔으매 you& # 39 를 넣을 수 있는 a, d 가 문장열 목록이거나 튜플.

39 로 that& 대한 효율적인 얻을 수 있기 때문에, s 의 내장 메서드입니다.

많은 덮어쓰기/추가 작업을 할 경우 대규모 문자열이어야 구축하십시오 사용할 수 있습니다 ([스트린조] https://docs.python.org/3/library/io.html # 리오스트린조) 또는 카스트린조. 이 인터페이스는 마치 절실해졌습니다. 예: you '쓰기' 첨부하려면 텍스트 예정이다.

39 를 사용할 경우, 다음 두 문장열 you& re 그냥 그냥 '+'.

정말 응용 프로그램에 따라 달라집니다. # 39 you& 경우, re 루프을 단어 수백 그들 모두 알고 있으며, '를 통해 첨부하려면 바뀌엇어요 스타인 ()' 가 더 좋습니다. # 39 신앙이니라 you&, re, re you& # 39, 긴 퍼팅 함께 사용하여 '+ =' 마디였나 좋습니다.

[F 문장열] [1] 는 파이썬 3.6tb 우리를 보기입니다 있는 delight):

var1 = "foo"
var2 = "bar"
var3 = f"{var1}{var2}"
print(var3)                       # prints foobar

대부분의 중괄호 안에 아무것도 할 수 있습니다.

print(f"1 + 1 == {1 + 1}")        # prints 1 + 1 == 2

[1]: https://docs.python.org/3/whatsnew/3.6.html # whatsnew36-pep498

기본적으로 따른 차이는 없습니다. 모든 것을 얻을 수 있는 유일한 일관됨 흐름이 느린 파이썬 버전을 것으로 보인다. : (

목록

%%timeit
x = []
for i in range(100000000):  # xrange on Python 2.7
    x.append('a')
x = ''.join(x)

• 파이썬 2.7*

&gt. 1 루프, best 3: 루프당 7.34 s

• 파이썬 3.4*

&gt. 1 루프, best 3: 루프당 7.99 s

• 파이썬 3.5*

&gt. 1 루프, best 3: 루프당 8.48 s

• 파이썬 3.6*

&gt. 1 루프, best 3: 루프당 9.93 s

문자열

%%timeit
x = ''
for i in range(100000000):  # xrange on Python 2.7
    x += 'a'

• 파이썬 2.7*:

&gt. 1 루프, best 3: 루프당 7.41 s

• 파이썬 3.4*

&gt. 1 루프, best 3: 루프당 9.08 s

• 파이썬 3.5*

&gt. 1 루프, best 3: 루프당 8.82 s

• 파이썬 3.6*

&gt. 1 루프, best 3: 루프당 9.24 s

함께 덮어쓰기/추가 문장열 add 함수

str = "Hello"
str2 = " World"
st = str.__add__(str2)
print(st)

출력입니다

Hello World