Revision information:
Notes from Mastering Perl for Bioinformatics by James Tisdall. O’Reilly & Assoc’s 2003.
Web page for book = catalog/mperlbio
Basics:
Run perl programs using perl prog_name
Edit in MSWord saving as text only with line breaks.
Default file extension is .pl. Modules or classes must use .pm.
Edit data files the same way, but use text only if inputs are longer than one line, like sequence files.
Begin files with ref to perl program #!/usr/bin/perl;
Current folder & standard perl folders checked when calls to access file made.
use ref /usr/etc/etc/folder_name; allows other local folder to be accessed, or on command line by
perl -I/dir/dir/lastdir progam.pl
use warnings; gives debugging info & use strict; forces my to define variables.
# is used for notes (rest of line after # is ignored by program)
Variables & functions to manipulate them:
$var is scalar (auto parsed to # or text, use ‘###’ to treat # as text)
Can assign multiple things at once w/ ()’s ($a,$b,$c) = (1,2,3).
Arrays: @arr = (1, “2”, ‘cow’, “frog”, $var1) makes 1D array. @a=qw(a b c) omits need for “” & ,.
Access elements by $elem = $arr[0] where 0 is 1st element
Using array where Perl expects a scalar value returns # of elements in array, e.g. if (@arr ’val2’) makes hash, w/ => equiv to “,” but allows you to not put quotes around key2.
Access elements by $value = $h{‘key_name’}
Get all keys with @keys = keys %h or values with @vals = values %h
my $var defines $var locally within subroutine or file where my is called- outside of which it is removed from memory UNLESS it is referred to by any subroutine (a “closure”). If that subroutine(s) is enclosed in the same block it is the only way to access that variable… e.g.
{ my $var; sub up_var ($var++}; sub get_var{print “$var”} } often used in OO modules
Default variables (e.g. things passed to subroutines) $_ (for 1) or @_
$! (error message), $& string returned from =~ binding functions.
@ARGV is array of command line arguments to script.
Note for $obj=OO_Class->new calls 1st element in @_ is ‘OO_Class’ & any subsequent $obj->method(args) $obj (reference) is 1st argument passed.
Variables must be initialized (assigned w/ =) before they can be used in calcs or print statements etc. For scalars =’’ or 0 works, for arrays & hashes @a or %a= () OK. Or w/ refs $a = [] or {}.
Closures variables
References:
$ref = \$var gives ref to memory location of $var
$value_of_var = $$ref (dereferenced by $, or @ or % for array or hash refs)
$array_ref = [0,1,2,3] makes ref to anonomous array
access whole array with @arr=@$array_ref
access element w/ $val =$$array_ref[0] (returns 0) OR =$array_ref->[0]
$hash_ref = {key => ‘val’, key2 =>’val2’} makes ref to anon hash
access whole hash with %$hash_ref, or data w/ $$hash_ref{key} OR $hash_ref->{key}
can, if desired, make this clearer with {}’s, e.g. $$ref equals ${$ref}
ref EXPR if EXPR is reference returns type of thing it points to e.g. SCALAR, ARRAY, REF, HASH or OO_Class1 if it has been blessed by an OO module, else returns false.
Complex data structures:
Matrices: Can specify 1) directly with $arr[x][y]=, or…
2) by filling array with refs to other arrays. Simplest @arr = ([1,2],[3,4]) which puts anon arrays into array. Better: define refs $a=[1,2]; $b=[3,4] & put in array @arr=($a,$b). Doing this (I think) lets you pull back elements normally as $arr[x][y]…
3) Most flexibly, by making everything a reference, so $arr=[[1,2],[3,4]] or $arr=[$a,$b]. If so, need to derefrence to access elements, as $$arr[x][y] or $arr->[x][y] or @{$arr->[x]} to get array from posit x. If everything is always a reference, it’s most flexible, allowing complex mixed data structures, such as $mess = [1,{k1=>’hi’,k2=>[“what”,”the”,”hell?”]},[1,2, [9,8.7]],”end”], that can be accessed like $mess->[0] gives 1, ${$mess->[1]}{k1} gives “hi’, ${${$mess->[1]}{k2}}[2] gives “hell?” & ${${$mess->[2]}[2]}[0] is 9. Most sensibly these could also be written with many arrows $mess->[1]->{k2}->[2] or @mess->[1]->{k2}.
Order appears to be from inside out or left to right. So pointer to top level array position 1st, etc.
Still darn confusing re when defreferencing is needed, etc.
Operators:
Logical: not (or !) (returns true if something is false) see If statement
and (&&), or (||)- meaning either, xor (meaning only one not both)
Note statement1 or statement2 only executes statement 2 if 1 is false.
Comparison: == (for #’s) or eq (for strings), != (or ne for strings) also < (lt), = (ge), > (gt)
Assignament: $a = $b assigns value of $b to $a, $a++ or $a-- (increment or decrement)
$a+=$b ($a=$a+$b), also -=,*=,/=($a/$b), **=($a raised to $b) & %= remainder of $a/$b, for strings $a.=$b appends $b to $a, $a x=$b (repeat $a $b times)
Common programming functions:
die args end the program printing args
for (intial condit; continue so long as this is true; do each iteration) {statements;}
e.g. for($i=1;$i>”ouput append to existing
Lines of file is in array & accessed by @arr= ;
foreach $val {} steps thru file assigning each line to val
When finished close(FILEHANDLE);
read (FH, scalar, length, offset) puts data of length from current position w/ optional offset into scalar
rename oldname newname to rename file
seek FILEHANDLE, OFFSET, WHENCE posits file pointer to offset bytes, if whence 1 offset added to current posit, if 2 offset subtracted from end (could use to reset pointer by seek(FH,0) ??
tell FH gives current position in bytes
Position in file can be reffed by range e.g. while {if (1.. /search pattern/) {next;}, where 1 is 1st line
Text handling & modification
Binding operators:
Search: $a =~ /pattern/ returns pattern in $& special var if pattern in $a (but doesn’t change $a?), same as m/pattern. pos $a gives position in string where last m// search left off.
Substitute: $a =~ s/pattern1/pattern2/ replaces 1st 1 w/ 2
Transpose: $a =~ tr/123/567/ converts all 1’s to 5’s etc. in A (can use for DNA complent)
Modifiers: / … /g (match all instances), //s (let . match newline) //I (ignore up/low case), d??
Special chars & ranges:
. (any char) \s (whitespace), \S (nonwhitspace), \d (digit 0-9)
[1234] (any of this set), [^1234] (any not in set), (wd1|wd2|wd3) (any of these 3 words)
^ line start, $ line end.
Groups indicated by multiple ()’s will output to $1, $2 etc. w/ 1st “(“ encountered ->$1.
Prepending \ allows search for Metacharacters \|(){{^$*+? or . (e.g. /\\/ finds “\”
Quantifiers: * (0 or more of thing, e.g. x*), + (1 or more), ? (0 or 1) {3} 3, {3,6} 3 to 6, {3,} 3 or more. Generally return max, so ‘ABCCCCD’ =~ /A.*C/ gives ABCCCC. To get shortest string append ? to quantifier, so =~/A.*?C/ gives ABC.
chomp $str or list/array removes terminal newlines from $str or array, chop removes last char
index string substring returns position of 1st instance, rindex gives last instance
lc EXPR returns lower case
length EXPR gives length in characters
reverse $string reverses
split /pattern/,$str returns array of $str split at every /pattern/. if pattern is omitted uses white spaces as pattern
substr($string,offset, length,replacement) offset = start posit-1 (e.g. substr($s,0,1) gives 1st char. Negative offset = distance from right end. Length omitted -> $str end. Length negative, leave # chars to end off. So… substr(“ABCDEF”, 2, -2) gives ‘CD’. If replacemnet specified, replace substr w/ it.
uc($str) returns upper case of $str
Modules
Must end with 1; as last statement and file name must end with .pm (e.g. module1.pm)
Made accesible by use module1; can specify subdiretory like so use dir::subdir:module1
Subroutines in module called by program using module1::subrout(args)
Built-in modules
AUTOLOAD; use vars ‘$AUTOLOAD’; or our $AUTOLOAD in Perl 5.6 or greater, then any call to an undefined subroutine calls up autoload passing subroutine name, typically in “operation_attribute” form, in $AUTOLOAD + any args)
sub AUTOLOAD {my ($self, @args) = @_; my ($operation, $attribute) = ($AUTOLOAD =~ /(get|set)(_\w+)$/); if($operation eq ‘get’ AND exists $self->{$attribute}) {
no strict ‘refs’; *{$AUTOLOAD} = sub {shift->{$attribute}; no strict ‘refs’;
(this turns off strict briefly, uses * to put $AUTOLOAD value as subroutine in symbols table, uses shift (on default @_ to pull $obj & accesses $attribute key in $obj, then toggles off strict)
return $self->$attribute; } (performs proper subroutine function 1st time called, in later calls subroutine will have been defined by AUTOLOAD).
Carp: use Carp gives carp(statement) prints more detailed error message & croak(statement) does this & dies.
DESTROY need not be defined by use statement, automatically removes any variable that is out of scope (e.g. locally defined by my in {}’s). Can define sub DESTROY {thing to do;} to have other things, such as decreasing running count of data objects, called when DESTROY activates.
DB_File: use DB_File; allows database file of hash to be stored in memory after exit from program, see perlman DB_File for details. Uses tie (%hash, ‘DB_File’, $file_name, flags, mode, $DB_HASH) where ‘DB_File’ & $DB_HASH must be verbatim, flags can be of type O_RDWR | O_CREAT & mode is 0444 (??). Apparently DB files are space delimited
CPAN modules
For more info use perldoc CPAN, for info about installed module perldoc mod_dir::mod_name
Find modules by browsing
Insall using perl –MCPAN –e ‘install module_dir::module_name’
Objects, Classes, Methods & Object Oriented Programming
Object is a datastructure blessed by OO module (& thus part of a Class) by calling new
Methods are defined in the class & are only “legit” way of accessing data in objects
Classes of objects are defind & managed in special module .pm files
Begin with package Class1; statement where Class1 is filename without .pm
After other use calls then…
{ my %attribute_table = (_name => [‘default_value’, ‘permissions.e.g.read.write’, _dat=> etc.);
sub _all_attributes {keys %_attribute_table;} }(this sub call w/in same {} sets closure on %_attribute table, etc., note prepended underscores indicates something accessible only in module & not intended to be accessed by calling program)
sub new {
my ($class, % arg) = @_; (1st arg when OO module sub called is always class name)
… (tests to confirm keys in %arg are defined in %attribute table etc.)
return bless( { _name => $arg{name} || die, _dat => $arg{dat} }, $class || “?”);
} (note, here use || or to give default in case of failure
sub get_name { $_[0] -> {_name} }; (a method: default is to return resulting value ->assoc’d with key)
sub get_dat { $_[0]-> {_dat} }; (note, $obj->get_dat call, receives $obj ref as 1st arg, then any others)
sub set_name{
my($input_obj, $name) = @_;
if $name { $input_obj->{_name} = $name;
}
(changes ‘keyname’ that might be specified in calling program to “_keyname”, which will prevent their direct access except through subs in class1. Bless associates object with Class1 so that $obj->subroutine() calls use Methods in Class1.)
1;
=head1 Documentation 1
Descriptors
=head1 more documentaiton
Examples etc.
=cut (this is “POD”/”plain old documentation”; everyting between =head1 & = cut ignored by program, but is called up with perldoc module_name)
Program that makes Class 1 objects & manipulates them
use Class1;
my $obj1 = Class1->new(name=>’Thing1’,dat=>1); (Class1->sub call passes “Class1” as 1st arg). $obj is a blessed reference that if I call $obj1->method, it will pass $obj to method in the Class1 module)
print $obj1->get_name, “\n”; (apparently this calls the name function in Class1 passing it an array containing the $obj1 reference and then any other input values… prints Thing1
$obj1->set_name(“Thing2”);
print $obj1->get_name, “\n”; prints Thing2
print ref($obj1); prints Class1 (since it’s been blessed by class name)
Inheritance:
use base (“Module_name”); uses Module name as a base module. Any subs changed in current module are used, otherwise module_name subroutines used as default.
Relational Databases & SQL
................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.
Related searches
- std 8 revision papers
- year 3 revision cambridge
- year 8 revision booklets
- ks3 science revision notes
- ks3 science revision worksheets pdf
- science revision year 7
- maths revision year 7
- class 8 revision papers
- science revision questions
- science revision questions jc
- ks3 revision science
- year 7 maths revision worksheets