Bonjour! I’m including my response in English (native language) and chat-gpt translated French - Hopefully it makes sense!
Bonjour ! Je joins ma réponse en anglais (ma langue maternelle) et en français traduit par chat-gpt - J'espère que cela a du sens !

There are two approaches:
Il existe deux approches:

1. If all you’re always going to have the same fields then you can use an AttributeCreator to sum the values up. Something like:
   Si vous allez toujours avoir les mêmes champs, vous pouvez utiliser un AttributeCreator pour additionner les valeurs. Quelque chose comme :

   @Evaluate(@Value(la06)+@Value(la07)+@Value(la08)+...)

2. If you’re going to have an unknown number of fields, and they all start with ‘la’ you can use python. Something like:
   Si vous allez avoir un nombre inconnu de champs, et qu'ils commencent tous par 'la', vous pouvez utiliser Python. Quelque chose comme :

   import fme
   import fmeobjects
   
   
   class FeatureProcessor(object):
       """Template Class Interface:
       When using this class, make sure its name is set as the value of the 'Class to Process Features'
       transformer parameter.
       """
   
       def __init__(self):
           """Base constructor for class members."""
           pass
   
       def has_support_for(self, support_type: int):
           """This method is called by FME to determine if the PythonCaller supports Bulk mode,
           which allows for significant performance gains when processing large numbers of features.
           Bulk mode cannot always be supported. 
           More information available in transformer help.
           """
           return support_type == fmeobjects.FME_SUPPORT_FEATURE_TABLE_SHIM
   
       def input(self, feature: fmeobjects.FMEFeature):
           """This method is called for each feature which enters the PythonCaller. 
           Processed input features can be emitted from this method using self.pyoutput().
           If knowledge of all input features is required for processing, then input features should be 
           cached to a list instance variable and processed using group processing or in the close() method.
           """
   
           val = 0
           for i in feature.getAllAttributeNames():
               if i.startswith("la"):
                   val += feature.getAttribute(i)
   
           feature.setAttribute('total', val)
           self.pyoutput(feature)
   
       def close(self):
           """This method is called once all the FME Features have been processed from input()."""
           pass
   
       def process_group(self):
           """This method is called by FME for each group when group processing mode is enabled.
           This implementation should reset any instance variables used for the next group. 
           Bulk mode should not be enabled when using group processing. 
           More information available in transformer help.
           """
           pass

    

Bonjour, j'ai créé un workflow qui fait ce que je pense que vous demandez. Cependant, j'ai ajouté quelques commentaires mais ils sont tous en anglais, donc j'espère que vous pourrez comprendre ce qui se passe. L'exemple utilise uniquement des transformateurs standard sans avoir besoin du pythoncaller. P.S. J'ai également utilisé une IA pour traduire ce texte en français, donc je m'excuse s'il est illisible