Symbols

! (bang), Conditional tests and matching braces, Logical Operators and the Range Operator, Command Interpretation, Logical Operators, Binding Operators

! (logical negation) operator, Logical Operators and the Range Operator, Logical Operators

!= (not equal to) operator, Conditional tests and matching braces

!~ (binding) operator, Binding Operators

#! (shebang) notation, Command Interpretation

" (quotes, double), Strings, Concatenating DNA Fragments, Conditional tests and matching braces, Turning Arrays into Scalars with join, Strings

within double-quoted strings, Conditional tests and matching braces

empty strings, representing with, Turning Arrays into Scalars with join

string interpolation, Concatenating DNA Fragments

in strings, Strings, Strings

"exclusive-OR" operator (xor), Bitwise Operators, Logical Operators

"point-and-click" interaction with data, Graphics Programming

# (sharp), Comments, Command Interpretation

#! (shebang notation), command interpretation line, Command Interpretation

in Perl comments, Comments

$ (dollar sign), Arrays, Exploding Strings into Arrays, Subroutines: Pass by Reference, A program with bugs, Seeding the Random Number Generator, Finding the Restriction Sites, Finding the Restriction Sites, Finding the Restriction Sites, Finding the Restriction Sites, Pattern modifiers, Examples of pattern modifiers, Separating annotations from sequence, Parsing BLAST Alignments, Loops, Beginning and end of strings with ^ and $

$$, returning Perl program ID number, Seeding the Random Number Generator

$& variables, Finding the Restriction Sites, Examples of pattern modifiers

$' variables, Finding the Restriction Sites, Finding the Restriction Sites

$/ (input record separator), Separating annotations from sequence

$_ variables, Exploding Strings into Arrays, A program with bugs, Loops

