Python: Règles syntaxiques, blocs: Difference between revisions

From Wiki Cours
Jump to navigation Jump to search
 
(21 intermediate revisions by the same user not shown)
Line 1: Line 1:
__NOTOC__
[[Memento_Python|<--Sommaire]]
== Structuration et notion de bloc ==


== Notion de bloc ==
En Python, chaque instruction s'écrit sur une ligne sans mettre d'espace:
<source lang=python>
a = 10
b = 3
print(a, b)
</source>
Les instructions simples peuvent cependant être mises sur la même ligne en les séparant par des points virgules ''';''', les lignes étant exécutées dans l'ordre de gauche à droite:
<source lang=python>
a = 10; b = 3; print(a, b)
</source>


En Python, la séparation entre les 'en-tête's qui sont des lignes de définition de boucles, de fonction, de classe et le contenu ou 'bloc' d'instructions correspondant se fait par '''indentation''' des lignes. Une indentation s'obtient par le bouton correspondant sur le clavier (avec deux flèches à gauche) ou bien par 4 espaces successifs.  
De plus, la séparation entre les 'en-tête's qui sont des lignes de définition de boucles, de fonction, de classe qui se terminent par les deux points ''':''' et le contenu ou 'bloc' d'instructions correspondant se fait par '''indentation''' des lignes. Une indentation s'obtient par le bouton '''tab''' (pour tabulation) correspondant sur le clavier (bouton  à gauche avec deux flèches) ou bien par 4 espaces successifs.  


Un programme python se structurera donc typiquement sous la forme:
Un programme python se structurera donc typiquement sous la forme:
<source lang=python>
<source lang=python>
ligne-bloc
instruction-1
 
en-tête-1:
en-tête-1:
    instruction-2
    instruction-2
     en-tête-2:
     en-tête-2:
         ligne-bloc
         instruction-3
         ligne-bloc
         instruction-3
     en-tête-2:
     en-tête-2:
         ligne-bloc
         instruction-3
         ligne-bloc
         instruction-3
     ligne-bloc
     instruction-2
     ligne-bloc
     instruction-2
 
instruction-1
ligne-bloc
instruction-1
ligne-bloc
</source>
</source>
Par exemple:
Par exemple:
Line 25: Line 37:
def inverse(x):
def inverse(x):
     if x == 0.0:
     if x == 0.0:
         return 'inf'
         return 'Inf'
     else:
     else:
         return 1./x
         return 1./x


inverse(1.34)
print(inverse(1.34), inverse(0.0))
inverse(0.0)
</source>
Le bloc global constitue également un module appelé __main__
 
== Les lignes trop longues ==
 
Il peut arriver que les expressions sur une ligne deviennent trop longue pour une bonne lisibilité du code ou tout simplement pour améliorer la lisibilité du code.
Il est alors possible de poursuivre les instructions en utilisant le symbole '\' (le symbole '\n' signifie retour à la ligne):
<source lang=python>
labamba = "Para bailar la bamba,\n" \
          "Para bailar la bamba,\n" \
          "Se necesita una poca de gracia.\n" \
          "Una poca de gracia pa mi pa ti."
print(labamba)
 
from math import exp, sin, log
a = lambda x: exp( - sin( x) / x ) * log(x + 1) \
              + sin(x) / exp(x) \
              - 2
</source>
Remarque ces deux autres solutions possibles pour le texte:
<source lang=python>
labamba = "Para bailar la bamba,\n\
Para bailar la bamba,\n\
Se necesita una poca de gracia.\n\
Una poca de gracia pa mi pa ti."
 
labamba = """Para bailar la bamba,
Para bailar la bamba,
Se necesita una poca de gracia.
Una poca de gracia pa mi pa ti."""
</source>
Chacun choisira se version préférée selon ses goûts, mais la dernière est probablement la plus claire pour du texte.
 
== Commentaires ==
 
Tout ce qui est écrit après le symbole '''#''' ne sera pas lu par l'interpréteur.
Cela permet d'introduire des commentaires explicatifs dans la source même du programme.
<source lang=python>
# voici une affectation
a = 10 # ou alors on aurait pu mettre b = 10
</source>
Pour commenter plusieurs ligne, il y a une solution inélégante et plutôt à éviter qui consiste à utiliser les trois guillemets habituellement réservés à la documentation des fonctions, des classes ou des modules.
<source lang=python>
a = 10
"""
a -= 2
a *= 10
"""
a += 1
</source>
Si on veut omettre une partie du code, on peut le faire précéder par un test faux puis le transformer en test vrai pour l'activer mais ce n'est pas très élégant
<source lang=python>
a = 10
if False:
    print(a+1)
if True:
    print(a+2)
</source>
Une dernière astuce, dans un script, est la possibilité
<source lang=python>
...
...
quit()
... # les lignes en dessous ne seront pas exécutées
...
 
</source>
</source>


Line 36: Line 113:


Ces mots ont une signification dans le langage et ne peuvent être utilisés pour des noms de variables, de fonctions, etc...
Ces mots ont une signification dans le langage et ne peuvent être utilisés pour des noms de variables, de fonctions, etc...
{{Div col|cols=3}}
 
