Perl, Object Orientation

Transcription

1 Perl, Object Orientation (and a little Graph Theory) Nick Stylianou nickstylianou@yahoo.co.uk 1

2 Outline Preliminaries (History, Resources) 1) The Perl Language 2) Object-Orientation (OO) in Perl 3) Example Application: Graph Theory Conclusions, Questions & Discussion 2

3 A Brief History of Perl Created by Larry Wall Natural and Artificial Languages, Seattle Pacific University (1970s) NASA JPL, System Development Corporation (SDC) Unisys (1986) Perl v1.0 released in 1987 Perl v5.0 released in 1994 Perl Free Software Foundation Award 1998 for the Advancement of Free Software v5.6 (2000) Unicode, 64-bit, standardised version numbering v5.8 (2002) Unicode, I/O, Threads, widely distributed Current stable production version 5.24 (2016) Perl 6 specification proposed in 2000 redesign, not backwards-compatible; implementations (Pugs, Rakudo) 3

4 Resources 4

5 Download 5

6 Documentation 6

7 Community 7

8 Add-On Modules 8

9 1) The Perl Language Hello world! & the Perl philosophy Data Structures Primitive Data Types and Common Code Patterns References (Pointers) Modularity Subroutines and Packages 9

10 Hello world & the Perl philosophy print Howdy, world!\n that s it!!! (p. 1) Perl is designed to make the easy jobs easy, without making the hard jobs impossible. (p. ix) With Perl you re free to do The Right Thing, however you care to define it. (p. 1) If you re starting to get the feeling that much of Perl culture is governed by mere convention, then you re starting to get the right feeling... (p. 278) The Camel Book Larry Wall et al., Programming Perl (1996) 10

11 Best Practice Hello world helloworld.pl #!/usr/bin/perl #!/usr/bin/perl v5.10; v5.10; strict; strict; warnings; warnings; print print "Hello "Hello world!\n"; world!\n"; exit exit 0; 0; 11

12 Data Structures: Primitive Data Types Scalars $a = 3; $price = 5.8; print $a; # prints 3 $c = orange ; Arrays = (10,20,30,40, banana ); $a[5] = 60; print $a[0]; # prints = (20,30,40) Hashes key value %price = ( espresso => 1.8, latte => 2.0 ); $price{tea} = 1.5; print $price{espresso}; # prints

13 Common Code Patterns: Arrays ($x,$y,$z) = (0,0,0); # $x=0; $y=0; $z=0; ($a,$b) = ($b,$a); # swaps values of $a and = for ( $i=0; $i <= $#a; for ( $i=0; $i < $i++) { $a[$i]++; } $i++) { $a[$i]++; } foreach $e (@a) { $e++; } $x = $y; # stack $x = $y; # queue The of is encouraged for strict lexical scoping strict 13

14 Common Code Patterns: Hashes foreach $k (keys %price) { $price{$k}*=1.2; } foreach $k (sort keys %price) { print } Take care with quotes: $price{latte} $price{ latte } $price{ latte } $price{$k} $price{ $k } $price{ $k } defined and exists : $hash{key} = undef; delete $hash{key}; value defined $hash{key} key exists $hash{key} 14