$` variables, Finding the Restriction Sites

before embedded newlines, Parsing BLAST Alignments

metacharacter, Beginning and end of strings with ^ and $

metacharacter in regular expressions, Pattern modifiers

for scalar variable names, Arrays, Subroutines: Pass by Reference

$PATH or $path variable, Unix or Linux

% (percent sign), Subroutines: Pass by Reference, Hashes, The printf Function

in directives, The printf Function

for hash names, Subroutines: Pass by Reference, Hashes

& (ampersand), Writing Subroutines, Logical Operators and the Range Operator, Bitwise Operators, Logical Operators

&& (logical and) operator, Logical Operators and the Range Operator, Logical Operators

(bitwise and) operator, Bitwise Operators

subroutine names, starting with, Writing Subroutines

' (quotes, single), Strings, Turning Arrays into Scalars with join, Strings

empty strings, representing with, Turning Arrays into Scalars with join

in strings, Strings, Strings

() (parentheses), Writing Subroutines, Scoping, The Redundancy of the Genetic Code, Regular Expressions, Precedence of Operations and Parentheses, Separating annotations from sequence, Finding Atomic Coordinates, Capturing Matched Patterns

for capturing in patterns, Capturing Matched Patterns

enclosing subroutine arguments, Writing Subroutines

grouping in regular expressions, The Redundancy of the Genetic Code, Regular Expressions

in regular expressions, Separating annotations from sequence

metacharacter in regular expressions, Finding Atomic Coordinates

order of operations, specifying with, Precedence of Operations and Parentheses

variables from @_ array, enclosing with, Scoping

(angle brackets), Reading Proteins in Files, Conditional tests and matching braces, Conditional tests and matching braces, Getting User Input from the Keyboard, FASTA Format, Finding Atomic Coordinates, format and write, format and write, Bitwise Operators, Bitwise Operators, Input from Files Named on the Command Line

< (left angle bracket), Conditional tests and matching braces, format and write, Bitwise Operators

<< left shift operator, Bitwise Operators

for left justification, format and write

less than operator, Conditional tests and matching braces

> (right angle bracket), Conditional tests and matching braces, FASTA Format, format and write, Bitwise Operators

>> right shift operator, Bitwise Operators

FASTA file headers, beginning with, FASTA Format

greater than operator, Conditional tests and matching braces

right justification, format and write

line input (angle) operator, Reading Proteins in Files, Getting User Input from the Keyboard, Finding Atomic Coordinates, Input from Files Named on the Command Line

* (asterisk), Pattern matching with =~ and regular expressions, Regular Expressions, Regular Expressions, Parsing BLAST Alignments, Quantifiers: * + {MIN,} {MIN,MAX} ?

*? quantifier, Parsing BLAST Alignments

character wildcard, Pattern matching with =~ and regular expressions

quantifier, Quantifiers: * + {MIN,} {MIN,MAX} ?

in regular expressions, Regular Expressions, Regular Expressions

+ (plus sign), Exploding Strings into Arrays, Exploding Strings into Arrays, Arithmetic Operators, Quantifiers: * + {MIN,} {MIN,MAX} ?

++ (autoincrement) operator, Exploding Strings into Arrays, Arithmetic Operators

+= (add assignment) operator, Exploding Strings into Arrays

quantifier, Quantifiers: * + {MIN,} {MIN,MAX} ?

, (comma), Concatenating DNA Fragments, Writing Subroutines

separating items in lists, Concatenating DNA Fragments

separating subroutine arguments, Writing Subroutines

-- (minus sign), autodecrement operator, Arithmetic Operators

-d (debug) command-line switch, How to start and stop the debugger

-e (exists) file test, The Stride Secondary Structure Predictor

-w command-line switch, turning on warnings, use warnings; and use strict;

. (dot), Concatenating DNA Fragments, Pattern matching with =~ and regular expressions, Making a Sentence, Logical Operators and the Range Operator, Logical Operators and the Range Operator, Pattern modifiers, Matching any character with .

.. (range) operator, Logical Operators and the Range Operator, Logical Operators and the Range Operator

character wildcard, Pattern matching with =~ and regular expressions, Matching any character with .

metacharacter in regular expressions, Pattern modifiers

string concatenation operator, Concatenating DNA Fragments, Making a Sentence

/ (forward slash), Transcription: DNA to RNA, Regular Expressions, Pattern modifiers, Separating annotations from sequence

// (double slash), Regular Expressions, Separating annotations from sequence

enclosing regular expressions, Regular Expressions

end-of-record separator, Separating annotations from sequence

in pattern modifiers, Pattern modifiers

s/// (substitution) operator, Transcription: DNA to RNA

/g (global) pattern modifier, Pattern modifiers, Parsing BLAST Alignments

/i (case-insensitive) matching, Pattern modifiers, Pattern Modifiers

/m pattern modifier, Pattern modifiers, Separating annotations from sequence, Parsing BLAST Alignments

program to extract annotation from sequence, Separating annotations from sequence

/s pattern modifier, Pattern modifiers, Separating annotations from sequence

program to extract annotation from sequence, Separating annotations from sequence

3' (three prime) end, nucleotides, The Organization of DNA

3D protein structure, What Is Bioinformatics?, The Organization of Proteins, Overview of PDB

5' (five prime) end, nucleotides, The Organization of DNA

; (semicolon), ending Perl statements, Statements, Statements and Blocks

= (equal sign), Assignment, Transcription: DNA to RNA, Conditional Statements, Conditional Statements, Pattern matching with =~ and regular expressions, Stepping through statements with the debugger, Binding Operators

== (equal to) operator, Conditional Statements

==> current line marker, Stepping through statements with the debugger

=~ (pattern binding) operator, Transcription: DNA to RNA, Pattern matching with =~ and regular expressions, Binding Operators

assignment operator, Assignment, Conditional Statements

? (question mark), in quantifiers, Quantifiers: * + {MIN,} {MIN,MAX} ?

@ (at sign), Arrays, Arguments, Command-Line Arguments and Arrays, Subroutines: Pass by Reference, Subroutines: Pass by Reference

@ARGV array variables, Command-Line Arguments and Arrays

@_ arrays, Arguments, Subroutines: Pass by Reference

beginning array variables with, Arrays

for array names, Subroutines: Pass by Reference

@ARGV arrays, Input from Files Named on the Command Line

[] (brackets), Regular expressions and character classes, Hashes

array element lookups, Hashes

enclosing character class in, Regular expressions and character classes

\\ (backslash), Conditional tests and matching braces, Subroutines: Pass by Reference, Escaping with , Metasymbols

escaping metacharacters, Escaping with

escaping quotes within quoted strings, Conditional tests and matching braces

metasymbols, use in, Metasymbols

references, use in, Subroutines: Pass by Reference

\\n or \\n\\n (newlines), Concatenating DNA Fragments

^ (caret), Restriction Enzyme Data, Pattern modifiers, Separating annotations from sequence, Finding Atomic Coordinates, Parsing BLAST Alignments, format and write, Bitwise Operators, Beginning and end of strings with ^ and $

beginning of string, anchoring to, Separating annotations from sequence

bitwise xor operator, Bitwise Operators

end of line assertion (in matching), Parsing BLAST Alignments

for filled text in formats, format and write

metacharacter in regular expressions, Pattern modifiers, Finding Atomic Coordinates, Beginning and end of strings with ^ and $

restriction enzyme cut site (REBASE), Restriction Enzyme Data

` (backticks), command input operator, The Stride Secondary Structure Predictor

{} (curly braces), Concatenating DNA Fragments, Conditional tests and matching braces, Hashes, Quantifiers: * + {MIN,} {MIN,MAX} ?

hash lookups, use in, Hashes

quantifier, Quantifiers: * + {MIN,} {MIN,MAX} ?

for statement blocks, Conditional tests and matching braces

in string interpolation, Concatenating DNA Fragments

| (vertical bar), Debugger command summary, Seeding the Random Number Generator, The Redundancy of the Genetic Code, Logical Operators and the Range Operator, format and write, Bitwise Operators, Logical Operators, Alternation with |

(bitwise OR) operator, Seeding the Random Number Generator, Bitwise Operators

alternation, Alternation with |

for centering, format and write

debugger commands, Debugger command summary

regular expressions, use in, The Redundancy of the Genetic Code

|| (logical or) operator, Logical Operators and the Range Operator, Logical Operators

~~ (tildes), for multiline data in fields, format and write