U
|
Z ±dqM ã @ s¤ d Z ddlmZ ddlmZmZmZmZmZm Z ddl
|
m Z ddl m Z mZ zddlmZmZmZ W n( ek
|
r ddlmZmZmZ Y nX G dd d eeZd
|
S ) aE Sorted Set
|
=============
|
|
:doc:`Sorted Containers<index>` is an Apache2 licensed Python sorted
|
collections library, written in pure-Python, and fast as C-extensions. The
|
:doc:`introduction<introduction>` is the best way to get started.
|
|
Sorted set implementations:
|
|
.. currentmodule:: sortedcontainers
|
|
* :class:`SortedSet`
|
|
é )Úchain)ÚeqÚneÚgtÚgeÚltÚle)Údedenté )Ú
|
SortedListÚrecursive_repr)Ú
|
MutableSetÚSequenceÚSetc @ s e Zd ZdZdHddZedIddZedd Zd d
|
Z d d Z
|
d d Z dd Z e e ddZe eddZe eddZe eddZe eddZe edd Zee Z d d Zd d Zd!d" Z d#d$ Z e Z d%d& Z d'd( Z e Z!d)d* Z"d+d, Z#e#Z$dJd.d/Z%d0d1 Z&d2d3 Z'e'Z(d4d5 Z)e)Z*d6d7 Z+e+Z,e,Z-d8d9 Z.e.Z/d:d; Z0e0Z1e1Z2d<d= Z3e3Z4d>d? Z5e5Z6e6Z7d@dA Z8e8Z9e8Z:dBdC Z;e< dDdE Z=dFdG Z>dS )KÚ SortedSetaû Sorted set is a sorted mutable set.
|
|
Sorted set values are maintained in sorted order. The design of sorted set
|
is simple: sorted set uses a set for set-operations and maintains a sorted
|
list of values.
|
|
Sorted set values must be hashable and comparable. The hash and total
|
ordering of values must not change while they are stored in the sorted set.
|
|
Mutable set methods:
|
|
* :func:`SortedSet.__contains__`
|
* :func:`SortedSet.__iter__`
|
* :func:`SortedSet.__len__`
|
* :func:`SortedSet.add`
|
* :func:`SortedSet.discard`
|
|
Sequence methods:
|
|
* :func:`SortedSet.__getitem__`
|
* :func:`SortedSet.__delitem__`
|
* :func:`SortedSet.__reversed__`
|
|
Methods for removing values:
|
|
* :func:`SortedSet.clear`
|
* :func:`SortedSet.pop`
|
* :func:`SortedSet.remove`
|
|
Set-operation methods:
|
|
* :func:`SortedSet.difference`
|
* :func:`SortedSet.difference_update`
|
* :func:`SortedSet.intersection`
|
* :func:`SortedSet.intersection_update`
|
* :func:`SortedSet.symmetric_difference`
|
* :func:`SortedSet.symmetric_difference_update`
|
* :func:`SortedSet.union`
|
* :func:`SortedSet.update`
|
|
Methods for miscellany:
|
|
* :func:`SortedSet.copy`
|
* :func:`SortedSet.count`
|
* :func:`SortedSet.__repr__`
|
* :func:`SortedSet._check`
|
|
Sorted list methods available:
|
|
* :func:`SortedList.bisect_left`
|
* :func:`SortedList.bisect_right`
|
* :func:`SortedList.index`
|
* :func:`SortedList.irange`
|
* :func:`SortedList.islice`
|
* :func:`SortedList._reset`
|
|
Additional sorted list methods available, if key-function used:
|
|
* :func:`SortedKeyList.bisect_key_left`
|
* :func:`SortedKeyList.bisect_key_right`
|
* :func:`SortedKeyList.irange_key`
|
|
Sorted set comparisons use subset and superset relations. Two sorted sets
|
are equal if and only if every element of each sorted set is contained in
|
the other (each is a subset of the other). A sorted set is less than
|
another sorted set if and only if the first sorted set is a proper subset
|
of the second sorted set (is a subset, but is not equal). A sorted set is
|
greater than another sorted set if and only if the first sorted set is a
|
proper superset of the second sorted set (is a superset, but is not equal).
|
|
Nc C s || _ t| dst | _t| j|d| _| j}|j| _|j| _|j| _| j}|j | _ |j
|
| _
|
|j | _ |j | _ |j | _ |j| _|j| _|dk r¬|j| _|j| _|j| _|j| _|dk r¾| |¡ dS )a Initialize sorted set instance.
|
|
Optional `iterable` argument provides an initial iterable of values to
|
initialize the sorted set.
|
|
Optional `key` argument defines a callable that, like the `key`
|
argument to Python's `sorted` function, extracts a comparison key from
|
each value. The default, none, compares values directly.
|
|
Runtime complexity: `O(n*log(n))`
|
|
>>> ss = SortedSet([3, 1, 2, 5, 4])
|
>>> ss
|
SortedSet([1, 2, 3, 4, 5])
|
>>> from operator import neg
|
>>> ss = SortedSet([3, 1, 2, 5, 4], neg)
|
>>> ss
|
SortedSet([5, 4, 3, 2, 1], key=<built-in function neg>)
|
|
:param iterable: initial values (optional)
|
:param key: function used to extract comparison key (optional)
|
|
Ú_set©ÚkeyN)Ú_keyÚhasattrÚsetr r Ú_listÚ
|
isdisjointÚissubsetÚ
|
issupersetÚ bisect_leftÚbisectÚ bisect_rightÚindexZirangeÚisliceZ_resetZbisect_key_leftZbisect_key_rightZ
|
bisect_keyZ
|
irange_keyÚ_update)ÚselfÚiterabler r r © r# úQd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sortedcontainers/sortedset.pyÚ__init__l s.
|
zSortedSet.__init__c C s t | ¡}||_|j|d |S )ztInitialize sorted set from existing set.
|
|
Used internally by set operations that return a new set.
|
|
r )ÚobjectÚ__new__r r% )ÚclsÚvaluesr Z
|
sorted_setr# r# r$ Ú_fromset« s
|
zSortedSet._fromsetc C s | j S )zFunction used to extract comparison key from values.
|
|
Sorted set compares values directly when the key function is none.
|
|
)r ©r! r# r# r$ r ¸ s z SortedSet.keyc C s
|
|| j kS )aQ Return true if `value` is an element of the sorted set.
|
|
``ss.__contains__(value)`` <==> ``value in ss``
|
|
Runtime complexity: `O(1)`
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> 3 in ss
|
True
|
|
:param value: search for value in sorted set
|
:return: true if `value` in sorted set
|
|
©r ©r! Úvaluer# r# r$ Ú __contains__Â s zSortedSet.__contains__c C s
|
| j | S )aØ Lookup value at `index` in sorted set.
|
|
``ss.__getitem__(index)`` <==> ``ss[index]``
|
|
Supports slicing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> ss = SortedSet('abcde')
|
>>> ss[2]
|
'c'
|
>>> ss[-1]
|
'e'
|
>>> ss[2:5]
|
['c', 'd', 'e']
|
|
:param index: integer or slice for indexing
|
:return: value or list of values
|
:raises IndexError: if index out of range
|
|
)r )r! r r# r# r$ Ú __getitem__Ô s zSortedSet.__getitem__c C sF | j }| j}t|tr*|| }| |¡ n|| }| |¡ ||= dS )aÝ Remove value at `index` from sorted set.
|
|
``ss.__delitem__(index)`` <==> ``del ss[index]``
|
|
Supports slicing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> ss = SortedSet('abcde')
|
>>> del ss[2]
|
>>> ss
|
SortedSet(['a', 'b', 'd', 'e'])
|
>>> del ss[:2]
|
>>> ss
|
SortedSet(['d', 'e'])
|
|
:param index: integer or slice for indexing
|
:raises IndexError: if index out of range
|
|
N)r r Ú
|
isinstanceÚsliceÚdifference_updateÚremove)r! r r r r) r. r# r# r$ Ú __delitem__í s
|
|
zSortedSet.__delitem__c s: fdd} j }d |¡|_ d}t| |||¡|_|S )zMake comparator method.c s2 t |tr | j|jS t |tr. | j|S tS )z&Compare method for sorted set and set.)r1 r r r ÚNotImplemented)r! Úother©Úset_opr# r$ Úcomparer s
|
|
|
z&SortedSet.__make_cmp.<locals>.comparerz__{0}__a3 Return true if and only if sorted set is {0} `other`.
|
|
``ss.__{1}__(other)`` <==> ``ss {2} other``
|
|
Comparisons use subset and superset semantics as with sets.
|
|
Runtime complexity: `O(n)`
|
|
:param other: `other` set
|
:return: true if sorted set is {0} `other`
|
|
)Ú__name__Úformatr Ú__doc__)r9 ÚsymbolÚdocr: Z set_op_nameZdoc_strr# r8 r$ Z
|
__make_cmp s zSortedSet.__make_cmpz==zequal toz!=z not equal toú<za proper subset ofú>za proper superset ofz<=z a subset ofz>=z a superset ofc C s
|
t | jS )z|Return the size of the sorted set.
|
|
``ss.__len__()`` <==> ``len(ss)``
|
|
:return: size of sorted set
|
|
)Úlenr r+ r# r# r$ Ú__len__2 s zSortedSet.__len__c C s
|
t | jS )zìReturn an iterator over the sorted set.
|
|
``ss.__iter__()`` <==> ``iter(ss)``
|
|
Iterating the sorted set while adding or deleting values may raise a
|
:exc:`RuntimeError` or fail to iterate over all values.
|
|
)Úiterr r+ r# r# r$ Ú__iter__= s zSortedSet.__iter__c C s
|
t | jS )zûReturn a reverse iterator over the sorted set.
|
|
``ss.__reversed__()`` <==> ``reversed(ss)``
|
|
Iterating the sorted set while adding or deleting values may raise a
|
:exc:`RuntimeError` or fail to iterate over all values.
|
|
)Úreversedr r+ r# r# r$ Ú __reversed__I s zSortedSet.__reversed__c C s( | j }||kr$| |¡ | j |¡ dS )a Add `value` to sorted set.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> ss = SortedSet()
|
>>> ss.add(3)
|
>>> ss.add(1)
|
>>> ss.add(2)
|
>>> ss
|
SortedSet([1, 2, 3])
|
|
:param value: value to add to sorted set
|
|
N)r Úaddr ©r! r. r r# r# r$ rH U s
|
z SortedSet.addc C s | j ¡ | j ¡ dS )zPRemove all values from sorted set.
|
|
Runtime complexity: `O(n)`
|
|
N)r Úclearr r+ r# r# r$ rJ l s
|
zSortedSet.clearc C s | j t| j| jdS )zwReturn a shallow copy of the sorted set.
|
|
Runtime complexity: `O(n)`
|
|
:return: new sorted set
|
|
r )r* r r r r+ r# r# r$ Úcopyv s zSortedSet.copyc C s || j krdS dS )a Return number of occurrences of `value` in the sorted set.
|
|
Runtime complexity: `O(1)`
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> ss.count(3)
|
1
|
|
:param value: value to count in sorted set
|
:return: count
|
|
r
|
r r, r- r# r# r$ Úcount s zSortedSet.countc C s( | j }||kr$| |¡ | j |¡ dS )aq Remove `value` from sorted set if it is a member.
|
|
If `value` is not a member, do nothing.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> ss.discard(5)
|
>>> ss.discard(0)
|
>>> ss == set([1, 2, 3, 4])
|
True
|
|
:param value: `value` to discard from sorted set
|
|
N©r r4 r rI r# r# r$ Údiscard s
|
zSortedSet.discardéÿÿÿÿc C s | j |¡}| j |¡ |S )a Remove and return value at `index` in sorted set.
|
|
Raise :exc:`IndexError` if the sorted set is empty or index is out of
|
range.
|
|
Negative indices are supported.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> ss = SortedSet('abcde')
|
>>> ss.pop()
|
'e'
|
>>> ss.pop(2)
|
'c'
|
>>> ss
|
SortedSet(['a', 'b', 'd'])
|
|
:param int index: index of value (default -1)
|
:return: value
|
:raises IndexError: if index is out of range
|
|
)r Úpopr r4 )r! r r. r# r# r$ rP « s z SortedSet.popc C s | j |¡ | j |¡ dS )a Remove `value` from sorted set; `value` must be a member.
|
|
If `value` is not a member, raise :exc:`KeyError`.
|
|
Runtime complexity: `O(log(n))` -- approximate.
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> ss.remove(5)
|
>>> ss == set([1, 2, 3, 4])
|
True
|
>>> ss.remove(0)
|
Traceback (most recent call last):
|
...
|
KeyError: 0
|
|
:param value: `value` to remove from sorted set
|
:raises KeyError: if `value` is not in sorted set
|
|
NrM r- r# r# r$ r4 È s zSortedSet.removec G s | j j| }| j|| jdS )aï Return the difference of two or more sets as a new sorted set.
|
|
The `difference` method also corresponds to operator ``-``.
|
|
``ss.__sub__(iterable)`` <==> ``ss - iterable``
|
|
The difference is all values that are in this sorted set but not the
|
other `iterables`.
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> ss.difference([4, 5, 6, 7])
|
SortedSet([1, 2, 3])
|
|
:param iterables: iterable arguments
|
:return: new sorted set
|
|
r )r Ú
|
differencer* r )r! Ú iterablesÚdiffr# r# r$ rQ à s zSortedSet.differencec G sf | j }| j}tt| }dt| t|krJ| |¡ | ¡ | |¡ n| j}|D ] }|| qT| S )a Remove all values of `iterables` from this sorted set.
|
|
The `difference_update` method also corresponds to operator ``-=``.
|
|
``ss.__isub__(iterable)`` <==> ``ss -= iterable``
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> _ = ss.difference_update([4, 5, 6, 7])
|
>>> ss
|
SortedSet([1, 2, 3])
|
|
:param iterables: iterable arguments
|
:return: itself
|
|
é ) r r r r rB r3 rJ ÚupdateÚ_discard)r! rR r r r) rV r. r# r# r$ r3 ø s
|
|
zSortedSet.difference_updatec G s | j j| }| j|| jdS )aø Return the intersection of two or more sets as a new sorted set.
|
|
The `intersection` method also corresponds to operator ``&``.
|
|
``ss.__and__(iterable)`` <==> ``ss & iterable``
|
|
The intersection is all values that are in this sorted set and each of
|
the other `iterables`.
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> ss.intersection([4, 5, 6, 7])
|
SortedSet([4, 5])
|
|
:param iterables: iterable arguments
|
:return: new sorted set
|
|
r )r Ú intersectionr* r )r! rR Z intersectr# r# r$ rW s zSortedSet.intersectionc G s, | j }| j}|j| | ¡ | |¡ | S )aß Update the sorted set with the intersection of `iterables`.
|
|
The `intersection_update` method also corresponds to operator ``&=``.
|
|
``ss.__iand__(iterable)`` <==> ``ss &= iterable``
|
|
Keep only values found in itself and all `iterables`.
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> _ = ss.intersection_update([4, 5, 6, 7])
|
>>> ss
|
SortedSet([4, 5])
|
|
:param iterables: iterable arguments
|
:return: itself
|
|
)r r Úintersection_updaterJ rU )r! rR r r r# r# r$ rX 1 s
|
|
z SortedSet.intersection_updatec C s | j |¡}| j|| jdS )aó Return the symmetric difference with `other` as a new sorted set.
|
|
The `symmetric_difference` method also corresponds to operator ``^``.
|
|
``ss.__xor__(other)`` <==> ``ss ^ other``
|
|
The symmetric difference is all values tha are in exactly one of the
|
sets.
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> ss.symmetric_difference([4, 5, 6, 7])
|
SortedSet([1, 2, 3, 6, 7])
|
|
:param other: `other` iterable
|
:return: new sorted set
|
|
r )r Úsymmetric_differencer* r )r! r7 rS r# r# r$ rY M s z SortedSet.symmetric_differencec C s, | j }| j}| |¡ | ¡ | |¡ | S )a Update the sorted set with the symmetric difference with `other`.
|
|
The `symmetric_difference_update` method also corresponds to operator
|
``^=``.
|
|
``ss.__ixor__(other)`` <==> ``ss ^= other``
|
|
Keep only values found in exactly one of itself and `other`.
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> _ = ss.symmetric_difference_update([4, 5, 6, 7])
|
>>> ss
|
SortedSet([1, 2, 3, 6, 7])
|
|
:param other: `other` iterable
|
:return: itself
|
|
)r r Úsymmetric_difference_updaterJ rU )r! r7 r r r# r# r$ rZ f s
|
|
z%SortedSet.symmetric_difference_updatec G s | j tt| f| | jdS )a Return new sorted set with values from itself and all `iterables`.
|
|
The `union` method also corresponds to operator ``|``.
|
|
``ss.__or__(iterable)`` <==> ``ss | iterable``
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> ss.union([4, 5, 6, 7])
|
SortedSet([1, 2, 3, 4, 5, 6, 7])
|
|
:param iterables: iterable arguments
|
:return: new sorted set
|
|
r )Ú __class__r rD r )r! rR r# r# r$ Úunion s zSortedSet.unionc G sl | j }| j}tt| }dt| t|krP| j}| |¡ | ¡ | |¡ n| j}|D ] }|| qZ| S )a Update the sorted set adding values from all `iterables`.
|
|
The `update` method also corresponds to operator ``|=``.
|
|
``ss.__ior__(iterable)`` <==> ``ss |= iterable``
|
|
>>> ss = SortedSet([1, 2, 3, 4, 5])
|
>>> _ = ss.update([4, 5, 6, 7])
|
>>> ss
|
SortedSet([1, 2, 3, 4, 5, 6, 7])
|
|
:param iterables: iterable arguments
|
:return: itself
|
|
rT )r r r r rB rU rJ Ú_add)r! rR r r r) r] r. r# r# r$ rU s
|
|
zSortedSet.updatec C s t | | j| jffS )zSupport for pickle.
|
|
The tricks played with exposing methods in :func:`SortedSet.__init__`
|
confuse pickle so customize the reducer.
|
|
)Útyper r r+ r# r# r$ Ú
|
__reduce__º s zSortedSet.__reduce__c C s8 | j }|dkrdnd |¡}t| j}d |t| |¡S )zReturn string representation of sorted set.
|
|
``ss.__repr__()`` <==> ``repr(ss)``
|
|
:return: string representation
|
|
NÚ z , key={0!r}z {0}({1!r}{2}))r r< r^ r; Úlist)r! r r Z type_namer# r# r$ Ú__repr__Ä s
|
zSortedSet.__repr__c sF | j | j}| ¡ t t|ks(tt fdd|D sBtdS )zMCheck invariants of sorted set.
|
|
Runtime complexity: `O(n)`
|
|
c 3 s | ]}| kV qd S )Nr# )Ú.0r. r, r# r$ Ú <genexpr>Ý s z#SortedSet._check.<locals>.<genexpr>N)r r Ú_checkrB ÚAssertionErrorÚall)r! r r# r, r$ re Ó s
|
zSortedSet._check)NN)N)rO )?r; Ú
|
__module__Ú __qualname__r= r% Ú classmethodr* Úpropertyr r/ r0 r5 Z_SortedSet__make_cmpr Ú__eq__r Ú__ne__r Ú__lt__r Ú__gt__r Ú__le__r Ú__ge__Ú staticmethodrC rE rG rH r] rJ rK Ú__copy__rL rN rV rP r4 rQ Ú__sub__r3 Ú__isub__rW Ú__and__Ú__rand__rX Ú__iand__rY Ú__xor__Ú__rxor__rZ Ú__ixor__r\ Ú__or__Ú__ror__rU Ú__ior__r r_ r rb re r# r# r# r$ r $ sl G
|
?
|
|
|
|
|
|
r N)r= Ú itertoolsr Úoperatorr r r r r r Útextwrapr Z
|
sortedlistr r Úcollections.abcr r r Ú ImportErrorÚ collectionsr r# r# r# r$ Ú<module> s
|
