Python : fonctions, fichiers et modules

id: 33-1183-python-fonctions-fichiers-modules slug: 33-1183-python-fonctions-fichiers-modules titre: 'Python : fonctions, fichiers et modules' chapitre: 4 chapitre_titre: Programmation en Python lecon: 1 niveau: 4eme-sci ordre: 10 prerequis: [] duree_estimee_min: 60 mots_cles:

• python
• fonctions
• parametres
• arguments
• fichiers
• modules
• import
• lecture
• ecriture langages:
• python objectifs:
• Définir et appeler une fonction en Python
• Distinguer paramètres et arguments
• Utiliser l'instruction return pour renvoyer une valeur
• Lire et écrire dans un fichier texte
• Importer et utiliser des modules et packages Python status: published source_pdf: 33_1183.pdf source_pages:
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44 kind: cours

À quoi servent les fonctions ?

Vous avez peut-être envisagé la possibilité de réutiliser un morceau de code avec quelques valeurs différentes. Au lieu de réécrire tout le code, il est beaucoup plus simple de définir une fonction, qui peut ensuite être utilisée à plusieurs reprises.

def tax(bill):
    """Adds 8% tax to a restaurant bill."""
    bill *= 1.08
    print "With tax: %f" % bill
    return bill

meal_cost = 100
meal_with_tax = tax(meal_cost)

Sortie :

With tax: 108.000000

Structure d'une fonction

Les fonctions sont définies avec trois composants :

• L'en-tête, qui comprend le mot-clé def, le nom de la fonction et tous les paramètres requis par la fonction. Exemple :

  def MyFunction()
  # Il n'y a pas de paramètres
  

• Le corps, qui décrit les procédures que la fonction effectue. Le corps est en retrait (indenté), tout comme dans les instructions conditionnelles.

def MyFunction():
    """Prints 'Hello World!' to the console."""
    print "Hello World!"

MyFunction()

Sortie :

Hello World!

Paramètres et arguments

• Les valeurs passées dans une fonction sont appelées les arguments.
• Un argument est une variable qui est une entrée dans une fonction. Il indique : « Plus tard, lorsque la fonction sera utilisée, vous pourrez entrer n'importe quelle valeur. »
• Pour l'instant, nous appellerons cette valeur future n.

def MyFunction(n):
    print " le n = ", n

MyFunction(10)

Sortie :

Le n = 10

Appel et réponse

Après avoir défini une fonction, celle-ci doit être appelée pour être exécutée. Dans l'exemple précédent, MyFunction(10) indique au programme de rechercher la fonction nommée MyFunction et d'exécuter le code qu'elle contient.

L'instruction return

• Le but des fonctions en général est de prendre des entrées et de retourner quelque chose.
• L'instruction return est utilisée lorsqu'une fonction est prête à renvoyer une valeur à l'appelant.
• L'instruction return provoque la fermeture de la fonction et le renvoi d'une valeur à l'appelant.

def carre(n):
    sqr = n ** 2
    print(f"Le carré de {n} est {sqr}")
    return sqr

carre(10)

Sortie :

le carré de 10 et 100

Une fonction qui appelle une autre fonction

Nous avons vu des fonctions permettant d'imprimer du texte ou de faire de l'arithmétique simple, mais ces fonctions peuvent être beaucoup plus puissantes. Par exemple, une fonction peut appeler une autre fonction.

def ajouterUn(n):
    return n + 1

def etUnAutre(n):
    return ajouterUn(n) + 1

print etUnAutre(3)

def cube(number):
    return number ** 3

def by_three(number):
    if number % 3 == 0:
        return cube(number)
    else:
        return False

Exemples de fonctions avec différents types d'arguments

Argument entier

number = 5
def my_function(x):
    return x * 3

print my_function(number)

Deux arguments

m = 5
n = 13
def add_function(x, y):
    return x + y

print add_function(m, n)

Argument chaîne de caractères

n = "Hello"
def string_function(s):
    return s + 'world'

print string_function(n)

Argument liste

def list_function(x):
    return x

n = [3, 5, 7]
print list_function(n)

Modifier une liste dans une fonction

def double_first(n):
    n[0] = n[0] * 2

numbers = [1, 2, 3, 4]
double_first(numbers)
print numbers

