Bilille is the Lille bioinformatics and biostatistics platform, within the UAR 2014 - US 41 “Plateformes Lilloises en Biologie et Santé”.

PLBS includes 8 platforms, providing access to expertise and equipments to support research in biology and health.

In Bilille, we currently are 10 full time engineers, directed by Jimmy Vandel (research engineer CNRS), Ségolène Caboche (research engineer University of Lille) and Mamadou-Dia Sow (research engineer University of Lille).

Our missions are to :

• support scientific projects
• organise training courses
• provide access to cloud computing resources
• ensure access to software resources
• conduct scientific and technical animation

Us

What about you ?

• name
  
• profile
  
• labs
  
• experience with programming (in few words) : have you already tried using Python or another language?
  
• your expectations regarding this training ?

• Programming languages are written as scripts.

• Python code files finish with .py extension.

• Scripts can be written in a notebook, but the development of projects can be difficult.

• Integrated development environments (IDE) are used to create projects and write scripts in any language that can help with project management and scripting, whether in Python, R, Julia, C…

• One of the most popular IDEs is VScode, which you are invited to download for use during the course.

It is not a variable name but only an object (a string). Variable names are not written between quotes.

It raises a NameError because the variable b hasn’t been assigned yet.

It raises a SyntaxError because your second variable starts with a number.

• Strings can be concatenated using the plus sign (+).”

'patient_' + '1'

'patient_1'

• A string can only be concatenated with another string.

'patient_' + 1

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[8], line 1
----> 1 'patient_' + 1

TypeError: can only concatenate str (not "int") to str

• You can concatenate two variables together if they both contain strings.

a = "patient_"
b = "1"
a + b

'patient_1'

• If you want to repeat a string a certain number of times, you can use the asterisk (*) with an integer.

laugh = "ha" * 3
laugh

'hahaha'

• Integers and floats can be converted to string with str(variable).

a = 1
'patient_' + str(a)

'patient_1'

• In some cases, strings can be converted to integer or float with int(variable) or float(variable).

• The print() function can be used to display what is between the parentheses.
  

• A quick way to concatenate string and integer or float is to use the formatted string literals syntax also called f-string syntax.

You can also separate strings and variables with commas. This adds spaces automatically.

• You can also use raw string (r-string) in order to print exactly what’s between the quote. It comes handy when writing with lots of backslash (\) (cf : Windows path)

• You can also use two backslashes (\\). The first backslash (\) escapes the second one, so it is interpreted as a literal backslash.

• If you don’t use one of these methods, you will get an error.

The following arithmetic operators are available in Python:

• addition:

addition = number1 + number2
print(f'{number1} + {number2} = {addition}')

5 + 3 = 8

• subtraction:

subtraction = number1 - number2
print(f'{number1} - {number2} = {subtraction}')

5 - 3 = 2

• multiplication:

multiplication = number1 * number2
print(f'{number1} * {number2} = {multiplication}')

5 * 3 = 15

• division:

division = number1 / number2
print(f'{number1} / {number2} = {division}')

5 / 3 = 1.6666666666666667

• power:

power = number1 ** number2
print(f'{number1} ** {number2} = {power}')

5 ** 3 = 125

• A simple division will always return a float even if the result is an integer.

• The spaces before and after the operator are optional but helpful for readability.

• Operations can be performed directly on variables by putting the operator in front of the equal (=) symbol. The two following syntaxes are equivalent:

• This can be done with all operators.
  

To compare values we can use the following operators:

• They can be used to compare numbers (int or float) in numerical order, or strings in lexicographical order (based on their ASCII value).

• Methods are associated with a variable type.

• They can create new objects that can be assigned to a variable, or modify existing objects.

• Each type of variable has its own set of methods.

• Syntax: variable.method(*optional parameters*).

Here are some examples of useful methods for strings.

Consider the following string:

my_str = "       THIS IS a string  "
print(f'*{my_str}*')

*       THIS IS a string  *

• Applying a method to a string does not change the string itself; it must be reassigned to a variable (but the same variable name can be reused).

• Without reassignment:

