Many developers install Python on their Windows 7 machine and when they try to run the console command Python they get the following error message:

‘python’ is not recognized as an internal or external command, operable program or batch file.

Follow the steps below to see how to install and start coding in Python on Windows 7.

First visit the official Python page and download the latest release. At the time of this writing the latest version is 2.7.

Install it by double clicking the setup file and follow the wizard along.

Next, let’s open the Start Menu and right click My Computer. Click on Advanced System Settings.

Then click on Environment Variables.

Find the PATH variable and click Edit. You want to add ;C:\Python27 to the end of that string. Save your changes!

So what exactly is happening here?

When you type in ‘python‘ in a command prompt, Windows will use the PATH variable to get a list of directories to go looking for the ‘python‘ command. Before you followed the steps here, it couldn’t find the python.exe file, hence the error.

Now that the PATH variable is set, when you use ‘python‘ you’ll see a familiar programming prompt.

Python running in Windows 7.

def is_number(s):
  try:
    float(s)
    return True
  except ValueError:
    return False

print is_number("foo") # "False"
print is_number("baz") # "False"

print is_number(1) # "True"
print is_number(1.3) # "True"
print is_number(-1.37) # "True"

print is_number(1e3) # "True"

Everything’s An Object

You’ll often hear it said that, in Python, everything’s an object. It’s pretty much true, with a few exceptions. An expression is not an object, but it always expresses one. Because the Interpreter will evaluate any expression on contact, as soon as it reads one, an expression is essentially the object it evaluates to. A name is not an object either, but it always references an object. Names are also evaluated on contact, evaluating to whichever object they reference at that point in time. So, ultimately, everything is pretty much an object.

Each object is of a particular type. There’s a range of different types of objects built into Python, they’re predefined, and you can also define others yourself as needed. The built-in types include String, Float, List, Function, Module and so on. You can do a lot with these built-in types, but you can do a lot more if you learn to combine them to create custom types of object, tailored to your application. You might define a SpaceInvader type, an Employee type, an Account type; it can be anything. Once you have defined, for example, an Account type, you can then create as many instances of that type as you need. In the same way that you can have as many strings as you need, you can have as many accounts as you need.

Classically, there was a conceptual division between data and logic. Stuff like numbers and strings and so on were data, stuff like if branches and while loops were logic, and the two things were to be kept apart. Many modern languages have a different approach, combining data and logic to create objects. An object is a singular thing, with attributes, which store data, and methods, which define logic. Pretty much any ‘thing’ can be thought of as an object and defined in terms of its attributes and methods.

An object’s attributes are really just values assigned to names and the methods are just like functions, so objects are pretty easy to understand if you know a little Python already.

If you wanted to do some banking, you might want to define some bank account objects. You’d start by defining a new object type, we’ll call it Account. Then, you could give it two attributes, one called fullname that’d have a string assigned to it, the person’s name, and one called balance that’d have a number, maybe a float, assigned to it, the current balance. The Account type would also need a method, we’ll call it transact, which changes the value of an Account object’s balance attribute, by adding to it or subtracting from it.

Lego and Object Orientation

So why would thinking in terms of objects be useful? Think about building with Lego. Lego provides primitive object types, Bricks, Tiles, Plates and so on that we can build almost any construction with. If you only want to build a very simple model, a wall perhaps, you can get away with picking up a single brick and just adding bits until you’ve got what you want. If you want to build something more elaborate, say a city, you need to approach it differently. If you just keep adding bits to an ever expanding lump of Lego, you’ll only ever end up with a huge mess. You’ll instead need to think in terms of objects and interfaces.

Lego elements are objects that have pretty simple interfaces; there’s not much complexity in how bricks interface with other bricks or tiles or whatever. They can clip on the top or bottom, there’s not much to it. Because they have clean, simple interfaces, it’s easy to combine Lego elements to make more complex objects, a wall, a chimney, a fireplace. The important thing is to ensure that you build each of these new objects with simple interfaces too.

Well designed chimney objects have simple interfaces for attaching them to wall objects. A fireplace object should just clip onto the chimney and wall in a simple way. Assuming it’s designed well, you can forget how you made the fireplace, you may have spent a long time getting it looking just right, but it’s no longer relevant, only the complexity of its interface is an issue. So long as your fireplace clips easily into place, it doesn’t make any difference how complicated it was to build. That complexity is encapsulated inside the fireplace object, leaving only the complexity of its interface exposed.

