Introduction¶ PyQwt is a set of Python bindings for the Qwt library. For a manifold speedup with respect to pure Python. You can think of a 2-dimension array as.

The pdb module is a simple but adequate console-mode debugger for Python. It is part of the standard Python library, and is. You can also write your own debugger by using the code for pdb as an example. The IDLE interactive development environment, which is part of the standard Python distribution (normally available as Tools/scripts/idle), includes a graphical debugger. PythonWin is a Python IDE that includes a GUI debugger based on pdb. The Pythonwin debugger colors breakpoints and has quite a few cool features such as debugging non-Pythonwin programs. Pythonwin is available as part of the project and as a part of the ActivePython distribution (see ).

Is an IDE and GUI builder that uses wxWidgets. It offers visual frame creation and manipulation, an object inspector, many views on the source like object browsers, inheritance hierarchies, doc string generated html documentation, an advanced debugger, integrated help, and Zope support.

Is an IDE built on PyQt and the Scintilla editing component. Pydb is a version of the standard Python debugger pdb, modified for use with DDD (Data Display Debugger), a popular graphical debugger front end. Pydb can be found at and DDD can be found. There are a number of commercial Python IDEs that include graphical debuggers. They include: • Wing IDE () • Komodo IDE () • PyCharm (). PyChecker is a static analysis tool that finds bugs in Python source code and warns about code complexity and style. You can get PyChecker from.

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. In addition to the bug checking that PyChecker performs, Pylint offers some additional features such as checking line length, whether variable names are well-formed according to your coding standard, whether declared interfaces are fully implemented, and more. Provides a full list of Pylint’s features. You don’t need the ability to compile Python to C code if all you want is a stand-alone program that users can download and run without having to install the Python distribution first. There are a number of tools that determine the set of modules required by a program and bind these modules together with a Python binary to produce a single executable.

One is to use the freeze tool, which is included in the Python source tree as Tools/freeze. It converts Python byte code to C arrays; a C compiler you can embed all your modules into a new program, which is then linked with the standard Python modules. It works by scanning your source recursively for import statements (in both forms) and looking for the modules in the standard Python path as well as in the source directory (for built-in modules). It then turns the bytecode for modules written in Python into C code (array initializers that can be turned into code objects using the marshal module) and creates a custom-made config file that only contains those built-in modules which are actually used in the program. It then compiles the generated C code and links it with the rest of the Python interpreter to form a self-contained binary which acts exactly like your script. Obviously, freeze requires a C compiler. There are several other utilities which don’t.

One is Thomas Heller’s py2exe (Windows only). >>>foo () Traceback (most recent call last). UnboundLocalError: local variable 'x' referenced before assignment This is because when you make an assignment to a variable in a scope, that variable becomes local to that scope and shadows any similarly named variable in the outer scope. Since the last statement in foo assigns a new value to x, the compiler recognizes it as a local variable. Consequently when the earlier print(x) attempts to print the uninitialized local variable and an error results. In the example above you can access the outer scope variable by declaring it global.

In Python, variables that are only referenced inside a function are implicitly global. If a variable is assigned a value anywhere within the function’s body, it’s assumed to be a local unless explicitly declared as global. Though a bit surprising at first, a moment’s consideration explains this. On one hand, requiring 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 built-in function or to a component of an imported module. This clutter would defeat the usefulness of the global declaration for identifying side-effects.

In general, don’t use from modulename import *. Doing so clutters the importer’s namespace, and makes it much harder for linters to detect undefined names.

Import modules at the top of a file. Doing so makes it clear what other modules your code requires and avoids questions of whether the module name is in scope. Using one import per line makes it easy to add and delete module imports, but using multiple imports per line uses less screen space. It’s good practice if you import modules in the following order: • standard library modules – e.g. Sys, os, getopt, re • third-party library modules (anything installed in Python’s site-packages directory) – e.g. Mx.DateTime, ZODB, PIL.Image, etc. • locally-developed modules It is sometimes necessary to move imports to a function or class to avoid problems with circular imports.

Gordon McMillan says. Circular imports are fine where both modules use the “import ” form of import. They fail when the 2nd module wants to grab a name out of the first (“from module import name”) and the import is at the top level. That’s because names in the 1st are not yet available, because the first module is busy importing the 2nd. In this case, if the second module is only used in one function, then the import can easily be moved into that function. By the time the import is called, the first module will have finished initializing, and the second module can do its import.

