Python is known as a dynamically typed language, which means that you don't have to explicitly identify the data type when you initialize a variable. In the code example above, the variable name is assigned to the string value "Jim". However, you don't specifically identify the variable as a string variable. Python knows, based on the value it has been given, that it should allocate memory for a string. Likewise for the age integer variable and the highschoolGPA float variable.

The following table shows the most commonly used available data types and their attributes:

An identifier is a unique name that enables you to identify something. Identifiers are used to label variables, functions, classes, objects, and modules. They begin with either a letter or an underscore, and they can contain letters, underscores, or digits. They cannot contain punctuation marks.

When you have a multiple expression like 5 + 4 * 7, which operation is done first, the addition or the multiplication? If it isn't too painful to recall your high school algebra class, you might remember learning the rules of operator precedence. These kinds of complex expressions require a set of rules defining which expressions are executed first.

The following list describes the basic rules of operator precedence in Python (don't worry if you don't understand all the terms right now; they'll be explained as you need them):

It is possible to have a single statement span multiple lines. You could do this for aesthetic reasons or simply because the line is too long to read on one screen. To do this, simply put a space and a backslash at the end of the line. Here are a few examples:

name = "Jim 
   Knowlton"

sum = 12 + 
   13

Unlike in Java, the for loop in Python is more than a simple construct based on a counter. Instead, it is a sequence iterator that will step through the items of any sequenced object (such as a list of names, for instance). Here's a simple example of a for loop:

>>> names = ["Jim", "Joe"]
>>> for x in names:
  print x


  Jim
  Joe
>>>

As you can see, the basic syntax is for <variable> in <object>:, followed by the code block to be iterated.

A while loop is similar to a for loop but it's more flexible. It enables you to test for a particular condition and then terminate the loop when the condition is true. This is great for situations when you want to terminate a loop when the program is in a state that you can't predict at runtime (such as when you are processing a file, and you want the loop to be done when you reach the end of the file).

Here's an example of a while loop:

>>> counter = 5
>>> x = 0
>>> while x < counter:
 print "x=",x
 print "counter = ", counter
 x += 1


x =  0
counter =  5
x =  1
counter =  5
x =  2
counter =  5
x =  3
counter =  5
x =  4
counter =  5
>>>

As with C, in Python you can break out of the innermost for or while loop by using the break statement. Also as with C, you can continue to the next iteration of a loop by using the continue statement.

The if statement in Python, as in other languages, evaluates an expression. If the expression is true, then the code block is executed. Conversely, if it isn't true, then program execution jumps to the end. Python also supports use of zero or more elif statements (short for "else if"), and an optional else statement, which appears at the end if you also have elif statements, and would be the "default" choice if none of the if statements were true.

Here's an example:

>>> name = "Jim"
>>> if name == "Jim":
 print "your name is Jim"
elif name == "Joe":
 print "your name is Joe"
else:
 print "I have no idea what your name is"


your name is Jim
>>>

You define a function in Python with the following simple syntax:

def functionName(paramenter1, parameter2=default_value):
 <code block>
 return value (optional)

Note two elements in the preceding example:

Here's an example of a function definition:

>>> def getname(name):
 return name + " is very hungry"

>>>

To call a function, simply enter the function name with the function signature:

functionName(paramenter1, parameter2)

If a parameter has a default value in its definition, then you can omit that parameter when you call the function, and the parameter will contain its default value. Alternately, you can override the default value by entering the value yourself when you call the function.

For example, if a function were defined as follows:

def jimsFunc(age, name = "Jim"):

Then you could call the function in any of the following three ways:

jimsFunc(23)

jimsFunc(42, "James")
jimsFunc(42, firstName="Joe")

In the first example, I simply took the default value for the first parameter; in the second, I replaced it with "James."

To use a module, you import it. Usually import statements occur at the beginning of the Python module. Importing modules is a fairly simple operation, but it requires a little explanation. Consider the following examples:

1.      import os
2.      import os, sys
3.      from os import getcwd
4.      import os as operatingSystem

These examples highlight some variations in how you can import modules:

Reload is another very useful command, especially when entering code within the Python interactive interpreter. It enables you to reload a particular module without reloading Python. For example, if you wanted to reload the os module, you would simply enter reload os.

If you're wondering why you would ever want to do that, one scenario would be if you have a Python script that runs all the time and it accesses a module on another machine. Assuming you always want to ensure that you're running the most current version of the remote module you're accessing, you'd use the reload command.

Python has a predefined priority specifying where it should look for modules, known as the module search path. When you enter an import command and the name of the module, Python checks the following locations in the order shown here:

If you ever want to see your system's Python search path, all you have to do is bring up the interactive interpreter, import the sys module, and type sys.path. The full Python module search path will be returned, as shown in the following example:

>>> import sys
>>> sys.path
['C:\Python25', 'C:\Python25\Lib\idlelib', 'C:\Program Files\PythonNet',
'c:\scripts\python', 'c:\python25', 'C:\Python25\pyunit-1.4.1',
'c:\python25\pamie', 'C:\WINDOWS\system32\python25.zip', 'C:\Python25\DLLs',
'C:\Python25\lib', 'C:\Python25\lib\plat-win', 'C:\Python25\lib\lib-tk',
'C:\Python25\lib\site-packages', 'C:\Python25\lib\site-packages\win32',
'C:\Python25\lib\site-packages\win32\lib', 'C:\Python25\lib\site-
packages\
Pythonwin', 'C:\Python25\lib\site-packages\wx-2.8-msw-ansi']
>>>