Gauld A.Learning to program (Python)

powerful programs. It might be a good idea to take some time out to try creating some programs of your own, just a couple, to try to sound these ideas into your head nbefore we move on to the next set of topics. Here are a few sample ideas:

A simple game such as OXO or Hangman

A basic database, maybe based on our address book, for storing details of your video, DVD or CD collection.

A diary utility that will let you store important events or dates and, if you feel really keen, that automatically pops up a reminder.

To complete any of the above you will neeed to use all of the language features we have discussed and probably a few of the language modules too. Remember to keep checking the documentation, there will probably be quite a few tools that will make the job easier if you look for them. Also don't forget the power of the Python >>> prompt. Try things out there until you understand how they work then transfer that knowledge into your program - it's how the professionals do it! Most of all, have fun!

See you in the Advanced section :-)

Things to remember

Check VBScript error codes using an if statement

Catch exceptions with a Python except or JavaScript catch clause Generate exceptions using the Python raise or JavaScript throw keyword Error types can be a class in Python or a simple string in JavaScript

Previous Next Contents

If you have any questions or feedback on this page send me mail at: alan.gauld@btinternet.com

Namespaces

What will we cover?

The meaning of namespace and scope and why they are important

How namespaces work in Python

Namespaces in VBScript and JavaScript

Introduction

What's a namespace? I hear you ask. Well, it's kinda hard to explain. Not because they are especially complicated, but because every language does them differently. The concept is pretty straightforward, a namespace is a space or region, within a program, where a name (variable, class etc) is valid. We actually use this idea in everyday life. Suppose you work in a big company and there is a colleague called Joe. In the accounts department there is another guy called Joe who you see occasionally but not often. In that case you refer to your colleague as "Joe" and the other one as "Joe in Accounts". You also have a colleague called Susan and there is another Susan in Engineering with whom you work closely. When referring to them you might say "Our Susan" or "Susan from Engineering". Do you see how you use the department name as a qualifier? That's what namespaces do in a program, they tell both programmers and the translator which of several identical names is being referred to.

They came about because early programming languages (like BASIC) only had Global Variables, that is, ones which could be seen throughout the program - even inside functions. This made maintenance of large programs difficult since it was easy for one bit of a program to modify a variable without other parts of the program realizing it - this was called a side-effect. To get round this, later languages (including modern BASICs) introduced the concept of namespaces. (C++ has taken this to extremes by allowing the programmer to create their own namespaces anywhere within a program. This is useful for library creators who might want to keep their function names unique when mixed with libraries provided by another supplier)

Another term used to decribe a namespace is scope. The scope of a name is the extent of a program whereby that name can be unambiguously used, for example inside a function or a module. A name's namespace is exactly the same as it's scope. There are a few very subtle diferences between the terms but only a Computer Scientist pedant would argue with you, and for our purposes namespace and scope are identical.

Python's approach

In Python every module creates it's own namespace. To access those names we have to either precede them with the name of the module or explicitly import the names we want to use into our modules namespace. Nothing new there, we've been doing it with the sys and time modules already. (In a sense a class definition also creates its own namespace. Thus, to access a method or property of a class, we need to use the name of the instance variable or the classname first. More about that in the OOP topic)

In Python there are only ever 3 namespaces (or scopes):

1.Local scope - names defined within a function or a class method

2.Module scope - names defined within a file, confusingly this is often referred to as global scope in Python

3. Builtin scope - names defined within Python itself, these are always available.

So far so good. Now how does this come together when variables in different namespaces have the same name? Or when we need to reference a name that is not in the current namespace?

Accessing Names outside the Current Namespace

Here we look in more detail at exactly how Python locates names even when the names we are using if the are not in the immediate namespace. It is resolved as follows, Python will look:

1.wihin it's local namespace(the current function),

2.within the module scope (the current file),

3.the builtin scope.

But what if the name is in a different module? Well, we import the module, as we've already seen many times in the tutorial. Importing the module actually makes the module name visible in our module namespace. WE can then use themodule name to access the variable names within the module using our familiar module.name style. This explains why, in general, it is not a good idea to import all the names from a module into the current file: there is a danger that a module variable will have the same name as one of your variables and one of them will mask the other causing stringe behaviour in the program.

For example let's define two modules, where the second imports the first:

#####module first.py #########

spam = 42

def print42(): print spam

###############################

#####module second.py ########

from first import * # import all names from first

################################

So although it's more typing it is much safer to access names in foreign modules using the dot notation. There are a few modules, suchj as Tkinter which we'lll meet later, which are commonly used by importing all of the names, but they are written in such a way to minimise the risk of name conflicts, although the risk always exists and can create very hard to find bugs.

Finally there is another safe way to import a single name from a module, like this:

from sys import exit

Here we only bring the exit function into the local namespace. We cannot use any other sys names, not even sys itself!

Avoiding Name Clashes

If a function refers to a variable called X and there exists an X within the function (local scope) then that is the one that will be seen and used by Python. It's the programmer's job to avoid name clashes such that a local variable and module variable of the same name are not both required in the same function - the local variable will mask the module name.

