.. index:: py::builtins::list .. _doxycast_pypp_classpy_1_1builtins_1_1list: .. _py-builtins-list: *py::builtins::*\ list ====================== *Defined in* ```` .. code-block:: cpp template < class type, class allocator = std::allocator > class list; Container for holding and randomly accessing elements of a single type. ``py::builtins::list`` allows to hold elements of a single type and access them randomly in constant time. This container stores element contiguously, so elements can be accessed with offsets on pointers to other elements (not applicable when element type is ``bool``, see :ref:`below `). .. _list-uses-std-vector: .. note:: ``py::builtins::list`` uses ``std::vector`` to hold elements, so when using this container to hold element of type ``bool``, every element usually uses a bit instead of a byte (*depends on the C++ standard library implementation*). Template parameters ------------------- ``type``: The type of elements. ``allocator``: The type of allocator. Members ------- * :ref:`value_type ` * :ref:`allocator_type ` * :ref:`size_type ` * :ref:`difference_type ` * :ref:`reference ` * :ref:`const_reference ` * :ref:`pointer ` * :ref:`const_pointer ` * :ref:`iterator ` * :ref:`const_iterator ` * :ref:`reverse_iterator ` * :ref:`const_reverse_iterator ` * :ref:`list ` * :ref:`count ` * :ref:`size ` * :ref:`index ` * :ref:`append ` * :ref:`insert ` * :ref:`extend ` * :ref:`clear ` * :ref:`pop ` * :ref:`remove ` * :ref:`sort ` * :ref:`reverse ` * :ref:`begin ` * :ref:`cbegin ` * :ref:`rbegin ` * :ref:`crbegin ` * :ref:`end ` * :ref:`cend ` * :ref:`rend ` * :ref:`crend ` * :ref:`operator [] ` * :ref:`operator = ` .. toctree:: :hidden: value_type allocator_type size_type difference_type reference const_reference pointer const_pointer iterator const_iterator reverse_iterator const_reverse_iterator list count size index append insert extend clear pop remove sort reverse begin cbegin rbegin crbegin end cend rend crend operator [] operator = Non-member helpers ------------------ * :ref:`operator \< ` * :ref:`operator > ` * :ref:`operator == ` * :ref:`operator != ` * :ref:`operator \<= ` * :ref:`operator >= ` Example ------- .. code-block:: cpp #include #include int main() { py::list list = {0, 1, 2, 3, 4, 5, 6}; py::print(list); list.append(7); py::print(list); } **Output**: .. code-block:: text {0, 1, 2, 3, 4, 5, 6} {0, 1, 2, 3, 4, 5, 6, 7}