__len__()
, and 
__call__()
.
class 
collections.
Iterable
ABC for classes that  provide the 
__iter__()
method. See also the definition of
iterable.
class 
collections.
Iterator
ABC for classes that provide the 
__iter__()
and 
next()
methods. See also the
definition of iterator.
class 
collections.
Sequence
class 
collections.
MutableSequence
ABCs for read-only and mutable sequences.
class 
collections.
Set
class 
collections.
MutableSet
ABCs for read-only and mutable sets.
class 
collections.
Mapping
class 
collections.
MutableMapping
ABCs for read-only and mutable mappings.
class 
collections.
MappingView
class 
collections.
ItemsView
class 
collections.
KeysView
class 
collections.
ValuesView
ABCs for mapping, items, keys, and values views.
These ABCs allow us to ask classes or instances if they provide particular functionality,
for example:
size = None
if isinstance(myvar, collections.Sized):
size = len(myvar)
Several of the ABCs are also useful as mixins that make it easier to develop classes
supporting container APIs. For example, to write a class supporting the full 
Set
API, it
only  necessary  to  supply  the  three  underlying  abstract  methods: 
__contains__()
,
__iter__()
 and 
__len__()
 The  ABC  supplies  the  remaining  methods  such  as
__and__()
and 
isdisjoint()
Pdf file security - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
decrypt pdf with password; pdf security
Pdf file security - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
add security to pdf; secure pdf
class ListBasedSet(collections.Set):
''' Alternate set implementation favoring space over speed
and not requiring the set elements to be hashable. '''
def __init__(self, iterable):
self.elements = lst = []
for value in iterable:
if value not in lst:
lst.append(value)
def __iter__(self):
return iter(self.elements)
def __contains__(self, value):
return value in self.elements
def __len__(self):
return len(self.elements)
s1 = ListBasedSet('abcdef')
s2 = ListBasedSet('defghi')
overlap = s1 & s2 # The __and__() method is supported automatically
Notes on using 
Set
and 
MutableSet
as a mixin:
1. Since some set operations create new sets, the default mixin methods need a way to
create new instances from an iterable. The class constructor is assumed to have a
signature in the form 
ClassName(iterable)
. That assumption is factored-out to an
internal classmethod called 
_from_iterable()
which calls 
cls(iterable)
to produce
a new set. If the 
Set
mixin is being used in a class with a different constructor
signature, you will need to override 
_from_iterable()
with a classmethod that can
construct new instances from an iterable argument.
2. To override the comparisons (presumably for speed, as the semantics are fixed),
redefine 
__le__()
and then the other operations will automatically follow suit.
3. The 
Set
mixin provides a 
_hash()
method to compute a hash value for the set;
however, 
__hash__()
is not defined because not all sets are hashable or immutable.
To add set hashabilty using mixins, inherit from both 
Set()
and 
Hashable()
, then
define 
__hash__ = Set._hash
.
See also:
OrderedSet recipe for an example built on 
MutableSet
.
For more about ABCs, see the 
abc
module and PEP 3119.
index
modules |
next |
previous |
Python » Python v2.7.6 documentation » The Python Standard Library » 8. Data Types »
© Copyright
1990-2013, Python Software Foundation. 
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Nov 10, 2013. Found a bug
Created using Sphinx
1.0.7.
VB.NET PDF Password Library: add, remove, edit PDF file password
Remove password from PDF. Set PDF security level. This Visual Basic coding example will help you open an encrypted PDF file. ' Define input file path.
can print pdf security; add security to pdf document
C# PDF Password Library: add, remove, edit PDF file password in C#
advanced PDF password remover component can help users unlock PDF file without password. PDF document in C# project, XDoc.PDF provides some PDF security settings
create secure pdf; creating secure pdf files
index
modules |
next |
previous |
8.4. 
heapq
— Heap queue algorithm
New in version 2.3.
Source code: Lib/heapq.py
This module provides an implementation of the heap queue algorithm, also known as the
priority queue algorithm.
Heaps are binary trees for which every parent node has a value less than or equal to any
of its children. This implementation uses arrays for which 
heap[k] <= heap[2*k+1]
and
heap[k] <= heap[2*k+2]
for  all k,  counting  elements  from  zero. For  the sake  of
comparison, non-existing elements are considered to be infinite. The interesting property
of a heap is that its smallest element is always the root, 
heap[0]
.
The API below differs from textbook heap algorithms in two aspects: (a) We use zero-
based  indexing. This makes the relationship between the index for a node and the
indexes for its children slightly less obvious, but is more suitable since Python uses zero-
based indexing. (b) Our pop method returns the smallest item, not the largest (called a
“min heap” in textbooks; a “max heap” is more common in texts because of its suitability
for in-place sorting).
These two make it possible to view the heap as a regular Python list without surprises:
heap[0]
is the smallest item, and 
heap.sort()
maintains the heap invariant!
To create a heap, use a list initialized to 
[]
, or you can transform a populated list into a
heap via function 
heapify()
.
The following functions are provided:
heapq.
heappush
(
heap, item
)
Push the value item onto the heap, maintaining the heap invariant.
heapq.
heappop
(
heap
)
Pop and return the smallest item from the heap, maintaining the heap invariant. If the
heap is empty, 
IndexError
is raised.
heapq.
heappushpop
(
heap, item
)
Push item on the heap, then pop and return the smallest item from the heap. The
Python » Python v2.7.6 documentation » The Python Standard Library » 8. Data Types »
Online Split PDF file. Best free online split PDF tool.
You can use our .NET PDF SDK to set file split settings for your PDF You can receive the PDF files by simply clicking download and you are good to Web Security.
pdf password unlock; create encrypted pdf
Online Remove password from protected PDF file
You can receive the unlocked PDF by simply clicking download and you are good to go! Web Security. When you upload a file it is transmitted using a secure
convert locked pdf to word doc; pdf password security
combined action runs more efficiently than 
heappush()
followed by a separate call to
heappop()
.
New in version 2.6.
heapq.
heapify
(
x
)
Transform list x into a heap, in-place, in linear time.
heapq.
heapreplace
(
heap, item
)
Pop and return the smallest item from the heap, and also push the new item. The
heap size doesn’t change. If the heap is empty, 
IndexError
is raised.
This one step operation is more efficient than a 
heappop()
followed by 
heappush()
and  can  be  more  appropriate  when  using  a  fixed-size  heap.  The  pop/push
combination always returns an element from the heap and replaces it with item.
The value returned may be larger than the item added. If that isn’t desired, consider
using 
heappushpop()
instead. Its push/pop combination returns the smaller of the two
values, leaving the larger value on the heap.
The module also offers three general purpose functions based on heaps.
heapq.
merge
(
*iterables
)
Merge  multiple  sorted  inputs  into  a  single  sorted  output  (for  example,  merge
timestamped entries from multiple log  files). Returns  an iterator over the sorted
values.
Similar  to 
sorted(itertools.chain(*iterables))
but returns an iterable, does not
pull the data into memory all at once, and assumes that each of the input streams is
already sorted (smallest to largest).
New in version 2.6.
heapq.
nlargest
(
n, iterable
[
, key
]
)
Return a list with the n largest elements from the dataset defined by iterable. key, if
provided, specifies a function of one argument that is used to extract a comparison
key  from  each  element  in  the  iterable: 
key=str.lower
Equivalent  to:
sorted(iterable, key=key, reverse=True)[:n]
New in version 2.4.
Changed in version 2.5: Added the optional key argument.
Online Convert PDF file to Word. Best free online PDF Conversion
Your word file is converted to look just the same as it does in your office We try to make it as easy as possible to convert your PDF files to Docx Web Security.
change security settings pdf reader; change security settings on pdf
Online Convert PDF file to Tiff. Best free online PDF Tif
Your Tiff file is converted to look just the same as it does in your office We try to make it as easy as possible to convert your PDF files to Tiff Web Security.
pdf security remover; change security settings pdf
heapq.
nsmallest
(
n, iterable
[
, key
]
)
Return a list with the n smallest elements from the dataset defined by iterable. key, if
provided, specifies a function of one argument that is used to extract a comparison
key  from  each  element  in  the  iterable: 
key=str.lower
Equivalent  to:
sorted(iterable, key=key)[:n]
New in version 2.4.
Changed in version 2.5: Added the optional key argument.
The latter two functions perform best for smaller values of n. For larger values, it is more
efficient to use the 
sorted()
function. Also, when 
n==1
, it is more efficient to use the
built-in 
min()
and 
max()
functions.
8.4.1. Basic Examples
heapsort can be implemented by pushing all values onto a heap and then popping off
the smallest values one at a time:
>>> def heapsort(iterable):
...  'Equivalent to sorted(iterable)'
...  h = []
...  for value in iterable:
...  heappush(h, value)
...  return [heappop(h) for i in range(len(h))]
...
>>> heapsort([1357924680])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Heap elements can be tuples. This is useful for assigning comparison values (such as
task priorities) alongside the main record being tracked:
>>> = []
>>> heappush(h, (5'write code'))
>>> heappush(h, (7'release product'))
>>> heappush(h, (1'write spec'))
>>> heappush(h, (3'create tests'))
>>> heappop(h)
(1, 'write spec')
8.4.2. Priority Queue Implementation Notes
priority queue is common use for a heap, and it presents several implementation
challenges:
Online Change your PDF file Permission Settings
You can receive the locked PDF by simply clicking download and you are good to go!. Web Security. When you upload a file it is transmitted using a secure
convert locked pdf to word online; decrypt password protected pdf
Online Convert PDF file to Word. Best free online PDF Conversion
Your PDF file is converted to look just the same as it does in your office to make it as easy as possible to convert your Tiff/Tif files to PDF. Web Security.
convert secure webpage to pdf; add security to pdf in reader
Sort stability: how do you get two tasks with equal priorities to be returned in the
order they were originally added?
In the future with Python 3, tuple comparison breaks for (priority, task) pairs if the
priorities are equal and the tasks do not have a default comparison order.
If the priority of a task changes, how do you move it to a new position in the heap?
Or if a pending task needs to be deleted, how do you find it and remove it from the
queue?
A solution to the first two challenges is to store entries as 3-element list including the
priority, an entry count, and the task. The entry count serves as a tie-breaker so that two
tasks with the same priority are returned in the order they were added. And since no two
entry counts are the same, the tuple comparison will never attempt to directly compare
two tasks.
The remaining challenges revolve around finding a pending task and making changes to
its priority or removing it entirely. Finding a task can be done with a dictionary pointing to
an entry in the queue.
Removing the entry or changing its priority is more difficult because it would break the
heap structure invariants. So, a possible solution is to mark the existing entry as removed
and add a new entry with the revised priority:
pq = [] # list of entries arranged in a heap
entry_finder = {} # mapping of tasks to entries
REMOVED = '<removed-task>' # placeholder for a removed task
counter = itertools.count() # unique sequence count
def add_task(task, priority=0):
'Add a new task or update the priority of an existing task'
if task in entry_finder:
remove_task(task)
count = next(counter)
entry = [priority, count, task]
entry_finder[task] = entry
heappush(pq, entry)
def remove_task(task):
'Mark an existing task as REMOVED.  Raise KeyError if not found.'
entry = entry_finder.pop(task)
entry[-1= REMOVED
def pop_task():
'Remove and return the lowest priority task. Raise KeyError if empty.'
while pq:
priority, count, task = heappop(pq)
if task is not REMOVED:
del entry_finder[task]
return task
raise KeyError('pop from an empty priority queue')
8.4.3. Theory
Online Convert PowerPoint to PDF file. Best free online export
Your PDF file is converted to look just the same as it does in your office to make it as easy as possible to convert your PPTX/PPT files to PDF. Web Security.
cannot print pdf security; decrypt a pdf file online
Heaps are arrays for which 
a[k] <= a[2*k+1]
and 
a[k] <= a[2*k+2]
for all k, counting
elements from 0. For the sake of comparison, non-existing elements are considered to be
infinite. The interesting property of a heap is that 
a[0]
is always its smallest element.
The strange invariant above is meant to be an efficient memory representation for a
tournament. The numbers below are k, not 
a[k]
:
0
                                2
              4                5               6
7       8       9       10      11      12      13      14
15 16   17 18   19 20   21 22   23 24   25 26   27 28   29 30
In the tree above, each cell k is topping 
2*k+1
and 
2*k+2
. In an usual binary tournament
we see in sports, each cell is the winner over the two cells it tops, and we can trace the
winner down the tree to see all opponents s/he  had. However, in many computer
applications of such tournaments, we do not need to trace the history of a winner. To be
more memory efficient, when a winner is promoted, we try to replace it by something else
at a lower level, and the rule becomes that a cell and the two cells it tops contain three
different items, but the top cell “wins” over the two topped cells.
If this heap invariant is protected at all time, index 0 is clearly the overall winner. The
simplest algorithmic way to remove it and find the “next” winner is to move some loser
(let’s say cell 30 in the diagram above) into the 0 position, and then percolate this new 0
down the tree, exchanging values, until the invariant is re-established. This is clearly
logarithmic on the total number of items in the tree. By iterating over all items, you get an
O(n log n) sort.
A nice feature of this sort is that you can efficiently insert new items while the sort is
going on, provided that the inserted items are not “better” than the last 0’th element you
extracted. This is especially useful in simulation contexts, where the tree holds all
incoming events, and the “win” condition means the smallest scheduled time. When an
event schedules other events for execution, they are scheduled into the future, so they
can easily go into the heap. So, a heap is a good structure for implementing schedulers
(this is what I used for my MIDI sequencer :-).
Various structures for implementing schedulers have been extensively studied, and heaps
are good for this, as they are reasonably speedy, the speed is almost constant, and the
worst case is not much different than the average case. However, there are other
representations which are more efficient overall, yet the worst cases might be terrible.
Heaps are also very useful in big disk sorts. You most probably all know that a big sort
implies producing “runs” (which are pre-sorted sequences, which size is usually related to
the amount of CPU memory), followed by a merging passes for these runs, which
merging is often very cleverly organised [1]. It is very important that the initial sort
produces the longest runs possible. Tournaments are a good way to that. If, using all the
memory available to hold a tournament, you replace and percolate items that happen to
fit the current run, you’ll produce runs which are twice the size of the memory for random
input, and much better for input fuzzily ordered.
Moreover, if you output the 0’th item on disk and get an input which may not fit in the
current tournament (because the value “wins” over the last output value), it cannot fit in
the heap, so the size of the heap decreases. The freed memory could be cleverly reused
immediately for progressively building a second heap, which grows at exactly the same
rate the first heap is melting. When the first heap completely vanishes, you switch heaps
and start a new run. Clever and quite effective!
In a word, heaps are useful memory structures to know. I use them in a few applications,
and I think it is good to keep a ‘heap’ module around. :-)
Footnotes
[1]
The disk balancing algorithms which are current, nowadays, are more annoying than
clever, and this is a consequence of the seeking capabilities of the disks. On devices
which cannot seek, like big tape drives, the story was quite different, and one had to
be very clever to ensure (far in advance) that each tape movement will be the most
effective possible (that is, will best participate at “progressing” the merge). Some
tapes were even able to read backwards, and this was also used to avoid the
rewinding time. Believe me, real good tape sorts were quite spectacular to watch!
From all times, sorting has always been a Great Art! :-)
index
modules |
next |
previous |
Python » Python v2.7.6 documentation » The Python Standard Library » 8. Data Types »
© Copyright
1990-2013, Python Software Foundation. 
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Nov 10, 2013. Found a bug
Created using Sphinx
1.0.7.
index
modules |
next |
previous |
8.5. 
bisect
— Array bisection algorithm
New in version 2.1.
Source code: Lib/bisect.py
This module provides support for maintaining a list in sorted order without having to sort
the list after each insertion. For long lists of items with expensive comparison operations,
this can be an improvement over the more common approach. The module is called
bisect
because it uses a basic bisection algorithm to do its work. The source code may
be most useful as a working example of the algorithm (the boundary conditions are
already right!).
The following functions are provided:
bisect.
bisect_left
(
a, x, lo=0, hi=len(a)
)
Locate the insertion point for x in a to maintain sorted order. The parameters lo and hi
may be used to specify a subset of the list which should be considered; by default the
entire list is used. If x is already present in a, the insertion point will be before (to the
left of) any existing entries. The return value is suitable for use as the first parameter
to 
list.insert()
assuming that a is already sorted.
The returned insertion point i partitions the array a into two halves so that 
all(val <
x for val in a[lo:i])
for the left side and 
all(val >= x for val in a[i:hi])
for
the right side.
bisect.
bisect_right
(
a, x, lo=0, hi=len(a)
)
bisect.
bisect
(
a, x, lo=0, hi=len(a)
)
Similar to 
bisect_left()
, but returns an insertion point which comes after (to the right
of) any existing entries of x in a.
The returned insertion point i partitions the array a into two halves so that 
all(val <=
x for val in a[lo:i])
for the left side and 
all(val > x for val in a[i:hi])
for
the right side.
bisect.
insort_left
(
a, x, lo=0, hi=len(a)
)
Insert x in a in sorted order. This is equivalent to 
a.insert(bisect.bisect_left(a, x,
lo, hi), x)
assuming that a is already sorted. Keep in mind that the O(log n) search
is dominated by the slow O(n) insertion step.
Python » Python v2.7.6 documentation » The Python Standard Library » 8. Data Types »
bisect.
insort_right
(
a, x, lo=0, hi=len(a)
)
bisect.
insort
(
a, x, lo=0, hi=len(a)
)
Similar to 
insort_left()
, but inserting x in a after any existing entries of x.
See also:  SortedCollection recipe that uses bisect to build a full-featured collection
class with straight-forward search methods and support for a key-function. The keys
are precomputed to save unnecessary calls to the key function during searches.
8.5.1. Searching Sorted Lists
The above 
bisect()
functions are useful for finding insertion points but can be tricky or
awkward to use for common searching tasks. The following five functions show how to
transform them into the standard lookups for sorted lists:
def index(a, x):
'Locate the leftmost value exactly equal to x'
= bisect_left(a, x)
if i != len(a) and a[i] == x:
return i
raise ValueError
def find_lt(a, x):
'Find rightmost value less than x'
= bisect_left(a, x)
if i:
return a[i-1]
raise ValueError
def find_le(a, x):
'Find rightmost value less than or equal to x'
= bisect_right(a, x)
if i:
return a[i-1]
raise ValueError
def find_gt(a, x):
'Find leftmost value greater than x'
= bisect_right(a, x)
if i != len(a):
return a[i]
raise ValueError
def find_ge(a, x):
'Find leftmost item greater than or equal to x'
= bisect_left(a, x)
if i != len(a):
return a[i]
raise ValueError
8.5.2. Other Examples
The 
bisect()
function can be useful for numeric table lookups. This example uses
Documents you may be interested
Documents you may be interested