Différences

Ci-dessous, les différences entre deux révisions de la page.

--- teaching:progappchim:presentation_principes [2017/01/30 17:57] – villersd
+++ teaching:progappchim:presentation_principes [2023/02/21 14:56] (Version actuelle) – villersd
@@ Ligne 32: / Ligne 32: @@
 <WRAP group>
 <WRAP half column>
-<diagram>
+<flowchartjs default>
-| AAA | |AAA{border-color:black;background-color:lightblue}=Code source
+  box1=>operation: Code source
-| |!@4| | AB |AB{border-color:white}=Compilation
+  → Compilation
-| BBB | | | | | | | | | | |BBB{border-color:black;background-color:lightblue}=Code objet
+  box2=>operation: Code objet
-| |!@4| | BC |BC{border-color:white}=Exécution
+  → Exécution
-| CCC | | | | | | | | | | |CCC{border-color:black;background-color:lightblue}=Résultat
+  box3=>operation: Résultat
-</diagram>
+  box1->box2->box3
+</flowchartjs>
 </WRAP>
 <WRAP half column>
@@ Ligne 50: / Ligne 52: @@
 <WRAP group>
 <WRAP half column>
-<diagram>
+<flowchartjs default>
-| AAA | |AAA{border-color:black;background-color:lightblue}=Code source
+  box1=>operation: Code source
-| |!@4| | AB |AB{border-color:white}=Interprétation
+  → Interprétation
-| BBB | | | | | | | | | | |BBB{border-color:black;background-color:lightblue}=Résultat
+  box2=>operation: Résultat
-</diagram>
+  box1->box2
+</flowchartjs>
 </WRAP>
 <WRAP half column>
@@ Ligne 69: / Ligne 73: @@
 <WRAP group>
 <WRAP half column>
-<diagram>
+<flowchartjs default>
-| AAA | |AAA{border-color:black;background-color:lightblue}=Code source Python (.py, .py3)
+  box1=>operation: Code source Python (.py)
-| |!@4| | AB |AB{border-color:white}=Compilation
+  → Compilation
-| BBB | | | | | | | | | | |BBB{border-color:black;background-color:lightblue}=Python Bytecode (.pyc)
+  box2=>operation: Python Bytecode (.pyc)
-| |!@4| | BC |BC{border-color:white}=Interprétation
+  → Interprétation
-| CCC | | | | | | | | | | |CCC{border-color:black;background-color:lightblue}=Résultat
+  box3=>operation: Résultat
-</diagram>
+  box1->box2->box3
+</flowchartjs>
 </WRAP>
 <WRAP half column>
@@ Ligne 156: / Ligne 162: @@
 >>>
 </code>
-  * Commandes : copyrigth, credits, license(), quit, help, help(),...
+  * Commandes : copyright, credits, license(), quit, help, help(),...
 ==== Notion de variable ====
@@ Ligne 165: / Ligne 171: @@
 >>> V=24*L
 >>> n=1
->>> zero=273.16
+>>> zero=273.15
 >>> T=20+zero
 >>> P=n*R*T/V
@@ Ligne 172: / Ligne 178: @@
 .51000000001 1.0022749568221072
 >>>
+</code>
 ==== Un peu de calcul ====
 On peut effectuer quelques calculs sur des entiers :
+<code>
 >>> 1236*5698
 7042728
@@ Ligne 184: / Ligne 190: @@
 >>> 12356*458955
-5670847980L
+5670847980
 >>> 123*456
@@ Ligne 193: / Ligne 199: @@
 ==== Division et division entière ====
 <code>
->>> 7/3
+>>> a =7/3
 .3333333333333335
->>> 7//3
+>>> b = 7//3
 >>>
 </code>
