Python is an interpreted, interactive, object-oriented programming
language. It incorporates modules, exceptions, dynamic typing, very
high level dynamic data types, and classes. Python combines remarkable
power with very clear syntax. It has interfaces to many system calls
and libraries, as well as to various window systems, and is extensible
in C or C++. It is also usable as an extension language for
applications that need a programmable interface. Finally, Python is
portable: it runs on many Unix variants, on the Mac, and on PCs under
MS-DOS, Windows, Windows NT, and OS/2.
Why can't I use an assignment in an expression?
Many people used to C or Perl complain that they want to use this C idiom:
while (line = readline(f)) {
...do something with line...
}
where in Python you're forced to write this:
while True:
line = f.readline()
if not line:
break
...do something with line...
The reason for not allowing assignment in Python expressions is a
common, hard-to-find bug in those other languages, caused by this
construct:
if (x = 0) {
...error handling...
}
else {
...code that only works for nonzero x...
}
The error is a simple typo: x = 0, which assigns 0 to the variable x,
was written while the comparison x == 0 is certainly what was
intended.
Many alternatives have been proposed. Most are hacks that save some
typing but use arbitrary or cryptic syntax or keywords, and fail the
simple criterion for language change proposals: it should intuitively
suggest the proper meaning to a human reader who has not yet been
introduced to the construct.
An interesting phenomenon is that most experienced Python programmers
recognize the "while True" idiom and don't seem to be missing the
assignment in expression construct much; it's only newcomers who
express a strong desire to add this to the language.
There's an alternative way of spelling this that seems attractive but
is generally less robust than the "while True" solution:
line = f.readline()
while line:
...do something with line...
line = f.readline()
The problem with this is that if you change your mind about exactly
how you get the next line (e.g. you want to change it into
sys.stdin.readline()) you have to remember to change two places in
your program -- the second occurrence is hidden at the bottom of the
loop.
The best approach is to use iterators, making it possible to loop
through objects using the for statement. For example, in the current
version of Python file objects support the iterator protocol, so you
can now write simply:
for line in f:
... do something with line...
Is there a tool to help find bugs or perform static analysis?
Yes.
PyChecker is a static analysis tool that finds bugs in Python source
code and warns about code complexity and style.
Pylint is another tool that checks if a module satisfies a coding
standard, and also makes it possible to write plug-ins to add a custom
feature.
How do you set a global variable in a function?
Did you do something like this?
x = 1 # make a global
def f():
print x # try to print the global
...
for j in range(100):
if q>3:
x=4
Any variable assigned in a function is local to that function. unless
it is specifically declared global. Since a value is bound to x as the
last statement of the function body, the compiler assumes that x is
local. Consequently the print x attempts to print an uninitialized
local variable and will trigger a NameError.
The solution is to insert an explicit global declaration at the start
of the function:
def f():
global x
print x # try to print the global
...
for j in range(100):
if q>3:
x=4
In this case, all references to x are interpreted as references to the
x from the module namespace.
What are the rules for local and global variables in Python?
In Python, variables that are only referenced inside a function are
implicitly global. If a variable is assigned a new value anywhere
within the function's body, it's assumed to be a local. If a variable
is ever assigned a new value inside the function, the variable is
implicitly local, and you need to explicitly declare it as 'global'.
Though a bit surprising at first, a moment's consideration explains
this. On one hand, requiring global for assigned variables provides a
bar against unintended side-effects. On the other hand, if global was
required for all global references, you'd be using global all the
time. You'd have to declare as global every reference to a builtin
function or to a component of an imported module. This clutter would
defeat the usefulness of the global declaration for identifying
side-effects.
How do I share global variables across modules?
The canonical way to share information across modules within a single
program is to create a special module (often called config or cfg).
Just import the config module in all modules of your application; the
module then becomes available as a global name. Because there is only
one instance of each module, any changes made to the module object get
reflected everywhere. For example:
config.py:
x = 0 # Default value of the 'x' configuration setting
mod.py:
import config
config.x = 1
main.py:
import config
import mod
print config.x
Note that using a module is also the basis for implementing the
Singleton design pattern, for the same reason.
No comments:
Post a Comment