15 Compound Data Structures Arrays of Arrays (multi-dimensional foreach $t (0..9) { foreach $u (0..9) { $a[$t][$u] = (10*$t)+$u; } } print $a[5][3]; # prints 53 u t Hashes of Hashes (nested hashes): %h=(); foreach $y ( a, b, c, d ) { foreach $x ( r, g, b ) { $h{$y}{$x} = $y$x ; } } print $h{ c }{ r }; # prints cr x r g b a ar ag ab y b br bg bb c cr cg cb d dr dg db 15

16 References (Pointers) Obtain a (hard) reference with the \ operator $s = r ; $p = = (); $q = \@a; %h = (); $r = \%h; De-reference with { } $t = %g = %{$r}; $t = $$p; (soft ref) $u = $a[0]; $u = ${$q}[0]; $v = $h{key}; $v = ${$r}{key}; or the -> operator: $u = $q->[0]; $v = $r->{key}; 16

17 More References Compound Arrays and Hashes $a[5][3] $a[5]->[3] $h{c}{r} $h{c}->{r} Anonymous Arrays and $a=[]; $a[0] = x ; $a->[0] = x ; %h=(); $h={}; $h{key} = 1; $h->{key} = 1; 17

18 Modularity: Subroutines A routine (function) is a named code block It returns the value of the last evaluated statement the return statement makes this explicit Arguments are passed in as the call-by-reference vs call-by-value (shift, is a single flattened array to maintain identities of distinct arrays, references 18

19 Subroutine Example ($a,$b) = (1,2); # # 2 arrays foo($a,$b,@a,@b); # adds the sum of first two args to # each of the remaining args foo { ($x,$y) = shift); foreach $e (@_) { $e += $x+$y; } } 19

20 Packages Basic Structure MyLib.pm package package MyLib; MyLib; 1; 1; identify identify print print "MyLib\n"; "MyLib\n"; app.pl MyLib; MyLib; MyLib::identify(); MyLib::identify(); 20

21 The Perl Language Recap 3 Primitive Data Types Code Patterns Compound Data Structures References Subroutines Packages scalars $, arrays [ ], hashes % { } => for/foreach, push/shift, keys %h, quotes, defined / exists arrays of arrays, hashes of hashes \, %{$r} ->, anonymous arrays/hashes: $a=[ ] $h={}, (flattened list), call by reference / value package,, :: 21

22 2) Object Orientation in Perl Constructors Composition Attributes Inheritance Methods Abstraction Initialisation OO Frameworks 22

23 Constructors app.pl MyClass.pm package package MyClass; MyClass; 1; 1; MyClass; MyClass; $instance $instance == new new MyClass(); MyClass(); ## MyClass->new(); MyClass->new(); ## MyClass::new(MyClass::); MyClass::new(MyClass::); new new $class $class == shift; shift; $self $self == {}; {}; return return $self; $self; 23

24 Attributes MyClass.pm app.pl package package MyClass; MyClass; MyClass; MyClass; $instance $instance == new new MyClass(); MyClass(); 1; 1; new new $class $class == shift; shift; $self $self == {}; {}; $self->{id} $self->{id} == 1; 1; return return $self; $self; printf printf %d\n, %d\n, $instance->{id}; $instance->{id}; 24

25 Methods: Aessors app.pl MyClass.pm new new $class $class == shift; shift; $self $self == {}; {}; $self->{id}=1; $self->{id}=1; return return $self; $self; MyClass; MyClass; $instance $instance == new new MyClass(); MyClass(); printf printf %d\n, %d\n, $instance->getid(); $instance->getid(); getid getid $self=shift; $self=shift; return return $self->{id}; $self->{id}; 25

26 Methods: Modifiers app.pl MyClass.pm new new $class $class == shift; shift; $self $self == {}; {}; $self->setid(1); $self->setid(1); return return $self; $self; getid getid setid setid MyClass; MyClass; $instance $instance == new new MyClass(); MyClass(); $instance->setid(5); $instance->setid(5); printf printf %d\n, %d\n, $instance->getid(); $instance->getid(); $self=shift; $self=shift; $self=shift; $self=shift; return return $self->{id}; $self->{id}; $self->{id}=shift; $self->{id}=shift; 26

27 Methods: Combined app.pl MyClass.pm MyClass; MyClass; $instance $instance == new new MyClass(); MyClass(); new new $class $class == shift; shift; $self $self == {}; {}; $self->id(1); $self->id(1); return return $self; $self; $instance->id(5); $instance->id(5); printf printf %d\n, %d\n, $instance->id; $instance->id; id id ## multi-purpose multi-purpose aessor/modifier aessor/modifier $self=shift; $self=shift; return return $self->{id}=shift $self->{id}=shift :: $self->{id} $self->{id} ;; 27

28 Initialisation MyClass.pm app.pl new new $class $class == shift; shift; $self $self == {}; {}; $self->_init(); $self->_init(); return return $self; $self; MyClass; MyClass; $instance $instance == new new MyClass(); MyClass(); $instance->id(5); $instance->id(5); printf printf %d\n, %d\n, $instance->id; $instance->id; _init _init $self $self == shift; shift; $self->id(1); $self->id(1); underscore indicates private method by convention only 28

29 Parameterised Initialisation app.pl MyClass.pm MyClass; MyClass; new new ($class,%param) $self = {}; $self = {}; $self->_init(%param); $self->_init(%param); return return $self; $self; $instance $instance == new new MyClass( MyClass( id id => => 55 ); ); printf printf %d\n, %d\n, $instance->id; $instance->id; _init _init ($self,%param) $self->id( $self->id( (exists (exists $param{id}) $param{id})?? $param{id} $param{id} :: 11 ); ); 29

30 Object-Orientation Recap1 Constructors: A class is a package with a constructor routine ( new ) An instance is a reference to a blessed anonymous hash Attributes are the key-value pairs of this hash Methods are additional routines ( invoked with -> ): Aess/Modify attributes (combined) distinction: instance methods ($self), class methods ($class) notion of private methods by convention only ( _ prefix ) Initialisation Separate from construction Parameterised initialisation (using key-value pairs) 30

31 Composition: Objects within Objects app.pl MyClass; MyClass; MyOtherclass; MyOtherclass; $instance $instance == new new MyClass( MyClass( id => 5, id => 5, part part => => new new MyOtherclass( MyOtherclass( index index => => 11 )) ); ); MyClass.pm printf printf %d\n, %d\n, $instance->part->index; $instance->part->index; _init _init ($self,%param) ($self,%param) $self->part( $self->part( (exists (exists $param{part}) $param{part})?? $param{part} $param{part} :: new new MyOtherclass() MyOtherclass() ); ); part part ## multi-purpose multi-purpose aessor/modifier aessor/modifier $self=shift; $self=shift; return return (@_) (@_)?? $self->{part}=shift $self->{part}=shift :: $self->{part} $self->{part} ;; 33

32 Inheritance (almost!) package package MySubclass; MySubclass; parent parent 'MyClass'; 'MyClass'; package package MyClass; MyClass; new new ($class,%param) $self = {}; $self = {}; $self->_init(%param); $self->_init(%param); return return $self; $self; _init _init ($self,%param) $self->id( $param{id} $self->id( $param{id} ); ); new new ($class,%param) $self = {}; $self = {}; $self->_init(%param); $self->_init(%param); return return $self; $self; MyClass; MyClass; MySubclass; MySubclass; $v $v == new new MyClass( ); MyClass( ); $n $n == new new MySubclass( ); MySubclass( ); _init _init ($self,%param) $self->name( $param{name} $self->name( $param{name} ); ); but id isn t initialised!!! 34

33 Inheritance package package MySubclass; MySubclass; parent parent 'MyClass'; 'MyClass'; package package MyClass; MyClass; new new ($class,%param) $self = {}; $self = {}; $self->_init(%param); $self->_init(%param); return return $self; $self; _init _init ($self,%param) $self->id( $param{id} $self->id( $param{id} ); ); new new ($class,%param) $self = new MyClass(%param); $self = new MyClass(%param); $self->_init(%param); $self->_init(%param); MyClass; MyClass; return $self; return $self; MySubclass; MySubclass; $v $v == new new MyClass( ); MyClass( ); _init _init $n $n == new new MySubclass( ); MySubclass( ); ($self,%param) $self->name( $self->name( $param{name} $param{name} ); ); 35

34 Inheritance package package MySubclass; MySubclass; parent parent 'MyClass'; 'MyClass'; package package MyClass; MyClass; new new ($class,%param) $self = {}; $self = {}; $self->_init(%param); $self->_init(%param); return return $self; $self; _init _init ($self,%param) $self->id( $param{id} $self->id( $param{id} ); ); new new ($class,%param) $self = {}; $self = {}; $self->_init(%param); $self->_init(%param); return return $self; $self; MyClass; MyClass; MySubclass; MySubclass; $v $v == new new MyClass( ); MyClass( ); $n $n == new new MySubclass( ); MySubclass( ); _init _init ($self,%param) $self->super::_init(%param); $self->super::_init(%param); $self->name( $self->name( $param{name} $param{name} ); ); 36

35 Abstraction package package MySubclass; MySubclass; parent parent 'MyClass'; 'MyClass'; package package MyClass; MyClass; ## abstract abstract new new ($class,%param) $self = {}; $self = {}; $self->_init(%param); $self->_init(%param); return return $self; $self; _init _init ($self,%param) $self->id( $param{id} $self->id( $param{id} ); ); new new ($class,%param) $self = {}; $self = {}; $self->_init(%param); $self->_init(%param); return return $self; $self; MyClass; MyClass; MySubclass; MySubclass; $v $v == new new MyClass(); MyClass(); $n $n == new new MySubclass(); MySubclass(); _init _init ($self,%param) $self->super::_init(%param); $self->super::_init(%param); $self->name( $self->name( $param{name} $param{name} ); ); id id 37

36 Object-Orientation Recap2 (Constructors, Attributes, Methods, Initialisation) Recap1 Composition: Objects within objects Inheritance: parent, SUPER:: no class constructor Abstraction no superclass constructor 38

37 Perl OO Frameworks: Moose 39

38 3) Example Application: Graph Theory Basic overview of graph theory Implementing graphs with: Native Perl (hashes) Object-Orientation CPAN: The Graph module 40

