[BBC] Introduction to Python for Biologists 12-16 Dec 2016 Edinburgh - Few places left

[Bert Overduin]

We still have a few places left on the following course:

INTRODUCTION TO PYTHON FOR BIOLOGISTS

DATE: Monday 12 – Friday 16 December 2016
VENUE: The King's Buildings, The University of Edinburgh, Edinburgh,
Scotland, UK
REGISTRATION DEADLINE: Monday 28 November 2016 noon
CANCELLATION DEADLINE: Monday 5 December 2016 noon
PLACES: 20 (first come, first served)
REGISTRATION FEE: £500 (includes coffee/tea, but no lunch)
INFORMATION: Bert Overduin (bert.overduin at ed.ac.uk), Martin Jones (
martin at pythonforbiologists.com)

TO REGISTER: http://genomics.ed.ac.uk/services/introduction-
python-biologists

Python is a dynamic, readable language that is a popular platform for all
types of bioinformatics work, from simple one-off scripts to large, complex
software projects. This workshop is aimed at complete beginners and assumes
no prior programming experience. It gives an overview of the language with
an emphasis on practical problem-solving, using examples and exercises
drawn from various aspects of bioinformatics work. The workshop is
structured so that the parts of the language most useful for bioinformatics
are introduced as early as possible, and that students can start writing
plausibly-useful programs after the first few sessions. After completing
the workshop, students should be in a position to (1) apply the skills they
have learned to tackling problems in their own research and (2) continue
their Python education in a self-directed way.

"Great learning from someone with a biology background rather than computer
science - meant we were on the same wavelength." (February 2016)
"Brilliantly well-run. From the book; to the USB stick with all the files
we need; to the topics covered; to the system of helping us one-on-one, I
cannot fault this course." (February 2016)

INSTRUCTORS

Dr. Martin Jones (Founder, Python for Biologists)
Dr. Bert Overduin (Training and Outreach Bioinformatician, Edinburgh
Genomics)

WORKSHOP FORMAT

The workshop is delivered over ten half-day sessions. Each session consists
of roughly a one hour lecture followed by two hours of practical exercises,
with breaks at the organiser’s discretion. Each session uses examples and
exercises that build on material from the previous one, so it’s important
that students attend all sessions. A description of the sessions can be
found at the bottom of this page.

WHO SHOULD ATTEND

This workshop is aimed at researchers and technical workers with a
background in biology who want to learn programming. The syllabus has been
planned with complete beginners in mind; people with previous programming
experience are welcome to attend as a refresher but may find the pace a bit
slow. If in doubt, take a look at the detailed session content below or
drop Martin Jones or Bert Overduinan email.

REQUIREMENTS

Students should have enough biological/bioinformatics background to
appreciate the examples and exercise problems (i.e. they should know what a
protein accession number, BLAST report, and FASTA sequence is). No previous
programming experience or computer skills (beyond the ability to use a text
editor) are necessary.

SESSION CONTENT

1. Introduction

In this session I introduce the students to Python and explain what we
expect them to get out of it and how learning to program can benefit their
research. I explain the format of the course and take care of any
housekeeping details (like coffee breaks and catering arrangements). I
outline the edit-run-fix cycle of software development and talk about how
to avoid common text editing errors. In this session, we also check that
the computing infrastructure for the rest of the course is in place (e.g.
making sure that everybody has an appropriate version of Python installed).
Core concepts introduced: source code, text editors, whitespace, syntax and
syntax errors, Python versions

2. Manipulating text

In this session students learn to write very simple programs that produce
output to the terminal, and in doing so become comfortable with editing and
running Python code. This session also introduces many of the technical
terms that we’ll rely on in future sessions. I run through some examples of
tools for working with text and show how they work in the context of
biological sequence manipulation. We also cover different types of errors
and error messages, and learn how to go about fixing them methodically.
Core concepts introduced: terminals, standard output, variables and naming,
strings and characters, special characters, output formatting, statements,
functions, methods, arguments, comments.

3. Working with files

