org.python.modules._collections

## Class PyDeque

- java.lang.Object
- - org.python.core.PyObject
  - - org.python.modules._collections.PyDeque

- All Implemented Interfaces:
    java.io.Serializable, Traverseproc
  Direct Known Subclasses:
    PyDequeDerived

      public class PyDeque
      extends PyObject
      implements Traverseproc

  PyDeque - This class implements the functionalities of Deque data structure. Deques are a generalization of stacks and queues (the name is pronounced 'deck' and is short for 'double-ended queue'). Deques support thread-safe, memory efficient appends and pops from either side of the deque with approximately the same O(1) performance in either direction. Though list objects support similar operations, they are optimized for fast fixed-length operations and incur O(n) memory movement costs for pop(0) and insert(0, v) operations which change both the size and position of the underlying data representation. collections.deque([iterable[, maxlen]]) - returns a new deque object initialized left-to-right (using append()) with data from iterable. If iterable is not specified, the new deque is empty. If maxlen is not specified or is None, deques may grow to an arbitrary length. Otherwise, the deque is bounded to the specified maximum length. Once a bounded length deque is full, when new items are added, a corresponding number of items are discarded from the opposite end.
  See Also:
    Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.python.core.PyObject

      `PyObject.ConversionException`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static PyType` | `TYPE`

    - ### Fields inherited from class org.python.core.PyObject

      `gcMonitorGlobal`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PyDeque()`
    `PyDeque(PyType subType)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `__delitem__(PyObject key)` Equivalent to the standard Python __delitem__ method.
    `PyObject` | `__eq__(PyObject o)` Equivalent to the standard Python __eq__ method.
    `PyObject` | `__finditem__(PyObject key)` Very similar to the standard Python __getitem__ method.
    `PyObject` | `__ge__(PyObject o)` Equivalent to the standard Python __ge__ method.
    `PyObject` | `__gt__(PyObject o)` Equivalent to the standard Python __gt__ method.
    `PyObject` | `__iadd__(PyObject o)` Equivalent to the standard Python __iadd__ method.
    `PyObject` | `__iter__()` Return an iterator that is used to iterate the element of this sequence.
    `PyObject` | `__le__(PyObject o)` Equivalent to the standard Python __le__ method.
    `int` | `__len__()` Equivalent to the standard Python __len__ method.
    `PyObject` | `__lt__(PyObject o)` Equivalent to the standard Python __lt__ method.
    `PyObject` | `__ne__(PyObject o)` Equivalent to the standard Python __ne__ method.
    `boolean` | `__nonzero__()` Equivalent to the standard Python __nonzero__ method.
    `PyObject` | `__reduce__()` Used for pickling.
    `void` | `__setitem__(PyObject index, PyObject value)` Equivalent to the standard Python __setitem__ method.
    `void` | `deque___init__(PyObject[] args, java.lang.String[] kwds)`
    `void` | `deque_append(PyObject obj)` Add obj to the right side of the deque.
    `void` | `deque_appendleft(PyObject obj)` Add obj to the left side of the deque.
    `void` | `deque_clear()` Remove all elements from the deque leaving it with length 0.
    `PyObject` | `deque_count(PyObject x)` Count the number of deque elements equal to x.
    `void` | `deque_extend(PyObject iterable)` Extend the right side of the deque by appending elements from the iterable argument.
    `void` | `deque_extendleft(PyObject iterable)` Extend the left side of the deque by appending elements from iterable.
    `PyObject` | `deque_pop()` Remove and return an element from the right side of the deque.
    `PyObject` | `deque_popleft()` Remove and return an element from the left side of the deque.
    `PyObject` | `deque_remove(PyObject value)` Removed the first occurrence of value.
    `PyObject` | `deque_reverse()` Reverse the elements of the deque in-place and then return None.
    `void` | `deque_rotate(int steps)` Rotate the deque n steps to the right.
    `PyObject` | `getMaxlen()` If maxlen is not specified or is None, deques may grow to an arbitrary length.
    `int` | `hashCode()`
    `boolean` | `isMappingType()`
    `boolean` | `isSequenceType()`
    `boolean` | `refersDirectlyTo(PyObject ob)` Optional operation.
    `void` | `setMaxlen(PyObject o)`
    `java.lang.String` | `toString()`
    `int` | `traverse(Visitproc visit, java.lang.Object arg)` Traverses all directly contained `PyObject`s.

    - ### Methods inherited from class org.python.core.PyObject

      `__abs__, __add__, __and__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __cmp__, __coerce__, __coerce_ex__, __complex__, __contains__, __delattr__, __delattr__, __delete__, __delitem__, __delslice__, __delslice__, __dir__, __div__, __divmod__, __ensure_finalizer__, __findattr__, __findattr__, __findattr_ex__, __finditem__, __finditem__, __float__, __floordiv__, __format__, __get__, __getattr__, __getattr__, __getitem__, __getitem__, __getnewargs__, __getslice__, __getslice__, __hash__, __hex__, __iand__, __idiv__, __idivmod__, __ifloordiv__, __ilshift__, __imod__, __imul__, __index__, __int__, __invert__, __ior__, __ipow__, __irshift__, __isub__, __iternext__, __itruediv__, __ixor__, __long__, __lshift__, __mod__, __mul__, __neg__, __not__, __oct__, __or__, __pos__, __pow__, __pow__, __radd__, __rand__, __rdiv__, __rdivmod__, __reduce_ex__, __reduce_ex__, __repr__, __rfloordiv__, __rlshift__, __rmod__, __rmul__, __ror__, __rpow__, __rrshift__, __rshift__, __rsub__, __rtruediv__, __rxor__, __set__, __setattr__, __setattr__, __setitem__, __setitem__, __setslice__, __setslice__, __str__, __sub__, __tojava__, __truediv__, __trunc__, __unicode__, __xor__, _add, _and, _callextra, _cmp, _div, _divmod, _doget, _doget, _doset, _eq, _floordiv, _ge, _gt, _iadd, _iand, _idiv, _idivmod, _ifloordiv, _ilshift, _imod, _imul, _in, _ior, _ipow, _irshift, _is, _isnot, _isub, _itruediv, _ixor, _jcall, _jcallexc, _jthrow, _le, _lshift, _lt, _mod, _mul, _ne, _notin, _or, _pow, _rshift, _sub, _truediv, _xor, asDouble, asIndex, asIndex, asInt, asInt, asIterable, asLong, asLong, asName, asName, asString, asString, asStringOrNull, asStringOrNull, bit_length, conjugate, delDict, delType, dispatch__init__, equals, fastGetClass, fastGetDict, getDict, getType, implementsDescrDelete, implementsDescrGet, implementsDescrSet, invoke, invoke, invoke, invoke, invoke, invoke, isCallable, isDataDescr, isIndex, isInteger, isNumberType, noAttributeError, object___subclasshook__, readonlyAttributeError, setDict, setType`

    - ### Methods inherited from class java.lang.Object

      `getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### TYPE

          public static final PyType TYPE

  - ### Constructor Detail

    - #### PyDeque

          public PyDeque()

    - #### PyDeque

          public PyDeque(PyType subType)

  - ### Method Detail

    - #### deque___init__

          public final void deque___init__(PyObject[] args,
                                           java.lang.String[] kwds)

    - #### getMaxlen

          public PyObject getMaxlen()

      If maxlen is not specified or is None, deques may grow to an arbitrary length. Otherwise, the deque is bounded to the specified maximum length.

    - #### setMaxlen

          public void setMaxlen(PyObject o)

    - #### deque_append

          public final void deque_append(PyObject obj)

      Add obj to the right side of the deque.

    - #### deque_appendleft

          public final void deque_appendleft(PyObject obj)

      Add obj to the left side of the deque.

    - #### deque_clear

          public final void deque_clear()

      Remove all elements from the deque leaving it with length 0.

    - #### deque_extend

          public final void deque_extend(PyObject iterable)

      Extend the right side of the deque by appending elements from the iterable argument.

    - #### deque_extendleft

          public final void deque_extendleft(PyObject iterable)

      Extend the left side of the deque by appending elements from iterable. Note, the series of left appends results in reversing the order of elements in the iterable argument.

    - #### deque_pop

          public final PyObject deque_pop()

      Remove and return an element from the right side of the deque. If no elements are present, raises an IndexError.

    - #### deque_popleft

          public final PyObject deque_popleft()

      Remove and return an element from the left side of the deque. If no elements are present, raises an IndexError.

    - #### deque_remove

          public final PyObject deque_remove(PyObject value)

      Removed the first occurrence of value. If not found, raises a ValueError.

    - #### deque_count

          public final PyObject deque_count(PyObject x)

      Count the number of deque elements equal to x.

    - #### deque_rotate

          public final void deque_rotate(int steps)

      Rotate the deque n steps to the right. If n is negative, rotate to the left. Rotating one step to the right is equivalent to: d.appendleft(d.pop()).

    - #### deque_reverse

          public final PyObject deque_reverse()

      Reverse the elements of the deque in-place and then return None.
      Returns:
        Py.None

    - #### toString

          public java.lang.String toString()

      Overrides:
        `toString` in class `PyObject`

    - #### __len__

          public int __len__()

      Description copied from class: `PyObject`
      Equivalent to the standard Python __len__ method. Part of the mapping discipline.
      Overrides:
        `__len__` in class `PyObject`
      Returns:
        the length of the object

    - #### __nonzero__

          public boolean __nonzero__()

      Description copied from class: `PyObject`
      Equivalent to the standard Python __nonzero__ method. Returns whether of not a given `PyObject` is considered true.
      Overrides:
        `__nonzero__` in class `PyObject`

    - #### __finditem__

          public PyObject __finditem__(PyObject key)

      Description copied from class: `PyObject`
      Very similar to the standard Python __getitem__ method. Instead of throwing a KeyError if the item isn't found, this just returns null. Classes that wish to implement __getitem__ should override this method instead (with the appropriate semantics.
      Overrides:
        `__finditem__` in class `PyObject`
      Parameters:
        `key` - the key to lookup in this container
      Returns:
        the value corresponding to key or null if key is not found

    - #### __setitem__

          public void __setitem__(PyObject index,
                                  PyObject value)

      Description copied from class: `PyObject`
      Equivalent to the standard Python __setitem__ method.
      Overrides:
        `__setitem__` in class `PyObject`
      Parameters:
        `index` - the key whose value will be set
        `value` - the value to set this key to

    - #### __delitem__

          public void __delitem__(PyObject key)

      Description copied from class: `PyObject`
      Equivalent to the standard Python __delitem__ method.
      Overrides:
        `__delitem__` in class `PyObject`
      Parameters:
        `key` - the key to be removed from the container

    - #### __iter__

          public PyObject __iter__()

      Description copied from class: `PyObject`
      Return an iterator that is used to iterate the element of this sequence. From version 2.2, this method is the primary protocol for looping over sequences.

      If a PyObject subclass should support iteration based in the __finditem__() method, it must supply an implementation of __iter__() like this:

           public PyObject __iter__() {
               return new PySequenceIter(this);
           }

      When iterating over a python sequence from java code, it should be done with code like this:

           for (PyObject item : seq.asIterable()) {
               // Do something with item
           }

      Overrides:
        `__iter__` in class `PyObject`

    - #### __eq__

          public PyObject __eq__(PyObject o)

      Description copied from class: `PyObject`
      Equivalent to the standard Python __eq__ method.
      Overrides:
        `__eq__` in class `PyObject`
      Parameters:
        `o` - the object to compare this with.
      Returns:
        the result of the comparison.

    - #### __ne__

          public PyObject __ne__(PyObject o)

      Description copied from class: `PyObject`
      Equivalent to the standard Python __ne__ method.
      Overrides:
        `__ne__` in class `PyObject`
      Parameters:
        `o` - the object to compare this with.
      Returns:
        the result of the comparison.

    - #### __lt__

          public PyObject __lt__(PyObject o)

      Description copied from class: `PyObject`
      Equivalent to the standard Python __lt__ method.
      Overrides:
        `__lt__` in class `PyObject`
      Parameters:
        `o` - the object to compare this with.
      Returns:
        the result of the comparison.

    - #### __le__

          public PyObject __le__(PyObject o)

      Description copied from class: `PyObject`
      Equivalent to the standard Python __le__ method.
      Overrides:
        `__le__` in class `PyObject`
      Parameters:
        `o` - the object to compare this with.
      Returns:
        the result of the comparison.

    - #### __gt__

          public PyObject __gt__(PyObject o)

      Description copied from class: `PyObject`
      Equivalent to the standard Python __gt__ method.
      Overrides:
        `__gt__` in class `PyObject`
      Parameters:
        `o` - the object to compare this with.
      Returns:
        the result of the comparison.

    - #### __ge__

          public PyObject __ge__(PyObject o)

      Description copied from class: `PyObject`
      Equivalent to the standard Python __ge__ method.
      Overrides:
        `__ge__` in class `PyObject`
      Parameters:
        `o` - the object to compare this with.
      Returns:
        the result of the comparison.

    - #### __iadd__

          public PyObject __iadd__(PyObject o)

      Description copied from class: `PyObject`
      Equivalent to the standard Python __iadd__ method.
      Overrides:
        `__iadd__` in class `PyObject`
      Parameters:
        `o` - the object to perform this binary operation with (the right-hand operand).
      Returns:
        the result of the iadd, or null if this operation is not defined

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `PyObject`

    - #### __reduce__

          public PyObject __reduce__()

      Description copied from class: `PyObject`
      Used for pickling. Default implementation calls object___reduce__.
      Overrides:
        `__reduce__` in class `PyObject`
      Returns:
        a tuple of (class, tuple)

    - #### isMappingType

          public boolean isMappingType()

      Overrides:
        `isMappingType` in class `PyObject`

    - #### isSequenceType

          public boolean isSequenceType()

      Overrides:
        `isSequenceType` in class `PyObject`

    - #### traverse

          public int traverse(Visitproc visit,
                              java.lang.Object arg)

      Description copied from interface: `Traverseproc`
      Traverses all directly contained `PyObject`s. Like in CPython, `arg` must be passed unmodified to `visit` as its second parameter. If `Visitproc.visit(PyObject, Object)` returns nonzero, this return value must be returned immediately by traverse. `Visitproc.visit(PyObject, Object)` must not be called with a `null` PyObject-argument.
      Specified by:
        `traverse` in interface `Traverseproc`

    - #### refersDirectlyTo

          public boolean refersDirectlyTo(PyObject ob)
                                   throws java.lang.UnsupportedOperationException

      Description copied from interface: `Traverseproc`
      Optional operation. Should only be implemented if it is more efficient than calling `Traverseproc.traverse(Visitproc, Object)` with a visitproc that just watches out for `ob`. Must return `false` if `ob` is `null`.
      Specified by:
        `refersDirectlyTo` in interface `Traverseproc`
      Throws:
        `java.lang.UnsupportedOperationException`

Jython homepage