Perl Tutorial
based on a tutorial by Nano Gough
http://www.computing.dcu.ie/~ngough/perl/tutorial.ppt
Why Perl?
• Perl is
– Pathologically Eclectic Rubbish Lister
– the duct tape of the internet
– the Swiss-army chain saw of UNIX
• good at
• bad at
– text processing
– numeric processing
– rapid development
– debugging
– flexibility
– efficiency
– operating system stuff
• in particular UNIX/LINUX
– code re-use
• CPAN:large repository of re-usable modules
The Three Virtues of a Good Programmer
(not necessarily of a good Student)
• LAZINESS:
– The quality that makes you go to great effort to
reduce overall energy expenditure.
– makes you want to re-use other people's code
• IMPATIENCE:
– The anger you feel when the computer is being lazy.
– makes you get things done quickly (rapid prototyping)
and efficiently (optimize code)
• HUBRIS:
– Excessive pride.
– makes you want to show off (code sharing) and write
(and maintain) programs that other people won't want
to say bad things about.
Running Perl
#!/usr/local/bin/perl (tells the file to run through perl)
Use .pl extension
Perl programName (to run the program)
Perl -d programName (to run using debugger)
Perl – w programName (to run with warnings)
Printing
#The hash symbol (#) is use to comment lines of code
; Every statement in perl ends with a semi-colon (;)
Print “Hello World. I love perl.”;
#prints: Hello World. I love perl.
Print “Hello World\nI love perl\n”;
#prints:
Hello World.
I love perl.
Scalar Variables
Examples:
• scalars store a single value
$name = ‘mary’; • regardless of type (there are no types)
$age = 27; • scalar variables always start with a '$'
Operations and Assignment
(* multiplication) (\ division) (- subtraction)
$a = 1 + 2; # Add 1 and 2 and store in $a
$a = 5 % 2; # Remainder of 5 divided by 2
++$a; # Increment $a and then return it
$a++; # Return $a and then increment it
--$a; # Decrement $a and then return it
$a--; # Return $a and then decrement it
Operations and Assignment contd..
$a = 5; $b=7;
$a = $b; # Assign $b to $a ($a=7)
$a += $b; or $a=$a+b; # Add $b to $a ($a=12)
$a -= $b; or $a=$a-$b; # Subtract $b from $a ($a=-2)
Concatenation Interpolation
$a = 'Monday'; $b='Tuesday'; # double quotations may include vars
$c=$a . ' ' . $b; $c= “$a $b”;
$c= 'Monday Tuesday'; # c is now 'Monday Tuesday';
$d= $a . ' and ' . $b; $d= “$a and $b”;
$d=‘Monday and Tuesday’; # $d is now 'Monday and Tuesday';
Testing
Numbers
$a == $b # Is $a numerically equal to $b?
# don’t use $a=$b as this will not compare but just assign $b to $a
$a != $b # Is $a numerically unequal to $b?
$a<$b / $a>$b # Is $a less than/greater than $b
$a <=$b / $a >=$b # Is a less than or equal to/ g.t or eq to $b
There are no Boolean values
Strings • false are
• the empty string ''
$a eq $b # Is $a string-equal to $b? • the number 0
$a ne $b # Is $a string-unequal to $b? • undefined value undef
• empty list
• everything else is true
#You can also use logical and, or and not:
($a && $b) # Is $a and $b true?
($a || $b) # Is either $a or $b true? !($a)
Conditionals
#if $a is equal red print the colour is red
If($a eq ‘red’) { print “the colour is $a\n”;}
#in any other case (if $a not equal to red) print $a is not red
else { print “The colour $a is not red\n”;}
######################################
#if $a is equal to 1 , add 2 to $a
If($a ==1){ $a = $a+2;}
#elsif $a is equal to 2, add 3 to $a
elsif ($a ==2) {$a =$a+3;}
#in any other case add 1 to $a
else { $a++;}
#################################
#if $a is equal to 1 AND $b is equal to red: print Colour 1 is red
If(($a==1) || ($b eq ‘red’)){print “Colour $a is $b\n”;}
Arrays
Initialize an array/set to null
@colours=();
Functions push and pop
#assign elements to array @colours
@colours=(“red”,”blue”,”yellow”);
#use push function to add an element to the end of array
push(@colours,”green”);
#colours now contains:
“red”,”blue”,”yellow”,”green”
#use pop function to remove an element from the end of array
pop(@colours);
#colours now contains
“red”, “blue”, “yellow”
#Functions shift and unshift
@colours=(“red”,”blue”,”yellow”);
$new_el=“green”;
#use unshift to append $new_el to start of array
unshift(@colours, $new_el);
@colours is now:
“green”,“red”,”blue”,”yellow”
#use shift to remove an element from the front of array
shift(@colours);
@colours is now:
“red”,”blue”,”yellow”
Accessing an element of the array
@colours = (“red”,”blue”,”yellow”);
print “$colours[0]”; #prints: red
# $#colours points to index of last element of array @colours
print “$colours[$#colours]; #prints: yellow
print @colours; #prints: redblueyellow
print “@colours”; #print: red blue yellow
$colours = "@colours"; #assigns colours to string
print $colours; #prints: red blue yellow
Loops
#Loops can be used to iterate through elements of an array
Foreach Loop
foreach $el (@colours)
{
print “The colour is : $el\n”;
}
#The foreach loop iterates through the array element by #element. In
#the first iteration $el is assigned the value of the first element of
#colours (ie; red) etc..
#The result of executing this foreach statement is:
The colour is : red
The colour is : blue
The colour is : yellow
Loops contd…
For Loop
for($i=0; $i <= $#colours; $i++)
{
print “The colour is : $colours[$i]\n”;
}
Can also be written as:
$i < @colours
While Loop
$i=0; Explanation:
while($i <= $#colours) In a “scalar context”
(whenever the parser
{ expects a scalar) an array
is interpreted as the
print “$colours[$i]\n”; number of elements
$i++; contained in it
}
Split
#split is a useful function : splits up a string and puts it on an
#array
$example = “My name is Nano Gough”;
@name=split(/\s+/,$example);
@name = “My”, “name”, “is”, “Nano”, “Gough”
#using split you can also assign elements to variables
$name = “Nano:Gough”;
($first_name, $surname)=split(/\:/,$name);
$first_name = “Nano”;
$surname = “Gough”;
Associative arrays / hashes
The elements of associative arrays have keys with associated values
Initialize
%Mygrades=();
Assign elements
$Mygrades{‘english’}=80;
$Mygrades{‘irish’}=70;
$Mygrades{‘maths’}=50;
Printing
while (($key,$value) = each %Mygrades)
{print “$key => $value\n”;}
Prints:
english => 80
irish => 70
maths => 50
File handling
Opening a file
$filename =“MyFile.txt”;
open(FILE,"/users/capg/ngough/perl/MyFile.txt") || die ("Cannot open file
MyFile : $!\n");
File: Filehandle for MyFile.txt
Die: If the file cannot be opened for reading the program will ‘die’ (ie quit
execution) and the reason for this will be returned in $!
The above file has been opened for reading : open(FILE,”…..);
To open a file for writing: open(FILE,”> OutFile.txt”);
Outfile.txt will be overwritten each time the program is executed
To open a file for appending: open(FILE,”>> Append.txt”);
Close File: close(FILE);
File processing
#open input file for reading
open(IN,”< InFile.txt”) || die “Can’t open file….$!\n”;
#open output file for writing
open(OUT,”> OutFile.txt”) || die “Cant open file….$!\n”;
while(<IN>) #while there are still lines in InFile.txt
{
$line=$_; #read in the lines one at a time
chop($line); #remove end of line character
#if $line meets conditional print to OutFile.txt
if($line eq “Number 7”)
{ print OUT “$line\n”; } #endif
}#endWhile
close(IN); close(OUT); #close Files
Regular expressions
#A regular expression is contained in slashes, and matching occurs with
the =~ operator.
#The following expression is true if the string the appears in variable
$sentence.
$sentence =~ /the/
#The RE is case sensitive, so if $sentence = "The quick brown fox"; then
the above match will be false.
$sentence !~/the/ (True) because the (lower case) is not in $sentence
#To eliminate case use i
$sentence =~ /the/i; (True) because case has been eliminated with i
These Special characters can be used to match the
following:
. # Any single character except a newline
^ # The beginning of the line or string
$ # The end of the line or string
* # Zero or more of the last character
+ # One or more of the last character
? # Zero or one of the last character
#####################################
\s+ (matches one or more spaces)
\d+ (matches one or more digits)
\t (matches a tab)
\n (matches a new line)
\b (matches a word boundary)
An Example using RE’s
TASK : We have a file containing lines in different formats. We want to
pick out the lines which start with a digit and end in a full stop, but
remove the digit from the beginning of these lines
while(<FILE>)
{
$line=$_;
chop($line); # removes a newline at the end of the line
if($line =~ /^\d+(.*\.)$/)
{print “$1\n”;}
}
^\d+ (specifies that $line must begin with one or more digits)
() are used for grouping and remembering parts of the RE
.* This digit can be followed by any character any no. of times
\. This is followed by a full stop (The slash is included to despecialise the ‘.’ )
$. This specifies that the previous character (‘.’) must be the last on the line
$1 contains anything that has matched between the first pair of ()
RE’s contd
[a-z] (matches any lower case letter)
[a-zA-z] (matches any letter)
In the previous example a line was matched under the following
condition:
if($line =~/^\d+(.*)\.$)
The RE would match the line: 10 people went to the concert.
\d+ = 10; (.*) = “people went to the concert”;
Perl groups the elements specified by (.*) together and assigns it a
default variable name : $1;
Print “$1\n”; # prints : people went to the concert
Substitution
#substitution is a useful facility in perl which can be used to
replace one element with another
#replaces the first instance of london (lc) in $sentence to London (uc);
$sentence =~ s/london/London/;
#replaces all instances (because of g) of red in $sentence to blue
$sentence =~ s/red/blue/g;
Example
$sentence= “the red and white dress”;
$sentence =~ s/red/blue;
# $sentence is now = “the blue and white dress”
Some on-line Perl Tutorials:
http://www.comp.leeds.ac.uk/Perl/start.html
http://archive.ncsa.uiuc.edu/General/Training/PerlIntro/
http://www.pageresource.com/cgirec/index2.htm
Text books:
Perl cookbook; Tom Christiansen and Nathan Torkington
Programming Perl; Larry Wall, Tom Christiansen, and Randal L
Schwartz
