Because Perl and Python are interpreted languages, you can often type in commands a line at a time or type and save commands in a file. A simple Perl program might look like this:

print "This is a simple Perl program.
";
exit;

A Python program is even simpler:

print "This is a simple Python program."

Perl adapts the syntax of the C language including the use of semicolons at the end of each statement and the use of curly brackets to identify a block of commands. Python omits semicolons, and instead of using curly brackets to identify a block of comments, Python uses indentation. To identify a block of commands in Perl, use curly brackets like this:

if $x > 5
  {
  command1;
  command2;
  }

In Python, the same program might look like this:

if x > 5:
  command1;
  command2;

To write a comment in Perl, use the # symbol. Anything that appears to the right of the # symbol is treated as a comment, such as

# This is a comment
print "This is a simple Perl program.
";
exit; # This is another comment

In Python, you can also use the # symbol to create comments on a single line. If you want to create a comment covering multiple lines, use triple quotes to define the start and end of a comment, such as

""" This is a multiple line comment.
    The triple quotes highlight the beginning
    and the end of the multiple lines. """
print "This is a simple Python program."

Both Perl and Python allow variables to hold any data types. In Perl, variable names begin with the dollar sign symbol, such as $myVar. Perl and Python are case-sensitive languages, so the Perl variable $myVar is considered completely different from $MYVar while the Python variable DueDate is completely different from the variable duedate.

The three types of operators used are mathematical, relational, and logical. Mathematical operators calculate numeric results such as adding, multiplying, or dividing numbers, as shown in Table 3-1.

9/4 = 2

If at least one number is a decimal, the result will also be a decimal, such as

9.0/4 = 2.25

Or

9/4.0 = 2.25

Relational operators compare two values and return a True or False value. The six relational operators available are shown in Table 3-2.

Perl offers a unique comparison with signed result operator (< = >), which compares two values and returns 0 (if the two values are equal), 1 (if the first value is greater than the second), or -1 (if the first value is less than the second), as shown in Table 3-3.

Logical operators compare two Boolean values (True [1] or False [0]) and return a single True or False value, as shown in Table 3-4.

j = 5;
i = j + 1;

j = 5;
i = ++j;

j = 5;
i = j++;

j = 5;
i = --j;

j = 5;
i = j--;

i = 59;

The simplest branching statement is an IF statement that only runs one or more commands if a Boolean condition is True. In Perl, the IF statement uses curly brackets to enclose one or more commands:

if (condition) {
  Command1;
  Command2;
  }

In Python, the IF statement uses indentation to enclose one or more commands:

if (condition):
  Command1
  Command2

To make the computer choose between two mutually exclusive sets of commands, you can use an IF-ELSE statement in Perl like this:

if (condition) {
  Command;
  Command;
  }
else {
  Command;
  Command;
  }

In Python, the IF-ELSE statement looks like this:

if (condition):
  Command
  Command
else:
  Command
  Command

The IF-ELSE statement only offers two choices. If you want to offer multiple choices, you can use the IF-ELSEIF statement, which uses two or more Boolean conditions to choose which of two or more groups of commands to run. In Perl, use the ELSIF keyword, such as

if (condition1) {
  Command;
  Command;
  }
elsif (condition2) {
  Command;
  Command;
  }
elsif (condition3) {
  Command;
  Command;
  }

In Python, use the ELIF keyword, such as

if (condition1):
  Command
  Command
elif (condition2):
  Command
  Command
elif (condition3):
  Command
  Command

A looping statement repeats one or more commands for a fixed number of times or until a certain Boolean condition becomes True. To create a loop that repeats for a fixed number of times, use the FOR loop, which looks like this:

for (startvalue; endvalue; increment) {
  Command;
  }

If you wanted the FOR loop to run five times, you could set the Start value to 1 and the End value to 5, such as

for (i = 1; i <= 5; i++) {
  Command;
  }

In Python, the FOR loop looks dramatically different:

for variable in (list):
  Command
  Command

To make a Python FOR loop repeat five times, you could do this:

for x in (1,2,3,4,5):
  print x

The preceding Python FOR loop would print

1
2
3
4
5

