index
modules |
next |
previous |
8.11. 
weakref
— Weak references
New in version 2.1.
Source code: Lib/weakref.py
The 
weakref
module  allows  the  Python  programmer  to  create weak  references  to
objects.
In the  following,  the term referent means the object which is referred to by a weak
reference.
A weak reference to an object is not enough to keep the object alive: when the only
remaining references to a referent are weak references, garbage collection is free to
destroy the referent and reuse its memory for something else. A primary use for weak
references is to implement caches or mappings holding large objects, where it’s desired
that a large object not be kept alive solely because it appears in a cache or mapping.
For example, if you have a number of large binary image objects, you may wish to
associate a name with each. If you used a Python dictionary to map names to images, or
images to names, the image objects would remain alive just because they appeared as
values or  keys  in  the dictionaries. The 
WeakKeyDictionary
and 
WeakValueDictionary
classes supplied by the 
weakref
module are an alternative, using weak references to
construct mappings that don’t keep objects alive solely because they appear in the
mapping objects. If, for example, an image object is a value in a 
WeakValueDictionary
,
then when the last remaining references to that image object are the weak references
held by weak mappings, garbage collection can reclaim the object, and its corresponding
entries in weak mappings are simply deleted.
WeakKeyDictionary
and 
WeakValueDictionary
use  weak  references  in  their
implementation, setting up callback functions on the weak references that notify the weak
dictionaries  when  a  key  or  value  has  been  reclaimed  by  garbage  collection. Most
programs should find that using one of these weak dictionary types is all they need – it’s
not  usually  necessary  to  create  your  own  weak  references  directly. The  low-level
machinery  used  by the  weak dictionary implementations is exposed  by the 
weakref
module for the benefit of advanced uses.
Not  all  objects  can  be  weakly  referenced;  those  objects  which  can  include  class
instances, functions written in Python (but not in C), methods (both bound and unbound),
Python » Python v2.7.6 documentation » The Python Standard Library » 8. Data Types »
Pdf encryption - 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
change security settings pdf; create encrypted pdf
Pdf encryption - 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
convert secure pdf to word; pdf security remover
sets, frozensets, file objects, generators, type objects, 
DBcursor
objects from the 
bsddb
module, sockets, arrays, deques, regular expression pattern objects, and code objects.
Changed in version 2.4: Added support for files, sockets, arrays, and patterns.
Changed in version 2.7: Added support for thread.lock, threading.Lock, and code objects.
Several built-in types such as 
list
and 
dict
do not directly support weak references but
can add support through subclassing:
class Dict(dict):
pass
obj = Dict(red=1, green=2, blue=3# this object is weak referenceable
CPython implementation detail: Other built-in types such as 
tuple
and 
long
do not
support weak references even when subclassed.
Extension types can easily be made to support weak references; see Weak Reference
Support.
class 
weakref.
ref
(
object
[
, callback
]
)
Return a weak reference to object. The original object can be retrieved by calling the
reference object if the referent is still alive; if the referent is no longer alive, calling the
reference object will cause 
None
to be returned. If callback is provided and not 
None
,
and the returned weakref object is still alive, the callback will be called when the object
is  about  to  be  finalized;  the  weak  reference  object  will  be  passed  as  the  only
parameter to the callback; the referent will no longer be available.
It is allowable for many weak references to be constructed for the same object.
Callbacks registered for each weak reference will be called from the most recently
registered callback to the oldest registered callback.
Exceptions raised by the callback will be noted on the standard error output, but
cannot be propagated; they are handled in exactly the same way as exceptions raised
from an object’s 
__del__()
method.
Weak references are hashable if the object is hashable. They will maintain their hash
value even after the object was deleted. If 
hash()
is called the first time only after the
object was deleted, the call will raise 
TypeError
.
Weak references support tests for equality, but not ordering. If the referents are still
C# PDF Password Library: add, remove, edit PDF file password in C#
A professional PDF encryption and decryption control able to be integrated in C#.NET WinForm and ASP.NET WebForm application. Able
decrypt pdf password online; creating secure pdf files
Online Remove password from protected PDF file
Find your password-protected PDF and upload it. If there is no strong encryption on your file, it will be unlocked and ready to download within seconds.
create pdf the security level is set to high; create pdf security
alive,  two  references  have  the  same  equality  relationship  as  their  referents
(regardless of the callback). If either referent has been deleted, the references are
equal only if the reference objects are the same object.
Changed  in  version  2.4: This is  now  a  subclassable  type  rather  than  a  factory
function; it derives from 
object
.
weakref.
proxy
(
object
[
, callback
]
)
Return a proxy to object which uses a weak reference. This supports use of the proxy
in  most  contexts  instead  of  requiring  the  explicit  dereferencing  used  with  weak
reference  objects. The  returned  object  will  have  a  type  of  either 
ProxyType
or
CallableProxyType
, depending on whether object is callable. Proxy objects are not
hashable regardless of the referent; this avoids a number of problems related to their
fundamentally mutable nature, and prevent their use as dictionary keys. callback is
the same as the parameter of the same name to the 
ref()
function.
weakref.
getweakrefcount
(
object
)
Return the number of weak references and proxies which refer to object.
weakref.
getweakrefs
(
object
)
Return a list of all weak reference and proxy objects which refer to object.
class 
weakref.
WeakKeyDictionary
(
[
dict
]
)
Mapping class that references keys weakly. Entries in the dictionary will be discarded
when there is no longer a strong reference to the key. This can be used to associate
additional data with an object owned by other parts of an application without adding
attributes to those objects. This can be especially useful with objects that override
attribute accesses.
Note:  Caution: Because a 
WeakKeyDictionary
is built on top of a Python dictionary,
it must not change size when iterating over it. This can be difficult to ensure for a
WeakKeyDictionary
because actions performed by the program during iteration may
cause items in the dictionary to vanish “by magic” (as a side effect of garbage
collection).
WeakKeyDictionary
objects have  the following additional methods. These expose the
internal references directly. The references are not guaranteed to be “live” at the time
they are used, so the result of calling the references needs to be checked before being
used. This can be used to avoid creating references that will cause the garbage collector
to keep the keys around longer than needed.
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
NET class. Also able to uncompress PDF file in VB.NET programs. Support PDF encryption in VB.NET class applications. A professional
copy from locked pdf; change pdf security settings
VB.NET PDF Password Library: add, remove, edit PDF file password
Dim outputFilePath As String = Program.RootPath + "\\" 3_pw_a.pdf" ' Create a PasswordSetting = New PasswordSetting("Hello World") ' Set encryption level to
add security to pdf; decrypt pdf online
WeakKeyDictionary.
iterkeyrefs
()
Return an iterator that yields the weak references to the keys.
New in version 2.5.
WeakKeyDictionary.
keyrefs
()
Return a list of weak references to the keys.
New in version 2.5.
class 
weakref.
WeakValueDictionary
(
[
dict
]
)
Mapping  class  that  references  values  weakly. Entries  in  the  dictionary  will  be
discarded when no strong reference to the value exists any more.
Note:   Caution: Because  a 
WeakValueDictionary
is  built  on  top  of  a  Python
dictionary, it must not change size when iterating over it. This can be difficult to
ensure  for  a 
WeakValueDictionary
because actions performed by the program
during iteration may cause items in the dictionary to vanish “by magic” (as a side
effect of garbage collection).
WeakValueDictionary
objects have the following additional methods. These method have
the same issues as the 
iterkeyrefs()
and 
keyrefs()
methods of 
WeakKeyDictionary
objects.
WeakValueDictionary.
itervaluerefs
()
Return an iterator that yields the weak references to the values.
New in version 2.5.
WeakValueDictionary.
valuerefs
()
Return a list of weak references to the values.
New in version 2.5.
class 
weakref.
WeakSet
(
[
elements
]
)
Set class that keeps weak references to its elements. An element will be discarded
when no strong reference to it exists any more.
New in version 2.7.
weakref.
ReferenceType
The type object for weak references objects.
.NET PDF Generator | Generate & Manipulate PDF files
on PDF documents; Add, remove, swap and delete any pages in PDFs; Add metadata of a PDF; Include flexible encryption schemes; Can be
decrypt pdf without password; add security to pdf file
C# PDF File Permission Library: add, remove, update PDF file
3.pdf"; String outputFilePath = Program.RootPath + "\\" 3_pw_a.pdf"; // Create a new PasswordSetting("Hello World"); // Set encryption level to AES-128.
pdf file security; decrypt password protected pdf
weakref.
ProxyType
The type object for proxies of objects which are not callable.
weakref.
CallableProxyType
The type object for proxies of callable objects.
weakref.
ProxyTypes
Sequence containing all the type objects for proxies. This can make it simpler to test if
an object is a proxy without being dependent on naming both proxy types.
exception 
weakref.
ReferenceError
Exception raised when a proxy object is used but the underlying object has been
collected. This is the same as the standard 
ReferenceError
exception.
See also:
PEP 0205 - Weak References
The proposal and rationale for this feature, including links to earlier implementations
and information about similar features in other languages.
8.11.1. Weak Reference Objects
Weak reference objects have no attributes or methods, but do allow the referent to be
obtained, if it still exists, by calling it:
>>> import weakref
>>> class Object:
...  pass
...
>>> = Object()
>>> = weakref.ref(o)
>>> o2 = r()
>>> is o2
True
If the referent no longer exists, calling the reference object returns 
None
:
>>> del o, o2
>>> print r()
None
Testing that a weak reference object is still live should be done using the expression
ref() is not None
. Normally, application code that needs to use a reference object
should follow this pattern:
VB.NET PDF File Permission Library: add, remove, update PDF file
Dim outputFilePath As String = Program.RootPath + "\\" 3_pw_a.pdf" ' Create a PasswordSetting = New PasswordSetting("Hello World") ' Set encryption level to
pdf security; change pdf document security
PDF Image Viewer| What is PDF
Promote use of metadata; Used on independent devices and applications; Prohibit encryption; Provide two levels of compliance PDF/A-1b (the lowest level) and PDF
creating a secure pdf document; pdf secure
# r is a weak reference object
= r()
if o is None:
# referent has been garbage collected
print "Object has been deallocated; can't frobnicate."
else:
print "Object is still live!"
o.do_something_useful()
Using a separate test for “liveness” creates race conditions in threaded applications;
another thread can cause a weak reference to become invalidated before the weak
reference is called; the idiom shown above is safe in threaded applications as well as
single-threaded applications.
Specialized versions of 
ref
objects can be created through subclassing. This is used in
the implementation of the 
WeakValueDictionary
to reduce the memory overhead for each
entry in the mapping. This may be most useful to associate additional information with a
reference, but could also be used to insert additional processing on calls to retrieve the
referent.
This example shows how a subclass of 
ref
can be used to store additional information
about an object and affect the value that’s returned when the referent is accessed:
import weakref
class ExtendedRef(weakref.ref):
def __init__(self, ob, callback=None**annotations):
super(ExtendedRef, self).__init__(ob, callback)
self.__counter = 0
for k, v in annotations.iteritems():
setattr(self, k, v)
def __call__(self):
"""Return a pair containing the referent and the number of
times the reference has been called.
"""
ob = super(ExtendedRef, self).__call__()
if ob is not None:
self.__counter += 1
ob = (ob, self.__counter)
return ob
8.11.2. Example
This simple example shows how an application can use objects IDs to retrieve objects
that it has seen before. The IDs of the objects can then be used in other data structures
without forcing the objects to remain alive, but the objects can still be retrieved by ID if
they do.
.NET Annotation SDK| Annotate, Redact Images
Rich options to move, resize, rotate, scale any kind of annotation; Provide enhanced redaction & encryption objects for sensitive information & security;
decrypt a pdf file online; decrypt pdf password
C# Image: How to Annotate Image with Freehand Line in .NET Project
Tutorials on how to add freehand line objects to PDF, Word and TIFF SDK; Protect sensitive image information with redaction and encryption annotation objects;
copy locked pdf; decrypt pdf password
import weakref
_id2obj_dict = weakref.WeakValueDictionary()
def remember(obj):
oid = id(obj)
_id2obj_dict[oid] = obj
return oid
def id2obj(oid):
return _id2obj_dict[oid]
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.12. 
UserDict
— Class wrapper for dictionary
objects
Source code: Lib/UserDict.py
The module defines a mixin, 
DictMixin
, defining all dictionary methods for classes that
already have a minimum mapping interface. This greatly simplifies writing classes that
need to be substitutable for dictionaries (such as the shelve module).
This module also defines a class, 
UserDict
, that acts as a wrapper around dictionary
objects. The need for this class has been largely supplanted by the ability to subclass
directly  from 
dict
(a feature that became available starting with Python version 2.2).
Prior to the introduction of 
dict
, the 
UserDict
class was used to create dictionary-like
sub-classes that obtained new behaviors by overriding existing methods or adding new
ones.
The 
UserDict
module defines the 
UserDict
class and 
DictMixin
:
class 
UserDict.
UserDict
(
[
initialdata
]
)
Class  that  simulates  a  dictionary. The  instance’s  contents are  kept  in  a  regular
dictionary,  which  is  accessible  via  the 
data
attribute  of 
UserDict
instances. If
initialdata is provided, 
data
is initialized with its contents; note that a reference to
initialdata will not be kept, allowing it be used for other purposes.
Note:  For backward compatibility, instances of 
UserDict
are not iterable.
class 
UserDict.
IterableUserDict
(
[
initialdata
]
)
Subclass of 
UserDict
that supports direct iteration (e.g. 
for key in myDict
).
In addition to supporting the methods and operations of mappings (see section Mapping
Types — dict), 
UserDict
and 
IterableUserDict
instances provide the following attribute:
IterableUserDict.
data
A real dictionary used to store the contents of the 
UserDict
class.
class 
UserDict.
DictMixin
Mixin  defining  all  dictionary  methods  for  classes  that  already  have  a  minimum
Python » Python v2.7.6 documentation » The Python Standard Library » 8. Data Types »
dictionary  interface  including 
__getitem__()
__setitem__()
__delitem__()
 and
keys()
.
This mixin should be used as a superclass. Adding each of the above methods adds
progressively  more  functionality. For  instance,  defining  all  but 
__delitem__()
will
preclude only 
pop()
and 
popitem()
from the full interface.
In  addition  to  the four  base methods,  progressively  more  efficiency  comes  with
defining 
__contains__()
__iter__()
, and 
iteritems()
.
Since the mixin has no knowledge of the subclass constructor, it does not define
__init__()
or 
copy()
.
Starting  with  Python  version  2.6,  it  is  recommended  to  use
collections.MutableMapping
instead of 
DictMixin
.
8.13. 
UserList
— Class wrapper for list objects
Note:  When Python 2.2 was released, many of the use cases for this class were
subsumed by the ability to subclass 
list
directly. However, a handful of use cases
remain.
This module provides a list-interface around an underlying data store. By default, that
data store is a 
list
; however, it can be used to wrap a list-like interface around other
objects (such as persistent storage).
In addition, this class can be mixed-in with built-in classes using multiple inheritance.
This can sometimes be useful. For example, you can inherit from 
UserList
and 
str
at
the same time. That would not be possible with both a real 
list
and a real 
str
.
This module defines a class that acts as a wrapper around list objects. It is a useful base
class for your own list-like classes, which can inherit from them and override existing
methods or add new ones. In this way one can add new behaviors to lists.
The 
UserList
module defines the 
UserList
class:
class 
UserList.
UserList
(
[
list
]
)
Class that simulates a list. The instance’s contents are kept in a regular list, which is
accessible via the 
data
attribute of 
UserList
instances. The instance’s contents are
initially set to a copy of list, defaulting to the empty list 
[]
. list can be any iterable, e.g.
a real Python list or a 
UserList
object.
Note:  The 
UserList
class has been moved to the 
collections
module in Python
3. The 2to3 tool will automatically adapt imports when converting your sources to
Python 3.
In addition to supporting the methods and operations of mutable sequences (see section
Sequence  Types  —  str,  unicode,  list,  tuple,  bytearray,  buffer,  xrange) , 
UserList
instances provide the following attribute:
UserList.
data
A real Python list object used to store the contents of the 
UserList
class.
Subclassing requirements: Subclasses of 
UserList
are expect to offer a constructor
which can be called with either no arguments or one argument. List operations which
return a new sequence attempt to create an instance of the actual implementation class.
To do so, it assumes that the constructor can be called with a single parameter, which is
a sequence object used as a data source.
If a derived class does not wish to comply with this requirement, all of the special
methods supported by this class will need to be overridden; please consult the sources
for information about the methods which need to be provided in that case.
Changed in version 2.0: Python versions 1.5.2 and 1.6 also required that the constructor
be callable with no parameters, and offer a mutable 
data
attribute. Earlier versions of
Python did not attempt to create instances of the derived class.
8.14. 
UserString
— Class wrapper for string
objects
Note:  This 
UserString
class from this module is available for backward compatibility
only. If you are writing code that does not need to work with versions of Python earlier
than Python 2.2, please consider subclassing directly from the built-in 
str
type instead
of using 
UserString
(there is no built-in equivalent to 
MutableString
).
This module defines a class that acts as a wrapper around string objects. It is a useful
base class for your own string-like classes, which can inherit from them and override
existing methods or add new ones. In this way one can add new behaviors to strings.
It should be noted that these classes are highly inefficient compared to real string or
Documents you may be interested
Documents you may be interested