teaching:progappchim:presentation_principes

Différences

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

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision
Révision précédente
teaching:progappchim:presentation_principes [2017/02/07 09:19] villersdteaching:progappchim:presentation_principes [2023/02/21 14:56] (Version actuelle) villersd
Ligne 32: Ligne 32:
 <WRAP group> <WRAP group>
 <WRAP half column> <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=>operationRésultat 
-</diagram>+   
 +  box1->box2->box3 
 +</flowchartjs>
 </WRAP> </WRAP>
 <WRAP half column> <WRAP half column>
Ligne 50: Ligne 52:
 <WRAP group> <WRAP group>
 <WRAP half column> <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=>operationRésultat 
-</diagram>+   
 +  box1->box2 
 +</flowchartjs>
 </WRAP> </WRAP>
 <WRAP half column> <WRAP half column>
Ligne 69: Ligne 73:
 <WRAP group> <WRAP group>
 <WRAP half column> <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=>operationRésultat 
-</diagram>+   
 +  box1->box2->box3 
 +</flowchartjs>
 </WRAP> </WRAP>
 <WRAP half column> <WRAP half column>
Ligne 156: Ligne 162:
 >>> >>>
 </code> </code>
-  * Commandes : copyrigth, credits, license(), quit, help, help(),...+  * Commandes : copyright, credits, license(), quit, help, help(),...
  
 ==== Notion de variable ==== ==== Notion de variable ====
Ligne 165: Ligne 171:
 >>> V=24*L >>> V=24*L
 >>> n=1 >>> n=1
->>> zero=273.16+>>> zero=273.15
 >>> T=20+zero >>> T=20+zero
 >>> P=n*R*T/V >>> P=n*R*T/V
Ligne 184: Ligne 190:
 669 669
 >>> 12356*458955 >>> 12356*458955
-5670847980L+5670847980
 >>> 123*456 >>> 123*456
 56088 56088
Ligne 209: Ligne 215:
 >>> Navogadro=6.02214199E23 >>> Navogadro=6.02214199E23
 >>> kboltzmann=1.3806505E-23 >>> kboltzmann=1.3806505E-23
->>> print Navogadro*kboltzmann+>>> print(Navogadro*kboltzmann)
 8.31447334956 8.31447334956
 >>> 2**0.5 >>> 2**0.5
Ligne 253: Ligne 259:
 >>> b="bonjour" >>> b="bonjour"
 >>> c=’Bonjour’ >>> c=’Bonjour’
->>> print a==b,a==c+>>> print(a==b,a==c)
 True False True False
 >>> d="pâté123#" >>> d="pâté123#"
Ligne 273: Ligne 279:
 ==== Opérations sur les chaînes ==== ==== Opérations sur les chaînes ====
 <code> <code>
->>> s=Mons, le 15 septembre 2009+>>> s='Mons, le 15 septembre 2009'  
 >>> s[8:] >>> s[8:]
-’ 15 septembre 2009 +15 septembre 2009' 
->>> s.find(le)+>>> s.find('le')
 6 6
 >>> s.split() >>> s.split()
-[Mons,le15septembre2009]+['Mons,''le''15''septembre''2009']
 >>> s.upper() >>> s.upper()
-MONS, LE 15 SEPTEMBRE 2009+'MONS, LE 15 SEPTEMBRE 2009'
 >>> s.replace(’ ’,’_’) >>> s.replace(’ ’,’_’)
-Mons,_le_15_septembre_2009+'Mons,_le_15_septembre_2009'
 >>> >>>
 </code> </code>
Ligne 323: Ligne 329:
   * nombreuses manipulations possibles (opérations, méthodes) : accéder, concaténer, trier, compléter, rechercher, réduire,...   * nombreuses manipulations possibles (opérations, méthodes) : accéder, concaténer, trier, compléter, rechercher, réduire,...
  
-==== Listes ====+==== Listes (bis) ====
 <code python> <code python>
 >>> a1 = [31, 16, 'mot','rouge', 1+3j, [2, 'bleu', 3.14]] >>> a1 = [31, 16, 'mot','rouge', 1+3j, [2, 'bleu', 3.14]]
Ligne 344: Ligne 350:
 </code> </code>
  
-==== Listes ====+==== Listes (ter) ====
 <code python> <code python>
 >>> a3[-1] >>> a3[-1]
Ligne 372: Ligne 378:
   * Les paires clés :valeurs sont séparées par des virgules et le tout encadré par une paire d’accolades {} forme le dictionnaire.   * 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 ====+==== Dictionnaires (bis) ====
 <code python> <code python>
 >>> d = {'e1': 8, 'e2': 9, 'e4': 11, 'e3': 3, 'e5' : 1} >>> d = {'e1': 8, 'e2': 9, 'e4': 11, 'e3': 3, 'e5' : 1}
Ligne 388: Ligne 394:
 >>>  >>> 
 </code> </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
 +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'
 +</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 =
 +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
 +</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]]
  
  • teaching/progappchim/presentation_principes.1486455540.txt.gz
  • Dernière modification : 2017/02/07 09:19
  • de villersd