It may also be necessary to move imports out of the top level of code if some of the modules are platform-specific. In that case, it may not even be possible to import all of the modules at the top of the file. In this case, importing the correct modules in the corresponding platform-specific code is a good option. Only move imports into a local scope, such as inside a function definition, if it’s necessary to solve a problem such as avoiding a circular import or are trying to reduce the initialization time of a module. This technique is especially helpful if many of the imports are unnecessary depending on how the program executes. You may also want to move imports into a function if the modules are only ever used in that function. Note that loading a module the first time may be expensive because of the one time initialization of the module, but loading a module multiple times is virtually free, costing only a couple of dictionary lookups.

Even if the module name has gone out of scope, the module is probably available in. >>>x = [] >>>y = x >>>y.

Append ( 10 ) >>>y [10] >>>x [10] you might be wondering why appending an element to y changed x too. There are two factors that produce this result: • Variables are simply names that refer to objects. Doing y = x doesn’t create a copy of the list – it creates a new variable y that refers to the same object x refers to.

This means that there is only one object (the list), and both x and y refer to it. • Lists are, which means that you can change their content. After the call to append(), the content of the mutable object has changed from [] to [10]. Since both the variables refer to the same object, using either name accesses the modified value [10].

If we instead assign an immutable object to x. >>>x = 5 # ints are immutable >>>y = x >>>x = x + 1 # 5 can't be mutated, we are creating a new object here >>>x 6 >>>y 5 we can see that in this case x and y are not equal anymore. This is because integers are, and when we do x = x + 1 we are not mutating the int 5 by incrementing its value; instead, we are creating a new object (the int 6) and assigning it to x (that is, changing which object x refers to). After this assignment we have two objects (the ints 6 and 5) and two variables that refer to them ( x now refers to 6 but y still refers to 5). Some operations (for example y.append(10) and y.sort()) mutate the object, whereas superficially similar operations (for example y = y + [10] and sorted(y)) create a new object.

In general in Python (and in all cases in the standard library) a method that mutates an object will return None to help avoid getting the two types of operations confused. So if you mistakenly write y.sort() thinking it will give you a sorted copy of y, you’ll instead end up with None, which will likely cause your program to generate an easily diagnosed error. However, there is one class of operations where the same operation sometimes has different behaviors with different types: the augmented assignment operators. For example, += mutates lists but not tuples or ints ( a_list += [1, 2, 3] is equivalent to a_list.extend([1, 2, 3]) and mutates a_list, whereas some_tuple += (1, 2, 3) and some_int += 1 create new objects).

In other words: • If we have a mutable object (,,, etc.), we can use some specific operations to mutate it and all the variables that refer to it will see the change. • If we have an immutable object (,,, etc.), all the variables that refer to it will always see the same value, but operations that transform that value into a new value always return a new object. If you want to know if two variables refer to the same object or not, you can use the operator, or the built-in function.

>>>B = A >>>a = B () >>>b = a >>>print ( b ) >>>print ( a ) Arguably the class has a name: even though it is bound to two names and invoked through the name B the created instance is still reported as an instance of class A. Res2dinv Keygen Generator Download. However, it is impossible to say whether the instance’s name is a or b, since both names are bound to the same value.

Generally speaking it should not be necessary for your code to “know the names” of particular values. Unless you are deliberately writing introspective programs, this is usually an indication that a change of approach might be beneficial. In comp.lang.python, Fredrik Lundh once gave an excellent analogy in answer to this question. For integers, use the built-in type constructor, e.g.

Int('144') == 144. Similarly, converts to floating-point, e.g. Float('144') == 144.0. By default, these interpret the number as decimal, so that int('0144') == 144 and int('0x144') raises. Int(string, base) takes the base to convert from as a second optional argument, so int('0x144', 16) == 324. If the base is specified as 0, the number is interpreted using Python’s rules: a leading ‘0o’ indicates octal, and ‘0x’ indicates a hex number. Do not use the built-in function if all you need is to convert strings to numbers.

Will be significantly slower and it presents a security risk: someone could pass you a Python expression that might have unwanted side effects. For example, someone could pass __import__('os').system('rm -rf $HOME') which would erase your home directory.

