Jusqu'ici nos programmes étaient une suite d'instructions et s'exécutaient inlassablement de haut en bas :
instruction 1 instruction 2 instruction 3 ...
L'ordinateur lisait les instructions une à une et effectuait la tâche demandée. Ce n'est pas très intéressant ni pour lui ni pour nous, et heureusement il est possible de casser cette monotonie avec les instructions composées.
Les instructions composées sont des procédures qui agissent sur un ensemble d'instructions simples : le bloc d'instructions. Elles se présentent sous cette forme :
instruction composée : instruction 1 instruction 2 ...
La déclaration de l'instruction composée se termine par deux points et toutes les instructions sur lesquelles elle agit sont sous elle, décalées d'une tabulation par rapport à elle. Je marque ce dernier point car le grand intérêt des instructions composées c'est de pouvoir s'emboiter à l'infini :
instruction 1 instruction composée 1 : instruction 2 instruction 3 instruction composée 2 : instruction 4 instruction 5 instruction 6
Ici l'instruction composée 1 comprends les instructions 2 et 3 mais aussi l'instruction composée 2 et l'instruction 5, qui sont toutes sous elle et décalées d'une tabulation. L'instruction 4 est comprise dans l'instruction composée 2 et doit donc être décalée de deux tabulations. Les instructions 1 et 6 ne font quand à elle parti d'aucune instruction composées : l'instruction 1 car elle est située au-dessus de la déclaration de l'instruction composée 1, et l'instruction 6 car elle n'est pas décalée d'une tabulation.
Les instructions conditionnelles permettent comme leur nom l'indique de faire une action sous certaines conditions.
Un booléen est un type de valeur, à l'instar des entiers ou des tableaux. Sa caractéristique est de ne pouvoir prendre que deux valeurs : soit True (vrai) soit False (faux).
On peut répondre à une condition directement avec un booléen :
condition = True print condition # la condition est vraie condition = False print condition # la condition est fausse
Il est possible de comparer deux valeurs au moyen d'opérateurs de comparaison. Ces opérateurs, contrairement aux opérateurs d'affectation, ne font que retourner le résultat de la comparaison, sans modifier les valeurs.
Par exemple, pour comparer si deux valeurs sont égales, on utilise l'opérateur “==” :
print 5 == 2 # False print 5 == 5 # True print 5 == 5.5 # False print 5 == 5.0 # True print 'a' == 'b' # False print 'a' == 'a' # True
Pour comparer si une valeur est supérieure à une autre, on utilise l'opérateur “>” :
print 5 > 2 # True print 5 > 5 # False print 5.5 > 5 # True print 5 > 5.0 # False
Une liste des opérateurs est disponible ici.
Comme on peut le constater, le résultat d'une comparaison est un booléen : une comparaison est donc soit vraie, soit fausse.
On peut comparer tous les types de valeurs, toutefois certains résultats auront peu de sens : le mot tomate est-il supérieur à 2.5 ?
Il est possible de faire des conditions plus complexes à l'aide des opérateurs logiques and, or et not.
On peut dire par exemple:
La condition n'est vraie que si x est supérieur à 10 et si y est inférieur à 5 :
print 75 > 10 and 4 < 5 # True print 75 > 10 and 6 < 5 # False
La condition n'est vraie que si x est supérieur à 0 et inférieur à 20 :
print 2 > 0 and 2 < 20 # True print 33 > 0 and 33 < 20 # False
On peut dans ce cas écrire :
0 < x < 20
La condition est vraie si x est supérieur à 0 ou si y est égal à 5 :
print 5 > 0 or 6 == 5 # True print 0 > 0 or 6 == 5 # False
La condition n'est vraie que si x n'est pas supérieur à y :
print not 5 > 7 # True print not 8 > 7 # False
L'instruction if…elif…else permet de n'exécuter un ensemble d'instructions que sous certaines conditions.
On écrit, au minimum :
if condition : instruction 1 instruction 2 ...
Le mot clé if indique qu'il s'agit d'une instruction conditionnelle. Si la condition est vraie, le bloc d'instruction sera exécuté.
Il est possible de faire suivre une instruction if d'une instruction else :
if condition : instruction 1 instruction 2 else : instruction 3
Si la condition est vraie, les instructions 1 et 2 seront exécutées, sinon c'est l'instruction 3 qui sera exécutée.
Il est aussi possible d'utiliser l'instruction elif, contraction de else if :
if condition 1 : instruction 1 instruction 2 elif condition 2 : instruction 3 else : instruction 4
Si la condition 1 est vraie, les instructions 1 et 2 seront exécutées, sinon si la condition 2 est vraie, l'instruction 3 sera exécutée, sinon c'est l'instruction 4 qui sera exécutée.
Et il est possible de mettre plusieurs elif :
if condition 1 : instruction 1 instruction 2 elif condition 2 : instruction 3 elif condition 3 : instruction 4 instruction 5 else : instruction 6
Dans une pile comme celle-ci, les elif et le else sont relatifs au if qui les précèdes : leur action dépend du résultat de la première condition.
n = 5 if n > 0 : print "n est positif" elif n < 0 : print "n est négatif" else : print "n est égal à zéro"
Résultat avec n = 5 :
n est positif
Le if était vrai donc son instruction a été exécutée et le reste à été sauté.
Résultat avec n = -5 :
n est négatif
Le if était faux et a été sauté mais le elif était vrai donc son instruction a été exécutée et le else a été sauté.
Résultat avec n = 0 :
n est égal à zéro
Le if et le elif étaient faux donc l'instruction du else a été exécutée.
age = 20 if age > 0 : print "Le capitaine est né" else : print "Le capitaine n'est pas encore né" if age < 18 : print "Le capitaine est mineur" else : print "Le capitaine est majeur"
Résultat avec age = 20 :
Le capitaine est né Le capitaine est majeur
Résultat avec age = 0 :
Le capitaine n'est pas encore né Le capitaine est mineur
age = 20 if age > 0 : print "Le capitaine est né" if age < 18 : print "Le capitaine est mineur" else : "Le capitaine est majeur" else : print "Le capitaine n'est pas encore né"
Résultat avec age = 20 :
Le capitaine est né Le capitaine est majeur
Résultat avec age = 0 :
Le capitaine n'est pas encore né
import maya.cmds as mel #créer une sphère et la nommer "boule" (objet et shape) #la lier à un matériau blinn1 #récupère et affiche la position en x de l'objet boule x = mel.getAttr('boule.tx') print x if x < 0: #si x < 0 on colore la boule en rouge mel.setAttr('blinn1.color', 1,0,0) elif x > 0 : #si x > 0 on colore la boule en bleu mel.setAttr('blinn1.color',0,0,1) else : #sinon (donc si x == 0) on colore la boule en vert mel.setAttr('blinn1.color',0,1,0)
Les boucles permettent de répéter un bloc d'instructions un certain nombre de fois.
La boucle while fonctionne ainsi:
Tant que condition : fais ceci
On l'écrit ainsi:
while condition :
instructions
Comme pour les instructions conditionnelles, il faut mettre “:” après la condition et une tabulation avant les instructions.
Nous devons donc créer une condition de sortie, au moyen d'une variable s'incrémentant (dont la valeur augmente) à chaque tour:
# on crée une variable qui nous servira de compteur compteur = 0 while compteur < 10 : # tant que compteur < 10 # affiche la valeur de compteur print compteur, # ajoute 1 a compteur compteur = compteur + 1
0 1 2 3 4 5 6 7 8 9
La variable compteur s'incrémente de 1 à chaque tour de la boucle, et au moment ou elle vaut 10 la condition étant fausse la boucle s'arrête.
import maya.cmds as mel # on initialise le compteur a 0 c = 0 while c < 15 : # tant que c est inférieur à 15 # on crée un cube mel.polyCube() # et on le bouge en x et en z à la valeur de c mel.move(c,c,0) # on incrémente le compteur c = c + 1
La boucle for…in fonctionne (au plus simple), ainsi :
Pour toute valeur contenue dans cette plage de nombres : fais ceci
for valeur in range(debut,fin) : instructions
A noter que l'on peut mettre en fait tout conteneur que l'on veut à la place de range() (listes, tableaux…).
# pour chaque nombres de 257 à 260 for val in range(257,261) : print val, # affiche la valeur
257 258 259 260
# pour chaque nombres de 0 à 4 for val in range(0,5) : print val, # affiche la valeur
0 1 2 3 4
On aurait dans ce cas (affichage de x nombres depuis 0) pu écrire, de manière simplifiée:
# pour chaque nombres de 0 à 4 for val in range(5) : print val, # affiche la valeur
0 1 2 3 4
tata = 'tomate' # pour chaque élément de la chaine de caractères for val in tata : print val, # on affiche la valeur
t o m a t e
# liste de tous les objets dont le nom contiens "tomate" tata = ls('*tomate*') # pour chaque élément de la liste for val in tata : print val, # on affiche la valeur
objet_tomate objet_tomateMesh tomate_light
tata = 'tomate' # pour chaque élément du tableau for val in ['toto', 7, tata, 0.85] : print val, # affiche la valeur
toto 7 tomate 0.85
La boucle while :
La boucle for :
L'instruction break permet d'arrêter une boucle. Associé à une condition dans la boucle il permet de spécifier des conditions de sorties particulières.
for i in range(-10,11): j = 10.0/i
Error
Il y a une erreur car lorsque i deviens égal à 0, le calcul 10.0/i est impossible (divide by zero!). Pour éviter l'erreur, on peut donc utiliser l'instruction break :
for i in range(-10,11): if i == 0: break # arête la boucle si i = 0 else: j = 10.0/i print i
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1
Le code s'est bien exécuté jusqu'à ce que i prenne pour valeur 0, et une fois le break rencontré a stoppé la boucle.
L'instruction continue permet, dans une boucle, de sauter l'étape en cours.
import maya.cmds as mel for i in range(-10,11): if i == 0: continue # saute la valeur i = 0 et continue else: j = 10.0/i print i
-10 -9 -8 -7 -6 -5 -4 -3 -2 -1 1 2 3 4 5 6 7 8 9 10
Le code s'est exécuté jusqu'à ce que i prenne pour valeur 0, et une fois le continue rencontré, est directement passé au tour de boucle suivant, sans passer par la case départ et sans toucher 1000 euros.
Le try…except permet d'essayer quelque chose et, si cela fait une erreur, faire autre chose:
essaie : ça
si ça fait une erreur : fait ça
try : instructions except : instructions
Contrairement à une if associé à un continue, on n'a ici pas à se soucier à trouver l'étape qui amène l'erreur.
for i in range(-2,3): # de -2 à 2 try: #j’essaye de faire ce calcul x = 10/i print x except: # si il y a eu erreur, j’affiche ceci print "erreur sur", i
-2 -1 erreur sur 0 1 2
import maya.cmds as cmds # liste les objets dont le nom comprend "Light" lum = cmds.ls("*Light*") print lum for i in lum: try: # tester l'on peut regler l'intensite cmds.setAttr(i+".intensity") except: # sinon ce n'est pas une lumiere print i, " pas une lumiere"
pointLight1 areaLight1 lightView DefaultLightsList lightView pas une lumiere DefaultLightsList pas une lumiere
Les fonctions sont des blocs d'instructions auxquels l'on donne un nom, ce qui permet de les exécuter depuis n'importe quel endroit du programme. Tout ce qu'on utilise du type polyCube(), setAttr(), ls() sont des fonctions.
On crée une nouvelle fonction en utilisant le mot clé def (définir) suivi de son nom et de parenthèses…
def nomFonction() : instructions
…et on l'appelle simplement en criant son nom (“hé, jean-louis!”) :
nomFonction()
Comme toutes les instructions composées, ce qui fait parti de la fonction doit être indenté.
On peut par exemple faire une fonction créant un cube et le déplaçant…
def creerCube() : mel.polyCube() mel.move(10,0,0)
… et ainsi créer pleins de cubes positionnés à 10 sur x en écrivant :
creerCube() creerCube() ...
Toutefois ainsi fait cela ne sert pas à grand chose. Ce serait plus utile de pouvoir dire à ma fonction la taille de mon cube par exemple, non?
Il est possible de faire passer une/des valeur à la fonction, et c'est là que tout l'intérêt réside :
Pour que ma fonction attende un argument, par exemple la hauteur de mon cube dans ma superbe fonction creerCube, on écrira :
def creerCube(hauteur) :
Ainsi dans ma fonction, la variable hauteur peut être utilisée…
def creerCube(hauteur) : mel.polyCube(height = hauteur) mel.move(10, 0, 0)
…et elle correspondra à ce que l'on aura demandé en appelant la fonction :
creerCube(hauteur = 10) creerCube(hauteur = 50)
Pour définir plusieurs arguments séparez-les simplement par une virgule en créant la fonction. Par exemple rajoutons un argument position à notre fonction :
# création de la fonction def creerCube(hauteur, position) : mel.polyCube(height = hauteur) mel.move(position, 0, 0) # appel de la fonction creerCube(hauteur = 10, position = 10) creerCube(hauteur = 50, position = 5)
A noter que l'on n'est pas obligé d'indiquer le nom de l'argument lorsqu'on appelle la fonction :
creerCube(10,20) creerCube(50,10)
Toutefois dans ce cas l'ordre des arguments (s'il y en a plusieurs) doit nécessairement être respecté.
On peut vouloir un argument sans qu'il soit obligatoire, comme par exemple… la position du cube de la fonction creerCube. On écrira alors :
def creerCube(hauteur, position = 10) : mel.polyCube(n='monCube',height=hauteur) mel.move(position,0,0)
Ainsi au cas ou l'argument position n'est pas fourni, la fonction lui donnera une valeur de 10 :
# crée un cube de hauteur 5, à la position par défaut creerCube(hauteur = 5) # crée un cube de hauteur 5, à la position 20 creerCube(hauteur = 5, position = 20)
Il est aussi possible de définir qu'une fonction peut prendre n'importe quel nombre d'arguments. Pour cela, dans la définition de la fonction on écrira :
def fonction(&args) :
fonction(1,2,3,4) # args = (1,2,3,4)
Le & devant la variable indique que toutes les valeurs qui seront données lors de l'appel de la fonction devront être stockées dans une liste nommée ici args.
Cet argument illimité peut être utilisé conjointement avec des arguments habituels…
def fonction(a, &args) :
fonction(1,2,3,4) # a = 1 et args = (2,3,4)
…et avec des arguments optionnels :
def fonction(a, b = 0, &args) :
fonction(1) # a = 1 et b = 0 fonction(1,2) # a = 1 et b = 2 fonction(1,2,3,4) # a = 1, b = 2 et args = (3,4)
Quand vous créez vos fonctions il est indispensables de les expliquer, les documenter. Une fonction est faite pour pouvoir être réutilisées plus tard, être utilisée par quelqu'un d'autre, être vendue au M.I.T., etc… Chercher l'utilité et le le fonctionnement de maFonctionNumero53 pendant des heures peut s'avérer frustrant.
Donc, pour la documenter on ajoute un petit commentaire au début expliquant à quoi elle sert, c'est ce que l'on appelle une docstring :
def creerCube(hauteur, position = 10) : """ Crée un cube avec une hauteur spécifiée et a une position en x spécifiée """ mel.polyCube(n='monCube',height=hauteur) mel.move(position,0,0)
Ce commentaire doit être placé à cet endroit, entre triples guillements. Des programmes permettent ensuite de scanner un code source pour créer et mettre en page automatiquement une documentation de toutes ses fonctions, d'où le nom docstring (doc from string).
Cette fonction crée une ligne de colonnes du nombre voulu, à la taille voulue, espacée d'une distance voulue:
import maya.cmds as mel def ligneColonnes(n, hauteur, espacement) : """ Crée n colonnes cotes à cotes, de hauteur et espacement spécifiés. """ for i in(n) : # fais ceci n fois # crée un cube de hauteur donnée mel.polyCube(h = hauteur) # le déplace selon l'espacement donné mel.move(i * espacement, 0, 0) # exécute la fonction ligneColonnes(nombre = 10, hauteur = 5, espacement = 2)
Si vous avez des questions, des remarques, des suggestions, n'hésitez pas à m'en faire part.
~~DISCUSSION~~