commonly available model leaves 
int
as 32 bits.)
A limit of 2147483647 items doesn’t really matter on a 32-bit platform because you’ll run
out of memory before hitting the length limit. Each list item requires space for a pointer,
which is 4 bytes, plus space for a 
PyObject
representing the item. 2147483647*4 is
already more bytes than a 32-bit address space can contain.
It’s possible to address that much memory on a 64-bit platform, however. The pointers
for a list that size would only require 16 GiB of space, so it’s not unreasonable that
Python programmers might construct lists that large. Therefore, the Python interpreter
had to be changed to use some type other than 
int
, and this will be a 64-bit type on 64-
bit  platforms. The change will cause incompatibilities on 64-bit machines, so it was
deemed worth making the transition now, while the number of 64-bit users is still relatively
small. (In 5 or 10 years, we may all be on 64-bit machines, and the transition would be
more painful then.)
This change most strongly affects authors of C extension modules. Python strings and
container types such as lists and tuples now use 
Py_ssize_t
to store their size. Functions
such  as 
PyList_Size()
now  return 
Py_ssize_t
.  Code  in  extension  modules  may
therefore need to have some variables changed to 
Py_ssize_t
.
The 
PyArg_ParseTuple()
and 
Py_BuildValue()
functions have a new conversion code, 
n
,
for 
Py_ssize_t
PyArg_ParseTuple()
‘s 
s#
and 
t#
still output 
int
by default, but you can
define the macro 
PY_SSIZE_T_CLEAN
before  including 
Python.h
to make them return
Py_ssize_t
.
PEP 353 has a section on conversion guidelines that extension authors should read to
learn about supporting 64-bit platforms.
See also:
PEP 353 - Using ssize_t as the index type
PEP written and implemented by Martin von Löwis.
PEP 357: The ‘__index__’ method
The NumPy developers had a problem that could only be solved by adding a new special
method, 
__index__()
. When using slice notation, as in 
[start:stop:step]
, the values of
the start, stop, and step indexes must all be either integers or long integers. NumPy
defines a variety of specialized integer types corresponding to unsigned and signed
integers of 8, 16, 32, and 64 bits, but there was no way to signal that these types could
Pdf secure signature - 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
pdf file security; pdf security remover
Pdf secure signature - 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
pdf password security; convert secure pdf to word
be used as slice indexes.
Slicing can’t just use the existing 
__int__()
method because that method is also used to
implement coercion to integers. If slicing used 
__int__()
, floating-point numbers would
also become legal slice indexes and that’s clearly an undesirable behaviour.
Instead, a new special method called 
__index__()
was added. It takes no arguments and
returns an integer giving the slice index to use. For example:
class C:
def __index__ (self):
return self.value
The return value must be either a Python integer or long integer. The interpreter will
check that the type returned is correct, and raises a 
TypeError
if this requirement isn’t
met.
A corresponding 
nb_index
slot was added to the C-level 
PyNumberMethods
structure to let
C extensions implement this protocol. 
PyNumber_Index(obj)()
can be used in extension
code to call the 
__index__()
function and retrieve its result.
See also:
PEP 357 - Allowing Any Object to be Used for Slicing
PEP written and implemented by Travis Oliphant.
Other Language Changes
Here are all of the changes that Python 2.5 makes to the core Python language.
The 
dict
type has a new hook for letting subclasses provide a default value when a
key isn’t contained in the dictionary. When a key isn’t found, the dictionary’s
__missing__(key)()
method will be called. This hook is used to implement the new
defaultdict
class in the 
collections
module. The following example defines a
dictionary that returns zero for any missing key:
class zerodict (dict):
def __missing__ (self, key):
return 0
= zerodict({1:12:2})
print d[1], d[2# Prints 1, 2
print d[3], d[4# Prints 0, 0
XDoc.HTML5 Viewer for .NET, All Mature Features Introductions
to search text-based documents, like PDF, Microsoft Office typing new signature, deleting added signature from the text selecting in order to secure your web
add security to pdf document; create secure pdf online
C# Create PDF Library SDK to convert PDF from other file formats
for C# developers to create a highly-secure and industry What's more, you can also protect created PDF file by adding digital signature (watermark) on PDF
create pdf security; create pdf the security level is set to high
Both 8-bit and Unicode strings have new 
partition(sep)()
and 
rpartition(sep)()
methods that simplify a common use case.
The 
find(S)()
method is often used to get an index which is then used to slice the
string and obtain the pieces that are before and after the separator. 
partition(sep)
()
condenses this pattern into a single method call that returns a 3-tuple containing
the substring before the separator, the separator itself, and the substring after the
separator. If the separator isn’t found, the first element of the tuple is the entire
string and the other two elements are empty. 
rpartition(sep)()
also returns a 3-
tuple but starts searching from the end of the string; the 
r
stands for ‘reverse’.
Some examples:
>>> ('http://www.python.org').partition('://')
('http', '://', 'www.python.org')
>>> ('file:/usr/share/doc/index.html').partition('://')
('file:/usr/share/doc/index.html', '', '')
>>> (u'Subject: a quick question').partition(':')
(u'Subject', u':', u' a quick question')
>>> 'www.python.org'.rpartition('.')
('www.python', '.', 'org')
>>> 'www.python.org'.rpartition(':')
('', '', 'www.python.org')
(Implemented by Fredrik Lundh following a suggestion by Raymond Hettinger.)
The 
startswith()
and 
endswith()
methods of string types now accept tuples of
strings to check for.
def is_image_file (filename):
return filename.endswith(('.gif''.jpg''.tiff'))
(Implemented by Georg Brandl following a suggestion by Tom Lynn.)
The 
min()
and 
max()
built-in functions gained a 
key
keyword parameter analogous
to the 
key
argument for 
sort()
. This parameter supplies a function that takes a
single argument and is called for every value in the list; 
min()
/
max()
will return the
element with the smallest/largest return value from this function. For example, to find
the longest string in a list, you can do:
= ['medium', 'longest''short']
# Prints 'longest'
print max(L, key=len)
# Prints 'short', because lexicographically 'short' has the largest value
print max(L)
DocImage SDK for .NET: HTML Viewer, View, Annotate, Convert, Print
from popular documents & images in .NET, including Microsoft Word, Excel, PPT, PDF, Tiff, Dicom type(s). Later, you can make an order in our secure online store
decrypt a pdf file online; change security settings on pdf
WinForms .NET Imaging SDK | Royalty-free Image SDK
Support common image and document file format, including BMP, Gif, PNG, PDF, JPEG 2000 our License Agreement and choose a suitable one in our secure online store
copy paste encrypted pdf; pdf security password
(Contributed by Steven Bethard and Raymond Hettinger.)
Two new built-in functions, 
any()
and 
all()
, evaluate whether an iterator contains
any true or false values. 
any()
returns 
True
if any value returned by the iterator is
true; otherwise it will return 
False
all()
returns 
True
only if all of the values
returned by the iterator evaluate as true. (Suggested by Guido van Rossum, and
implemented by Raymond Hettinger.)
The result of a class’s 
__hash__()
method can now be either a long integer or a
regular integer. If a long integer is returned, the hash of that value is taken. In earlier
versions the hash value was required to be a regular integer, but in 2.5 the 
id()
built-in was changed to always return non-negative numbers, and users often seem
to use 
id(self)
in 
__hash__()
methods (though this is discouraged).
ASCII is now the default encoding for modules. It’s now a syntax error if a module
contains string literals with 8-bit characters but doesn’t have an encoding declaration.
In Python 2.4 this triggered a warning, not a syntax error. See PEP 263 for how to
declare a module’s encoding; for example, you might add a line like this near the top
of the source file:
# -*- coding: latin1 -*-
 new  warning, 
UnicodeWarning
,  is  triggered  when you attempt to compare a
Unicode string and an 8-bit string that can’t be converted to Unicode using the
default ASCII encoding. The result of the comparison is false:
>>> chr(128== unichr(128# Can't convert chr(128) to Unicode
__main__:1: UnicodeWarning: Unicode equal comparison failed
to convert both arguments to Unicode - interpreting them
as being unequal
False
>>> chr(127== unichr(127# chr(127) can be converted
True
Previously this would raise a 
UnicodeDecodeError
exception, but in 2.5 this could
result  in  puzzling  problems  when  accessing  a  dictionary. If  you  looked  up
unichr(128)
and 
chr(128)
was  being  used  as  a  key,  you’d  get  a
UnicodeDecodeError
exception. Other changes in 2.5 resulted in this exception being
raised  instead  of  suppressed  by  the  code  in 
dictobject.c
that  implements
dictionaries.
Raising an exception for such a comparison is strictly correct, but the change might
have broken code, so instead 
UnicodeWarning
was introduced.
Java Imaging SDK Library: Document Image Scan, Process, PDF
View, edit, re-order, clean-up and convert documents/image from PDF, Tiff, Png Read our license Agreement and choose a suitable one in our secure online store!
advanced pdf encryption remover; decrypt pdf
.NET DICOM SDK | DICOM Image Viewing
Developed based on the latest DICOM specification, RasterEdge DICOM codec provides complete DICOM Data Sets, secure communication and more.
copy text from encrypted pdf; decrypt pdf file
(Implemented by Marc-André Lemburg.)
One error that Python programmers sometimes make is forgetting to include an
__init__.py
module  in  a  package  directory.  Debugging  this  mistake  can  be
confusing, and usually requires running Python with the -v switch to log all the paths
searched. In Python 2.5, a new 
ImportWarning
warning is triggered when an import
would have picked up a directory as a package but no 
__init__.py
was found. This
warning is silently ignored by default; provide the -Wd option when running the
Python executable to display the warning message. (Implemented by Thomas
Wouters.)
The list of base classes in a class definition can now be empty. As an example, this
is now legal:
class C():
pass
(Implemented by Brett Cannon.)
Interactive Interpreter Changes
In the interactive interpreter, 
quit
and 
exit
have long been strings so that new users get
a somewhat helpful message when they try to quit:
>>> quit
'Use Ctrl-D (i.e. EOF) to exit.'
In Python 2.5, 
quit
and 
exit
are now objects that still produce string representations of
themselves, but are also callable. Newbies who try 
quit()
or 
exit()
will now exit the
interpreter as they expect. (Implemented by Georg Brandl.)
The Python executable now accepts the standard long options --help and --version; on
Windows, it also accepts the /? option for displaying a help message. (Implemented by
Georg Brandl.)
Optimizations
Several of the optimizations were developed at the NeedForSpeed sprint, an event held
in Reykjavik, Iceland, from May 21–28 2006. The sprint focused on speed enhancements
to the CPython implementation and was funded by EWT LLC with local support from CCP
Games. Those optimizations added at this sprint are specially marked in the following list.
When they were introduced in Python 2.4, the built-in 
set
and 
frozenset
types were
PDF Image Viewer| What is PDF
information; Royalty-free to develop PDF compatible software; Open standard for more secure, dependable electronic information exchange.
pdf security options; pdf secure signature
DICOM Image Viewer| What is DICOM
SDK and Web Document Viewer provide high-quality, full-featured and secure medical image into other file formats, including Bitmap, Png, Gif, Tiff, PDF, MS-Word
decrypt pdf password; convert secure webpage to pdf
built on top of Python’s dictionary type. In 2.5 the internal data structure has been
customized for implementing sets, and as a result sets will use a third less memory
and are somewhat faster. (Implemented by Raymond Hettinger.)
The speed of some Unicode operations, such as finding substrings, string splitting,
and character map encoding and decoding, has been improved. (Substring search
and splitting improvements were added by Fredrik Lundh and Andrew Dalke at the
NeedForSpeed sprint. Character maps were improved by Walter Dörwald and Martin
von Löwis.)
The 
long(str, base)()
function is now faster on long digit strings because fewer
intermediate results are calculated. The peak is for strings of around 800–1000 digits
where the function is 6 times faster. (Contributed by Alan McIntyre and committed at
the NeedForSpeed sprint.)
It’s now illegal to mix iterating over a file with 
for line in file
and calling the file
object’s 
read()
/
readline()
/
readlines()
methods. Iteration uses an internal buffer
and the 
read*()
methods don’t use that buffer. Instead they would return the data
following the buffer, causing the data to appear out of order. Mixing iteration and
these  methods  will  now  trigger  a 
ValueError
from  the 
read*()
method.
(Implemented by Thomas Wouters.)
The 
struct
module  now  compiles  structure  format strings  into  an  internal
representation and caches this representation, yielding a 20% speedup. (Contributed
by Bob Ippolito at the NeedForSpeed sprint.)
The 
re
module got a 1 or 2% speedup by switching to Python’s allocator functions
instead of the system’s 
malloc()
and 
free()
. (Contributed by Jack Diederich at the
NeedForSpeed sprint.)
The code generator’s peephole optimizer now performs simple constant folding in
expressions. If you write something like 
a = 2+3
, the code generator will do the
arithmetic and produce code corresponding to 
a = 5
. (Proposed and implemented by
Raymond Hettinger.)
Function calls are now faster because code objects now keep the most recently
finished frame (a “zombie frame”) in an internal field of the code object, reusing it the
next time the code object is invoked. (Original patch by Michael Hudson, modified by
Armin Rigo and Richard Jones; committed at the NeedForSpeed sprint.) Frame
objects are also slightly smaller, which may improve cache locality and reduce
memory usage a bit. (Contributed by Neal Norwitz.)
Python’s built-in exceptions are now new-style classes, a change that speeds up
instantiation considerably. Exception handling in Python 2.5 is therefore about 30%
faster  than  in  2.4.  (Contributed  by  Richard  Jones,  Georg  Brandl  and  Sean
Reifschneider at the NeedForSpeed sprint.)
Importing now caches the paths tried, recording whether they exist or not so that the
interpreter makes fewer 
open()
and 
stat()
calls on startup. (Contributed by Martin
von Löwis and Georg Brandl.)
New, Improved, and Removed Modules
The standard library received many enhancements and bug fixes in Python 2.5. Here’s a
partial list of the most notable changes, sorted alphabetically by module name. Consult
the 
Misc/NEWS
file in the source tree for a more complete list of changes, or look through
the SVN logs for all the details.
The 
audioop
module now supports the a-LAW encoding, and the code for u-LAW
encoding has been improved. (Contributed by Lars Immisch.)
The 
codecs
module gained support for incremental codecs. The 
codec.lookup()
function now returns a 
CodecInfo
instance instead of a tuple. 
CodecInfo
instances
behave like a 4-tuple to preserve backward compatibility but also have the attributes
encode
decode
incrementalencoder
incrementaldecoder
streamwriter
 and
streamreader
. Incremental codecs can receive input and produce output in multiple
chunks; the output is the same as if the entire input was fed to the non-incremental
codec.  See  the 
codecs
module  documentation  for  details.  (Designed  and
implemented by Walter Dörwald.)
The 
collections
module gained a new type, 
defaultdict
, that subclasses the
standard 
dict
type. The new type mostly behaves like a dictionary but constructs a
default value when a key isn’t present, automatically adding it to the dictionary for the
requested key value.
The first argument to 
defaultdict
‘s constructor is a factory function that gets called
whenever a key is requested but not found. This factory function receives no
arguments, so you can use built-in type constructors such as 
list()
or 
int()
. For
example, you can make an index of words based on their initial letter like this:
words = """Nel mezzo del cammin di nostra vita
mi ritrovai per una selva oscura
che la diritta via era smarrita""".lower().split()
index = defaultdict(list)
for w in words:
init_letter = w[0]
index[init_letter].append(w)
Printing 
index
results in the following output:
defaultdict(<type 'list'>, {'c': ['cammin', 'che'], 'e': ['era'],
'd': ['del', 'di', 'diritta'], 'm': ['mezzo', 'mi'],
'l': ['la'], 'o': ['oscura'], 'n': ['nel', 'nostra'],
'p': ['per'], 's': ['selva', 'smarrita'],
'r': ['ritrovai'], 'u': ['una'], 'v': ['vita', 'via']}
(Contributed by Guido van Rossum.)
The 
deque
double-ended queue type supplied by the 
collections
module now has a
remove(value)()
method that removes the first occurrence of value in the queue,
raising 
ValueError
if the value isn’t found. (Contributed by Raymond Hettinger.)
New module: The 
contextlib
module contains helper functions for use with the new
with
‘ statement. See section The contextlib module for more about this module.
New module: The 
cProfile
module is a C implementation of the existing 
profile
module that has much lower overhead. The module’s interface is the same as
profile
: you run 
cProfile.run('main()')
to profile a function, can save profile data
to a file, etc. It’s not yet known if the Hotshot profiler, which is also written in C but
doesn’t match the 
profile
module’s interface, will continue to be maintained in
future versions of Python. (Contributed by Armin Rigo.)
Also,  the 
pstats
module for analyzing the data measured by the profiler now
supports directing the output to any file object by supplying a stream argument to the
Stats
constructor. (Contributed by Skip Montanaro.)
The 
csv
module, which parses files in comma-separated value format, received
several enhancements and a number of bugfixes. You can now set the maximum
size in bytes of a field by calling the 
csv.field_size_limit(new_limit)()
function;
omitting the new_limit argument will return the currently-set limit. The 
reader
class
now has a 
line_num
attribute that counts the number of physical lines read from the
source; records can span multiple physical lines, so 
line_num
is not the same as the
number of records read.
The CSV parser is now stricter about multi-line quoted fields. Previously, if a line
ended within a quoted field without a terminating newline character, a newline would
be inserted into the returned field. This behavior caused problems when reading files
that contained carriage return characters within fields, so the code was changed to
return the field without inserting newlines. As a consequence, if newlines embedded
within fields are important, the input should be split into lines in a manner that
preserves the newline characters.
(Contributed by Skip Montanaro and Andrew McNamara.)
The 
datetime
class in the 
datetime
module now has a 
strptime(string, format)()
method for parsing date strings, contributed by Josh Spoerri. It uses the same
format characters as 
time.strptime()
and 
time.strftime()
:
from datetime import datetime
ts = datetime.strptime('10:13:15 2006-03-07',
'%H:%M:%S %Y-%m-%d')
The 
SequenceMatcher.get_matching_blocks()
method in the 
difflib
module now
guarantees to return a minimal list of blocks describing matching subsequences.
Previously, the algorithm would occasionally break a block of matching elements into
two list entries. (Enhancement by Tim Peters.)
The 
doctest
module  gained a 
SKIP
option that keeps an example from being
executed at all. This is intended for code snippets that are usage examples intended
for the reader and aren’t actually test cases.
An encoding parameter was added to the 
testfile()
function and the 
DocFileSuite
class to specify the file’s encoding. This makes it easier to use non-ASCII characters
in tests contained within a docstring. (Contributed by Bjorn Tillenius.)
The 
email
package has been updated  to version 4.0. (Contributed by Barry
Warsaw.)
The 
fileinput
module  was  made  more  flexible.  Unicode  filenames  are  now
supported, and a mode parameter that defaults to 
"r"
was added to the 
input()
function to allow opening files in binary or universal newlines mode. Another new
parameter, openhook, lets you use a function other than 
open()
to open the input
files. Once you’re iterating over the set of files, the 
FileInput
object’s new 
fileno()
returns the file descriptor for the currently opened file. (Contributed by Georg
Brandl.)
In the 
gc
module, the new 
get_count()
function returns a 3-tuple containing the
current collection counts for the three GC generations. This is accounting information
for the garbage collector; when these counts reach a specified threshold, a garbage
collection sweep will be made. The  existing 
gc.collect()
function now takes an
optional generation argument of 0, 1, or 2 to specify which generation to collect.
(Contributed by Barry Warsaw.)
The 
nsmallest()
and 
nlargest()
functions in the 
heapq
module now support a 
key
keyword parameter similar to the one provided by the 
min()
/
max()
functions and the
sort()
methods. For example:
>>> import heapq
>>> = ["short"'medium''longest''longer still']
>>> heapq.nsmallest(2, L) # Return two lowest elements, lexicographically
['longer still', 'longest']
>>> heapq.nsmallest(2, L, key=len# Return two shortest elements
['short', 'medium']
(Contributed by Raymond Hettinger.)
The 
itertools.islice()
function  now  accepts 
None
for  the  start  and  step
arguments. This makes it more compatible with the attributes of slice objects, so that
you can now write the following:
= slice(5) # Create slice object
itertools.islice(iterable, s.start, s.stop, s.step)
(Contributed by Raymond Hettinger.)
The 
format()
function  in  the 
locale
module has been modified and two new
functions were added, 
format_string()
and 
currency()
.
The 
format()
function’s val parameter could previously be a string as long as no
more than one %char specifier appeared; now the parameter must be exactly one
%char specifier with no surrounding text. An optional monetary parameter was also
added which, if 
True
, will use the locale’s rules for formatting currency in placing a
separator between groups of three digits.
To format strings with multiple %char specifiers, use the new 
format_string()
function that works like 
format()
but also supports mixing %char specifiers with
arbitrary text.
A new 
currency()
function was also added that formats a number according to the
current locale’s settings.
(Contributed by Georg Brandl.)
The 
mailbox
module underwent a massive rewrite to add the capability to modify
mailboxes in addition to reading them. A new set of classes that include 
mbox
MH
,
and 
Maildir
are used to read mailboxes, and have an 
add(message)()
method to
add  messages, 
remove(key)()
to  remove  messages,  and 
lock()
/
unlock()
to
lock/unlock the mailbox. The following example converts a maildir-format mailbox into
Documents you may be interested
Documents you may be interested