view.show_popup("None\n<br>Mutable Sequence Types<br>**********************<br><br>List and ``bytearray`` objects support additional operations that<br>allow in-place modification of the object. Other mutable sequence<br>types (when added to the language) should also support these<br>operations. Strings and tuples are immutable sequence types: such<br>objects cannot be modified once created. The following operations are<br>defined on mutable sequence types (where *x* is an arbitrary object):<br><br>+--------------------------------+----------------------------------+-----------------------+<br>| Operation                      | Result                           | Notes                 |<br>+================================+==================================+=======================+<br>| ``s[i] = x``                   | item *i* of *s* is replaced by   |                       |<br>|                                | *x*                              |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s[i:j] = t``                 | slice of *s* from *i* to *j* is  |                       |<br>|                                | replaced by the contents of the  |                       |<br>|                                | iterable *t*                     |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``del s[i:j]``                 | same as ``s[i:j] = []``          |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s[i:j:k] = t``               | the elements of ``s[i:j:k]`` are | (1)                   |<br>|                                | replaced by those of *t*         |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``del s[i:j:k]``               | removes the elements of          |                       |<br>|                                | ``s[i:j:k]`` from the list       |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.append(x)``                | same as ``s[len(s):len(s)] =     | (2)                   |<br>|                                | [x]``                            |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.extend(x)``                | same as ``s[len(s):len(s)] = x`` | (3)                   |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.count(x)``                 | return number of *i*'s for which |                       |<br>|                                | ``s[i] == x``                    |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.index(x[, i[, j]])``       | return smallest *k* such that    | (4)                   |<br>|                                | ``s[k] == x`` and ``i <= k < j`` |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.insert(i, x)``             | same as ``s[i:i] = [x]``         | (5)                   |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.pop([i])``                 | same as ``x = s[i]; del s[i];    | (6)                   |<br>|                                | return x``                       |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.remove(x)``                | same as ``del s[s.index(x)]``    | (4)                   |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.reverse()``                | reverses the items of *s* in     | (7)                   |<br>|                                | place                            |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.sort([cmp[, key[,          | sort the items of *s* in place   | (7)(8)(9)(10)         |<br>| reverse]]])``                  |                                  |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br><br>Notes:<br><br>1. *t* must have the same length as the slice it is  replacing.<br><br>2. The C implementation of Python has historically accepted multiple<br>   parameters and implicitly joined them into a tuple; this no longer<br>   works in Python 2.0.  Use of this misfeature has been deprecated<br>   since Python 1.4.<br><br>3. *x* can be any iterable object.<br><br>4. Raises ``ValueError`` when *x* is not found in *s*. When a negative<br>   index is passed as the second or third parameter to the ``index()``<br>   method, the list length is added, as for slice indices.  If it is<br>   still negative, it is truncated to zero, as for slice indices.<br><br>   Changed in version 2.3: Previously, ``index()`` didn't have<br>   arguments for specifying start and stop positions.<br><br>5. When a negative index is passed as the first parameter to the<br>   ``insert()`` method, the list length is added, as for slice<br>   indices.  If it is still negative, it is truncated to zero, as for<br>   slice indices.<br><br>   Changed in version 2.3: Previously, all negative indices were<br>   truncated to zero.<br><br>6. The ``pop()`` method's optional argument *i* defaults to ``-1``, so<br>   that by default the last item is removed and returned.<br><br>7. The ``sort()`` and ``reverse()`` methods modify the list in place<br>   for economy of space when sorting or reversing a large list.  To<br>   remind you that they operate by side effect, they don't return the<br>   sorted or reversed list.<br><br>8. The ``sort()`` method takes optional arguments for controlling the<br>   comparisons.<br><br>   *cmp* specifies a custom comparison function of two arguments (list<br>   items) which should return a negative, zero or positive number<br>   depending on whether the first argument is considered smaller than,<br>   equal to, or larger than the second argument: ``cmp=lambda x,y:<br>   cmp(x.lower(), y.lower())``.  The default value is ``None``.<br><br>   *key* specifies a function of one argument that is used to extract<br>   a comparison key from each list element: ``key=str.lower``.  The<br>   default value is ``None``.<br><br>   *reverse* is a boolean value.  If set to ``True``, then the list<br>   elements are sorted as if each comparison were reversed.<br><br>   In general, the *key* and *reverse* conversion processes are much<br>   faster than specifying an equivalent *cmp* function.  This is<br>   because *cmp* is called multiple times for each list element while<br>   *key* and *reverse* touch each element only once.  Use<br>   ``functools.cmp_to_key()`` to convert an old-style *cmp* function<br>   to a *key* function.<br><br>   Changed in version 2.3: Support for ``None`` as an equivalent to<br>   omitting *cmp* was added.<br><br>   Changed in version 2.4: Support for *key* and *reverse* was added.<br><br>9. Starting with Python 2.3, the ``sort()`` method is guaranteed to be<br>   stable.  A sort is stable if it guarantees not to change the<br>   relative order of elements that compare equal --- this is helpful<br>   for sorting in multiple passes (for example, sort by department,<br>   then by salary grade).<br><br>10. **CPython implementation detail:** While a list is being sorted,<br>    the effect of attempting to mutate, or even inspect, the list is<br>    undefined.  The C implementation of Python 2.3 and newer makes the<br>    list appear empty for the duration, and raises ``ValueError`` if<br>    it can detect that the list has been mutated during a sort.<br>")