Perl Programming Basic

INTRODUCTION TO PERL Prepared with the help internet, Google and countless contributors to this PPT Thanks to all of them Presented By Viswanatha Yarasi [email protected] (9849743894)

PERL Programming • Objectives – Introduction to PERL Programming. – Where to get perl. – Writing a perl script – How to execute the perl intrepreter. – Variables • Scalars • Arrays • Hashes

Objectives Contd. – Using strict. – Built in help – perldoc. – Conditional and looping statements – Built in functions. – Regular expressions. – File/Directory handling. – Input/Output – Functions

What Is Perl – Practical Extraction and Report language – Pathologically Eclectic Rubbish Lister?

– Perl is a High-level Scripting language – Released in 1987 by Larry Wall – Faster than sh or csh, slower than C – More powerful than C, and easier to use – No need for sed, awk, tr, wc, cut, …

Larry Wall

Larry Wall Quotes • “Even if you aren't in doubt, consider the mental welfare of the person who has to maintain the code after you, and who will probably put parens in the wrong place. “ • "It is easier to port a shell than a shell script." • “The three chief virtues of a programmer are: Laziness, Impatience and Hubris” • “And don't tell me there isn't one bit of difference between null and space, because that's exactly how much difference there is. :-) “

What Is Perl (Contd.) – Compiles at run-time – Available for Unix, PC, Mac – Best Regular Expressions on Earth – Originally designed to address the short comings of Unix Scripts. – The Swiss Army chainsaw of scripting languages – Open source and free.

What Is Perl (Contd.) – Thousands of modules available from http://www.cpan.org – Originally designed to address the short comings of Unix Scripts. – “More than one way to skin a cat” – Can be used in conjunction with other languages like C,Python, Java etc. – Can be difficult to read.

What Is Perl Good For? – Quick scripts, complex scripts – Parsing & restructuring data files – CGI-BIN scripts – Biotechnology – Prototypes – System Administration – QA – High-level programming • Networking libraries • Graphics libraries • Database interface libraries

Strengths of Perl • Text processing (pattern matching) • List processing • Database access • System language

What Is Perl Bad For? – Compute-intensive applications (use C) – Hardware interfacing (device drivers…)

Where To Get Perl – Latest release is 5.8.5 – Most used is 5.6.1 – Download from http://www.cpan.org/ports/ for the OS being used – Easy installation of Perl on Windows from • http://www.cygwin.com

– For Linux/Windows/Solaris • http://www.activestate.com/Products/ActivePerl/ • http://www.perl.com/download.csp

Perl is reasonably well documented! • Programming Perl – Wall&Schwartz; O’Reilly/Nutshell – the “camel book”

• Programming Perl – Wall, Christiansen,&Schwartz; O’Reilly – the other camel book

• www-cgi.cs.cmu/cgi-bin/perl-man – html-based manual

Perl is an interpreted language • Program is text file • Perl loads it, compiles into internal form • Executes the intermediate code

Perl scripts – Writing a perl script #!/usr/bin/perl -w Statements(;) Comments(#) – Editing a perl script vi script1.pl #!/usr/bin/perl -w #print some text print “Hello World\n”;

Command Line Options • From the shell: /usr/bin/perl [optional parameters] • As a shell script: #!/usr/bin/perl [optional parameters] • -c - check syntax without doing execution • -d - run the Perl debugger • -e - specify one line of script (like sed) • -v - print minimal version information • -V - print verbose version information • -w - prints VERY useful syntax and runtime warnings; everybody should make a habit of testing their scripts with this!

Perl scripts (Contd.) • Running a perl script ./script1.pl • Make your file executable (chmod u+x)!! • chmod u+x script1.pl or • Chmod 755 script1.pl

Hello World $a = 123; $b = 55; $c = $a + $b; $d = "kakukk\n"; $d = 'kakukk\n' if $c == 178; if( $d eq "kakukk\n" ){ print "Hello World!\n"; }else{ print "This is not a good day!\n"; } OUTPUT: This is not a good day!

