# Valeur calculée de la variable

## Variable avec une valeur par défaut calculée

Créons une variable dont la valeur est retournée par la fonction "return_no" :

```
<variables>
    <variable name="my_calculated_variable"/>
</variables>
<constraints>
    <fill name="return_no">
        <target>my_calculated_variable</target>
    </fill>
</constraints>
```

Puis créons la fonction "return_no" :

```
def return_no():
    return 'no'
```

La [cible (de type variable)](../target/variable.md) du calcul est ici "my_calculated_variable".

Dans ce cas, la valeur par défaut est la valeur retournée par la fonction (ici "no"), elle sera calculée tant que l'utilisateur n'a pas de spécifié de valeur à cette variable.

Attention, si une valeur par défaut est définit dans la variable "my_calculated_variable" :

```
<variable name="my_calculated_variable">
    <value>yes</value>
</variable>
```
Cette valeur par défaut sera complètement ignorée. C'est le calcul qui en définira la valeur.

Il est possible de définir des [paramètres](../param/README.md) à cette fonction.

## Variable avec une valeur calculée

En ajoutant le paramètre "hidden" à "True" dans la variable précédente, l'utilisateur n'aura plus la possibilité de modifié la valeur. La valeur de la variable sera donc systématiquement calculée :

```
<variable name="my_calculated_variable" hidden="True"/>
```

Si une condition "hidden_if_in" est spécifié à la variable, la valeur sera modifiable par l'utilisateur si elle n'est pas cachée mais elle sera systèmatiquement calculée (même si elle a déjà était modifiée) si la variable est cachée.

## Variable meneuse ou suiveuse avec valeur calculé

Une [variable suiveuse](../family/leadership.md) ne peut pas être calculé automatiquement.
Une [variable meneuse](../family/leadership.md) peut être calculé automatiquement.
Si la variable n'est pas multiple, il ne faut pas que le calcule retourne une liste.

## Variable dynamique avec une valeur calculée

Il est également possible de calculer [une variable d'une famille dynamique](../family/auto.md) à partir d'une variable standard :

```
<variables>
    <variable name='suffixes' type='string' description="Suffixes of dynamic family" multi="True">
        <value>val1</value>
        <value>val2</value>
    </variable>
    <variable name="my_variable" type="string" description="My variable">
        <value>val</value>
    </variable>
    <family name='dyn' dynamic="suffixes">
        <variable name="my_calculated_variable_dyn\_" type="string" description="My calculated variable"/>
            <value>val</value>
        </variable>
    </family>
</variables>
<constraints>
    <fill name="return_value">
        <param type="variable">my_variable</param>
        <target>my_calculated_variable_dyn_</target>
    </fill>
</constraints>
```

Dans ce cas, les variables dynamiques "my_calculated_variable_dyn_" seront calculés à partir de la valeur de la variable "my_variable".
Que cela soit pour la variable "my_calculated_variable_dyn_val1" et "my_calculated_variable_dyn_val2".

Par contre, il n'est pas possible de faire un calcul pour une seule des deux variables issues de la variable dynamique.
Si c'est ce que vous cherchez à faire, il faudra prévoir un traitement particulier dans votre fonction.

Dans ce cas, il faut explicitement demander la valeur du suffix dans la fonction :

```
<constraints>
    <fill name="return_value_suffix">
        <param type="variable">my_variable</param>
        <param type="suffix"/>
        <target>my_calculated_variable_dyn_</target>
    </fill>
</constraints>
```

Et ainsi faire un traitement spécifique pour ce suffix :

```
def return_value_suffix(value, suffix):
    if suffix == 'val1':
        return value
```

## Variable avec valeur calculée obligatoire

Par défaut les variables calculées ne sont pas des variables obligatoires.
Dans ce cas un calcul peut retourner "None" ou "", mais surtout un utilisateur peut spécifier une valeur nulle à cette variable. Dans ce cas le calcul ne sera plus réalisé.