Skip to main content

Syntaxe de base de Python (avec exemples)

Python est similaire aux langages de la "famille C", mais il existe des différences significatives et des propriétés uniques.

La différence syntaxique la plus évidente entre Python et des langages tels que C et ST est que l'analyseur Python reconnaît les structures de blocs par leur indentation. Il n'y a pas BEGIN/END ou bretelles {} pour identifier les blocs de IF/ELSE les conditions, FOR et WHILE boucles ou fonctions.

Les commentaires commencent par # et s'étendre jusqu'à la fin de la ligne. Dans la première et la deuxième ligne du code source, vous pouvez définir un marqueur spécial pour déclarer l'encodage du fichier. Nous vous recommandons d'utiliser UTF-8 comme encodage si les caractères ASCII ne sont pas requis.

À des fins de débogage, vous utilisez print pour une sortie facile. Avec le % opérateur, vous obtenez une fonctionnalité similaire à la fonction C printf(). La sortie est affichée dans la vue des messages de CODESYS.

Exemple 4. Exemple: print
# encoding:utf-8

# defining a function with the parameter i
def do_something(i):
    # if branch
    if i>0:
        print("The value is: %i" % i)
                                                                sum += i
        print("The new sum is: %i" % sum)

    # else if (optional, there can be none or several elif branches)
    elif i=0:
        print("The sum did not change: %i" % sum)

    # and the final else branch (also optional).
    else:
        handle_error()

# an endless while loop
while True:
    print("I got stuck forever!")


Tout ce qui appartient au même bloc doit être en retrait de la même distance. La taille de l'indentation n'a pas d'importance. Les éléments tels que les crochets et les accolades ont une priorité plus élevée que les indentations. Par conséquent, le segment de code suivant est tout à fait correct, même s'il est écrit dans un "style de programmation médiocre":

Exemple 5. Exemple : Indentation
# warning: bad style below. Kids, don't try this at home!
if foo >= bar:
               print("foobar")
else:
    print(
          "barfoo"
)


Pour éviter toute ambiguïté, vous ne devez pas mélanger les tabulations et les espaces dans un fichier.

Astuce

À l'heure actuelle, mélanger des tabulations et des espaces dorés dans Python 3 est considéré comme une erreur de syntaxe.

Le guide de style Python officiel recommande une indentation de quatre espaces et inclut quelques exemples de style bon et mauvais. Le didacticiel Python fournit un résumé du style de codage.

Python est "sensible à la casse", similaire à C et contrairement à ST. Mots-clés, tels que def, if, else, et while, doivent être en minuscules (contrairement à la règle ST : les mots clés sont en majuscules). Deux identifiants, tels que "i" et "I", identifient également deux variables différentes.

Les mots-clés suivants sont réservés en Python et ne peuvent pas être utilisés comme identificateurs de variables, fonctions, etc. : and | as | assert | break | class | continue | def | del | elif | else | except | exec | finally | for | from | global | if | import | in | is | lambda | not | or | pass | print | raise | return | try | while | with | yield.

Python 3 a défini quatre autres mots-clés : False | None | True | nonlocal. Alors que les trois premiers sont vraiment nouveaux, les trois premiers étaient déjà des constantes prédéfinies dans Python 2 et ne doivent pas être utilisés à d'autres fins.

Pour plus d'informations, consultez : Guide de style Python et Tutoriel Python

Variables et types de données

Python est un langage puissant à typage dynamique -- toutes les informations de type sont évaluées au moment de l'exécution. Les variables contiennent des références à des objets, et l'objet connaît son type, pas la variable. Lorsqu'un programmeur tente d'exécuter une opération qui n'est pas possible (par exemple, ajouter un entier et une chaîne), Python lève une exception lors de l'exécution.

Par conséquent, il n'y a pas de déclarations de variables et de leurs types. En Python, les variables sont créées uniquement pour leur attribuer des valeurs. C'est complètement différent en C et ST où les types sont forts et statiques. Chaque variable est déclarée avec un type, et au moment de la compilation, le compilateur vérifie que le type et les opérateurs sont autorisés.

Consultez les exemples suivants pour gérer les variables :

Exemple 6. Exemple : Variables
# assign the integer 1 to the variable i (also "creates" the variable")
i = 1