Variables • Variables are containers to hold values • Values can change within a script • Types – Scalars – single pieces of information – Arrays – lists of information – Hashes – 'look-up' table of information – Special variables, like $_ or $/

Scalars • • • • • • •

Contain single pieces of info Naming conventionsPreceded by '$' No spaces (use '_') Usually lowercase e.g. $test_scalar Store various types including strings and numbers

Scalars – Scalar values $days

# the simple scalar value "days"

$days[28] @days

# the 29th element of array

$days{'Feb'} # the 'Feb' value from hash %days $#days

# the last index of array @days

Scalars – Scalar values $abc = 12345; $abc = 12345.67; $abc = 0xffff; # hexadecimal $abc = 0377; # octal $abc = 'a simple string\n'; $abc = "a string with a newline\n";

Scalars $a = 123; $b = 55; $c = $a + $b; $d = "kakukk\n"; $d = 'kakukk\n' if $c == 178; if( $d eq "kakukk\n" ){ print "Hello World!\n"; }else{ print "This is not a good day!\n"; }

• Variables start with $ • There is nothing like reserved words • $else $if $while are good variables

Scalars $a = 123; $b = 55; $c = $a + $b; $d = "kakukk\n"; $d = 'kakukk\n' if $c == 178; if( $d eq "kakukk\n" ){ print "Hello World!\n"; }else{ print "This is not a good day!\n"; }

• ”kakukk\n” is interpolated string • ’kakukk\n’ is NOT interpolated, 8 characters

Scalars $n = 1234; # decimal integer $n = 0b1110011; # binary integer $n = 01234; # octal integer $n = 0x1234; # hexadecimal integer $n = 12.34e-56; # exponential notation $n = "-12.34e56"; # number specified as a string $n = "1234"; # number specified as a string

Scalars Example ./script2.pl • $bit_of_text assigned value with '=' #!/usr/bin/perl -w #create variable with value of 'Hello World' $bit_of_text = “Hello World\n”; print $bit_of text;

Simple Arithmetic • #!usr/bin/perl -w $number1 = 6; $number2 = 3; $add = $number1 + $number2; print "Addition answer is $add\n"; $subtract = $number1 - $number2; print "Subtraction answer is $subtract\n";

Simple Arithmetic $multiply = $number1 * $number2; print "Multiplication answer is $multiply\n"; $divide = $number1/$number2; print “Division answer is $divide"; $modulus = $number1 % $number2; print “Modulus answer is $modulus\n”; $exponent = $number1 ** $number2; Print “Exponent is $exponent\n”;

Simple Arithmetic • Incrementing • Numbers can be incremented with '++' $number1 = 3; $number1++; print “$number1\n”; # prints 4

Simple Arithmetic • Decrementing • Numbers can be decremented with '--' $number1 = 3; $number1--; print “$number1\n”; # prints 2

Expression (1) • Expression is just as in other programming language • + - / * arithmetic operators • . string concatenation • == equality numeric comparison • != non equal, <=, <, >, >= numeric comparison • eq, ne, lt, le, gt, ge string comparison

Expression (2) • Precedence as usual • Use ( and ) to group sub-expressions • condition ? true-exp:false-exp

• , comma operator • = assignment operator • op= operator assignment operators +=, -=, *=, /=, =~

Operating on Assignments • Sometimes you see code like: – chop ($name = $_);

• Perl is following these rules: – process parenthesized stuff first – the "value" of an assignment statement is the thing on the left hand side.

• Another example you might see: – …read into the $email variable… ($user = $email) =~ s/@sedona\.intel\.com//;

– This only modifies the variable $user • •

first an assignment then a substitution

A note on equality • When we use control structures, we generally compare one thing to another. • What we are looking for in gneralised terms is "do X if A=B" or "do Y if A=C". • When comparing scalars you can compare them in a numerical context or a string context • Equals: $integer == 1 $string eq "perl"