39 Basic Overview of Graph Theory A graph is: a collection of nodes (vertices)... connected by edges A graph can be: undirected / directed unweighted / weighted Graph Theory is the study of these structures and their properties. 41

40 A Graph as a Hash of Edges graph.pl data.txt aa bb aa bb bb dd aa bb %edge=(); %edge=(); open open INFILE,"<data.txt"; INFILE,"<data.txt"; while while (<INFILE>) (<INFILE>) ## $_ $_ implicit implicit chomp; chomp; ($from,$to) ($from,$to) == split split "\t"; "\t"; $edge{$from}{$to} $edge{$from}{$to} == 1; 1; close close INFILE; INFILE; foreach foreach $from $from (( foreach foreach $to $to (( printf printf "%s\n", "%s\n", $$ aa bb graph.pl graph.pl bb aa dd sort sort keys keys %edge %edge )) sort sort keys keys %{$edge{$from %{$edge{$from )) join("\t",$from,$to); join("\t",$from,$to); 42

41 Weighted Edges (Count) data.txt aa bb aa bb bb dd aa bb graph.pl ## build build aa hash hash of of graph graph ## $edge{$from}{$to} $edge{$from}{$to} == $edge{$from}{$to}++; $edge{$from}{$to}++; edges edges 1; 1; $$ aa bb graph.pl graph.pl bb aa 11 dd 11 ## plain plain text text output output of of graph graph edges edges $weight $weight == $edge{$from}{$to}; $edge{$from}{$to}; printf printf "%s\n", "%s\n", join("\t",$from,to,$weight); join("\t",$from,to,$weight);