Parcours et traitement de listes dans une fonction

Afficher chaque élément

n = [3, 5, 7]
def print_list(x):
    for i in range(0, len(x)):
        print x[i]

print_list(n)

Doubler chaque élément

n = [3, 5, 7]
def double_list(x):
    for i in range(0, len(x)):
        x[i] = x[i] * 2
    # N'oubliez pas de retourner votre nouvelle liste !
    return x

print double_list(n)

Ajouter un élément à une liste

n = [3, 5, 7]
def list_extender(lst):
    lst.append(9)
    return lst

print list_extender(n)

Concaténer des chaînes d'une liste

n = ["Michael", "Lieberman"]
def join_strings(words):
    result = ""
    for item in words:
        result = result + item
    return result

print join_strings(n)

Somme des éléments d'une liste

n = [3, 5, 7]
def total(numbers):
    result = 0
    for i in range(0, len(numbers)):
        result = result + numbers[i]
    return result

print total(n)

Concaténer deux listes

m = [1, 2, 3]
n = [4, 5, 6]
def join_lists(x, y):
    return x + y

print join_lists(m, n)

Aplatir une liste de listes

n = [[1, 2, 3], [4, 5, 6, 7, 8, 9]]
def flatten(lists):
    result = []
    for numbers in lists:
        for item in numbers:
            result.append(item)
    return result

print flatten(n)

Fonctions intégrées de Python

Examinons certaines fonctions intégrées à Python (aucun module requis). Vous connaissez déjà .upper(), .lower(), str() et len(). Voici des fonctions plus analytiques : max(), min(), abs().

def biggest_number(*args):
    print max(args)
    return max(args)

def smallest_number(*args):
    print min(args)
    return min(args)

def distance_from_zero(arg):
    print abs(arg)
    return abs(arg)

biggest_number(-10, -5, 5, 10)
smallest_number(-10, -5, 5, 10)
distance_from_zero(-10)

La fonction type()

La fonction type() renvoie le type des données qu'elle reçoit en argument.

print type(42)
print type(4.2)
print type('spam')

Sortie :

<type 'int'>
<type 'float'>
<type 'str'>

Supprimer des éléments d'une liste

Pour une liste appelée n :

n.pop(index)

Supprime l'élément à l'index donné et le retourne.

n = [1, 3, 5]
n.pop(1)    # Retourne 3 (l'élément à l'index 1)
print n     # Affiche [1, 5]

n.remove(item)

Supprime l'élément réel s'il le trouve.

n.remove(1)  # Supprime 1 de la liste,
             # PAS l'élément à l'index 1
print n      # Affiche [3, 5]

del(n[index])

Comme .pop() en ce sens qu'il supprime l'élément à l'index donné, mais ne le retourne pas.

del(n[1])  # Ne retourne rien
print n    # Affiche [1, 5]

La méthode count()

La méthode count() renvoie le nombre de fois où un objet apparaît dans la liste ou une sous-chaîne dans une chaîne.

st = "Python is awesome, isn't it?"
subst = "is"
count = st.count(subst)
print("The count is:", count)

On peut aussi délimiter la zone de recherche :

stg = "Python is awesome, isn't it?"
substg = "i"
count = stg.count(substg, 8, 25)
print("The count is:", count)

La fonction range()

Supposons que vous vouliez construire une liste des nombres de 0 à 50 (inclus). C'est possible facilement avec range().

my_list = range(51)

Résultat : [0, 1, 2, 3, ..., 50]

my_list = range(1, 51)

Résultat : [1, 2, 3, ..., 50]

my_list = range(1, 51, 2)

Résultat : [1, 3, 5, 7, ..., 49]

Les fichiers

Le caractère de saut de ligne

Si vous voulez imprimer quelque chose sur une nouvelle ligne, utilisez \n :

print "Docteur \n house"

Sortie :

Docteur
house

Les méthodes strip(), rstrip() et lstrip()