If you want a FOR loop to repeat many times (such as 100 times), it can be tedious to list 100 separate numbers. So Python offers a range() function that eliminates listing multiple numbers. To use the range() function to loop five times, you could do this:

for x in range(5):
  print x

Because the range() function starts with 0, the preceding Python FOR loop would print

0
1
2
3
4

Another way to use the range() function is by defining a lower and upper range like this:

for x in range(25, 30):
  print x

This FOR loop would print the numbers 25, 26, 27, 28, and 29. Rather than increment by one, you can also use the range() function to define your own increment, which can be positive or negative, such as

for x in range(25, 30, 2):
  print x

This FOR loop would print 25, 27, and 29.

If you don't know how many times you need to repeat commands, use a WHILE loop, which looks like this:

while (condition) {
  Command;
  Command;
}

If the condition is True, the loop runs at least once. If this condition is False, the loop doesn't run. In Python, the WHILE loop looks like this:

while (condition):
  Command
  Command

In Perl and Python, every subprogram is a function that can return a value. The format of a typical Perl function looks like this:

sub functionname {
  Commands;
  return $value;
  }

When you pass parameters to a Perl function, that function can access them with the foreach keyword and the @_ array, such as

sub functionname {
  foreach $variablename (@_) {
    Commands;
  }
  return $value;
  }

The foreach $variablename (@_) line stores a list of parameters in the @_ array. Then the foreach command plucks each item from the @_ array and temporarily stores it in $variablename.

A typical Python function looks like this:

def functionname (variablename)
  Commands
  return value

If you don't want a function to return a value, omit the return line.

Perl offers three data structures: arrays, hash arrays, and references. An array stores multiple items, identified by an index number. A hash array stores multiple items, identified by a key, which can be a number or a string.

@arrayname = (element1, element2, element3);

@numberarray = (1, 2, 3, 4, 5);

@numberarray = (1..5);

@numberarray = (1..10);
$thisone = $numberarray[0];

push(@arrayname, item2add);

$variablename = pop(@arrayname);

%hasharray = (
  key1 => value1,
  key2 => value2,
  key3 => value3,
);

%hasharray = ("key1", value1, "key2", value2, "key3",
   value3);

$variable = $hasharray ("key1");

Python offers tuples, lists, and dictionary data structures. Both tuples and lists contain a series of items, such as numbers and strings. The main difference is that items in a tuple can't be changed whereas items in a list can be changed. A dictionary stores values with keys, allowing you to retrieve values using its distinct key.

tuplename = (item1, item2, item3)

variablename = tuplename[1]

listname = [item1, item2, item3]

variablename = listname[0]

listname.append(newitem)

listname.insert(index, newitem)

listname.remove(existingitem)

dictionaryname = {key1:value1, key2:value2, key3:value3}

Variable = dictionary.name.get(key)

Both Perl and Python are true object-oriented programming languages (unlike C++), so you have no choice but to create and use objects in your programs. To create an object, you must define a class. In Perl, a typical class definition looks like this:

package className;
sub new {
  my $objectname = {
  Data;
  Data;
  };
  bless $objectname, $className;
  return $objectname;
sub methodname{
  Commands;
  Commands;
  };

In Python, a class looks like this:

class ClassName:
  Data
  Data
  def methodname (self):
    Commands
    Commands
    Commands

A class lists properties (data) along with one or more methods, which contain code for manipulating an object in some way.

After you define a class, you can create an object from that class by declaring a variable as a new class type. In Perl, you create an object by creating a constructor method commonly called new, such as

my $variablename = classname->new();

In Python, create an object like this:

objectname = new classname();

To use inheritance in Perl, use the @ISA variable inside a new class, such as

package newobject;
use class2inheritfrom;
@ISA = qw(class2inheritfrom);

To use inheritance in Python, identify the class to inherit from when you create a new class, such as

class ClassName (class2inheritfrom):
  Data
  Data
  def methodname (self):
    Commands
    Commands
    Commands

To inherit from multiple classes in Python, define additional classes, separated by a comma, such as

class ClassName (class2inheritfrom, anotherclass):
  Data
  Data
  def methodname (self):
    Commands
    Commands
    Commands