my_str = "this is another string"
print(my_str)
my_str.upper()
print(my_str)

this is another string
this is another string

• With reassignment:

print(my_str)
my_str_upper = my_str.upper()
print(my_str_upper)

this is another string
THIS IS ANOTHER STRING

• Inline comments are written after a sharp sign (#).
  You can write some code before the # but you cannot write code after the comment.
  

• Block comments
  

• Documentation strings are written between triple quotes:
  

If written on several lines, the triple quotes should be written on a line by themselves, and on the same line than the comment itself for one liner descriptions.

• The most common object types are integer, float, string, boolean, function, …

• To assign a value to a variable, use the equal sign (=).

• To display a variable or some text, use the print() function.

• Do not mix simple quotes ('), double quotes (") and f-strings!

• Mathematical operations can be performed on variables with an operation sign (+, -, *, /, //, %, **):

  Examples: my_variable *= 5 or my_variable = my_variable * 5.

• You can compare values with a comparison operator (>, <, >=, <=, ==, !=).

• Do not confuse = (variable assignment) and == (test equality)!

• To comment lines, you can use # before your comment or add """ around it.

• You can use lists to store multiple values in an orderly manner in the same variable.

• An empty list can be initialised with [] or list().

• A list can also be initialised with values:

numbers = [1, 3, 5, 7, 9]
print(numbers)

[1, 3, 5, 7, 9]

• It is possible to create a list from a string. In this case, each element of the list will contain a single character.

• You can store different types of data in the same list.

my_list = ["Mr_Pi", 3.1415, 5, True]

• Each item of a list can be accessed by giving its index, starting from 0 to n-1, with n the number of items in the list.

• The number of items in the list is given by len(numbers).

• Each item of a list can also be accessed in revert order from -1 (last item) to -n (first element).

• If you give as index a value that doesn’t exist, it will raise an error.

numbers[6]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[66], line 1
----> 1 numbers[6]

IndexError: list index out of range

• Please consider the following list:

amino_acids = ['Ala', 'Arg', 'Asp', 'Asn', 'Cys', 'Glu', 'Gln']

• What does the following element contain? amino_acids[1]

• How can you access the following element? 'Glu'

• In the previous chapter, we discovered a few methods for strings.

• There are string methods that work with lists.

• .join() turns a list of strings into a single string:

• .split() turns a string into a list:

• Modify an item of the list using its index:

numbers = [1, 3, 7, 7, 9]
numbers[2] = 5
print(numbers)

[1, 3, 5, 7, 9]

• Remove an item of a list and return it: removed_item = numbers.pop()
  If no index is given, the removed item is the last one.
  You can also provide the index of the item to be removed.
  

After using pop(), the list items are renumbered.

numbers[1]

7

• Remove an item of a list by using its value (not the index). Only the first item encountered will be removed; if the value exist several times in the list, the process has to be repeated.

• Reverse a list:

numbers.reverse()
print(numbers)

[11, 9, 7, 5, 1]

• Copy a list:

odds = numbers.copy()
print(odds)

[11, 9, 7, 5, 1]

Consider the following list:

We would like to create the same list called values:

Then we need to remove the second element from the numbers list:

Now let’s check the content of values. What do you expect to get?

Let’s try again.

This time we would like to remove the second-to-last element from the values list.
Which command(s) will work ? :

Now let’s check the content of numbers.

The numbers list has not been affected by the changes made to the values list.

• A list can contain any Python variable so it can also contain other lists.
  A single list may contain numbers, strings, and anything else.

• A matrix can be stored in a nested list.

• Another way to assign a nested list to a variable is to write it on a single line.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Consider the following nested list:

What command would you write to get :

Which animal will you get if you type :

• You can get a subset of a list by specifying ranges of values with a colon (:) in brackets.

• Syntax: my_list[start:end:step]: will slice my_list from start to end (excluded) with a step of step (default value 1 if not provided).

• Some examples with the following list:

amino_acids = ['Ala', 'Arg', 'Asp', 'Asn', 'Cys', 'Glu', 'Gln']

Returns the first two elements of the list.

amino_acids[0:2]

['Ala', 'Arg']

Returns every other element, from second element to fourth element (excluded).

amino_acids[1:4:2]

['Arg', 'Asn']

Returns every other element from the complete list, starting with the first element.

amino_acids[::2]

['Ala', 'Asp', 'Cys', 'Gln']

Returns the complete list except for the first element.

amino_acids[1:]

['Arg', 'Asp', 'Asn', 'Cys', 'Glu', 'Gln']

Returns the complete list except for the last element.

amino_acids[:-1]

['Ala', 'Arg', 'Asp', 'Asn', 'Cys', 'Glu']

Returns the complete list in reverse order.

amino_acids[::-1]

['Gln', 'Glu', 'Cys', 'Asn', 'Asp', 'Arg', 'Ala']

• If you don’t need a list anymore, you can delete it with the del keyword:

• It is also possible to delete part of the list using slicing:

• Tuples are similar to lists but they cannot be modified. They are immutable objects.

• An empty tuple can be initialised with () or tuple().

• A tuple can also be initialised with values:

values = (2.0, 7.5, 8.4, 3.1)
print(f"values = {values} and its type is {type(values)}")

values = (2.0, 7.5, 8.4, 3.1) and its type is <class 'tuple'>

• If you try to modify a tuple, Python won’t let you.

• A list is a variable that can store multiple values in an orderly manner.

• To initialise an empty list, you can use [] or list().

• To access (or update) the element at position i, use my_list[i] (or my_list[i] = elt).

• To get a subset of your list, you can use my_list[start:end:step].

• To delete your list, use del(my_list).

• Dictionaries are used to store data in a disorderly manner in the form of key:value pairs.

• Each key is unique. If a key is reused, its contents will be overwritten.

• An empty dictionary can be initialised with {} or dict().

• A dictionary can also be initialised directly with data:

animal_sounds = {'cat': 'meow', 'dog':'woof', 'cow':'moo'}

Each item of a dictionary can be accessed by giving its key:

• with the key in brackets:

print(f"Cat says {animal_sounds['cat']}.")
print(f"Fox says {animal_sounds['fox']}.")

Cat says meow.

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[124], line 2
      1 print(f"Cat says {animal_sounds['cat']}.")
----> 2 print(f"Fox says {animal_sounds['fox']}.")

KeyError: 'fox'

If you give a key that is not present in the dictionary it will raise an error.

• with get() you can provide a default value in case the key is not in the dictionary:
  This method only allows you to access an item; it does not allow you to modify it.
  Syntax: my_dict.get(key, default_value)

animal_sounds.get('fox', 'This sound is not registered.')

'This sound is not registered.'

• Dict keys must be immutable objects like strings, numbers or tuples.
  You can get all the keys with .keys().

animal_sounds.keys()

dict_keys(['cat', 'dog', 'cow'])

• Dict values can contain items of different types, including other dictionaries.
  You can get all the values with .values().

animal_sounds.values()

dict_values(['meow', 'woof', 'moo'])

• You can get all the pairs of key:value pairs as a list of tuple using .items():

animal_sounds.items()

dict_items([('cat', 'meow'), ('dog', 'woof'), ('cow', 'moo')])

• Get the number of key:value pairs:

len(animal_sounds)

3

• Add an element or update an existing one:

animal_sounds['lion'] = 'roar'
print(animal_sounds)

{'cat': 'meow', 'dog': 'woof', 'cow': 'moo', 'lion': 'roar'}

The pop method can be used to delete a key:value pair and store the value in a variable.

was_removed = animal_sounds.pop('dog')
print(f"The removed value is {was_removed}.")
print(f"The dictionary contains {animal_sounds}.")

The removed value is woof.
The dictionary contains {'cat': 'meow', 'cow': 'moo', 'lion': 'roar', 'rooster': 'cock-a-doodle-doo'}.

If we want to remove a value from a dictionary, we can use the del keyword:

• for a single key:

del(animal_sounds['cow'])
animal_sounds

{'cat': 'meow', 'lion': 'roar', 'rooster': 'cock-a-doodle-doo'}

• for the whole dictionary:

del(animal_sounds)
animal_sounds

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[134], line 2
      1 del(animal_sounds)
----> 2 animal_sounds

NameError: name 'animal_sounds' is not defined

We received 10 apples, 5 pears and 1 banana.

How would you implement it ?

Nice! But in the meantime, we received 45 more bananas and 10 grapes… and then someone ate an apple (oops).

Pears are now prohibited worldwide, but we get 2 apples in exchange for each pear.

Unfortunately, we should remove the fruits_shop, as it has become useless and we need the space for something else. How would you proceed?

• A dictionary is a variable that can store data in a disorderly manner in the form of key:value pairs.

• An empty dictionary can be initialised with {} or dict().

• Dictionaries are not indexed as lists are.

• To add or update an element, use my_dict[k] = new_value.

• To delete a key:value pair, use remove = my_dict.pop(k) or del(my_dict[k]).

• To delete the dictionary, use del(my_dict).

• An if / elif / else statement allows to determine which part of the code is executed, according to one or several conditions.

• if, elif and else lines end with colon (:).
  The blocks of code to be executed are indented.
  

• elif and else are optional. If they are not provided, nothing will be executed if the if statement is not true.

• You can write as many elif statements as needed.
  elif is short for else if.

• If a statement is true, the other ones are not tested.

• Example 1:

- `current_speed = 60` ?

- `current_speed = 160` ?

- `current_speed = 30` ?

• Example 2:
  Note: Instructions are executed in the order in which they are written.
  

In the example on the right we will never enter the current_speed > limit + 50 block.

• We can combine expressions using and or or.

• if A and B will be executed only if the 2 expressions are true.

admission = none
if age >= 18 and age < 65:
    admission = "full_price"

Note: there is a simpler syntax for checking whether a number is within a range.

if 18 <= age < 65:
    admission = "full_price"

• if A or B will be executed if at least one of the 2 expressions is true.

if age < 18 or age >= 65:
    admission = "reduced_price"

There is no limit to the number of conditions, but it may be useful to use parentheses to indicate priorities.

You can nest multiple conditions.

Before leaving home, you should take an accessory depending on the weather.
Consider the following code:

• Question 1: What does this code print?

This code prints: Wear sunglasses.

• Question 2: Give an example of variables to obtain the message: Wear a scarf.

We must have rain == False and temperature between 0 and 14°C.

• Question 3: When should you wear gloves?

When the temperature is strictly below 0°C.

You should take an umbrella.

• Question 5: Tomorrow, it is supposed to be 28°C and sunny.
  Which accessory or accessories will you take or wear?

Tomorrow, I will wear a hat and sunglasses.

Sometimes it is easier to check whether a condition is not true.
We can do this with the operator not.

This is equivalent to the following syntax:

• An if / elif / else statement allows to determine which part of the code is executed, according to one or several conditions.

• elif is short for if and else.

• if, elif and else lines end with colon (:).
  The blocks of code to be executed are indented.

• elif and else are optional.

• It is possible to combine expressions with and, or and add parentheses () to indicate priorities.

• You can use in and not in keywords to check if an element is in a list.

• The for loop allows to perform an action for each element in a group like a list, a dictionary, a string…

• The line with for instruction must end with a colon (:) and the code that will run inside the for loop must be indented.

• General syntax:

for element in collection:
    # Perform some action(s) on element.  
    # These actions can spread on several lines
    # which must all be indented.  

• Example 1:

odds = [1, 3, 5, 7]
for element in odds:
    print(f"element contains {element}.")

element contains 1.
element contains 3.
element contains 5.
element contains 7.

• Example 2:

odds = [1, 3, 5, 7]
numbers_power2 = list()
for i in odds:
    numbers_power2.append(i**2)
    print(f"i contains {i} and numbers_power2 contains {numbers_power2}.")

i contains 1 and numbers_power2 contains [1].
i contains 3 and numbers_power2 contains [1, 9].
i contains 5 and numbers_power2 contains [1, 9, 25].
i contains 7 and numbers_power2 contains [1, 9, 25, 49].

• Iterate over the keys:

• Iterate over the values:

• Iterate over both keys and values:

• The while loop allows to perform an action as long as an expression is true.

• The line with while instruction must end with a colon (:) and the code that will run inside the while loop must be indented.

• Sometimes you may need to end a loop prematurely.

• With the break statement we can stop the loop even if the while condition is still true or if we are not done with the for iteration.
  

• With the continue statement we can go directly to the next iteration without executing the code in the loop for the current iteration.
  

• As you could see in previous slides, it is possible to combine multiple loops and conditions within the same block of code.

Let’s generate all possible pairs of fruits among orange, mango, and lemon.

We have a list of integers from 0 to 12.

We want to classify them in a dictionary with keys odd and even. Each key in the dictionary has a list of numbers as its value.

How would you do that?

First, we initialise our list and dictionary:

my_int_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
my_number_dict = {"odd" : list(), "even" : list()}

Then we will iterate over my_int_list. For each element we will test if it is even or odd, and add the element to the list of the appropriate key.

• Syntax: the keyword for/while, an iterator, the keyword in, a list/dictionary and a colon (:).

• The code inside a loop must be indented.

• If the expression evaluated by a while loop is not modified, you will get an infinite loop.

• With the break statement, the loop will stop prematurely.

• With the continue statement, the loop will go to the next iteration prematurely.

• To create a Jupyter notebook, go to the Explorer menu on the top-left and click on New file.

• Click on Select Kernel on the top-right of the tab to choose a Python version to run your code.

• To create a markdown cell, click on + Markdown.

• You can write anything you want in this cell: it won’t be interpreted as code.

• You can run a markdown cell to convert raw text to markdown format by clicking on the right-pointing arrow on the right.

• This is what it looks like after being executed.

• To edit a Markdown cell after it has been executed, double-click on it.

• To delete a Markdown cell, click on the dustbin on the right.

• To create a Python cell, click on + Code.

• To run a Python cell, click on right-pointing arrow on the left.

• There are other types of Python cell execution.

• Execute Above Cells: Runs every cell above the current cell.
  It is useful if you have modified your variables and want to revert to a previous state.

• Execute Cell and Below: Runs the current cell and all of the cells below this one.
  It is useful if you have modified your variables and want to refresh the resulting code.

• Run All: Runs every cell in the notebook.
  It is useful if you know you are going to execute all cells.

• Restart: Empties the memory (restarts the kernel).
  It is useful if you use it before a Run All to check if your code works correctly before giving it to someone.

• To delete a Python cell, click on the dustbin on the right of the cell.

• General syntax:

def function_name():
    # Perform some action(s).
    # These actions can spread on several lines
    # which must all be indented.

• Example:

def hello():
    print("Hi !")

• Function variables are specific to the code within the function block.

def square(x):
    sqr=x**2

square(2)
print(f"The square of 2 is {sqr}.")

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[176], line 5
      2     sqr=x**2
      4 square(2)
----> 5 print(f"The square of 2 is {sqr}.")

NameError: name 'sqr' is not defined

• Example:

def speed_limit(x):
    limit = 50
    if x > limit:
      return "Too fast !"
    else:
      return "Perfect !"

print("You are driving at 51km/h.")
result = speed_limit(51)
print(result)

print("You are driving at 30km/h.")
result = speed_limit(30)
print(result)

You are driving at 51km/h.
Too fast !
You are driving at 30km/h.
Perfect !

• You can add a default value to your arguments, but these arguments must be placed at the end of the argument list in the function.

• Indeed, the default value is used when no value has been passed to this argument. If you provide a value, the function will use it instead of the default value:

def power(x, n = 2) :
    return x**n

pow_value = power(2,3)

print(f"2**3 = {pow_value}")

2**3 = 8

• Function names should be lowercase and words separated by underscores (_) for a better readability.

• You can specify the type of your argument and of the returned value. It is helpful to remember which type of value you should set as input. It is helpful but not mandatory.

Imagine you want to create a function called ‘enzyme’, which takes a string as an argument and returns a split list. It splits every time there is a serine (S) residue (we are in a wonderful world where enzymes cut every time and there are no steric hindrances…).

How would you do that ?

We define the name of the function.

def enzyme():

We can then add the argument(s) :

We can then add the instructions (beware of indentation):

Then, we want see the result !

Now let’s try !

Great, it works ! I want to see it in a variable.

Oops, I forgot to include the return in the function.

OK, now let’s enhance our function! Currently it cuts only on uppercase S but we want to be able to accept sequences in upper and lower case letters.

That’s pretty good, but now we want to add the ability to cut according to another amino acid, while keeping Serine as the default value.

You may have noticed that… the catalytic site is not in the list anymore… In reality, an enzyme can cut before or after the catalytic site, but the recognised amino acid should always be present. How would you approach this? (tips: before will be a boolean which, by default, performs an enzyme cut before a catalytic site).

We can see that if our peptide began or ended at the catalytic site, it might produce an unexpected split with an empty character. We don’t want this empty character.
How would you do this?

• Functions are useful for performing an operation multiple times within a program.

• Syntax: the keyword def, the function name, parenthesis () with optionally arguments inside and a colon (:).

• The function name should not be the same as other Python included functions/keywords.

• The code inside a function must be indented.

• The return statement ends the function and sends a result where it is called.

• There can be multiple return statements in a function if you use conditional statements but the first return encountered will stop the function execution and return back to the global code.

Some examples of useful packages:

• biopython : tools for computational molecular biology.
• pandas : dataframe and data analysis toolkit.
• scipy : toolkit for mathematics, statistics and various scientific processes.

• Example :

import random
print(random.randint(0,10))

7

Here we have imported the package random to use the function randint which draws a random integer between 0 and 10.

• All functions of a package can be imported at once using *.

• In the following example, all random functions have been imported and can be used directly by naming them like randint or choices.

from random import *
print("Random number:", randint(0,10))
print("Random name:", choices(['Binjamain','Izabèl','Toma','Lauraine']))

Random number: 7
Random name: ['Binjamain']

• It is also possible to define an alias for a module:

import random as rand
print("Random number:", rand.randint(0,10))

Random number: 9

• Aliases can be useful when the packages or function names are long. Using them can make your code more readable.
  Furthermore, it prevents from function overwrites as you should specify the function from the aliases.

• Like every variable, aliases can be overwritten if you specify something else with it.

• All packages available in The Python Package Index (PyPI) can be installed.

• We recommend doing a quick search of the desired package on https://pypi.org/.

• These can be downloaded easily through the package installer for Python pip.

pip install biopython

• If the package is strictly available on GitHub, you can use:

pip install git+https://github.com/pseudo/repo-name.git

• ./ means the same directory.
  ./Data/Sequences.fasta and Data/Sequences.fasta should work the same
  
• ../ means the parent directory.
  If you need to call Python_slides.html file from exercises.py you will use ../Python_slides.html

• To manage a file, we use a file handler, which can be created with function open().

• Open a file for reading with:

open('/home/Toto/Data/example.txt', 'r')

• Open a file for:

• There are two syntaxes for managing a file:

The syntax using with is recommended for most cases.
You can notice the alias as f, it means f is the file example.txt opened in r (read) mode.
File handler is automatically closed when you exit the with block.

• You can read a file all at once with method readlines(), or line by line.

• You can write to a file with write() method.

• To read a file, you can use:

• To write to a file, you can use:

• DataFrames are objects used to store tables of data, such as Excel tables.

• In Python, you can use multiple libraries in order to manipulate your dataframe, the most populars are pandas and Polars. In this training we will focus on pandas.

• You can install pandas using pip:

pip install pandas

• Then you may load it with an alias:

import pandas as pd

• pd is a common alias used for pandas, but you could also simply write import pandas then just use the functions by calling pandas.function.

• To create a dataframe, you can use pd.DataFrame, which creates an object DataFrame with various methods.

• A simple way to initialise a dataframe is to use a dictionary.