CPython implementation detail: Users should not touch 
__builtins__
; it is strictly an
implementation  detail. Users wanting to override values in the builtins namespace
should 
import
the 
__builtin__
(no ‘s’) module and modify its attributes appropriately.
The namespace for a module is automatically created the first time a module is imported.
The main module for a script is always called 
__main__
.
The 
global
statement has the same scope as a name binding operation in the same
block. If the nearest enclosing scope for a free variable contains a global statement, the
free variable is treated as a global.
A class definition is an executable statement that may use and define names. These
references follow the normal rules for name resolution. The namespace of the class
definition becomes the attribute dictionary of the class. Names defined at the class scope
are not visible in methods.
4.1.1. Interaction with dynamic features
There are several cases where Python statements are illegal when used in conjunction
with nested scopes that contain free variables.
If a variable is referenced in an enclosing scope, it is illegal to delete the name. An error
will be reported at compile time.
If the wild card form of import — 
import *
— is used in a function and the function
contains or is a nested block with free variables, the compiler will raise a 
SyntaxError
.
If 
exec
is used in a function and the function contains or is a nested block with free
variables, the compiler will raise a 
SyntaxError
unless the exec explicitly specifies the
local namespace for the 
exec
. (In other words, 
exec obj
would be illegal, but 
exec obj
in ns
would be legal.)
The 
eval()
execfile()
, and 
input()
functions and the 
exec
statement do not have
access to the full environment for resolving names. Names may be resolved in the local
and global namespaces of the caller. Free variables are not resolved in the nearest
enclosing namespace, but in the global namespace. [1]  The 
exec
statement and the
eval()
and 
execfile()
functions have optional arguments to override the global and
local namespace. If only one namespace is specified, it is used for both.
Pdf security options - 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
create pdf the security level is set to high; add security to pdf file
Pdf security options - 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
decrypt a pdf; convert secure webpage to pdf
4.2. Exceptions
Exceptions are a means of breaking out of the normal flow of control of a code block in
order to handle errors or other exceptional conditions. An exception is raised at the point
where the error is detected; it may be handled by the surrounding code block or by any
code block that directly or indirectly invoked the code block where the error occurred.
The Python interpreter raises an exception when it detects a run-time error (such as
division by zero). A Python program can also explicitly raise an exception with the 
raise
statement. Exception handlers are specified with the 
try
... 
except
statement. The
finally
clause of such a statement can be used to specify cleanup code which does not
handle the exception, but is executed whether an exception occurred or not in the
preceding code.
Python uses the “termination” model of error handling: an exception handler can find out
what happened and continue execution at an outer level, but it cannot repair the cause of
the error and retry the failing operation (except by re-entering the offending piece of code
from the top).
When an exception is not handled at all, the interpreter terminates execution of the
program, or returns to its interactive main loop. In either case, it prints a stack backtrace,
except when the exception is 
SystemExit
.
Exceptions are identified by class instances. The 
except
clause is selected depending on
the class of the instance: it must reference the class of the instance or a base class
thereof. The instance can be received by the handler and can carry additional information
about the exceptional condition.
Exceptions can also be identified by strings, in which case the 
except
clause is selected
by object identity. An arbitrary value can be raised along with the identifying string which
can be passed to the handler.
Note:  Messages to exceptions are not part of the Python API. Their contents may
change from one version of Python to the next without warning and should not be relied
on by code which will run under multiple versions of the interpreter.
See also the description of the 
try
statement in section The try statement and 
raise
statement in section The raise statement.
Footnotes
.NET PDF SDK - Description of All PDF Processing Control Feastures
Easy to change PDF original password; Options for setting PDF security level; PDF text content, image and pages redact options. PDF Digital Signature.
copy locked pdf; pdf file security
.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 password protected pdf
[1]
This limitation occurs because the code that is executed by these operations is not
available at the time the module is compiled.
index
modules |
next |
previous |
Python » Python v2.7.6 documentation » The Python Language Reference »
© 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.
BMP to JPEG Converter | Convert Bitmap to JPEG, Convert JPEG to
to JPEG Converter provides flexible image processing related options to resize JPEG conversion; Add morphing effects, watermarks to images to protect security;
creating secure pdf files; convert locked pdf to word doc
DICOM to PDF Converter | Convert DICOM to PDF, Convert PDF to
Start DICOM - PDF image conversion through drag &drop method; Security protection provided with comment, logo, date or watermarks added to files;
change security on pdf; change pdf security settings reader
index
modules |
next |
previous |
5. Expressions
This chapter explains the meaning of the elements of expressions in Python.
Syntax Notes: In this and the following chapters, extended BNF notation will be used to
describe syntax, not lexical analysis. When (one alternative of) a syntax rule has the form
name ::=  othername
and no semantics are given, the semantics of this form of 
name
are the same as for
othername
.
5.1. Arithmetic conversions
When a description of an arithmetic operator below uses the phrase “the numeric
arguments are converted to a common type,” the arguments are coerced using the
coercion rules listed at Coercion rules. If both arguments are standard numeric types, the
following coercions are applied:
If either argument is a complex number, the other is converted to complex;
otherwise, if either argument is a floating point number, the other is converted to
floating point;
otherwise, if either argument is a long integer, the other is converted to long integer;
otherwise, both must be plain integers and no conversion is necessary.
Some additional rules apply for certain operators (e.g., a string left argument to the ‘%’
operator). Extensions can define their own coercions.
5.2. Atoms
Atoms are the most basic elements of expressions. The simplest atoms are identifiers or
literals. Forms enclosed in reverse quotes or in parentheses, brackets or braces are also
categorized syntactically as atoms. The syntax for atoms is:
atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display
generator_expression | dict_display | set_display
string_conversion | yield_atom
5.2.1. Identifiers (Names)
Python » Python v2.7.6 documentation » The Python Language Reference »
C# Image: Run RasterEdge Web Viewer Sample Project
Right-click the correspond site-> Edit Permissions -> Security -> Group or user names to provide powerful & profession imaging controls, PDF document, image to
advanced pdf encryption remover; convert secure pdf to word
JPEG2000 to JBIG2 Converter | Convert JPEG2000 to JBIG2, Convert
or batch conversion method; Convert GIF & JBIG2 image with morphing effects, watermarks added to protect security; Can be used as
decrypt pdf file online; creating a secure pdf document
An identifier occurring as an atom is a name. See section Identifiers and keywords for
lexical definition and  section Naming and binding for documentation of naming and
binding.
When the name is bound to an object, evaluation of the atom yields that object. When a
name is not bound, an attempt to evaluate it raises a 
NameError
exception.
Private name mangling: When an identifier that textually occurs in a class definition
begins with two or more underscore characters and does not end in two or more
underscores,  it  is  considered  a private  name  of  that  class.  Private  names  are
transformed to a longer form before code is generated for them. The transformation
inserts the class name, with leading underscores removed and a single underscore
inserted, in front of the name. For example, the identifier 
__spam
occurring in a class
named 
Ham
will be transformed to 
_Ham__spam
. This transformation is independent of the
syntactical context in which the identifier is used. If the transformed name is extremely
long (longer than 255 characters), implementation defined truncation may happen. If the
class name consists only of underscores, no transformation is done.
5.2.2. Literals
Python supports string literals and various numeric literals:
literal ::=  stringliteral | integer | longinteger
floatnumber | imagnumber
Evaluation of a literal yields an object of the given type (string, integer, long integer,
floating  point  number,  complex  number)  with  the  given  value. The value may be
approximated in the case of floating point and imaginary (complex) literals. See section
Literals for details.
All literals correspond to immutable data types, and hence the object’s identity is less
important than its value. Multiple evaluations of literals with the same value (either the
same occurrence in the program text or a different occurrence) may obtain the same
object or a different object with the same value.
5.2.3. Parenthesized forms
A parenthesized form is an optional expression list enclosed in parentheses:
parenth_form ::=  "(" [expression_list] ")"
A parenthesized expression list yields whatever that expression list yields: if the list
GIF to JBIG2 Converter | Convert GIF to JBIG2, Convert JBIG2 to
brightness and more; Convert GIF & JBIG2 image with morphing effects, watermarks added to protect security; Save original images &
change pdf document security; decrypt pdf password online
contains at least one comma, it yields a tuple; otherwise, it yields the single expression
that makes up the expression list.
An empty pair of parentheses yields an empty tuple object. Since tuples are immutable,
the rules for literals apply (i.e., two occurrences of the empty tuple may or may not yield
the same object).
Note that tuples are not formed by the parentheses, but rather by use of the comma
operator. The exception is the empty tuple, for which parentheses are required —
allowing unparenthesized “nothing” in expressions would cause ambiguities and allow
common typos to pass uncaught.
5.2.4. List displays
A list display is a possibly empty series of expressions enclosed in square brackets:
list_display        ::=  "[" [expression_list | list_comprehension] "]"
list_comprehension  ::=  expression list_for
list_for            ::=  "for" target_list "in" old_expression_list [list_iter]
old_expression_list ::=  old_expression [("," old_expression)+ [","]]
old_expression      ::=  or_test | old_lambda_expr
list_iter           ::=  list_for | list_if
list_if             ::=  "if" old_expression [list_iter]
A list display yields a new list object. Its contents are specified by providing either a list of
expressions or a list comprehension. When a comma-separated list of expressions is
supplied, its elements are evaluated from left to right and placed into the list object in that
order. When a list comprehension is supplied, it consists of a single expression followed
by at least one 
for
clause and zero or more 
for
or 
if
clauses. In this case, the elements
of the new list are those that would be produced by considering each of the 
for
or 
if
clauses a block, nesting from left to right, and evaluating the expression to produce a list
element each time the innermost block is reached [1].
5.2.5. Displays for sets and dictionaries
For constructing a set or a dictionary Python provides special syntax called “displays”,
each of them in two flavors:
either the container contents are listed explicitly, or
they  are  computed  via  a  set  of  looping  and  filtering  instructions,  called  a
comprehension.
Common syntax elements for comprehensions are:
comprehension ::=  expression comp_for
comp_for      ::=  "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" expression_nocond [comp_iter]
The comprehension consists of a single expression followed by at least one 
for
clause
and zero or more 
for
or 
if
clauses. In this case, the elements of the new container are
those that would be produced by considering each of the 
for
or 
if
clauses a block,
nesting from left to right, and evaluating the expression to produce an element each time
the innermost block is reached.
Note that the comprehension is executed in a separate scope, so names assigned to in
the target list don’t “leak” in the enclosing scope.
5.2.6. Generator expressions
A generator expression is a compact generator notation in parentheses:
generator_expression ::=  "(" expression comp_for ")"
A generator expression yields a new generator object. Its syntax is the same as for
comprehensions, except that it is enclosed in parentheses instead of brackets or curly
braces.
Variables used in the generator expression are evaluated lazily when the 
__next__()
method is called for generator object (in the same fashion as normal generators).
However, the leftmost 
for
clause is immediately evaluated, so that an error produced by
it can be seen before any other possible error in the code that handles the generator
expression. Subsequent 
for
clauses cannot be evaluated immediately since they may
depend on the previous 
for
loop. For example: 
(x*y for x in range(10) for y in
bar(x))
.
The parentheses can be omitted on calls with only one argument. See section Calls for
the detail.
5.2.7. Dictionary displays
A dictionary display is a possibly empty series of key/datum pairs enclosed in curly
braces:
dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression
dict_comprehension ::=  expression ":" expression comp_for
A dictionary display yields a new dictionary object.
If a comma-separated sequence of key/datum pairs is given, they are evaluated from left
to right to define the entries of the dictionary: each key object is used as a key into the
dictionary to store the corresponding datum. This means that you can specify the same
key multiple times in the key/datum list, and the final dictionary’s value for that key will be
the last one given.
A dict comprehension, in contrast to list and set comprehensions, needs two expressions
separated  with  a  colon  followed  by  the  usual  “for”  and  “if”  clauses.  When  the
comprehension is run, the resulting key and value elements are inserted in the new
dictionary in the order they are produced.
Restrictions on the types of the key values are listed earlier in section The standard type
hierarchy. (To summarize, the key type should be hashable, which excludes all mutable
objects.) Clashes between duplicate keys are not detected; the last datum (textually
rightmost in the display) stored for a given key value prevails.
5.2.8. Set displays
A set display is denoted by curly braces and distinguishable from dictionary displays by
the lack of colons separating keys and values:
set_display ::=  "{" (expression_list | comprehension) "}"
A set display yields a new mutable set object, the contents being specified by either a
sequence  of  expressions  or  a  comprehension. When  a  comma-separated  list  of
expressions is supplied, its elements are evaluated from left to right and added to the set
object. When a comprehension is supplied, the set is constructed from the elements
resulting from the comprehension.
An empty set cannot be constructed with 
{}
; this literal constructs an empty dictionary.
5.2.9. String conversions
A string conversion is an expression list enclosed in reverse (a.k.a. backward) quotes:
string_conversion ::=  "`" expression_list "`"
A string conversion evaluates the contained expression list and converts the resulting
object into a string according to rules specific to its type.
If the object is a string, a number, 
None
, or a tuple, list or dictionary containing only
objects whose type is one of these, the resulting string is a valid Python expression which
can be passed to the built-in function 
eval()
to yield an expression with the same value
(or an approximation, if floating point numbers are involved).
(In particular, converting a string adds quotes around it and converts “funny” characters
to escape sequences that are safe to print.)
Recursive  objects  (for  example,  lists  or  dictionaries  that  contain  a  reference  to
themselves, directly or indirectly) use 
...
to indicate a recursive reference, and the result
cannot be passed to 
eval()
to get an equal value (
SyntaxError
will be raised instead).
The built-in function 
repr()
performs exactly the same conversion in its argument as
enclosing it in parentheses and reverse quotes does. The built-in function 
str()
performs
a similar but more user-friendly conversion.
5.2.10. Yield expressions
yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list]
New in version 2.5.
The 
yield
expression is only used when defining a generator function, and can only be
used in the body of a function definition. Using a 
yield
expression in a function definition
is sufficient to cause that definition to create a generator function instead of a normal
function.
When a generator function is called, it returns an iterator known as a generator. That
generator then controls the execution of a generator function. The execution starts when
one of the generator’s methods is called. At that time, the execution proceeds to the first
yield
expression, where it is suspended again, returning the value of 
expression_list
to
generator’s caller. By suspended we mean that all local state is retained, including the
current bindings of local variables, the instruction pointer, and the internal evaluation
stack. When the execution is resumed by calling one of the generator’s methods, the
function can proceed exactly as if the 
yield
expression was just another external call.
The value of the 
yield
expression after resuming depends on the method which resumed
the execution.
All of this makes generator functions quite similar to coroutines; they yield multiple times,
they have more than one entry point and their execution can be suspended. The only
difference is that a generator function cannot control where should the execution continue
after it yields; the control is always transferred to the generator’s caller.
5.2.10.1. Generator-iterator methods
This subsection describes the methods of a generator iterator. They can be used to
control the execution of a generator function.
Note that calling any of the generator methods below when the generator is already
executing raises a 
ValueError
exception.
class 
generator
generator.
next
()
Starts the execution of a generator function or resumes it at the last executed 
yield
expression. When a generator function is resumed with a 
next()
method, the current
yield
expression always evaluates to 
None
. The execution then continues to the next
yield
expression, where the generator is suspended again, and the value of the
expression_list
is returned to 
next()
‘s caller. If the generator exits without yielding
another value, a 
StopIteration
exception is raised.
.
generator.
send
(
value
)
Resumes the execution and “sends” a value into the generator function. The 
value
argument becomes the result of the current 
yield
expression. The 
send()
method
returns the next value yielded by the generator, or raises 
StopIteration
if the
generator exits without yielding another value. When 
send()
is called to start the
generator, it must be called with 
None
as the argument, because there is no 
yield
expression that could receive the value.
generator.
throw
(
type
[
, value
[
, traceback
]]
)
Raises an exception of type 
type
at the point where generator was paused, and
returns the next value yielded by the generator function. If the generator exits without
yielding another value, a 
StopIteration
exception is raised. If the generator function
does not catch the passed-in exception, or raises a different exception, then that
exception propagates to the caller.
generator.
close
()
Documents you may be interested
Documents you may be interested