If you continue combining these new objects to form an even more elaborate object, say a house, you can very easily add that house object to your city object, again assuming simple interfaces. And so on. Every object should be constructed from more primitive objects, all with simple interfaces, all the way down.

Python Objects

In Python, if you defined an Account type as discussed above, you’d realise early on that only having the account holder’s name and the current balance is not realistically going to be enough, so you may decide to include other data like the account holder’s home address, date of birth, that type of stuff, as well as things like the date the account was opened. Then, you might want methods to close the account, modify the account holder’s name, maybe they get married, it can all become a bit too much fairly quickly. However, if you think in terms of objects, it’s obvious that you’d want to separate it out a bit.

We can always define a new Customer type that has the attributes and methods a customer would have, then define an Account type that has the attributes and methods of a bank account. The Account type would have an attribute called account_holder that would be assigned one of your Customer type objects, instead of just a string or something.

Object definitions are like blueprints. You first define a new type of object, an object definition, you then create instances of that type, these instances are the objects themselves. Every object is one instance of a particular type of object. It will have the same attribute names as all other objects of the same type. For example, all Account type objects will have an account_holder attribute, but, as all instances of Account are objects in their own right, each can have something different assigned to its account_holder attribute.

Likewise, each instance of an object has the same methods as all other instances of the same type, but calling one instance’s method is specific to that instance. Every string has an upper method because it’s a string and the string type is defined with an upper method. You can call upper on any string, but it only affects that particular instance of String.

Remember, everything’s an object. The arguments you pass to a function are objects, so you can write a function that takes Customer objects as arguments and references their attributes and calls their methods. You can have a list of Account objects and iterate over the list as normal. Anything you can do with a built-in type of object, you can do with one of your own types.

This will all be made much more concrete in articles that cover actual Python syntax. The aim here is to try and introduce the Object Oriented Paradigm in a way that helps you understand what an object actually is, whilst also encouraging you to think about how to use them more powerfully. Python wizardry begins with OOP.

While some programmers scoff at the idea of using anything more than a text editor, when you are working on a very big project consisting of many files, an IDE will have features that will make your life as a developer much easier.

Some features you can expect a good IDE to have are:

• Code completion
• Syntax highlighting
• Templates for common code
• Source Control support (subversion, mercurial or git)

Let’s see which Python IDE’s are the best and how they stack up against each other.

Eclipse with PyDev

Eclipse with PyDev

Eclipse with PyDev

Official Site: http://pydev.org/

Eclipse is a very versatile IDE that’s been around for a very long time. It’s a time tested offering and is very solid all around. Eclipse is like a sandbox IDE; it can support any language as long as somebody has baked in the support through a package. Such is the case with PyDev, a package that allows you to turn Eclipse into a very useful Python IDE.

It’s a completely free IDE that offer a wide array of features such as:

• Django integration
• Code completion
• Code completion with auto import
• Syntax highlighting
• Code analysis
• Go to definition
• Refactoring
• Mark occurrences
• Debugger
• Remote Debugger
• Tokens browser
• Interactive browser
• Unit test integration
• Code coverage
• and many many more

I use this when coding in Python on my Windows machine, it just works with minimal configuration.

Komodo Edit

Komodo Edit - Available in Windows, Linux and Mac.

Official site: http://www.activestate.com/komodo-edit

Komodo Edit is a very clean, professional Python IDE. It doesn’t have fluff and instead focuses on putting the thing you need right in front of you. No digging through random submenus looking for an option. It’s code completion is very good and fast; it pops up as you type with minimal loading time.

ActiveState offers a commercial version of their IDE, called Komodo IDE.

The differences between the two version are as follows:

Komodo Edit vs. Komodo IDE

PyCharm

PyCharm by JetBrains

Official Site: http://www.jetbrains.com/pycharm/

PyCharm is an IDE created by JetBrains. You might remember these guys as the authors of ReSharper, one of the best investments a .NET developer can make. Well PyCharm is no exception, and continuing with their outstanding pedigree, Jetbrains has released another excellent tool to the developer ecosystem.

Said to have the absolute best code completion technology, this one is worth at least a trial on your part.

• Cross Platfom
• Commercial
• Automatic Code-completion
• Integrated Python Debugging
• Error Markup
• Source Control integration
• Smart Indent
• Bracket Matching
• Line Numbering
• Code Folding
• Unit Testing