La méthode strip() renvoie une copie de la chaîne dans laquelle tous les caractères ont été supprimés au début et à la fin de la chaîne (caractères d'espacement par défaut).

str = "0000000this is example....wow!!!0000000"
print str.strip('0')

Sortie :

this is example....wow!!!

La méthode rstrip() (right) ou lstrip() (left) renvoie une copie de la chaîne dans laquelle les caractères ont été supprimés à la fin ou au début seulement.

str = "    this is example....wow!!!    "
print str.rstrip()
str = "8888this is example....wow!!!888"
print str.rstrip('8')

Sortie :

    this is example....wow!!!
8888this is example....wow!!!

Pourquoi utiliser des fichiers ?

En biologie, nous avons de la chance, car de nombreux types de données avec lesquelles nous travaillons sont stockés dans des fichiers texte qui sont relativement simples à traiter avec Python.

Parmi ces données, les principales sont les séquences d'ADN et de protéines, qui peuvent être stockées sous divers formats. Mais il existe de nombreux autres types : lectures de séquençage, scores de qualité, SNP, arbres phylogénétiques, cartes lues, données d'échantillons géographiques, matrices de distances génétiques…

Qu'est-ce qu'un fichier texte ?

En programmation, lorsque nous parlons de fichiers texte, nous ne parlons pas nécessairement de quelque chose qui est lisible par l'homme. Nous parlons plutôt d'un fichier contenant des caractères et des lignes, que l'on peut ouvrir et afficher dans un éditeur de texte.

Exemples de fichiers texte :

• Fichiers FASTA de séquences d'ADN ou de protéines
• Fichiers de sorties de programmes en ligne de commande (par exemple, BLAST)
• Fichiers FASTQ contenant des lectures de séquençage d'ADN
• Fichiers HTML
• Le code Python lui-même

Ouvrir un fichier texte

En Python, comme dans le monde physique, nous devons ouvrir un fichier avant de pouvoir lire ce qu'il contient.

f = open("dna.txt")

Cela indique à Python d'ouvrir dna.txt. Le résultat de cette opération est stocké dans un objet fichier, ici f. Par défaut, Python utilise le mode "r" (lecture).

Modes d'ouverture

f = open("dna.txt", "w")

Lire le contenu d'un fichier

Il existe deux façons de lire un fichier :

1. Lire tout le contenu du fichier d'un coup dans une seule chaîne de caractères.
2. Lire le contenu ligne par ligne.

Méthode 1 : tout lire d'un coup avec read()

La méthode read() lit le contenu d'un fichier ouvert dans une chaîne que l'on peut stocker dans une variable.

my_file_name = "dna.txt"
my_file = open(my_file_name)
file_contents = my_file.read()
print(file_contents)

Exemple : longueur d'une séquence d'ADN

Soit dna.txt contenant : ACTGTACGTGCACTGATC

# ouvrir le fichier
my_file = open("dna.txt")

# lire le contenu
my_dna = my_file.read()

# calculer la longueur
dna_length = len(my_dna)

# imprimer la sortie
print("sequence is " + my_dna + " and length is " + str(dna_length))

Sortie observée :

sequence is ACTGTACGTGCACTGATC
 and length is 19

Deux problèmes apparaissent :

• R1 : la longueur est fausse (19 au lieu de 18).
• R2 : la sortie a été répartie sur deux lignes, alors qu'il n'y a pas de \n dans le code.

Explication : Python a inclus le caractère de nouvelle ligne (\n) à la fin du fichier dna.txt dans le contenu. La chaîne lue est en réalité 'ACTGTACGTGCACTGATC\n'.

Solution : supprimer les \n avec .replace().

# ouvrir le fichier
my_file = open("dna.txt")

# lire le contenu en supprimant les retours à la ligne
my_dna = my_file.read().replace('\n', '')

# calculer la longueur
dna_length = len(my_dna)

# imprimer la sortie
print("sequence is " + my_dna + " and length is " + str(dna_length))

Méthode 2 : lire ligne par ligne avec readlines()

La fonction readlines() lit tout le contenu du fichier texte et place chaque ligne dans une liste.

Soit dna.txt contenant :

ACTGTACGT
GCACTGATC

f = open('dna.txt', "r")
lines = f.readlines()

Contenu de lines :

['ACTGTACGT\n', 'GCACTGATC']

Une autre façon équivalente :

f = open('dna.txt', "r")
lines = list(f)

Lire ligne par ligne avec une boucle while et readline()

f = open('my_text_file.txt')

# utilise readline() pour lire la première ligne
line = f.readline()

# Si le fichier n'est pas vide, continuez à lire
# une ligne à la fois jusqu'à ce que le fichier soit vide
while line:
    print(line)
    # utilise readline() pour lire la ligne suivante
    line = f.readline()

f.close()

Comme nous lisons une ligne à la fois avec readline(), nous pouvons facilement gérer de gros fichiers sans nous soucier des problèmes de mémoire.

Variante avec while True et break :

fh = open('my_text_file.txt')

while True:
    line = fh.readline()
    print line
    # vérifier si la ligne n'est pas vide
    if not line:
        break

fh.close()

Lire ligne par ligne avec un itérateur

La méthode la plus simple est d'utiliser directement le fichier comme itérateur :

fh = open('my_text_file.txt')

for line in fh:
    print(line)

fh.close()

Fermer le fichier

fh.close()

La méthode split()

À un moment donné, il se peut que vous deviez diviser une grande chaîne en petits morceaux. C'est l'opposé de la concaténation.

La fonction split() divise une chaîne et place les morceaux dans une liste, en utilisant un séparateur défini. Si aucun séparateur n'est défini, les espaces sont utilisés par défaut.

x = 'blue,red,green'
x.split(",")

Résultat :

['blue', 'red', 'green']

Écrire dans un fichier

La méthode write()

fh = open("hello.txt", "w")
fh.write("Put the text you want to add here")
fh.write("and more lines if need be.")
fh.close()

La méthode writelines()

La méthode writelines() écrit une séquence de chaînes dans le fichier (généralement une liste de chaînes).

fh = open("hello.txt", "w")

lines_of_text = ["One line of text here",
                 "and another line here",
                 "and yet another here",
                 "and so on and so forth"]

fh.writelines(lines_of_text)
fh.close()

Les modules et l'importation

Pour utiliser des fonctions d'un module dans un programme, il faut au début du fichier importer ce module.

Importation générique

Il existe un module Python nommé math qui inclut un certain nombre de variables et de fonctions utiles, dont sqrt(). Pour accéder à math, on utilise le mot-clé import. Lorsqu'on importe simplement un module de cette façon, cela s'appelle une importation générique.

import math
print math.sqrt(25)

Importation de fonction

Il est possible d'importer uniquement certaines variables ou fonctions d'un module donné. Extraire une seule fonction d'un module s'appelle une importation de fonction, faite avec le mot-clé from :

from math import sqrt
print sqrt(25)

Maintenant, on peut simplement taper sqrt() pour obtenir la racine carrée — plus besoin de math.sqrt() !

Importation universelle

Que faire si nous voulons toutes les variables et fonctions d'un module, mais sans avoir à taper constamment math. ?

from math import *
print sqrt(25)

Renommer un module avec un alias

On peut modifier un nom de module pour l'abréger :

import math as m
print(m.pi)

Dans le programme, on appelle maintenant la constante pi par m.pi plutôt que math.pi.

Pour certains modules, il est courant d'utiliser des alias. Par exemple, la documentation officielle de matplotlib.pyplot recommande l'alias plt :

import matplotlib.pyplot as plt

Cela permet d'utiliser plt.show() au lieu de matplotlib.pyplot.show().

Python et les packages

Installer un package avec pip

conda et pip sont des outils de gestion de packages permettant d'installer des modules scientifiques et analytiques écrits en Python.

Dans la fenêtre de commande Anaconda, tapez :

pip install nom_package

Cette commande fonctionne si l'on est connecté à internet. Sinon, pour une installation manuelle, on télécharge le package au format .zip puis on utilise :

cd emplacement_du_package
python setup.py install

Installer un package avec conda

conda install nom_package

C'est sous conda que l'on fait les mises à jour d'Anaconda :

conda update anaconda

Librairies utiles en bioinformatique

On a généralement besoin des librairies suivantes :

• NumPy : calcul numérique
• SciPy : calcul scientifique
• Matplotlib : graphiques
• Pandas : manipulation de données
• Biopython : bioinformatique
• Statsmodels : statistiques

Exemple : tracer un sinus avec Matplotlib

import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()
ax = plt.axes()
x = np.linspace(0, 10, 1000)
ax.plot(x, np.sin(x))

Références

• https://www.anaconda.com/download/
• http://www.programmingforbiologists.org/programming/
• https://www.codecademy.com/