# assign the string "foobar" to the variable s
s = "foobar"

# Add 5 to the integer i - this is equivalent to i = i + 5
i += 5
# i now holds the integer 6.

# Try to add i and s - this will throw an exception when executed
# TypeError: unsupported operand type(s) for +: 'int' and 'str'
result = i + s

# variables can also be "undeclared" by deleting them.
# Further access to the variable i will throw a NameError exception,
# as the variable does not exist any more.
del i

i += 5 # now throws an exception: NameError: name 'i' is not defined


Toutes les variables existantes font référence à une seule valeur. Il n'y a pas de variables non affectées ou non initialisées en Python. Pour exprimer l'absence de valeur, Python fournit un objet spécial : None. En C ou ST, vous utiliseriez un pointeur nul. Son seul but est d'exprimer "aucune valeur ici", bien que None est en fait une instance existante de la classe NoneType.

Types numériques et virgules flottantes

Contrairement aux dizaines de types entiers dans IEC ou C, il n'y a qu'un seul type entier en Python. Les types entiers en Python n'ont pas de taille fixe. Au lieu de cela, ils grandissent selon les besoins et ne sont limités que par la mémoire disponible.

Exemple 7. Exemple: Integers.py
from __future__ import print_function

i = 1
print(i)

j = 0x1234   # hex number, is 16#1234 in IEC and 4660 in decimal
k = 0o123    # octal number, is 8#123 in IEC and 83 decimal
l = 0b101010 # binary number, is 2#101010 in IEC and 42 in decimal
print(j, k, l)

m = (2 + 3)*10 # k is 50 now
print(m)

n = 10 ** 100 # 10 to the power of 100
print(n)

Sortie résultante :

_cds_script_messages_integers.png


Il n'y a également qu'un seul type à virgule flottante en Python qui est similaire au type de données IEC LREAL. Il fournit une arithmétique à virgule flottante IEEE 64 bits.

La syntaxe est similaire aux langages basés sur C pour la plupart :

Exemple 8. Exemple : Types à virgule flottante
# A simple float...
a = 123.456

# A float containing the integral value 2
b = 2.

# Leading zeroes can be left off
c = .3 # same as 0.3

# Exponential / scientific representation
d = -123e-5


Deux cas particuliers sont True et False, deux constantes qui définissent les valeurs de vérité booléennes. Ils se comportent de la même manière que les valeurs entières 0 et 1, sauf lorsqu'ils sont convertis en chaînes et renvoient leurs noms.

Exemple 9. Exemple: Booleans.py
# booleans behave like integers, except when converted to strings.
# The built-in function "type" can be used to query the type of a value.
print("True:  ", True, type(True))
print("False: ", False, type(False))
print("1:     ", 1, type(1))
print("False + 0: ", False + 0, type(False + 0))
print("True * 5: ", True * 5, type(True * 5))

Sortie résultante :

_cds_script_messages_booleans.png


Cordes

Dans IronPython, les chaînes sont toujours en Unicode et de n'importe quelle longueur. Cela ne fait aucune différence s'ils sont enfermés dans ' ou ". Les chaînes peuvent également avoir des guillemets triples """ ou ''', qui autorise les littéraux de chaîne multilignes.

Semblable à C, les caractères spéciaux peuvent être exclus au moyen de caractères de barre oblique inverse. A titre de comparaison, le signe dollar ($) est utilisé dans la CEI à cette fin.

Il existe également des chaînes brutes qui ont d'autres règles pour la barre oblique inverse. Ceci est pratique lorsque la chaîne doit avoir des barres obliques inverses littérales. Exemple : chemins de fichiers Windows ou expressions régulières.

Exemple 10. Exemple: Strings.py
# encoding:utf-8
from __future__ import print_function

a = "a simple string"
b = 'another string'
c = "strings may contain 'quotes' of the other type."
d = "multiple string literals" ' are concatenated ' '''by the parser'''
e = "Escaping: quotes: \" \' backslash: \\ newline: \r\n ascii code: \x40"
f = """triple-quoted strings may contain newlines, "single"
'quotes' and '''multiquotes''' of the other type"""
g = "Üňíçǿđȩ is also possible: 北京, Москва, Αθήνα, القاهرة"
h = r"c:\raw\strings\retain\backslashes.txt"

