Bonjour tout le monde,

Depuis pas mal de temps, je développe un jeu vidéo grâce au moteur de jeu Blender (en python). Depuis que je le développe, j'ai des interrogations que j'ai laissé en suspend, pensant que le temps n'était pas encore venu de les poser.

À présent, je les poses, car je vois qu'il me manque des infos ou des bon réflexes.

•     Les scripts python en général: Récemment, on m'a dit qu'il fallait respecter une largeur de 100 lignes/scripts. Est-ce vraiment nécessaire ?

•     Les classes: Je ne comprends pas le cas d'application de ceux-ci. À quel moment devrai-je estimer devoir les utiliser ?

Ensuite, un petit script de mon projet:

def joue_son(path, son, vol):
    if obj['son']:
        factory = aud.Factory(gl.expandPath(path) + son + '.mp3')
        device = aud.device()
        device.volume = vol
        #handle = device.play(factory)
        # stockage buffer pour utilisation régulière
        factory_buffered = aud.Factory.buffer(factory)
        handle_buffered = device.play(factory_buffered)
        # fin impulsion
        #handle.stop()
        #handle_buffered.stop()
        obj['son'] = False

def joue_son_reverse(path, son, vol):
    if obj['son']:
        factory = aud.Factory(gl.expandPath(path) + son + '.mp3')
        factory.reverse()
        device = aud.device()
        device.volume = vol
        
        factory_buffered = aud.Factory.buffer(factory)
        handle_buffered = device.play(factory_buffered)
        obj['son'] = False

def joue_son2(path, son, vol):
    factory = aud.Factory(gl.expandPath(path) + son + '.mp3')
    device = aud.device()
    device.volume = vol

    factory_buffered = aud.Factory.buffer(factory)
    handle_buffered = device.play(factory_buffered)

Comme vous le voyez, ces fonctions se ressemble à peu près. Je souhaiterai savoir si il est possible d'optimiser tout ça en une seule fonction au minimum. Par exemple, est-ce possible d'intercaler "factory.reverse()" de façon... dynamique ?

if cont.sensors['rot_arc'].positive:
        if cont.sensors['rot_arc'].hitObject.name == 'dist haut':
            if obj['roty'] < 80:
                obj['roty'] += 5
                scene.objects['Empty_arc'].applyRotation([0, 0.1, 0], True)
                
        elif cont.sensors['rot_arc'].hitObject.name == 'dist bas':
            if obj['roty'] > 0:
                obj['roty'] -= 5
                scene.objects['Empty_arc'].applyRotation([0, -0.1, 0], True)
        
        if dico['type mouvement'] == 'monture':
            if cont.sensors['rot_arc'].hitObject.name == 'dist_droite':
                if obj['rotx'] > 0:
                    obj['rotx'] -= 2
                    scene.objects['Empty_arc'].applyRotation([0, 0, -0.1], False)
            
            elif cont.sensors['rot_arc'].hitObject.name == 'dist_gauche':
                if obj['rotx'] < 160:
                    obj['rotx'] += 2
                    scene.objects['Empty_arc'].applyRotation([0, 0, 0.1], False)

Est-ce possible de pouvoir changer d'opérateur de façon dynamique ?

Si vous avez besoin de plus de détails, faites-le moi savoir.

-
Edité par RedstarBelgium 18 mai 2018 à 11:30:22

> Les scripts python en général: Récemment, on m'a dit qu'il fallait respecter une largeur de 100 lignes/scripts. Est-ce vraiment nécessaire ?

Non.

D'une facon générale il faut se méfier de ce genre de règles un peu gratuites: sans la justification qui vient avec, les règles ne valent rien.

La seule chose qui soit réellement limité dans un code python, et encore c'est juste une convention, c'est la largeur des lignes qui ne devrait pas dépasser 80 caractères. La raison à cela, c'est parce qu'un code présenté de cette façon est généralement plus confortable à lire : les yeux n'on pas besoin de trop bouger de gauche à droite, et les lignes courtes sont généralement plus simples, donc plus faciles à comprendre au premier coup d'oeil.

> Les classes: Je ne comprends pas le cas d'application de ceux-ci. À quel moment devrai-je estimer devoir les utiliser ?

Y'a pas de bon ou de mauvais moment. Ou plutôt, c'est d'abord une question de bon sens : si tu arrives à t'y retrouver dans un code procédural dans lequel il n'y a pas de classe, alors tu n'as pas besoin des classes. Il n'y a rien qu'on puisse faire avec des classes et pas sans, et inversement.

La différence tient juste dans la manière dont tu as pensé ton code, et il vaut mieux un code procédural bien pensé qu'un code orienté objet bâclé.

