Outils pour utilisateurs

Outils du site


teaching:progappchim:presentation_principes
→ Slide 1

Programmer en Python

→ Slide 2

Généralités

  • Qu'est-ce qu'un langage de programmation ?
  • Compilation ou interprétation, ou… ?
↓ Slide 3

Rôle des langages de programmation

  • Décrire des instructions dans un langage compréhensible par un être humain, mais transformable en d'autres instructions compréhensibles par l'ordinateur (langage machine)
  • Automatiser le traitement de l'information;
  • Effectuer des calculs, des simulations;
  • Traiter l'information en temps réel;
  • Fournir un interface à l'utilisateur;
↓ Slide 4

Évolution des langages

  • L’assembleur (à partir des années 50’s)
    • Mnémoniques équivalentes aux instructions machines, donc fonction du processeur utilisé
    • Instructions de bas niveaux (appel d’une variable en mémoire, opération arithmétique entre 2 opérandes,…)
  • Fortran, Cobol, Pascal, C, Basic,… (années 60s et 70s)
    • Indépendants de l’ordinateur utilisé
    • Proche d’un langage courant, description procédurale
  • Les langages à objets (années 80s et 90s)
    • Briques logicielles indépendantes et autonomes
    • Réutilisations aisées, sans devoir les approfondir
    • Java, C++, Python, perl, Ruby. . .sont les plus connus
  • Des langages spécialisés (PHP, SQL,…)
↓ Slide 5

Compilation et compilateur

Code source
Compilation
Code objet
Exécution
Résultat
  • Etape de traduction du code source en langage machine
  • Liaison éventuelle du code avec des bibliothèques existantes de code compilé
  • Exécution ultérieure du code machine (sur un ordinateur ne disposant pas du compilateur par exemple)
  • Le compilateur peut optimiser le code (passes multiples)
↓ Slide 6

Interprétation et interpréteur

Code source
Interprétation
Résultat
  • Traduction dynamique du code source et exécution immédiate en répétant sans cesse :
    • lecture et analyse d'une instruction
    • exécution de l'instruction (si elle est valide)
  • Le code est souvent moins optimisé, donc plus lent
  • Il est nécessaire de disposer de l'interpréteur sur l'ordinateur
  • On peut créer dynamiquement du code à interpréter pendant l'exécution
  • On peut éviter la phase lente de compilation
↓ Slide 7

Python / Langages à Bytecodes

