convert pdf to jpg c# itextsharp : Decrypt a pdf file online control Library system web page .net html console Official%20Python%20Manual%20of%20Python%202.7.6%2058-part1860

Changed in version 2.3: Support for a tuple of type information was added.
iter
(
o
[
, sentinel
]
)
Return an iterator object. The first argument is interpreted very differently depending
on the presence of the second argument. Without a second argument, o must be a
collection object which supports the iteration protocol (the 
__iter__()
method), or it
must  support  the  sequence  protocol  (the 
__getitem__()
method  with  integer
arguments starting at 
0
). If it does not support either of those protocols, 
TypeError
is
raised. If the second argument, sentinel, is given, then o must be a callable object.
The iterator created in this case will call o with no arguments for each call to its
next()
method; if the value returned is equal to sentinel, 
StopIteration
will be raised,
otherwise the value will be returned.
One useful application of the second form of 
iter()
is to read lines of a file until a
certain line is reached. The following example reads a file until the 
readline()
method
returns an empty string:
with open('mydata.txt'as fp:
for line in iter(fp.readline, ''):
process_line(line)
New in version 2.2.
len
(
s
)
Return the length (the number of items) of an object. The argument may be a
sequence (string, tuple or list) or a mapping (dictionary).
list
(
[
iterable
]
)
Return a list whose items are the same and in the same order as iterable‘s items.
iterable may be either a sequence, a container that supports iteration, or an iterator
object. If iterable  is  already  a  list,  a  copy  is  made  and  returned,  similar  to
iterable[:]
. For instance, 
list('abc')
returns 
['a', 'b', 'c']
and 
list( (1, 2,
3) )
returns 
[1, 2, 3]
. If no argument is given, returns a new empty list, 
[]
.
list
is a mutable sequence type, as documented in Sequence Types — str, unicode,
list, tuple, bytearray, buffer, xrange. For other containers see the built in 
dict
set
,
and 
tuple
classes, and the 
collections
module.
locals
()
Update and return a dictionary representing the current local symbol table. Free
variables are returned by 
locals()
when it is called in function blocks, but not in class
Decrypt a pdf file online - 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
add security to pdf file; change security on pdf
Decrypt a pdf file online - 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
copy text from locked pdf; create pdf security
blocks.
Note:  The contents of this dictionary should not be modified; changes may not
affect the values of local and free variables used by the interpreter.
long
(
x=0
)
long
(
x, base=10
)
Convert a string or number to a long integer. If the argument is a string, it must
contain a possibly signed number of arbitrary size, possibly embedded in whitespace.
The base argument is interpreted in the same way as for 
int()
, and may only be
given when x is a string. Otherwise, the argument may be a plain or long integer or a
floating point number, and a long integer with the same value is returned. Conversion
of floating point numbers to integers truncates (towards zero). If no arguments are
given, returns 
0L
.
The long type is described in Numeric Types — int, float, long, complex.
map
(
function, iterable, ...
)
Apply function to every item of iterable and return a list of the results. If additional
iterable arguments  are  passed, function must take that many arguments and is
applied to the items from all iterables in parallel. If one iterable is shorter than another
it is assumed to be extended with 
None
items. If function is 
None
, the identity function
is assumed; if there are multiple arguments, 
map()
returns a list consisting of tuples
containing the corresponding items from all iterables (a kind of transpose operation).
The iterable arguments may be a sequence or any iterable object; the result is always
a list.
max
(
iterable
[
, key
]
)
max
(
arg1, arg2, *args
[
, key
]
)
Return the largest item in an iterable or the largest of two or more arguments.
If one positional argument is provided, iterable must be a non-empty iterable (such as
a non-empty string, tuple or list). The largest item in the iterable is returned. If two or
more positional arguments are provided, the largest of the positional arguments is
returned.
The optional key argument specifies a one-argument ordering function like that used
for 
list.sort()
. The key argument, if supplied, must be in keyword form (for
example, 
max(a,b,c,key=func)
).
Changed in version 2.5: Added support for the optional key argument.
C# PDF Password Library: add, remove, edit PDF file password in C#
Allow to decrypt PDF password and open a password protected document in to add password to PDF document online or in C#.NET WinForms for PDF file protection.
can print pdf security; decrypt pdf file online
memoryview
(
obj
)
Return a “memory view” object created from the given argument. See memoryview
type for more information.
min
(
iterable
[
, key
]
)
min
(
arg1, arg2, *args
[
, key
]
)
Return the smallest item in an iterable or the smallest of two or more arguments.
If one positional argument is provided, iterable must be a non-empty iterable (such as
a non-empty string, tuple or list). The smallest item in the iterable is returned. If two or
more positional arguments are provided, the smallest of the positional arguments is
returned.
The optional key argument specifies a one-argument ordering function like that used
for 
list.sort()
. The key argument, if supplied, must be in keyword form (for
example, 
min(a,b,c,key=func)
).
Changed in version 2.5: Added support for the optional key argument.
next
(
iterator
[
, default
]
)
Retrieve the next item from the iterator by calling its 
next()
method. If default is
given, it is returned if the iterator is exhausted, otherwise 
StopIteration
is raised.
New in version 2.6.
object
()
Return a new featureless object. 
object
is a base for all new style classes. It has the
methods that are common to all instances of new style classes.
New in version 2.2.
Changed in version 2.3: This function does not accept any arguments. Formerly, it
accepted arguments but ignored them.
oct
(
x
)
Convert an integer number (of any size) to an octal string. The result is a valid Python
expression.
Changed in version 2.4: Formerly only returned an unsigned literal.
open
(
name
[
, mode
[
, buffering
]]
)
Open a file, returning an object of the 
file
type described in section File Objects. If
the file cannot be opened, 
IOError
is raised. When opening a file, it’s preferable to
use 
open()
instead of invoking the 
file
constructor directly.
The first two arguments are the same as for 
stdio
‘s 
fopen()
: name is the file name
to be opened, and mode is a string indicating how the file is to be opened.
The  most  commonly-used  values of mode  are 
'r'
for  reading, 
'w'
for writing
(truncating the file if it already exists), and 
'a'
for appending (which on some Unix
systems means that all writes append to the end of the file regardless of the current
seek position). If mode is omitted, it defaults to 
'r'
. The default is to use text mode,
which may convert 
'\n'
characters to a platform-specific representation on writing
and back on reading. Thus, when opening a binary file, you should append 
'b'
to the
mode value to open the file in binary mode, which will improve portability. (Appending
'b'
is useful even on systems that don’t treat binary and text files differently, where it
serves as documentation.) See below for more possible values of mode.
The  optional buffering argument specifies the file’s desired buffer size: 0 means
unbuffered, 1 means line buffered, any other positive value means use a buffer of
(approximately) that size (in bytes). A negative buffering means to use the system
default, which is usually line buffered for tty devices and fully buffered for other files. If
omitted, the system default is used. [2]
Modes 
'r+'
'w+'
and 
'a+'
open the file for updating (note that 
'w+'
truncates the
file). Append 
'b'
to the mode to open the file in binary mode, on systems that
differentiate between binary and text files; on systems that don’t have this distinction,
adding the 
'b'
has no effect.
In addition to the standard 
fopen()
values mode may be 
'U'
or 
'rU'
. Python is
usually built with universal newlines support; supplying 
'U'
opens the file as a text file,
but lines may be terminated by any of the following: the Unix end-of-line convention
'\n'
, the Macintosh convention 
'\r'
, or the Windows convention 
'\r\n'
. All of these
external representations are seen as 
'\n'
by the Python program. If Python is built
without universal newlines support a mode with 
'U'
is the same as normal text mode.
Note that file objects so opened also have an attribute called 
newlines
which has a
value of 
None
(if no newlines have yet been seen), 
'\n'
'\r'
'\r\n'
, or a tuple
containing all the newline types seen.
Python enforces that the mode, after stripping 
'U'
, begins with 
'r'
'w'
or 
'a'
.
Python  provides  many  file  handling  modules  including 
fileinput
os
os.path
,
tempfile
, and 
shutil
.
Changed in version 2.5: Restriction on first letter of mode string introduced.
ord
(
c
)
Given a string of length one, return an integer representing the Unicode code point of
the character when the argument is a unicode object, or the value of the byte when
the argument is an 8-bit string. For example, 
ord('a')
returns  the  integer 
97
,
ord(u'\u2020')
returns 
8224
. This is the inverse of 
chr()
for 8-bit strings and of
unichr()
for unicode objects. If a unicode argument is given and Python was built
with UCS2 Unicode, then the character’s code point must be in the range [0..65535]
inclusive; otherwise the string length is two, and a 
TypeError
will be raised.
pow
(
x, y
[
, z
]
)
Return x to the power y; if z is present, return x to the power y, modulo z (computed
more efficiently than 
pow(x, y) % z
). The two-argument form 
pow(x, y)
is equivalent
to using the power operator: 
x**y
.
The arguments must have numeric types. With mixed operand types, the coercion
rules for binary arithmetic operators apply. For int and long int operands, the result
has the same type as the operands (after coercion) unless the second argument is
negative; in that case, all arguments are converted to float and a float result is
delivered. For example, 
10**2
returns 
100
, but 
10**-2
returns 
0.01
. (This last feature
was added in Python 2.2. In Python 2.1 and before, if both arguments were of integer
types and the second argument was negative, an exception was raised.) If the second
argument is negative, the third argument must be omitted. If z is present, x and y
must be of integer types, and y must be non-negative. (This restriction was added in
Python 2.2. In Python 2.1 and before, floating 3-argument 
pow()
returned platform-
dependent results depending on floating-point rounding accidents.)
print
(
*objects, sep=' ', end='\n', file=sys.stdout
)
Print objects to the stream file, separated by sep and followed by end. sep, end and
file, if present, must be given as keyword arguments.
All non-keyword arguments are converted to strings like 
str()
does and written to the
stream, separated by sep and followed by end. Both sep and end must be strings;
they can also be 
None
, which means to use the default values. If no objects are given,
print()
will just write end.
The file argument must be an object with a 
write(string)
method; if it is not present
or 
None
sys.stdout
will  be  used. Output  buffering  is  determined  by file.  Use
file.flush()
to ensure, for instance, immediate appearance on a screen.
Note:  This function is not normally available as a built-in since the name 
print
is
recognized as the 
print
statement. To disable the statement and use the 
print()
function, use this future statement at the top of your module:
from __future__ import print_function
New in version 2.6.
property
(
[
fget
[
, fset
[
, fdel
[
, doc
]]]]
)
Return a property attribute for new-style classes (classes that derive from 
object
).
fget is a function for getting an attribute value, likewise fset is a function for setting,
and fdel a function for del’ing, an attribute. Typical use is to define a managed
attribute 
x
:
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
= property(getx, setx, delx, "I'm the 'x' property.")
If then c is an instance of C, 
c.x
will invoke the getter, 
c.x = value
will invoke the
setter and 
del c.x
the deleter.
If given, doc will be the docstring of the property attribute. Otherwise, the property will
copy fget‘s docstring (if it exists). This makes it possible to create read-only properties
easily using 
property()
as a decorator:
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
turns the 
voltage()
method into a “getter” for a read-only attribute with the same
name.
A property object has 
getter
setter
, and 
deleter
methods usable as decorators
that create a copy of the property with the corresponding accessor function set to the
decorated function. This is best explained with an example:
class C(object):
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
This code is exactly equivalent to the first example. Be sure to give the additional
functions the same name as the original property (
x
in this case.)
The returned property also has the attributes 
fget
fset
, and 
fdel
corresponding to
the constructor arguments.
New in version 2.2.
Changed in version 2.5: Use fget‘s docstring if no doc given.
Changed in version 2.6: The 
getter
setter
, and 
deleter
attributes were added.
range
(
stop
)
range
(
start, stop
[
, step
]
)
This is a versatile function to create lists containing arithmetic progressions. It is most
often used in 
for
loops. The arguments must be plain integers. If the step argument
is omitted, it defaults to 
1
. If the start argument is omitted, it defaults to 
0
. The full
form returns a list of plain integers 
[start, start + step, start + 2 * step, ...]
.
If step is positive, the last element is the largest 
start + i * step
less than stop; if
step is negative, the last element is the smallest 
start + i * step
greater than stop.
step must not be zero (or else 
ValueError
is raised). Example:
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(111)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0305)
[0, 5, 10, 15, 20, 25]
>>> range(0103)
[0, 3, 6, 9]
>>> range(0-10-1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(10)
[]
raw_input
(
[
prompt
]
)
If the prompt argument is present, it is written to standard output without a trailing
newline. The function then reads a line from input, converts it to a string (stripping a
trailing newline), and returns that. When EOF is read, 
EOFError
is raised. Example:
>>> = raw_input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"
If the 
readline
module was loaded, then 
raw_input()
will use it to provide elaborate
line editing and history features.
reduce
(
function, iterable
[
, initializer
]
)
Apply function of two arguments cumulatively to the items of iterable, from left to right,
so as to reduce the iterable to a single value. For example, 
reduce(lambda x, y:
x+y, [1, 2, 3, 4, 5])
calculates 
((((1+2)+3)+4)+5)
. The left argument, x, is the
accumulated value and the right argument, y, is the update value from the iterable. If
the optional initializer is present, it is placed before the items of the iterable in the
calculation, and serves as a default when the iterable is empty. If initializer is not given
and iterable contains only one item, the first item is returned. Roughly equivalent to:
def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
try:
initializer = next(it)
except StopIteration:
raise TypeError('reduce() of empty sequence with no initial value')
accum_value = initializer
for x in it:
accum_value = function(accum_value, x)
return accum_value
reload
(
module
)
Reload a previously imported module. The argument must be a module object, so it
must have been successfully imported before. This is useful if you have edited the
module source file using an external editor and want to try out the new version without
leaving the Python interpreter. The return value is the module object (the same as the
module argument).
When 
reload(module)
is executed:
Python modules’ code is recompiled and the module-level code reexecuted,
defining a new set of objects which are bound to names in the module’s
dictionary. The 
init
function of extension modules is not called a second time.
As with all other objects in Python the old objects are only reclaimed after their
reference counts drop to zero.
The names in the module namespace are updated to point to any new or
changed objects.
Other references to the old objects (such as names external to the module) are
not rebound to refer to the new objects and must be updated in each namespace
where they occur if that is desired.
There are a number of other caveats:
If a module is syntactically correct but its initialization fails, the first 
import
statement
for it does not bind its name locally, but does store a (partially initialized) module
object in 
sys.modules
. To reload the module you must first 
import
it again (this will
bind the name to the partially initialized module object) before you can 
reload()
it.
When a module is reloaded, its dictionary (containing the module’s global variables) is
retained. Redefinitions of names will override the old definitions, so this is generally
not a problem. If the new version of a module does not define a name that was
defined by the old version, the old definition remains. This feature can be used to the
module’s advantage if it maintains a global table or cache of objects — with a 
try
statement it can test for the table’s presence and skip its initialization if desired:
try:
cache
except NameError:
cache = {}
It is legal though generally not very useful to reload built-in or dynamically loaded
modules,  except  for 
sys
__main__
and 
__builtin__
. In many cases, however,
extension modules are not designed to be initialized more than once, and may fail in
arbitrary ways when reloaded.
If a module imports objects from another module using 
from
... 
import
..., calling
reload()
for the other module does not redefine the objects imported from it — one
way around this is to re-execute the 
from
statement, another is to use 
import
and
qualified names (module.*name*) instead.
If a module instantiates instances of a class, reloading the module that defines the
class does not affect the method definitions of the instances — they continue to use
the old class definition. The same is true for derived classes.
repr
(
object
)
Return a string containing a printable representation of an object. This is the same
value yielded by conversions (reverse quotes). It is sometimes useful to be able to
access this operation as an ordinary function. For many types, this function makes an
attempt to return a string that would yield an object with the same value when passed
to 
eval()
, otherwise the representation is a string enclosed in angle brackets that
contains the name of the type of the object together with additional information often
including the name and address of the object. A class can control what this function
returns for its instances by defining a 
__repr__()
method.
reversed
(
seq
)
Return a reverse iterator. seq must be an object which has a 
__reversed__()
method
or supports the sequence protocol (the 
__len__()
method and the 
__getitem__()
method with integer arguments starting at 
0
).
New in version 2.4.
Changed in version 2.6: Added the possibility to write a custom 
__reversed__()
method.
round
(
number
[
, ndigits
]
)
Return the floating point value number rounded to ndigits digits after the decimal
point. If ndigits is omitted, it defaults to zero. The result is a floating point number.
Values are rounded to the closest multiple of 10 to the power minus ndigits; if two
multiples are  equally close,  rounding  is  done away from  0  (so. for example,
round(0.5)
is 
1.0
and 
round(-0.5)
is 
-1.0
).
Note:   The  behavior  of 
round()
for  floats  can  be  surprising:  for  example,
round(2.675, 2)
gives 
2.67
instead of the expected 
2.68
. This is not a bug: it’s a
result of the fact that most decimal fractions can’t be represented exactly as a float.
See Floating Point Arithmetic: Issues and Limitations for more information.
Documents you may be interested
Documents you may be interested