Also has the effect of interpreting numbers as Python expressions, so that e.g. Eval('09') gives a syntax error because Python does not allow leading ‘0’ in a decimal number (except ‘0’). That’s a tough one, in general.

First, here are a list of things to remember before diving further: • Performance characteristics vary across Python implementations. This FAQ focusses on.

• Behaviour can vary across operating systems, especially when talking about I/O or multi-threading. • You should always find the hot spots in your program before attempting to optimize any code (see the module).

• Writing benchmark scripts will allow you to iterate quickly when searching for improvements (see the module). • It is highly recommended to have good code coverage (through unit testing or any other technique) before potentially introducing regressions hidden in sophisticated optimizations. That being said, there are many tricks to speed up Python code.

Here are some general principles which go a long way towards reaching acceptable performance levels: • Making your algorithms faster (or changing to faster ones) can yield much larger benefits than trying to sprinkle micro-optimization tricks all over your code. • Use the right data structures. Study documentation for the and the module. • When the standard library provides a primitive for doing something, it is likely (although not guaranteed) to be faster than any alternative you may come up with. This is doubly true for primitives written in C, such as builtins and some extension types. For example, be sure to use either the built-in method or the related function to do sorting (and see the for examples of moderately advanced usage). • Abstractions tend to create indirections and force the interpreter to work more.

If the levels of indirection outweigh the amount of useful work done, your program will be slower. You should avoid excessive abstraction, especially under the form of tiny functions or methods (which are also often detrimental to readability). If you have reached the limit of what pure Python can allow, there are tools to take you further away. For example, can compile a slightly modified version of Python code into a C extension, and can be used on many different platforms. Cython can take advantage of compilation (and optional type annotations) to make your code significantly faster than when interpreted. If you are confident in your C programming skills, you can also yourself.

The type constructor tuple(seq) converts any sequence (actually, any iterable) into a tuple with the same items in the same order. For example, tuple([1, 2, 3]) yields (1, 2, 3) and tuple('abc') yields ('a', 'b', 'c'). If the argument is a tuple, it does not make a copy but returns the same object, so it is cheap to call when you aren’t sure that an object is already a tuple. The type constructor list(seq) converts any sequence or iterable into a list with the same items in the same order.

For example, list((1, 2, 3)) yields [1, 2, 3] and list('abc') yields ['a', 'b', 'c']. If the argument is a list, it makes a copy just like seq[:] would.

Welcome, Currently I'm trying to install latest uwsgi on my VPS (Ubuntu 11.10) based on instruction from the site pip install uwsgi During compilation I see some errors. [gcc -pthread] spooler.o *** uWSGI compiling embedded plugins *** [gcc -pthread] plugins/python/python_plugin.o Complete output from command /usr/bin/python -c 'import setuptools;__file__='/etc/apt/sources.list.d/build/uwsgi/setup.py';exec(compile(open(__file__).read().replace(' r n', ' n'), __file__, 'exec'))' install --single-version-externally-managed --record /tmp/pip-joud1I-record/install-record.txt: running install In file included from plugins/python/python_plugin.c:1:0: plugins/python/uwsgi_python.h:2:20: fatal error: Python.h: No such file or directory compilation terminated. Using profile: buildconf/default.ini detected include path: ['/usr/lib/gcc/i686-linux-gnu/4.6.1/include','/usr/local/include', '/usr/lib/gcc/i686-linux-gnu/4.6.1/include-fixed', '/usr/include/i386-linux-gnu', '/usr/include'] Patching 'bin_name' to properly install_scripts dir. And finally I see. [gcc -pthread] spooler.o *** uWSGI compiling embedded plugins *** [gcc -pthread] plugins/python/python_plugin.o ---------------------------------------- Command /usr/bin/python -c 'import setuptools;__file__='/etc/apt/sources.list.d/build/uwsgi/setup.py';exec(compile(open(__file__).read().replace(' r n', ' n'), __file__, 'exec'))' install --single-version-externally-managed --record /tmp/pip-joud1I-record/install-record.txt failed with error code 1 in /etc/apt/sources.list.d/build/uwsgi Storing complete log in /root/.pip/pip.log Has anyone any suggestions how can I install latest uwsgi?

Regards, Grzegorz. Just so will be here in case someone else comes across this problem - Even though we had installed python2.7-dev successfully we still got this error.

What apparently was the problem was gcc's inability to find the libraries which were included in the build script pip was trying to run.