-  * En python, chaque "objet" possède son type :
+  * En python, chaque "objet" possède son type et un identifiant :
-    * type(7/3)
+    * type(a)
-    * type(7//3)
+    * id(a)
+    * type(b)
+    * id(b)
+==== De nombreuses autres possibilités avec les nombres... ====
+<code>
+>>> Navogadro=6.02214199E23
+>>> kboltzmann=1.3806505E-23
+>>> print(Navogadro*kboltzmann)
+.31447334956
+>>> 2**0.5
+.4142135623730951
+>>> (5+2j)*(3-7j)
+(29-29j)
+>>> (1.+1./1E6)**1E6
+.7182804690957272
+>>>
+</code>
+  * 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 !
+==== Un peu de logique : le type booléen ! ====
+<code>
+>>> 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'>
+</code>
+  * 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. [[wp>fr:Algèbre_de_Boole_(logique)|Algèbre de Boole]]
+==== 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 [[wp>fr:Unicode|Unicode]])
+  * CONSEIL : éviter les accents dans les noms des variables
+  * peuvent comprendre des retours à la ligne (Enter) si délimitées par ”””
+==== Les chaînes de caractères ====
+<code>
+>>> 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
+>>>
+</code>
+==== Opérations sur les chaînes ====
+<code>
+>>> s='Mons, le 15 septembre 2009'
+>>> s[8:]
+' 15 septembre 2009'
+>>> s.find('le')
+
+>>> s.split()
+['Mons,', 'le', '15', 'septembre', '2009']
+>>> s.upper()
+'MONS, LE 15 SEPTEMBRE 2009'
+>>> s.replace(’ ’,’_’)
+'Mons,_le_15_septembre_2009'
+>>>
+</code>
+==== Créer son premier programme ====
+  * Utiliser Idle3 comme éditeur (ou tout autre éditeur)
+  * Sauvegarder
+  * Exécuter
+  * Fermer
+  * Rouvrir Idle3 et le programme
+  * Exécuter
+<code python>
+#!/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)
+</code>
+===== Un peu plus loin dans Python =====
+==== 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
+  * ...
+==== 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,...
+==== Listes (bis) ====
+<code python>
+>>> 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)
+
+>>> 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]]
+</code>
+==== Listes (ter) ====
+<code python>
+>>> a3[-1]
+'tomate'
+>>> a3.pop()
+'tomate'
+>>> a3
+[31, 16, 'mot', 'rouge', (1+3j), [2, 'bleu', 3.14], 121, 'vert']
+>>> a3.pop()
+'vert'
+>>> a3.pop()
+
+>>> a4=a3.pop()
+>>> a4
+[2, 'bleu', 3.14]
+>>> a3.append(19.3)
+>>> a3
+[31, 16, 'mot', 'rouge', (1+3j), 19.3]
+</code>
+==== 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.
+==== Dictionnaires (bis) ====
+<code python>
+>>> 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']
+
+>>> 'e7' in d
+False
+>>> import operator
+>>> print(sorted(d.items(), key=operator.itemgetter(1)))
+[('e5', 1), ('e3', 3), ('e1', 8), ('e2', 9), ('e4', 11)]
+>>>
+</code>
+==== 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
+==== 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, ...
+==== 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
+==== Structure conditionnelle (exemple) ====
+<code python>
+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")
+</code>
+==== 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 ===
+<code python>
+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)
+</code>
+==== 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
+==== Exemples d’indentation ====
+<code python>
+print('Table de multiplication')
+a=range(11)
+for i in a:
+    for j in a:
+        print(i*j, end = ' ')
+    print(' sont multiples de ',i)
+</code>
+==== 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
+==== Exemple de fonction ====
+<code python>
+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))
+</code>
+==== Exemple de fonction (2) ====
+<code python>
+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))
+</code>
+==== Utilisation de librairies de fonctions standard ====
+<code python>
+>>> import math
+>>> math.pi
+.141592653589793
+>>> math.cos(0)
+.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'
+</code>
+On peut modifier les noms des fonctions et la façon de les stipuler (espaces de noms) par la directive import
+==== 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
+  * ...
+==== 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 N<sup>3</sup> opérations (si N est la taille des matrices)
+Référence : [[http://fr.wikipedia.org/wiki/Algorithmique]]
+===== Pour terminer =====
+Exemples d'applications
+==== Simple, avec le module standard Turtle ====
+<code python>
+from turtle import *
+reset()
+i=0
+while i<120:
+    forward(i)
+    left(90)
+    i=i+2
+input('Hit Enter to continue')
+</code>
+==== Coloré, avec le module standard Turtle ====
+<code python>
+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')
+</code>
+==== Simple, avec l’interface graphique Tkinter ====
+<code python>
+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)
+</code>
+==== Tkinter : animation ====
+<code python 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()
+</code>
+==== tkinter : tkDemo, demonstration of Tk widgets ====
+FIXME : ? tkdemo était proposé pour la branche 2 de Python. Rechercher pour la version python 3 ?
+Voir par exemple [[https://github.com/daleathan/widget-tour-py3|ce lien]]
+==== Graphiques simples avec matplotlib ====
+<code python>
+# 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()
+</code>
+==== Calculs numériques (FFT) et graphiques plus élaborés ====
+[[teaching:progappchim:numpy_simple#transformees_de_fourier]]
+{{ :teaching:progappchim:fonctions-ft-04.png }}
+==== Graphiques et illustrations plus complexes ====
+[[teaching:progappchim:matplotlib_gallery:potentiel_morse]]
+{{:teaching:progappchim:potentiel_morse-04.png|}}
+==== pH d’un acide en fonction d’un ajout de base et d’une dilution ====
+[[teaching:progappchim:ph-3d]]
+{{:teaching:progappchim:ph_topographic-01.png|}}
+==== Calculs sur des molécules ====
+<code>methanol - Formula = CH4O
+mol wt = 32.04186 - Numb atoms = 6 - Numb bonds =
+.0107 6 C x= 0.956 y= -0.086 z= -0.056
+.9994 8 O x= 0.488 y= -1.374 z= 0.299
+.00794 1 H x= 0.587 y= 0.64 z= 0.672
+.00794 1 H x= 0.584 y= 0.177 z= -1.05
+.00794 1 H x= 2.049 y= -0.08 z= -0.052
+.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
+</code>
+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
+===== Objectifs du cours =====
+==== 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
+==== 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
+==== 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
+  * ...
+==== 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 : [[teaching:progappchim:start]]
+  * Des références générales sur Python sont regroupées à la page : [[floss :python]]