There is no problem if we just want to read a global variable inside a function, Python simply looks for the name locally, and not finding it will look globally (and if need be at the built-in namespace too). The problem arises when we want to assign a value to a global variable. That would normally create a new local variable inside the function. So, how can we assign a value to a global variable without creating a local variable of the same name? We can achieve this by use of the

global keyword:

Here we see the global variable being changed by the modGlobal function but not changed by the modLocal function. The latter simply created its own internal variable and assigned it a value. At the end of the function that variable was garbage collected and its existence was unseen at the module level.

In general you should minimize the use of 'global' statements, it's usually better to pass the variable in as a parameter and then return the modified variable. Here is the modGlobal function above rewritten to avoid using a global statement:

var = 42

def modGlobal(aVariable): return aVariable - 21

print var

var = modGlobal(var) print var

In this case we assign the return value from the function to the original bvariable while also passing it in as an argument. The result is the same but the function now has no dependencies on any code outside itself - this makes it much easier to reuse in other programs. It also makes it much easier to see how the global value gets changed - we can see the explicit assignment taking place.

We can see all of this at work in this example (which is purely about illustrating the point!):

# variables with module scope W = 5

Y = 3

#parameters are like function variables #so X has local scope

def spam(X):

#tell function to look at module level and not create its own W global W

Z = X*2 # new variable Z created with local scope

W = X+5 # use module W as instructed above

if Z > W:

# pow is a 'builtin-scope' name print pow(Z,W)

return Z else:

return Y # no local Y so uses module version

VBScript

VBScript takes a fairly straightforward approach to scoping rules: if a variable is outside a function or subroutine then it is globally visible, if a variable is inside a function or subroutine it is local to that module. The programmer is responsible for managing all naming conflicts that might arise. Because all VBScript variables are created using the Dim statement there is never any ambiguity about which variable is meant as is the case with Python.

There are some slight twists that are unique to web pages, namely that regardless of <script> tag boundaries global variables are visible across an entire file, not just within the <script> tag in which they are defined.

We will illustrate those points in the following code:

<script language="VBScript"> Dim aVariable

Dim another

aVariable = "This is global in scope"

another = "A Global can be visible from a function" </script>

<script language="VBScript"> Sub aSubroutine

Dim aVariable

aVariable = "Defined within a subroutine" MsgBox aVariable

MsgBox another End Sub

</script>

<script language="VBScript"> MsgBox aVariable

aSubroutine MsgBox aVariable </script>

There are a couple of extra scoping features in VBSCript that allow you to make variables accessible across files on a web page (e.g from an index frame to a content frame and vice-versa). However we won't be going into that level of web page programming here so I'll simply alert you to the existence of the Public and Private keywords.

And JavaScript too

JavaScript follows much the same rules, variables declared inside a function are only visible within the function. Variables outside a function can be seen inside the function as well as by code on the outside. As with VBScript there are no conflicts as to which variable is intended because variables are explicitly created with the var statement.

Here is the equivalent example as above but written in JavaScript:

<script language="JavaScript">

var aVariable, another; // global variables aVariable = "This is Global in scope<BR>";

another = "A global variable can be seen inside a function<BR>";

aVariable = "Defined within a function<BR>"; document.write(aVariable); document.write(another);

}

document.write(aVariable);

aSubroutine();

document.write(aVariable);

</script>

This should, by now be straightforward.

Things to Remember

Scoping and Namespaces are different terms for the same thing.

The concepts are the same in every language but the precise rules can vary. Python has 3 scopes - file (global), function (local) and built-in.

VBScript and JavaScript have 2 scopes - file (global) and function (local).

Previous Next Contents

If you have any questions or feedback on this page send me mail at: alan.gauld@btinternet.com

Regular Expressions

What will we cover?

What regular expressions are

How to use regular expressions in Python programs

Regex support in JavaScript and VBSCript

Definition

Regular expressions are groups of characters that describe a larger group of characters. They describe a pattern of characters for which we can search in a body of text. They are very similar to the concept of wild cards used in file naming on most operating systems, whereby an asterisk(*) can be used to represent any sequence of characters in a file name. So *.py means any file ending in .py. In fact filename wildcards are a very small subset of regular expressions.

Regular expressions are extremely powerful tools and most modern programming languages either have built in support for using regular expressions or have libraries or modules available that you can use to search for and replace text based on regular expressions. A full description of them is outside the scope of this tutor, indeed there is at least one whole book dedicated to regular expressions and if your interest is roused I recommend that you investigate the O'Reilly book.

One interesting feature of regular expressions is that they manifest similarities of structure to programs. Regular expressions are patterns constructed from smaller units. These units are:

single characters wildcard characters

character ranges or sets and

groups which are surrounded by parentheses.

Note that because groups are a unit, so you can have groups of groups and so on to an arbitrary level of complexity. We can combine these units in ways reminiscent of a programming language using sequences, repititions or conditional operators. We’ll look at each of these in turn. So that we can try out the examples you will need to import the re module and use it’s methods. For convenience I will assume you have already imported re in most of the examples shown.