# we iterate over a sequence of all the variables defined above:
for i in (a,b,c,d,e,f,g,h):
    print(i) # prints the contents of the variable

Sortie résultante :

_cds_script_messages_strings.png


Python n'a pas de types de caractères. Les caractères sont exprimés par l'utilisation de chaînes d'une longueur de 1. De cette manière, l'itération via une chaîne, ou l'indexation dans une chaîne, renvoie une chaîne unique.

Listes et tuples (ensembles de données)

Les listes et les tuples correspondent essentiellement aux tableaux en C et CEI, mais il existe quelques différences notables :

  • L'accès à l'index est toujours vérifié. L'accès à une liste ou à un tuple avec un index invalide lève une exception.

  • Les listes et les tuples peuvent contenir des éléments de différents types (également d'autres listes et tuples). Contrairement au C et à l'IEC, les tableaux ne peuvent contenir que des éléments d'un seul type.

  • Les listes sont dynamiques et des éléments peuvent être ajoutés, supprimés ou remplacés à tout moment.

  • Les tuples ne sont pas modifiables : une fois qu'un tuple est créé, il ne peut plus être modifié.

Les listes sont créées avec le list() constructeur. Comme alternative, vous pouvez utiliser des parenthèses []. Les tuples sont créés avec le tuple() constructeur ou parenthèses ().

Exemple 11. Exemple: list_tuples.py
from __future__ import print_function
print("Testing tuples and lists")

# We define a tuple with the numbers from 1 to 10:
t = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print("Tuple:", t)

# We can access the 6th element of the tuple.
# As in C, index counting starts with 0.
print("Element 5:", t[5])

# Subscription is more powerful using the range syntax:
print("Range[2:5]:", t[2:5]) # lower bound is inclusive, upper bound is exclusive.
print("Range[2::2]:", t[2::2]) # start with 3rd element, and print every 2nd element.
print("Range[-3:-1]:", t[-3:-1]) # Start with the 3rd last element, end just before the last element (upper bound is exclusive)
print("Range[::-1]:", t[::-1]) # negative step with - print backwards

# lists are similar to tuples...
l = [11, 12, 13, "8", t] # contains mixed types: 3 integers, a string, and the tuple defined above.
print("List:", l)

# ... but elements can be added or removed dynamically.
l.append(9) # Add a 9 to the list.
print("List with 9:", l)
print("List Range[3:6:2]:", l[3:6:2]) # print the 4th and 6th element.

del l[1] # remove the element at index 1, the 12.
print("Removed[1]:", l)
del l[1:3] # Remove the elements at index 1 and 2, the 13 and the '8'.
print("Removed[1:3]:", l)

Sortie résultante :

_cds_script_messages_list_tuples.png


Dictionnaire

Python a également un type de table de hachage (également "hashmap"). Contrairement à la liste, elle peut être indexée avec n'importe quel élément, par exemple des chaînes. Son constructeur est dict() et ses littéraux sont déclarés avec des accolades {}.

L'exemple de scénario dictionaries.py crée la sortie affichée ci-dessous. Dans la dernière ligne, le script se termine par une exception "KeyError":

Exemple 12. Exemple: dictionaries.py
from __future__ import print_function
print("Testing dictionaries")

# Declare a dictionary with three entries, the third being a list
d = {1: "a", 2: "b", "my list": [1, 2, 3]}
print(d)

# print the value of the key 1
print(d[1])

# remove the value with the key "my list"
del d["my list"]

# Add a value 4 with the key 3
d[3] = 4
print(d)

# The "get" method returns the second argument if the key cannot be found.
print(d.get(1, 42))
print(d.get(23, 42))

# print all keys in the dictionary
for key in d:
    print(key)

# index access for unknown keys will throw a "KeyError" exception!
print(d[23])

Sortie résultante :

_cds_script_messages_dictionaries.png

Et puis dans la dernière ligne, le script se termine :

_cds_script_dictionaries_keyerror.png

Clique le Détails bouton pour afficher la trace de la pile. Ici, vous déterminez le numéro de ligne 27 et la clé inconnue 23.

_cds_script_dictionaries_keyerror_details.png