42 Weighted Edges (Sum) data.txt aa bb aa bb bb dd aa bb graph.pl $$ aa bb graph.pl graph.pl bb aa 11 dd 33 ## build build aa hash hash ## ($from,$to) ($from,$to) == split split "\t"; "\t"; ($from,$to,$weight) ($from,$to,$weight) == split split "\t"; "\t"; ## $edge{$from}{$to}++; $edge{$from}{$to}++; $edge{$from}{$to}+=$weight; $edge{$from}{$to}+=$weight; ## plain plain text text output output $weight $weight == $edge{$from}{$to}; $edge{$from}{$to}; printf printf "%s\n", "%s\n", join("\t",$from,to,$weight); join("\t",$from,to,$weight);

43 Weighted Edges (Array) data.txt aa bb aa bb bb dd aa bb $$ graph.pl graph.pl 55 aa bb 5:4 5:4 77 graph.pl bb 7:2 7:2 33 aa # build a hash # build a hash dd # $edge{$from}{$to}+=$weight; # $edge{$from}{$to}+=$weight; $weight; $weight; ## plain plain text text output output $weight $weight == join( :,@{$edge{$from}{$to); join( :,@{$edge{$from}{$to); printf printf "%s\n", "%s\n", join("\t",$from,to,$weight); join("\t",$from,to,$weight); ); ); ); ); 45