I introduce this session by talking about the importance of files in
bioinformatics pipelines and workflows, and we then explore the Python
interfaces for reading from and writing to files. This involves introducing
the idea of types and objects, and a bit of discussion about how Python
interacts with the operating system. The practical session is spent
combining the techniques from session 2 with the file IO tools to create
basic file- processing scripts. Core concepts introduced: objects and
classes, paths and folders, relationships between variables and values,
text and binary files, newlines.

4. Lists and loops

A discussion of the limitations of the techniques learned in session 3
quickly reveals that flow control is required to write more sophisticated
file-processing programs, and I introduce the concept of loops. We look at
the way in which Python loops work, and how they can be used in a variety
of contexts. We explore the use of loops and lists together to tackle some
more difficult problems. Core concepts introduced: lists and arrays, blocks
and indentation, variable scoping, iteration and the iteration interface,
ranges.

5. Conditions

I use the idea of decision-making as a way to introduce conditional tests,
and outline the different building-blocks of conditions before showing how
conditions can be combined in an expressive way. We look at the different
ways that we can use conditions to control program flow, and how we can
structure conditions to keep programs readable. Core concepts introduced:
Truth and falsehood, Boolean logic, identity and equality, evaluation of
statements, branching.

6. Writing functions

We discuss functions that we’d like to see in Python before considering how
we can add to our computational toolbox by creating our own. We examine the
nuts and bolts of writing functions before looking at best-practice ways of
making them usable. We also look at a couple of advanced features of Python
- named arguments and defaults. Core concepts introduced: argument passing,
encapsulation, data flow through a program.

7. Regular expressions

I show how a range of common problems in bioinformatics can be described in
terms of pattern matching, and give an overview of Pythons regex tools. We
look at the building blocks of regular expressions themselves, and learn
how they are a general solution to the problem of describing patterns in
strings, before practising writing some specific examples of regular
expressions. Core concepts introduced: domain-specific languages, modules
and namespaces.

8. Dictionaries

We discuss a few examples of key-value data and see how the problem of
storing them is a common one across bioinformatics and programming in
general. We learn about the syntax for dictionary creation and manipulation
before talking about the situations in which dictionaries are a better fit
that the data structures we have learned about thus far. Core concepts
introduced: paired data types, hashing, key uniqueness, argument unpacking
and tuples.

9. Working with the filesystem

We discuss the role of Python in the context of a bioinformatics workflow,
and how it is often used as a language to “glue” various other components
together. We then look at the Python tools for carrying out file and
directory manipulation, and for running external programs - two tasks that
are often necessary in order to integrate our own programs with existing
ones. Core concepts introduced: processes and subprocesses, the shell and
shell utilities, program return values.

10. BioPython

I discuss the benefits of having frequently-used code packaged into a
library and give a quick overview of the BioPython project. We look at how
BioPython can be used for sequence manipulation, and contrast the resulting
code with our examples from previous sessions, showing the benefits of
each. We see how we can use BioPython to do a job - GenBank file parsing -
that would require a huge amount of coding if we were to write a program
from scratch. Students carry out some exercises involving sequence object
manipulation and explore the parts of the BioPython hierarchy relevant to
their interests. Core concepts introduced: object hierarchies, packages.


-- 
Bert Overduin, PhD
TRAINING AND OUTREACH BIOINFORMATICIAN
Bert.Overduin at ed.ac.uk
orcid.org/0000-0002-5281-8838

EDINBURGH GENOMICS
The University of Edinburgh
Ashworth Laboratories
The King's Buildings
Charlotte Auerbach Road
Edinburgh EH9 3FL
Scotland, United Kingdom

tel. +44(0)1316507403
http://genomics.ed.ac.uk
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://maillist.psb.ugent.be/pipermail/bbclist/attachments/20161114/0d2c6c21/attachment-0001.html>
-------------- next part --------------
An embedded and charset-unspecified text was scrubbed...
Name: not available
URL: <http://maillist.psb.ugent.be/pipermail/bbclist/attachments/20161114/0d2c6c21/attachment-0001.ksh>