Sequences

As ever, the simplest construct is a sequence and the simplest regular expression is just a sequence of characters:

red

This will match, or find, any occurrence of the three letters ‘r’,’e’ and ‘d’ in order, in a string. Thus the words red, lettered and credible would all be found because they contain ‘red’ within them. To provide greater control over the outcome of matches we can supply some special characters (known as metacharacters) to limit the scope of the search:

Metacharacters used in sequences

The metacharacters above are known as anchors because they fix the position of the regular expression within a sentence or word. There are several other anchors defined in the re module documentation which we don’t cover in this chapter.

Sequences can also contain wildcard characters that can substitute for any character. The wildcard character is a period. Try this:

>>>import re

>>>re.match('be.t', 'best')

>>>re.match('be.t', 'bess')

The message in angle brackets tells us that the regular expression ‘be.t’, passed as the first argument matches the string ‘best’ passed as the second argument. ‘be.t’ will also match ‘beat’, ‘bent’, ‘belt’,

etc. The second example did not match because 'bess' didn’t end in t, so no MatchObject was created. Try out a few more matches to see how this works. (Note that match() only matches at the front of a string, not in the middle, we can use search() for that as we will see later!)

The next unit is a range or set. This consists of a collection of letters enclosed in square brackets and the regular expression will search for any one of the enclosed letters.

>>> re.match('s[pwl]am', 'spam')

This would also match 'swam' or 'slam' but not 'sham' since 'h' is not included in the regular expression set.

By putting a ^ sign as the first element of the group we can say that it should look for any character except those listed, thus in this example:

>>>re.match('[^f]ool', 'cool')

>>>re.match('[^f]ool','fool')

we can match ‘cool’ and ‘pool’ but we will not match ‘fool’ since we are looking for any character except 'f' at the beginning of the pattern.

Finally we can group sequences of characters, or other units, together by enclosing them in parentheses, which is not particularly useful in isolation but is useful when combined with the repetition and conditional features we look at next.

Repetition

We can also create regular expressions which match repeated sequences of characters by using some more special characters. We can look for a repetition of a single character or group of characters using the following metacharacters:

Metacharacters used in repetition

All of these repetition characters can be applied to groups of characters too. Thus:

>>> re.match('(.an){1,2}s', 'cans')

The same pattern will also match: ‘cancans’ or ‘pans’ or ‘canpans’ but not ‘bananas’ since there is no character before the second 'an' group.

There is one caveat with the {m,n} form of repetition which is that it does not limit the match to only n units. Thus the example in the table above, fo{1,2} will successfully match fooo because it matches the foo at the beginning of fooo. Thus if you want to limit how many characters are matched you need to follow the multiplying expression with an anchor or a negated range. In our case

fo{1,2}[^o] would prevent fooo from matching since it says match 1 or 2 ‘o’s followed by anything other than an ‘o’.

Greedy expressions

Regular expressions are said to be greedy. What that means is that the matching and searching functions will match as much as possible of the string rather than stopping at the first complete match. Normally this doesn’t matter too much but when you combine wildcards with repetition operators you can wind up grabbing more than you expect.

Consider the following example. If we have a regular expression like a.*b that says we want to find an a followed by any number of characters up to a b then the match function will search from the first a to the last b. That is to say that if the searched string includes more than one 'b' all but the last one will be included in the .* part of the expression. Thus in this example:

re.match('a.*b',’abracadabra')

The MatchObject has matched all of abracadab. Not just the first ab. This greedy matching behaviour is one of the most common errors made by new users of regular expressions.

To prevent this ‘greedy’ behaviour simply add a ‘?’ after the repition character, like so:

re.match('a.*?b','abracadabra')

which will now only match ‘ab’.

Conditionals

The final piece in the jigsaw is to make the regular expression search for optional elements or to select one of several patterns. We’ll look at each of these options separately:

Optional elements

You can specify that a character is optional using the zero or more repetition metacharacters:

>>> re.match('computer?d?', 'computer')

will match computer or computed. However it will also match computerd, which we don’t want.

By using a range within the expression we can be more specific. Thus:

>>> re.match('compute[rd]','computer')

will select only computer and computed but reject the unwanted computerd.

Optional Expressions

In addition to matching options from a list of characters we can also match based on a choice of sub-expressions. We mentioned earlier that we could group sequences of characters in parentheses, but in fact we can group any arbitrary regular expression in parentheses and treat it as a unit. In describing the syntax I will use the notation (RE) to indicate any such regular expression grouping.

The situation we want to examine here is the case whereby we want to match a regular expression containing (RE)xxxx or (RE)yyyy where xxxx and yyyy are different patterns. Thus, for example we want to match both premature and preventative. We can do this by using a selection metacharacter:

>>>regexp = 'pre(mature|ventative)'

>>>re.match(regexp,'premature')

>>>re.match(regexp,'preventative')

>>>re.match(regexp,'prelude')