Code source Python (.py, .py3)
Compilation
Python Bytecode (.pyc)
Interprétation
Résultat
  • Pour Python (et d'autres langages), c’est un peu plus compliqué…
  • Le programme est compilé vers un pseudo-code indépendant de l’ordinateur
  • Le Bytecode est interprété par la suite
  • Avantages :
    • Facilité de développement (cycle écriture-exécution rapide, “briques” logicielles)
    • Portabilité (même programme pour des ordinateurs et OS différents)
→ Slide 8

Premier aperçu de Python

  • Avantages généraux
  • Avantages techniques
  • Avantages pour l'apprentissage
  • Avantages pour le scientifique, le chimiste
  • Les premiers pas avec Python
↓ Slide 9

Avantages généraux

  • langage de haut niveau (orienté objet)
  • permet d’écrire des petits programmes ou suites d’instructions (scripts)
  • licence libre (et gratuit)
  • utilisable pour la programmation occasionnelle par des non-informaticiens
  • nombreuses librairies existantes (modules)
  • moderne et efficace pour les informaticiens
  • excellente lisibilité intrinsèque du code
  • bien documenté (aide et manuels en ligne, livres, forums, exemples…)
↓ Slide 10

Avantages techniques

  • mode interactif
  • non déclaratif
  • typage de haut niveau, dynamique et fort
  • ramasse-miette intégré
  • interfaçable avec d’autres langages (à partir de et vers)
  • version de base “piles comprises”
    • module mathématique
    • accès aux fichiers et répertoires (+ formats de données standards)
    • compression, archivage, gestion de bases de données
    • fonctions génériques du système d’exploitation
    • réseau et communication, protocoles internet (+email, html)
    • multimedia (son, image)
    • interface graphique (Tkinter)
    • outils de documentation et gestion d’erreurs (débogage)
    • modules spécifiques Windows, Mac, Linux
↓ Slide 11

Avantages pour l'apprentissage

  • Installation aisée
    • de la version de base
    • de “distributions” étendues (avec des modules complémentaires)
  • éditeur inclus (Idle) ou autre (SciTe, Pycharm, Eric,…)
  • mode interactif pour les premiers essais
  • principes de base identiques à de nombreux langages
  • on n’est pas obligé d’utiliser toute la puissance du langage
  • cycle d’écriture/essais très rapide
↓ Slide 12

Avantages pour le scientifique, le chimiste

  • possible de débuter en quelques jours
  • alternative à des logiciels spécialisés (matlab, scilab,…)
  • bon pour les calculs scientifiques, le graphisme, les simulations
  • modules spécialisés
    • représentations graphiques 2D (Matplotlib)
    • représentations graphiques 3D (Mayavi, Vpython, VTK,)
    • calculs scientifiques (numpy, scipy,. . .)
    • traitement d’images (PIL)
    • chimie (pymol, mmtk, chimera,…)
    • biochimie (biopython)
↓ Slide 13

Les premiers pas avec Python 3

↓ Slide 14

Ídle3 : interface d'exécution et d'édition

Idle3 : interpréteur Python en console, avec exécution directe

>>> (8.314*300/24E-3)/101325
1.0256600049346163
>>>
  • Commandes : copyrigth, credits, license(), quit, help, help(),…
↓ Slide 15

Notion de variable

On peut attribuer des noms de variables, pas seulement pour des nombres…

>>> R=8.314
>>> L=0.001
>>> V=24*L
>>> n=1
>>> zero=273.15
>>> T=20+zero
>>> P=n*R*T/V
>>> atm=101325
>>> print(P,P/atm)
101555.51000000001 1.0022749568221072
>>>
↓ Slide 16

Un peu de calcul

On peut effectuer quelques calculs sur des entiers :

>>> 1236*5698
7042728
>>> 12569+6233
18802
>>> 12+69+532+65-9
669
>>> 12356*458955
5670847980
>>> 123*456
56088
>>> 123**456 ?? A ESSAYER ??
  • On peut travailler avec des très très très grands nombres…
↓ Slide 17

Division et division entière

>>> a =7/3
2.3333333333333335
>>> b = 7//3
2
>>> 
  • En python, chaque “objet” possède son type et un identifiant :
    • type(a)
    • id(a)
    • type(b)
    • id(b)
↓ Slide 18

De nombreuses autres possibilités avec les nombres...

>>> Navogadro=6.02214199E23
>>> kboltzmann=1.3806505E-23
>>> print(Navogadro*kboltzmann)
8.31447334956
>>> 2**0.5
1.4142135623730951
>>> (5+2j)*(3-7j)
(29-29j)
>>> (1.+1./1E6)**1E6
2.7182804690957272
>>>
  • Les expressions numériques s’évaluent en respectant les régles habituelles de priorités : parenthèses, exponentiation, multiplication, division, addition, soustraction (“PEMDAS”)
  • On peut aussi travailler facilement avec des tableaux contenant des milliers de données !
↓ Slide 19

Un peu de logique : le type booléen !

>>> 12 < 16
True
>>> 12 < 11
False
>>> 12 == 12, 12 == 13
(True, False)
>>> 12 < 16 or 12 < 11
True
>>> 12 < 16 and 12 < 11
False
>>> type(12 < 11)
<class 'bool'>
  • Les tests, comparaisons et leurs combinaisons logiques sont utiles pour réaliser des opérations de manière conditionnelle. Pour la logique booléenne : cf. Algèbre de Boole
↓ Slide 20

Les chaînes de caractères

  • appelées aussi “string”
  • mots, phrases, ou texte long
  • délimitées par ’ (apostrophe) ou “ (guillemet)
  • la casse est significative
  • caractères accentués, spéciaux et chiffres permis (caractères Unicode)
  • CONSEIL : éviter les accents dans les noms des variables
  • peuvent comprendre des retours à la ligne (Enter) si délimitées par ”””
↓ Slide 21

Les chaînes de caractères

>>> a=’bonjour’
>>> b="bonjour"
>>> c=’Bonjour’
>>> print(a==b,a==c)
True False
>>> d="pâté123#"
>>> print d
pâté123#
>>> é=d
>>> long="""un
deux
...
dix"""
>>> print(long)
un
deux
...
dix
>>>
↓ Slide 22

Opérations sur les chaînes

>>> s=’Mons, le 15 septembre 2009’
>>> s[8:]
’ 15 septembre 2009’
>>> s.find(’le’)
6
>>> s.split()
[’Mons,’, ’le’, ’15’, ’septembre’, ’2009’]
>>> s.upper()
’MONS, LE 15 SEPTEMBRE 2009’
>>> s.replace(’ ’,’_’)
’Mons,_le_15_septembre_2009’
>>>
↓ Slide 23

Créer son premier programme

  • Utiliser Idle3 comme éditeur (ou tout autre éditeur)
  • Sauvegarder
  • Exécuter
  • Fermer
  • Rouvrir Idle3 et le programme
  • Exécuter
#!/usr/bin/env python
# -*- coding: utf-8 -*-
""" Programme élémentaire en Python
pour afficher une chaîne de caractères
"""
chaine = 'Message : Hello World !'
print(chaine)
→ Slide 24

Un peu plus loin dans Python

↓ Slide 25

Types de haut niveau

Au delà des types de base (integer, float, string,…) on peut avoir des types sophistiqués (containers)

  • listes
  • dictionnaires
  • tuples
  • sets
↓ Slide 26

Listes

  • collections/séquences ordonnées d’objets (types de base ou autres), introduits entre crochets et séparés par des virgules
  • peuvent être homogènes ou hétérogènes (types identiques ou mélangés)
  • on peut les compléter ou enlever des éléments dynamiquement
  • indicées (numérotées) à partir de 0
  • utilisables comme tableaux multidimensionnels
  • nombreuses manipulations possibles (opérations, méthodes) : accéder, concaténer, trier, compléter, rechercher, réduire,…
↓ Slide 27

Listes (bis)

>>> a1 = [31, 16, 'mot','rouge', 1+3j, [2, 'bleu', 3.14]]
>>> a1
[31, 16, 'mot', 'rouge', (1+3j), [2, 'bleu', 3.14]]
>>> a2 = [121,'vert', 'tomate']
>>> a3=a1+a2
>>> a3
[31, 16, 'mot', 'rouge', (1+3j), [2, 'bleu', 3.14], 121, 'vert', 'tomate']
>>> len(a3)
9
>>> a3[4]
(1+3j)
>>> a3[5]
[2, 'bleu', 3.14]
>>> a3[5][1]
'bleu'
>>> a3[2:6]
['mot', 'rouge', (1+3j), [2, 'bleu', 3.14]]
↓ Slide 28

Listes (ter)

>>> a3[-1]
'tomate'
>>> a3.pop()
'tomate'
>>> a3
[31, 16, 'mot', 'rouge', (1+3j), [2, 'bleu', 3.14], 121, 'vert']
>>> a3.pop()
'vert'
>>> a3.pop()
121
>>> a4=a3.pop()
>>> a4
[2, 'bleu', 3.14]
>>> a3.append(19.3)
>>> a3
[31, 16, 'mot', 'rouge', (1+3j), 19.3]
↓ Slide 29

Dictionnaires

  • collections/ensembles non-ordonnées de paires de clés et valeurs
  • Chaque clé doit être unique (n'apparaître qu'une fois) et identifie la valeur correspondante (les clés sont souvent des nombres ou des chaînes)
  • Les valeurs peuvent être un objet de n’importe quel type (de base ou autres)
  • Clés et valeurs sont séparées par le caractère ”:“
  • Les paires clés :valeurs sont séparées par des virgules et le tout encadré par une paire d’accolades {} forme le dictionnaire.
↓ Slide 30

Dictionnaires (bis)

>>> d = {'e1': 8, 'e2': 9, 'e4': 11, 'e3': 3, 'e5' : 1}
>>> d.keys()
dict_keys(['e5', 'e3', 'e1', 'e4', 'e2'])
>>> d
{'e5': 1, 'e3': 3, 'e1': 8, 'e4': 11, 'e2': 9}
>>> d['e4']
11
>>> 'e7' in d
False
>>> import operator
>>> print(sorted(d.items(), key=operator.itemgetter(1)))
[('e5', 1), ('e3', 3), ('e1', 8), ('e2', 9), ('e4', 11)]
>>> 
↓ Slide 31

Tuples

  • Les tuples sont comme les listes, MAIS :
  • entourés de parenthèses au lieu de crochets
  • les éléments sont non-modifiables après la création
  • pas de méthodes sur les tuples (rechercher, enlever un élément,…
  • les tuples sont plus rapides d’accès que les listes
  • ils peuvent être utilisés comme clés de dictionnaires
  • il est possible de convertir un tuple en liste et vice-versa
↓ Slide 32

Ensemble (set)

  • collection non ordonnée d'éléments non répétés (uniques)
  • L'utilisation des ensembles se fait par analogie avec les propriétés et opérations de la théorie mathématique des ensembles : appartenance, cardinalité (nombre d'éléments), union, intersection, différence, …
↓ Slide 33

Structure conditionnelle

Instruction d’exécution conditionnelle if…elif…else (si…sinon-si…autrement)

  • Commence par if expression :
  • Si l’expression est vraie, le bloc d’instructions qui suit est exécuté
  • Si c’est faux, elif expression : permet d’enchaîner une seconde condition
  • Si aucune condition n’est vérifiée, else : permet de déterminer les instructions à effectuer
↓ Slide 34

Structure conditionnelle (exemple)

a = int(input('Donnez une note ? '))
if a >= 18:
    print("Excellent")
elif a >= 16:
    print("Très bien")
elif a >= 14:
    print("Bien")
elif a >= 12:
    print("Satisfaisant")
elif a >= 10:
    print("Réussi")
else:
    print("À représenter")
↓ Slide 35

Structures de répétition while et for

While

  • Commence par while expression :
  • Si l’expression est vraie, le bloc d’instructions qui suit est exécuté
  • L’expression est à nouveau évaluée
  • Lorsque l’expression est (devient) fausse, le bloc n’est plus exécuté
  • break permet de quitter prématurément la structure de répétition

for

  • Commence par for element in sequence :
  • Le bloc d’instructions qui suit est exécuté autant de fois qu’il y a d’éléments dans la séquence
  • Else : permet d’exécuter un autre bloc après avoir considéré tous les éléments
  • break permet de quitter prématurément la structure de répétition

Exemples while et for

print('Structure while !')
c=0
while c< 4:
    print(c)
    c=c+1
print('valeur finale = ',c)
 
print('Structure for')
a=range(11)
print(a)
for n in a:
    print(n*7)
↓ Slide 36

Indentations des structures

L’indentation est intégrée à Python

  • Les retraits permettent de reconnaître et exécuter des structures dans des structures
  • Efficace, léger et très favorable à une écriture compacte et lisible des programmes
  • Tabulations (en fait remplacées par 4 espaces !)
  • Importance de la configuration correcte de l’éditeur (utilisation d'espaces)
  • Si l’indentation n’est pas respectée précisément : erreur
↓ Slide 37

Exemples d’indentation

print('Table de multiplication')
a=range(11)
for i in a:
    for j in a:
        print(i*j,)
    print(' sont multiples de ',i)
↓ Slide 38

Fonctions en Python

  • Permettent d’étendre le langage
  • Résolvent un problème délimité
  • Font appel elles-mêmes à d’autres fonctions
  • Dépendent de variables (arguments, paramètres)
  • Appelables autant de fois que souhaité, avec des arguments quelconques
  • Renvoient (ou non) un résultat utilisable dans une expression
  • Utilisent des noms de variables à portée locale
  • Définies par le programmeur, ou existantes dans des “librairies modules” supplémentaires
  • Spécifiées ou définies avant l’utilisation
↓ Slide 39

Exemple de fonction

def f1(x):
    return x**2.
 
def f3(w):
    print("a ",a)
    return a * w**3.     
 
def f2(x):
    a = 1.111111
    print("a ",a)
    return x**1.5 *f3(x)
 
a = 2.
u = 9.
print("f1 ",f1(u))
print("f2 ",f2(u))
print("f3 ",f3(u))
↓ Slide 40

Exemple de fonction (2)

def fractions(nummol):
    sum=0.
    for num in nummol:
        sum+=num
    fract=[]
    for num in nummol:
        fract.append(num/sum)
    return fract
 
li=input("Donnez les nombres de moles des constituants (séparés par des virgules)")
print(li,type(li))
n = [float(c) for c in li.split(',')]
print(n,type(n))
print(fractions(n))
↓ Slide 41

Utilisation de librairies de fonctions standard

>>> import math
>>> math.pi
3.141592653589793
>>> math.cos(0)
1.0
>>> math.__dict__
{'tanh': <built-in function tanh>, 'asin': <built-in function asin>, ...
...
>>> math.__doc__
'This module is always available.  It provides access to the\nmathematical functions defined by the C standard.'
>>> math.__name__
'math'

On peut modifier les noms des fonctions et la façon de les stipuler (espaces de noms) par la directive import

↓ Slide 42

Modules, objets, classes, librairies

Python est un langage très moderne → structures très avancées

  • Classes (programmation objet), regroupant variables, données et fonctions
  • Module : ensemble de code repris dans un seul fichier
  • Paquet ou Librairie : ensemble de modules avec une arborescence en répertoires

La programmation avancée en Python comprend aussi :

  • la gestion des erreurs
  • des procédures de tests
  • la génération de documentation sous différentes formes
  • la possibilité d'utiliser des versions spécifiques de librairies
↓ Slide 43

Notion d’algorithme

Algorithme : description des opérations à effectuer pour résoudre un problème

  • Indépendant des ordinateurs
  • Logique et systématique
  • Langage courant structuré
  • Transposable pour différents langages de programmation
  • Détermine le temps d’exécution et la mémoire nécessaire en terme de proportionnalité à la taille du problème

Exemple : la multiplication matricielle nécessite de l’ordre de N3 opérations (si N est la taille des matrices)

Référence : http://fr.wikipedia.org/wiki/Algorithmique

→ Slide 44

Pour terminer

Exemples d'applications

↓ Slide 45

Simple, avec le module standard Turtle

from turtle import *
 
reset()
i=0
while i<120:
    forward(i)
    left(90)
    i=i+2
input('Hit Enter to continue')
↓ Slide 46

Coloré, avec le module standard Turtle

from turtle import *
 
reset()
x=-100
y=-100
i=0
while i < 10:
    j=0
    while j <10:
        up()
        goto(x+i*20,y+j*20)
        down()
        begin_fill()
        n=0
        while n <4 :
            forward(16)
            left(90)
            n=n+1
        color((i*0.1,j*0.1,0))
        end_fill()
        color(0,0,0)
        j=j+1
    i=i+1
 
input('Hit Enter to continue')
↓ Slide 47

Simple, avec l’interface graphique Tkinter

from tkinter import *
 
fen01 = Tk()
fen01.title("Lecture de deux masses")
chaine1 = Label (fen01, text = "introduisez la première masse :")
chaine2 = Label  (fen01, text = "introduisez la deuxième masse :")
chaine1.grid(row =0)
chaine2.grid(row =1)
entr1= Entry(fen01)
entr2= Entry(fen01)
entr1.grid(row =0, column =1)
entr2.grid(row =1, column =1)
bou1=Button(fen01,text='Continuer',command=fen01.quit)
bou1.grid(row=2,column=1)
 
fen01.mainloop()
 
m1 = float(entr1.get())
m2 = float(entr2.get())
fen01.destroy()
 
print('Masses lues : ', m1,' et ',m2)
↓ Slide 48

Tkinter : animation

anima_auto_rebond.py
#! /usr/bin/env python
# -*- coding: utf-8 -*-
 
# Petit exercice utilisant la librairie graphique Tkinter
 
from tkinter import *
 
# définition des gestionnaires
# d'événements :
 
def move():
    "déplacement de la balle"
    global x1, y1, vx, vy, dt, flag
    x1, y1 = x1 +vx*dt, y1 + vy*dt
    if x1 < 0 or x1 > 220:
        vx=-vx
    if y1 < 0 or y1 > 220:
        vy = -vy
    can1.coords(oval1,x1,y1,x1+30,y1+30)
    if flag >0: 
        fen1.after(2,move)		# boucler après 50 millisecondes
 
def stop_it():
    "arret de l'animation"
    global flag    
    flag =0
 
def start_it():
    "démarrage de l'animation"
    global flag
    if flag ==0:	# pour éviter que le bouton ne puisse lancer plusieurs boucles 
       flag =1
       move()
 
#========== Programme principal =============
 
# les variables suivantes seront utilisées de manière globale :
x1, y1 = 40, 115		# coordonnées initiales
vx, vy = 10, 5		# vitesse du déplacement
dt=0.1       # pas temporel
flag =0			    # commutateur
 
# Création du widget principal ("parent") :
fen1 = Tk()
fen1.title("Exercice d'animation avec Tkinter")
# création des widgets "enfants" :
can1 = Canvas(fen1,bg='dark grey',height=250, width=250)
can1.pack(side=LEFT, padx =5, pady =5)
oval1 = can1.create_oval(x1, y1, x1+30, y1+30, width=2, fill='red')
bou1 = Button(fen1,text='Quitter', width =8, command=fen1.quit)
bou1.pack(side=BOTTOM)
bou2 = Button(fen1, text='Démarrer', width =8, command=start_it)
bou2.pack()
bou3 = Button(fen1, text='Arrêter', width =8, command=stop_it)
bou3.pack()
# démarrage du réceptionnaire d'évènements (boucle principale) :
fen1.mainloop()
↓ Slide 49

tkinter : tkDemo, demonstration of Tk widgets

FIXME : ? version python 3 ?

Voir par exemple ce lien

↓ Slide 50

Graphiques simples avec matplotlib

# cosinusoïde amortie
from pylab import *
 
def my_func(t):        
    s1 = cos(2*pi*t)        
    e1 = exp(-t)        
    return s1*e1
 
tvals = arange(0., 5., 0.05)
#plot(tvals, my_func(tvals))
#show()
 
plot(tvals, my_func(tvals), 'bo', tvals, my_func(tvals), 'k')
show()
↓ Slide 51

Calculs numériques (FFT) et graphiques plus élaborés

transformees_de_fourier

↓ Slide 52

Graphiques et illustrations plus complexes

potentiel_morse

↓ Slide 53

pH d’un acide en fonction d’un ajout de base et d’une dilution

ph-3d

↓ Slide 54

Calculs sur des molécules

methanol - Formula = CH4O
mol wt = 32.04186 - Numb atoms = 6 - Numb bonds =
12.0107 6 C x= 0.956 y= -0.086 z= -0.056
15.9994 8 O x= 0.488 y= -1.374 z= 0.299
1.00794 1 H x= 0.587 y= 0.64 z= 0.672
1.00794 1 H x= 0.584 y= 0.177 z= -1.05
1.00794 1 H x= 2.049 y= -0.08 z= -0.052
1.00794 1 H x= 0.831 y= -1.996 z= -0.365
partial charges = (0.28, -0.68, 0.0, 0.0, 0.0, 0.4)
total charge = 0

Ces données ont été générées à partir de la chaîne smile ’CO’ du méthanol en utilisant des librairies Python existantes et les programmes de chimie OpenBabel

→ Slide 55

Objectifs du cours

↓ Slide 56

Développer des capacités à programmer

L’apprentissage des rudiments de la programmation vous permettra :

  • d’utiliser des petits programmes existants en les modifiant légèrement (niveau élémentaire)
  • d’écrire un programme pour solutionner un problème scientifique, en utilisant du code et des librairies existants (niveau normal)
  • d’élaborer un programme original pour solutionner un problème scientifique (niveau supérieur)
  • Utiliser des techniques de programmation avancées pour solutionner un problème original (niveau excellent)

Quelque soit le niveau de la programmation, les programmes devront respecter les règles d’écriture communément admises

↓ Slide 57

Apprendre par la pratique

La pratique est la clé de l’apprentissage de tout langage ! Pour atteindre les objectifs, vous procéderez par étape :

  • Reproduire quelques programmes très simples pour se familiariser avec le cycle édition-exécution
  • Apprendre les bases en suivant le canevas proposé, un manuel/tutoriel, et en effectuant des exercices
  • Manipuler les outils d’aide, documenter et commenter Apprendre à rechercher et corriger les erreurs
  • Rechercher des exemples simples d’applications (scientifiques, mathématiques,…)
  • Programmer des problèmes inédits, simples
  • Utiliser des sources de codes et documentations diverses : livres, forums, sites web
  • Se donner un projet à réaliser, d’envergure adaptée à ses capacités, et le réaliser
↓ Slide 58

Aide en ligne, sites, manuels, fichiers, forums,...

  • Aide sur en ligne à partir de Idle, sous windows (touche F1)
  • sur python.org
  • sur les sites officiels de librairies utilisées
↓ Slide 59

Références

  • Des documents du cours, des exemples et des applications, des réalisations d’étudiants d’années antérieures, des suggestions de travaux sont sur la page : progappchim
  • Des références générales sur Python sont regroupées à la page : python
teaching/progappchim/presentation_principes.txt · Dernière modification: 2018/02/20 16:04 par villersd