44 Node Attributes data.txt aa bb aa bb bb dd aa bb We count the edges a node participates in... graph.pl $$ aa bb dd graph.pl graph.pl %edge=(); %edge=(); %node=(); %node=(); open open INFILE,"<data.txt"; INFILE,"<data.txt"; while while (<INFILE>) (<INFILE>) chomp; chomp; ($from,$to) ($from,$to) == split split "\t"; "\t"; $edge{$from}{$to}++; $edge{$from}{$to}++; $node{$from}++; but don t distinguish $node{$from}++; $node{$to}++; from and to! $node{$to}++; close close INFILE; INFILE; 46

45 Node Attributes graph.pl so we add node attributes... %edge=(); %edge=(); %node=(); %node=(); open open INFILE,"<data.txt"; INFILE,"<data.txt"; while while (<INFILE>) (<INFILE>) chomp; chomp; ($from,$to) ($from,$to) == split split "\t"; "\t"; $edge{$from}{$to}++; $edge{$from}{$to}++; $node{$from}{ from }++; looks Object $node{$from}{ from }++; $node{$to}{ to }++; Oriented!!! $node{$to}{ to }++; close close INFILE; INFILE; Class Instance Attribute Value 47

46 Bespoke Classes MyGraph/Edge.pm package package MyGraph::Edge; MyGraph::Edge; MyGraph/Graph.pm 1; 1; new new getsource getsource getdest getdest getweight getweight package package MyGraph::Graph; MyGraph::Graph; MyGraph::Edge; MyGraph::Edge; MyGraph::Node; MyGraph::Node; 1; 1; new new MyGraph/Node.pm addedge addedge getedges { } package package MyGraph::Node; MyGraph::Node; getedges { } 1; 1; new new addnode addnode getnodes getnodes getproperty getproperty graph.pl MyGraph::Graph; MyGraph::Graph; MyGraph::Edge; MyGraph::Edge; $g $g == new new Graph(); Graph(); while while (<INFILE>) (<INFILE>) $g->addedge($f,$t,$w); $g->addedge($f,$t,$w); foreach foreach $e $e ($g->getedges()) ($g->getedges()) $w $w == $e->getweight(); $e->getweight(); 48

47 Perl Graph Module $$ cpan cpan Graph Graph Graph Graph is is up up to to date date (0.9704). (0.9704). $$ 49

48 Perl Graph Module over over routines, routines, including: including: add_edge add_edge add_edges add_edges add_vertex add_vertex add_vertices add_vertices add_path add_path add_weighted_edge add_weighted_edge add_weighted_edges add_weighted_edges add_weighted_vertex add_weighted_vertex add_weighted_vertices add_weighted_vertices add_weighted_path add_weighted_path has_edge has_edge has_vertex has_vertex has_path has_path has_edges has_edges has_vertices has_vertices has_cycle has_cycle is_cyclic is_cyclic is_directed is_directed is_connected is_connected is_biconnected is_biconnected is_edge_connected is_edge_connected is_transitive is_transitive is_acyclic is_acyclic is_undirected is_undirected is_strongly_connected is_strongly_connected is_weakly_connected is_weakly_connected is_edge_separable is_edge_separable transitive_closure transitive_closure transpose_graph transpose_graph minimum_spanning_tree minimum_spanning_tree 50

49 Perl & Graph Theory - Recap Graphs in native Perl using nested hashes: Object-Oriented implementation: $class{instance}{attribute}=value (simple or complex) encapsulate functionality into packages/classes CPAN Graph module: provides extensive graph theory functionality follows Object-Oriented model typical of many CPAN modules 51

50 Conclusions While Perl is not strictly an OO platform... applying OO principles exposes aspects of the paradigm metaphor between nested hashes and OO classes OO thinking shapes many CPAN modules understanding is helpful for using and contributing modules Perl philsophy: favours convention over enforcement context: local readability vs global consistency programmer freedom / responsibility 52

51 Thank You! Nick Questions and Discussion? 53

52 Hello world & the Perl philosophy Perl was designed to work smoothly in the same way that natural language works smoothly. (p. 2) open LOG, >$logfile or die Failed to open $logfile ; die Failed to open $logfile unless open LOG, >$logfile ; print LOG Logging...\n if $logging_enabled; $logging_enabled and print LOG Logging...\n ; if ($logging_enabled) { print LOG Logging...\n ; } The Camel Book Larry Wall et al., Programming Perl (1996) 54