Wie kann ich mit append einen string an einen anderen in Python?

Wenn Sie nur einen Verweis auf eine Zeichenfolge, und Sie verketten eine andere Zeichenfolge bis zum Ende, CPython jetzt spezielle Fälle, und versucht verlängern Sie die Zeichenfolge im Ort.

Das Endergebnis ist, dass der Betrieb amortisiert O(n).

z.B.

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

verwendet werden, um O(n^2), aber jetzt ist es O(n).

Aus der Quelle (bytesobject.c):

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;
}

Ist es einfach genug, um zu überprüfen, empirisch.

$ python -m timeit -s"s="" "for i in xrange(10):s+='a'" 
1000000 loops, best of 3: 1.85 usec per loop 
$ python -m timeit -s"s="" "for i in xrange(100):s+='a'" 
10000 loops, best of 3: 16.8 usec per loop 
$ python -m timeit -s"s="" "for i in xrange(1000):s+='a'" 
10000 loops, best of 3: 158 usec per loop 
$ python -m timeit -s"s="" "for i in xrange(10000):s+='a'" 
1000 loops, best of 3: 1.71 MS pro Schleife 
$ python -m timeit -s"s="" "for i in xrange(100000):s+='a'" 
10 loops, best of 3: 14.6 MS pro Schleife 
$ python -m timeit -s"s="" "for i in xrange(1000000):s+='a'" 
10 loops, best of 3: 173 MS pro Schleife 

Es wichtig jedoch zu beachten, dass diese Optimierung nicht Teil der Python-spec. Es ist nur in der cPython-Implementierung, soweit ich weiß. Die gleichen empirischen Tests auf pypy oder jython zum Beispiel zeigen vielleicht die älteren O(n**2) Leistung .

$ pypy -m timeit -s"s="" "for i in xrange(10):s+='a'" 
10000 loops, best of 3: 90.8 usec per loop 
$ pypy -m timeit -s"s="" "for i in xrange(100):s+='a'" 
1000 loops, best of 3: 896 usec per loop 
$ pypy -m timeit -s"s="" "for i in xrange(1000):s+='a'" 
100 loops, best of 3: 9.03 MS pro Schleife 
$ pypy -m timeit -s"s="" "for i in xrange(10000):s+='a'" 
10 loops, best of 3: 89.5 pro msec Schleife 

So weit so gut, aber dann,

$ pypy -m timeit -s"s="" "for i in xrange(100000):s+='a'" 
10 loops, best of 3: 12.8 sec pro loop 

ouch noch schlimmer als die quadratische. So pypy ist etwas zu tun, das funktioniert gut mit kurzen Zeichenfolgen, aber schlecht für größere Zeichenfolgen.

InformationsquelleAutor John La Rooy

Nicht.

Ist, für die meisten Fällen werden Sie besser dran, die Generierung der ganze string in einem Rutsch eher dann anfügen an einen bestehenden string.

Beispielsweise nicht tun: obj1.name + ":" + str(obj1.count)

Statt: verwenden Sie "%s:%d" % (obj1.name, obj1.count)

Die leichter zu Lesen und mehr effizient.

InformationsquelleAutor Winston Ewert

Wenn Sie brauchen, um zu tun, viele append-Operationen zu bauen ist eine große Zeichenfolge, die Sie verwenden können, StringIO oder cStringIO. Die Schnittstelle wird wie eine Datei. dh: Sie write um text anzufügen.

Wenn Sie nur anfügen von zwei Saiten, dann verwenden Sie einfach +.

InformationsquelleAutor Laurence Gonsalves

Python 3.6 gibt uns f-Saiten, die sind ein Genuss:

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

Können Sie die meisten alles, was im inneren die geschweiften Klammern

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

InformationsquelleAutor Trenton

Im Grunde keinen Unterschied. Die einzige konsistente trend ist, dass Python scheint immer langsamer wird mit jeder version... 🙁

Liste

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

Python 2.7

1-Schleife, best-of-3: 7.34 s pro loop

Python 3.4

1-Schleife, best-of-3: 7.99 s pro loop

Python 3.5

1-Schleife, best-of-3: 8.48 s pro loop

Python 3.6

1-Schleife, best-of-3: 9.93 s pro loop

String

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

Python 2.7:

1-Schleife, best-of-3: 7.41 s pro Schleife

Python 3.4

1-Schleife, best-of-3: 9.08 s pro loop

Python 3.5

1-Schleife, best-of-3: 8.82 s pro loop

Python 3.6

1-Schleife, best-of-3: 9.24 s pro loop

InformationsquelleAutor ostrokach