• Not equals: $integer != 1 $string ne "perl"

Reading Input • Read input from the Diamond Operator print “Enter a string\n”; $a = <STDIN>; # read the next line print “You entered:$a\n”; while(defined($_ = <STDIN>)) { chomp($_); # other operations with $_ here }

IF/ELSE • A control expression that IF the condition is true, one statement block isexecuted, ELSE a different statement block is exected (ifelse.pl). if (control_expression is TRUE) { do this; and this; } else { do that; and that; }

ELSIF •

if/else is great for yes/no decisions. If you want to test mutltiple statements you can combine else and if to make 'elsif' (elsif.pl). if (condition 1 is TRUE) { do this; } elsif (condition 2 is TRUE) { do that; } elsif (condition 3 is TRUE) { do the other; } else { #all tests are failed do whatever; }

WHILE • Lets say you want to do a series of actions whilst a certain condition is true (while.pl): while (expression is true) { do this; do that; do the other; #until no longer true }

FOR • The statement people remember from BASIC (or C!) • An initial expression is set up ($init_val), a test expression is then set up which is tested at each iteration ($init_val < 10). Finally the initial expression is changed with each loop iteration ($init_val++). for ($init_val; $init_val < 10; $init_val++) { print "$init_val\n"; }

Other Control Structures • unless/else - like if/else - but unless (false) rather than if(true). • do/while and do/until - "does" a statement block "while" a condition is evaluated or "does" a statement block "until" expression is evaluated. • last - allows you to get out of a loop early - e.g. instead of loop finishing when loop conditions are met - a loop can end when conditions internal to theloop are met. See also "next" "redo" and read up on "labelled blocks" for more info.

Arrays • Using array as an whole array – @a = ( 1, 2, 3, )

• Using array element – $a[0] is scalar 1 – (unless $[ is assigned different from 0)

• Arrays are one dimensional – You will learn later how to emulate multi-dim arrays – Arrays are integer-indexed

Arrays @foo = (1,2,3); print $foo[1,2],"\n",@foo[1,2],"\n"; OUTPUT: 3 23

$foo[1,2] is the same as $foo[2] (comma operator) @foo[1,2] is an array slice, is the same as ($foo[1],$foo[2]) You can also use @foo[0..2]

Arrays • List of information • Each member of list is an element • Assign values using '=' and list () @test_array = (8,”hello”,5.6,$something)

• Refer to elements as $test_array[element number]

Arrays $test_array[1] is “hello”

• Arrays start at 0! $test_array[0] is 8

• Take care with variable naming! $test_array[0] is unrelated to..... $test_array

Assign to Array Slice @a = ( 1,2,3,4,5,6); print @a,"\n"; @a[0..2] = (3,2,1,0); print @a,"\n"; @a[0..2] = (0,0); print @a,"\n"; OUTPUT: 123456 321456 00456

You can assign value to a slice of an array. Extra elements are ignored. If there are less elements the array gets shorter.- “ITZ WRONG”. Instead of getting reduced that array element will hold NULL Value.

FOREACH • Takes a list of values and assigns them to a scalar variable, which executes a block of code (foreach.pl). foreach $element (@list) { do this; do that; do the_other; #until no more $element's }

FOREACH(2) • There's a few things missing from this code snippet compared to the previous one (foreach2.pl). • No specification of $element this time. And yet it still works! Why? foreach (@list) { do this; do that; do the_other; #until no more implied $_'s }

FOREACH(3) •

There is an implied scalar on the previous slide - $_

•

The $_ is a special scalar variable - almost like a scratchpad - its a container for information (foreach3.pl). Notice it works both for the foreach AND the print statement.

•

Perl knows that if you use foreach (@list) that it is going to assign each element to a scalar - so it will use $_ by default. foreach $_ (@list) { do this; do that; do the_other; #until no more $_'s }

FOREACH(4) %hash = (Gabor => 123, Peter => 78, Adam => 10); # returns an unordered list of the keys @list_of_keys = keys %hash;

# returns an unordered list of the values # useful only if you don't care about the keys # use it like this foreach $key (sort keys %hash) { print "$key $hash{$key}\n"; } @list_of_values = values %hash;

FOREACH(5) # iterates through the hash # do not change the keys here !! while (($key, $value) = each(%hash)) { print "$key $value\n"; } #EXAMPLE %h = (Gabor => 123, Peter => 78, Adam => 10); foreach $key (sort keys %h) { print "$key $h{$key}\n"; } Output: Adam 10 Gabor 123 Peter 78

Array Functions • pop – remove from right hand side • push – add to right hand side • shift – remove from left hand side • unshift – add to left hand side

Array Functions • Script4 -pop and push • #create an array @an_array = (8,54,78,2,5,6,4)

8

54

78

2

5

6

4

0

1

2

3

4

5

6

• POP into variable (variable=4) #pop the last value $pop_test = pop (@an_array);

8

54

78

2

5

6

0

1

2

3

4

5

8

54

78

2

5

6

4

0

1

2

3

4

5

6

• • •

PUSH variable back onto array #push $pop_test back on push (@an_array,$pop_test);

Array Functions • Script4 –shift and unshift #create an array @an_array = (8,54,78,2,5,6,4)

8

54

78

2

5

6

4

0

1

2

3

4

5

6

•

54

78

2

5

6

4

0

1

2

3

4

5

8

54

78

2

5

6

4

0

1

2

3

4

5

6

SHIFT into variable (variable=8) #shift the first value $shift_test = shift (@an_array); •

UNSHIFT variable back onto array #unshift $shift_test back on unshift (@an_array,$shift_test);

Hashes • Look-up table of 'Keys' with associated • 'Values' • e.g. Hash called 'car' • KEY VALUE • COLOUR BLUE • SIZE BIG • SPEED REALLY FAST

Hashes • Keys are arbitrary scalars • Preceded by %, e.g. %car • Use keys to retrieve values: $test_hash{key}=value $car{colour}=”blue”

What is hash • Hash is associative array • Index can be anything not only number • %hash = (1, 2, ”b”, 4); has 2 elements – $hash{1}=2 and $hash{”b”}=4 but also can be written as

• %hash = ( 1 => 2, ”b” => 4 );

Array Slices from hash %foo = (1=>2,3=>4,'apple'=>'peach'); print @foo{1,3},"\n"; • •

OUTPUT: 24

@foo{1,3} is a hash slice, is the same as ($foo{1},$foo{2}) It starts with @ and not %

Hash Tables & Key Lookups • Arrays are integer-indexed. • Hashes are string-indexed. • When you don't know what your data is, it's probably a string. • Array lookups are quick (multiply, add) – INDEX VALUE 0 Banana---1 Chips----2 Salsa----3 Wheelchair – 4 records, 10 chars each = 40 bytes – lookup: byte = (index * 10) + char;

Hash Tables & Key Lookups • Same lookup time for index 1 or 100000 • But what if the index you want to use is a string like someone's name? – storing names in an array and "searching" is not a good solution

• A really good solution is a Hash Table.

Hash Tables & Key Lookups • Terminology – The thing you look up with is a key. – The thing you get back is a value. – Together they're a key/value pair. – Sometimes we use hash tables on numericlooking things… • • •

Social Security numbers 555-61-6542 Credit Card numbers Phone Numbers

Hash Tables & Key Lookups • Example Hash Table – KEY 602-917-1111 602-822-2222 520-779-5555

VALUE Fred Flintstone Barney Rubble George Jetson

• Look up by phone number only now. • To look up by name, need a separate hash table with names as keys.

Hashes Example #Hash example - codon translation use strict; my %translate; $translate{'atg'} = 'M'; $translate{'taa'} = '*'; $translate{'ctt'} = 'L'; print "$translate{'atg'}\n";

Hashes Examples • Building Hash Tables – my(%phonebook) = ( "602-917-1111" => "Fred Flintstone", "602-822-2222" => "Barney Rubble", "520-779-5555" => "George Jetson", );

– Give me a list of all the keys – @phonenums = keys(%phonebook);

• Look up a phone number – $person = $phonebook{"602-822-2222"};

Hashes Examples • Adding to a Hash – $phonebook{"602-102-2001"} = "Daffy Duck";

• Deleting from a Hash – delete $phonebook{"602-102-2001"};

• Checking for existence of an element – if (exists $phonebook{"602-102-2001"}) …

Hash Functions • keys e.g. @codons = keys(%translate) • values e.g. @aas = values(%translate)

Printing Hash Contents my(%phonebook) = ( "602-917-1111" => "Fred Flintstone", "602-822-2222" => "Barney Rubble", "520-779-5555" => "George Jetson", ); while (($phonenum, $name) = each(%phonebook)) { print "phonenum:$phonenum, name:$name\n"; } print "\n";

Strings • Interpolated and non-interpolated strings $a = 'apple'; print "$a\n"; print '$a\n';

OUTPUT: apple $a\n

Multi-line strings $a = 'zero'; $b = <<END; this is ba: $a END print $b; $c = <<'END'; this is ca: $a END print $c;

OUTPUT: this is ba: zero this is ca: $a

Play with the interpolated strings putting expressions into it and experience what is interpolated and what is not!

Simple string handling operators • Concatenate strings: $a = ”apple” . ”peach”;

• Automatic conversion $a .= 555; OUTPUT: applepeach555

String Concatenation • Strings can be concatenated with '.' $string1 = “This”; $string2 = “ is”; $string3 = “ easy”; $string4 = “ so far”; print $string1.$string2.$string3.$string4; # prints This is easy so far

Changing Case on Strings • Applications – when comparing two strings, compare caseinsensitively •

force the case, then compare the strings.

– keyword recognition in configuration files – usernames, email addrs, … • •

wrong: if ($email eq "pab\@sedona.intel.com") better: $email =~ tr/A-Z/a-z/; if ($email eq "pab\@sedona.intel.com")

Changing Case on Strings • Well written programs observe this rule: – If humans might try it, your program ought to understand it. • •

ignore case where it should be ignored respect case where it should be respected – –

output to the user rewriting config files

Don’t program dangerous! • $variable • @variable • %variable • Are three different variables! • And still you can have subroutine with the name.

Use strict 'use strict;' • Forces you to declare variables before using them • Good for when scripts get bigger • Declarations start with 'my' e.g. my %translate;

local or my? $my = 'global'; $local = 'global'; &subi; &bubi; sub subi { my $my ='my'; local $local = 'local'; &bubi; }

my is really local.

sub bubi { print "$my\n$local\n"; }

local is actually global, but saves old value.

OUTPUT: global local global global

Calling Subroutines sub name { command(s) } • • • •

Arguments are put into the global array @_ You can $_[$i] or $v = shift Return value is return expression or just the last expression Local variables are created using keyword my or local

print printMsg("\nHello world passed"); sub printMsg { my ($my_var); local ($local_var); $my_var = 1; print "\nIn sub printMsg, \$my_var:$my_var\n"; print "\nInput arguments to the sub, printMsg:@_\n"; print "Input arguments through implicit array ". $_[0],$_[1],$_[2] . "\n"; return "Hello world received from sub, printMsg"; } OUTPUT: • In sub printMsg, $my_var:1 • • • • •

Input arguments to the sub, printMsg: Hello world passed Input arguments through implicit array Hello world passed Hello world received from sub, printMsg

Optimizing Perl - Some Tips • •

Perl is fast, but not that fast... Still need to take care with apparently simple things in 'hot' code • • • • •

•

•

Function/method calls have significant overheads per call. Copying data also isn't cheap, especially long strings (allocate and copy) Perl compiles to 'op codes' then executes them in a loop... The more ops, the slower the code (all else being roughly equal). Try to do more with fewer ops. Especially if you can move loops into ops.

Key techniques include: • Caching at many levels, from common sub-expression elimination to web caching • Functional programming: @result = map { … } grep { … } @data;

But don't get carried away... only optimize hot code, and only if needed • Don't optimize for performance at the cost of maintenance. Learn perl idioms. • Beware "Compulsive Tuning Disorder" - Gaja Krishna Vaidyanatha • And remember that "Premature optimization is the root of all evil" - Donald Knuth

Built In Functions • • • • • • • •

SPLIT JOIN LENGTH SUBSTR UC/LC S/// REVERSE and TR TR/REVERSE

SPLIT • split can take a scalar and chop it into bits, each individual bit then endsup in an array. The "recognition sequence" is user-defined but not retained (split.pl). $dna_strand = “AGCTATCGATGCTTTAAACGGCTATCGAGTTTTTTTT"; print "My DNA strand is: $dna_strand\n"; print "If we split this using TTTAAA we get the following fragments:\n"; @dna_fragments = split(/TTTAAA/,$dna_strand); foreach $fragment (@dna_fragments) { print "$fragment\n"; }

JOIN • join is the conceptual opposite of split. Lets think of it interms of a DNA ligation with a linker sequence (join.pl): my ($ligated_fragments); my (@dna_fragments); @dna_fragments=("AGGCTT", "AGCCCAAATT", "AGCCCCATTA"); $ligated_fragments = join ("aaattt", @dna_fragments); print "The fragments have been ligated with an aaattt linker:\n"; print "$ligated_fragments\n";

LENGTH • length - finds the length of a scalar (or a bit of DNA!) (length.pl). #!/usr/bin/perl -w use strict; my ($genome, $genome_length); $genome = "AGATCATCGATCGATCGATCAGCATTCAGCTACTAGC TAGCTGGGGGGATCATCTATC"; $genome_length = length($genome); print "My genome sequence is:\n$genome\nand is $genome_length bases long\n"

SUBSTR • substr extracts a specified part of a scalar (substr.pl). • substr($scalar, $start_position, $length) #!/usr/bin/perl -w use strict; my ($dna_sequence, $substring); $dna_sequence = "AGCTATACGACTAGTCTGATCGATCATCGATGCTGA"; $substring = substr ($dna_sequence, 0, 5); print "The first 5 bases of $dna_sequence are:\n$substring\n";

UC/LC • uc (uppercase) and lc (lowercase) simply change the case of a scalar (uclc.pl). #!/usr/bin/perl -w use strict; my ($mixed_case, $uppercase, $lowercase); $mixed_case = "AgCtAAGggGTCaCAcAAAAaCCCcATTTgcCC"; $uppercase = uc ($mixed_case); $lowercase = lc ($mixed_case); print "From $mixed_case we get:\n"; print "UPPERCASE: $uppercase\n"; print "lowercase: $lowercase\n";

S/// - SUBSTITUTE • This is proper Perl :-) • The obvious difference between DNA and RNA is the replacement of T with U. • Lets mimic the transcription of DNA to RNA with our new found Perl skills. • We can use the substitution operator 's'. • This can convert one element in a scalar to another element. • This takes the form s/[one thing]/[for another thing]/ • Let's see it in action (transcription.pl).

S/// - SUBSTITUTE (2) #!/usr/bin/perl -w use strict; my ($dna_molecule, $rna_molecule); $dna_molecule = "AGCTATCGATGCTTTCGATCACCGGCTATCGAGTTTTT TTT"; print "My DNA molecule is $dna_molecule\n"; $rna_molecule = $dna_molecule; $rna_molecule =~ s/T/U/g; print "My RNA molecule is $rna_molecule\n"; exit();

=~ • What is that crazy =~ sign? • This is called the "=~ operator". • Allows you to specify the target of a pattern matching operation (FYI the /[whatever]/ bit is a "matching operator"). • By default matching operators act on $_ ie. if you just saw s/T/U/g; in a program on its own it is acting on $_ • We have $rna_molecule =~ s/T/U/g; - which means perform the s/T/U/g on $rna_molecule. We have reassigned the effect of the matching operator from $_ to $rna_molecule. • If you want $rna_molecule to remain unchanged - but alter it in someway - assign it to another scalar first.

REVERSE and TR • So substitution allows you to change one thing ito another. This is great – we could use the same technique to get the complement of a DNA strand! • All we have to do is change all the A's to T's, all the G's to C's, all the T's to A's and all the C's to G's. • Then if we reverse it we get the reverse complement! Or do we? See wrong_revcom.pl. • I guess the game is given away in the filename that there's something up with this. • Look closely. • Think about what each line is going to do to the scalar $DNA. • Tell me why the code is wrong.

REVERSE and TR (2) #!/usr/bin/perl –w $DNA = "AAAAGGGGCCCCTTTAGCTAGCT"; $DNA_UNTOUCHED = $DNA; print "After no substitutions: DNA is : $DNA\n"; #substitute all the A's to T's $DNA =~ s/A/T/g; print "After A-T substitution: DNA is : $DNA\n"; #substiutute all the G's to C's $DNA =~ s/G/C/g; print "After G-C substitution: DNA is : $DNA\n"; #substitute all the C's to G's $DNA =~ s/C/G/g; print "After C-G substitution: DNA is : $DNA\n"; #subsitute all the T's to A's $DNA =~ s/T/A/g; print "After A-T substitution: DNA is : $DNA\n"; $DNA = reverse ($DNA); print "$DNA_UNTOUCHED reverse complemented is:\n$DNA\n";

REVERSE and TR (3) The answer • • • • • • • •

You can't use sequential substitutions! WATCH YOUR PERL SYNTAX vs YOUR INTERNAL LOGIC! If yourthinking is wrong, even if your Perl is correct – your output will be the result of your flawed logic! ie - WRONG! Ideally we want make all our substitutions in one statement that understands our needs. Come forth the tr operator. tr is like s, but better for tasks like this tr/ABCD/dcba would make AABBCCDD into ddccbbaa. Don't believe me? Look at revcomp.pl:

TR/REVERSE #!/usr/bin/perl -w use strict; my ($DNA, $DNA_UNTOUCHED); $DNA = "AAAAGGGGCCCCTTTAGCTAGCT"; $DNA_UNTOUCHED = $DNA; $DNA =~ tr/AGCT/TCGA/; $DNA = reverse ($DNA); print "$DNA_UNTOUCHED has a reverse complement of:\n$DNA\n"; exit ();

File Handling • open(FILEHANDLE,”filename”) • close FILEHANDLE • < FILEHANDLE > read a record from file • print FILEHANDLE expressionlist • read, write, seek, truncate, flock, binmode

File Opening and Closing open(FH,”file.txt”); #to read open(FH,”>file.txt”); #to write a new file open(FH,”>>f.txt”); #to append open(FH,”+f.txt”); #read/write but first truncate Return value is non-zero or undef in case of error. close FH; #closes the file

Reading Records From File • $/ specifies the record separator, \n by default • reads a line (bytes until the next record separator) • @a = ; # gives all the lines • $/=undef; $file=; reads the whole file

Reading Into A Loop open(FH,"test.pl"); # Returns undef when end of file while(){ # By default the buffer is read into $_ print $_; } close FH;

Printing To A File • print FILEHANDLE expression list – print – print – print – print

STDERR ”error output” STDOUT ”just output” ”to STDOUT default” FH ”a line into a file\n”

• STDERR, STDOUT are reserved words

Removing New Line open(FH,"test.pl"); # reads the whole line including the new line at the end of the line. while(){ # chomp chops off the new line safely if new line exists. chomp; print ”$_\n”; } close FH;

Truncate, Seek, Flock $LOCK_SH = 1; # shared lock $LOCK_EX = 2; # exclusive lock $LOCK_NB = 4; # non blocking lock $LOCK_UN = 8; # unlock open(FH,"+counter.txt"); flock FH,$LOCK_EX; seek F,0,0;# seek to the start of the file $counter = ; $counter++;# change here to -seek FH,0,0;# seek to the start of the file again truncate FH,0;# comment this out when decrementing print FH $counter; flock FH,$LOCK_UN; close FH; print $counter;

Handling Directories opendir(DIR,”dirname”); readdir(DIR); closedir DIR; • You can not open a directory for writing 

Example: Getting the list of the files opendir(DIR,'.'); @filesanddirs = readdir(DIR); closedir DIR; @files = (); for ( @filesanddirs ){ push @files, $_ if -f $_; } for(@files){ print "$_\n"; }

Example: Getting all files recursively $startDirectory = '.'; opendir(DIR,$startDirectory); @files = readdir(DIR); closedir(DIR); @dirs = grep( (-d "$startDirectory/$_") && /^[^.]/ ,@files); while( $#dirs > -1 ){ $cdir = pop @dirs; opendir(DIR,“sStartDirectory/$cdir"); @f = readdir(DIR); closedir(DIR); @d = grep( (-d "$startDirectory/$cdir/$_") && /^[^.]/,@f); for( @d ){ push @dirs, "$cdir/$_"; } for( @f ){ push @files, "$startDirectory/$cdir/$_"; } }

Implied Variables While ($a = ) { # Read FH $a =~ s/blah/quux/; print $a; } $_ is implied for reads from FH's, regexp, and print while () { # $_ instead of $a s/blah/quux/; print; } Subs return value of last operation if no return (see sorting) Implied variables decrease clutter, but increase complexity – use with care!

Global Special Variables $| $_ $. @_ $$ $< $> $( $)

Turn off line buffering The default input and pattern-searching space Input line number from files which are being read Arguments passes to the function $PID $PROCESS_ID Process ID (read only) $UID $REAL_USER_ID Real user ID of the process $EUID $EFFECTIVE_USER_ID Effective user id $GID $REAL_GROUP_ID The real group id of the process $EGID $EFFECTIVE_GROUP_ID The effective group id of the process

Global Special Variables (2) @array = qw(hello world have a nice day); # $_ is default input and pattern-searching space foreach $_ (@array) { print "Prinint default input, \$_:" . $_ . "\n"; if ($_ =~ "hello") { print "\nhello found\n\n"; } } foreach ('hickory','dickory','doc') { print; } print "\n\$\$:Process ID:" . $$ . "\n"; # process ID

Global Special Variables (3) while (($var_name, $var_value) = each(%ENV)) { print "var_name:$var_name, var_value:$var_value\n"; } foreach (@INC) { # Include path print "Include path:$_\n"; } print "\nPrinting file name \__FILE\__ :" . __FILE__ . "\n"; print "\nPrinting line number wich is useful in debugging \__LINE\__ :" . __LINE__ . "\n";

Global Special Variables (4) open(MY_FILE,"myperlbits.txt"); while( <MY_FILE> ) # print "Line number from $. { print $., $_, "\n"; } close (MY_FILE); &printMsg("Hello world passed"); sub printMsg { # input arguments from @_ print "\nInput arguments to the function, printMsg:@_\n"; }

Global Special Variables (5) $a = "print \"1\\n\";\nwhat is this?"; eval $a; print $a,"\n",$@; print "but we run fine\n"; $a = "print \"1\\n\";"; eval $a; print $a,"\n",$@; OUTPUT: print "1\n"; what is this? syntax error at (eval 1) line 3, at EOF but we run fine 1 print "1\n";