*<code>and</code>
<code>and</code> ,<code>as</code>
*<code>as</code>
,<code>assert</code>
*<code>assert</code>
,<code>break</code>
*<code>break</code>
,<code>class</code>
*<code>class</code>
,<code>continue</code>
*<code>continue</code>
,<code>def</code>
*<code>def</code>
,<code>del</code>
*<code>del</code>
,<code>elif</code>
*<code>elif</code>
,<code>else</code>
*<code>else</code>
,<code>except</code>
*<code>except</code>
,<code>exec</code>
*<code>exec</code>{{refn|group=note|name=noLongerReservedFrom3|Starting from Python 3, <code>exec</code> and <code>print</code> are functions, so they are not keywords anymore.}}
,<code>False</code>
*<code>False</code>{{refn|group=note|name=keywordIn3|Starting from Python 3, keywords <code>True</code>, <code>False</code> and <code>nonlocal</code> were introduced.}}
,<code>finally</code>
*<code>finally</code>
,<code>for</code>
*<code>for</code>
,<code>from</code>
*<code>from</code>
,<code>global</code>
*<code>global</code>
,<code>if</code>
*<code>if</code>
,<code>import</code>
*<code>import</code>
,<code>in</code>
*<code>in</code>
,<code>is</code>
*<code>is</code>
,<code>lambda</code>
*<code>lambda</code>
,<code>None</code>
*<code>None</code>
,<code>nonlocal</code>
*<code>nonlocal</code>{{refn|group=note|name=keywordIn3}}
,<code>not</code>
*<code>not</code>
,<code>or</code>
*<code>or</code>
,<code>pass</code>
*<code>pass</code>
,<code>print</code>
*<code>print</code>{{refn|group=note|name=noLongerReservedFrom3}}
,<code>raise</code>
*<code>raise</code>
,<code>return</code>
*<code>return</code>
,<code>True</code>
*<code>True</code>{{refn|group=note|name=keywordIn3}}
,<code>try</code>
*<code>try</code>
,<code>while</code>
*<code>while</code>
,<code>with</code>
*<code>with</code>
,<code>yield</code>
*<code>yield</code>
{{Div col end}}

Latest revision as of 11:25, 15 September 2016

<--Sommaire

Structuration et notion de bloc

En Python, chaque instruction s'écrit sur une ligne sans mettre d'espace:

a = 10
b = 3
print(a, b)

Les instructions simples peuvent cependant être mises sur la même ligne en les séparant par des points virgules ;, les lignes étant exécutées dans l'ordre de gauche à droite:

a = 10; b = 3; print(a, b)

De plus, la séparation entre les 'en-tête's qui sont des lignes de définition de boucles, de fonction, de classe qui se terminent par les deux points : et le contenu ou 'bloc' d'instructions correspondant se fait par indentation des lignes. Une indentation s'obtient par le bouton tab (pour tabulation) correspondant sur le clavier (bouton à gauche avec deux flèches) ou bien par 4 espaces successifs.

Un programme python se structurera donc typiquement sous la forme:

instruction-1
en-tête-1:
    instruction-2
    instruction-2
    en-tête-2:
        instruction-3
        instruction-3
    en-tête-2:
        instruction-3
        instruction-3
    instruction-2
    instruction-2
instruction-1
instruction-1

Par exemple:

def inverse(x):
    if x == 0.0:
        return 'Inf'
    else:
        return 1./x

print(inverse(1.34), inverse(0.0))

Le bloc global constitue également un module appelé __main__

Les lignes trop longues

Il peut arriver que les expressions sur une ligne deviennent trop longue pour une bonne lisibilité du code ou tout simplement pour améliorer la lisibilité du code. Il est alors possible de poursuivre les instructions en utilisant le symbole '\' (le symbole '\n' signifie retour à la ligne):

labamba = "Para bailar la bamba,\n" \
          "Para bailar la bamba,\n" \
          "Se necesita una poca de gracia.\n" \
          "Una poca de gracia pa mi pa ti."
print(labamba)

from math import exp, sin, log
a = lambda x: exp( - sin( x) / x ) * log(x + 1) \
              + sin(x) / exp(x) \
              - 2

Remarque ces deux autres solutions possibles pour le texte:

labamba = "Para bailar la bamba,\n\
Para bailar la bamba,\n\
Se necesita una poca de gracia.\n\
Una poca de gracia pa mi pa ti."

labamba = """Para bailar la bamba,
Para bailar la bamba,
Se necesita una poca de gracia.
Una poca de gracia pa mi pa ti."""

Chacun choisira se version préférée selon ses goûts, mais la dernière est probablement la plus claire pour du texte.

Commentaires

Tout ce qui est écrit après le symbole # ne sera pas lu par l'interpréteur. Cela permet d'introduire des commentaires explicatifs dans la source même du programme.

# voici une affectation
a = 10 # ou alors on aurait pu mettre b = 10

Pour commenter plusieurs ligne, il y a une solution inélégante et plutôt à éviter qui consiste à utiliser les trois guillemets habituellement réservés à la documentation des fonctions, des classes ou des modules.

a = 10
"""
a -= 2
a *= 10
"""
a += 1

Si on veut omettre une partie du code, on peut le faire précéder par un test faux puis le transformer en test vrai pour l'activer mais ce n'est pas très élégant

a = 10
if False:
    print(a+1)
if True:
    print(a+2)

Une dernière astuce, dans un script, est la possibilité

...
...
quit()
... # les lignes en dessous ne seront pas exécutées
...

Mots-clé réservés

Ces mots ont une signification dans le langage et ne peuvent être utilisés pour des noms de variables, de fonctions, etc...

and ,as ,assert ,break ,class ,continue ,def ,del ,elif ,else ,except ,exec ,False ,finally ,for ,from ,global ,if ,import ,in ,is ,lambda ,None ,nonlocal ,not ,or ,pass ,print ,raise ,return ,True ,try ,while ,with ,yield