Si tu ne saisis pas l'intérêt d'avoir des objets à manipuler (donc des classes qui définissent ces objets), alors c'est qu'il est probablement encore trop tôt pour que ça soit utile de te poser cette question.

-
Edité par nohar 17 avril 2018 à 19:02:35

Hey, pour l'optimisation des fonctions de son, ça peut sans doute se faire assez facilement. Déjà, "jouer_son" et "jouer_son_reverse" font exactement la même chose, mis à part que la deuxième inverse le son. Tu peux donc ajouter à la fonction un argument "reverse" qui vaudrait true ou false. S'il vaut true, tu inverse le son, sinon tu ne fais rien. La dernière fonction, enfin fait la même chose que la première mais sans la condition if obj['son']. Donc soit tu intercale cette condition hors de la fonction, soit tu ajoutes un dernier argument qui indique si cette condition doit être vérifiée.

Encore désolé pour la présentation vraiment dégueu, je ne suis pas sur ordi, je ne peux pas te montrer des exemples de code.

D'accord, nohar. Merci.

D'accord, Nicolas, je vois ce que tu veux dire, j'y ai pas pensé... .

Une nouvelle question:

• Dans quoi dois-je faire attention pour optimiser un script point de vue performance ? Par exemple, on m'avait conseillé de mettre des array (des listes) dans une variable globale (dans un dictionnaire, par exemple) plutôt que dans mon code...

from random import choice

if test:
   variable = choice([0, 1, 2, 3])
   test = False

-
Edité par RedstarBelgium 17 avril 2018 à 19:42:44

Bonjour,

Je me pose une question suite à mon projet. Actuellement, j'ai plusieurs scripts pythons qui ont chacun leurs rôles bien spécifique mais ils dépendent tous du même genre de module.

Du coup, quelle différence y a-t-il de faire:

import tartenpion
import machin
import truc

def ma_fonction():
     suites d'instructions.

Et ceci:

import tartenpion
import machin
import truc

ma_fonction(tartenpion, machin, truc)

En sachant que le script est renouvelé en boucle.

Donc, mon idée, c'est de ne pas tout le temps faire des imports dans tout mes scripts et j'ai choisi plutôt de faire une espèce d'héritage. Mais ai-je juste de faire comme ça ou ça sert à rien ?

-
Edité par RedstarBelgium 18 mai 2018 à 11:40:34

Dans le premier cas tu définis une fonction, dans le second tu l'appelles (donc tu l'exécutes).

Je n'ai pas compris ce que tu appelles héritage des imports.

Je reformule ma question:

J'ai un script.py principal qui contient des imports d'éléments systèmes (comme "import OS", par exemple). J'ai un second script à activer si nécessaire qui a besoin du module OS.

Ma question: est-ce mieux d'importer OS dans mon second script directement ou le mettre en argument dans une fonction, en sachant que tout se joue en boucle (question d'optimisation, en fait) ?

Concrètement:

import script2
import OS

script2.ma_fonction(OS)

L'instruction import fait plusieurs choses, mais pour faire simple, voici en gros ce qu'elle fait :

Si le module ou le package n'est pas déjà chargé (compilé en bytecode) dans le dictionnaire sys.modules :

• Chercher le fichier (module) ou le sous-dossier (package) dans les dossiers renseignés dans la liste sys.path.
• Si le module ou le package est trouvé, il est alors chargé et renseigné dans le dictionnaire sys.modules.

Si ou quand le module ou le package est chargé dans le dictionnaire sys.modules, l'instruction import ajoute le module à l'espace de noms courant.

Bref, cela signifie qu'un module n'est en réalité chargé qu'une seule fois, peu importe le nombre d'appel à l'instruction import, le reste n'est qu'une question d'espaces de noms pour accéder au module.

-
Edité par Anonyme 23 mai 2018 à 13:08:30

Donc, si je comprends bien, dans mon script1, il charge le module demandé, dans le script 2, il fait juste le lien ? Et cela veux dire qu'au deuxième passage (puisque c'est en boucle), ce n'est juste qu'un lien vers le module demandé ?

Comment ça « en boucle » ?

Il faut faire attention aux imports circulaires : tu ne peux pas importer un module B dans un module A si le module A importe lui aussi le module B. Il y a un mécanisme dans Python qui interdit cela sans quoi Python se retrouverait à importer en boucle les 2 modules à l'infini.

-
Edité par Anonyme 23 mai 2018 à 13:52:52

Non, le module B n'importe pas le module A, il a besoin du module OS, tout comme le module A, qui à besoin du module OS.

J'importe juste le module B dans A, pas l'inverse.

Ok alors oui, la première fois que Python lit l'instruction import os il charge le module et l'ajoute à l'espace de noms, et la deuxième fois qu'il lit cette instruction il ne fait que l'ajout à l'espace de nom.