# python: Utiliser derive
URL: https://generaltranslation.com/fr/docs/python/tutorials/derive.mdx
---
title: Utiliser derive
description: Comment utiliser derive pour l’accord grammatical, le contenu réutilisable et l’analyse statique
---

## Qu’est-ce que `derive` ?

[`derive`](/docs/python/api/derive) est une fonction identité qui sert à marquer du contenu pour l’analyse statique de la CLI GT. Lorsque la CLI analyse votre code, elle reconnaît les appels à `derive(...)` et détermine toutes les valeurs de retour possibles, en créant une entrée de traduction distincte pour chacune.

C’est utile pour :

* Préserver **l’accord grammatical** d’une langue à l’autre (genre, nombre, cas)
* Du **contenu réutilisable** avec des appels de fonction à l’intérieur de chaînes traduites
* Des **phrases fragmentées** où une partie de la chaîne ne peut prendre qu’un ensemble connu de valeurs

***

## Préserver l’accord grammatical

Certaines langues ont des règles grammaticales (genre, nombre, cas) qui influent sur les mots qui les entourent. Sans `derive`, une seule entrée de traduction ne peut pas gérer l’accord :

```python
# Sans derive — une seule traduction, aucun accord grammatical possible
message = t(f"The {get_subject(gender)} is playing.")
# "The boy is playing." et "The girl is playing." partagent la même traduction
```

Avec `derive`, le CLI crée des entrées distinctes pour chaque résultat :

```python
from gt_flask import derive, t

def get_subject(gender: str) -> str:
    return "boy" if gender == "male" else "girl"

message = t(f"The {derive(get_subject(gender))} is playing.")
```

Cela génère deux entrées de traduction :

* `"The boy is playing."` → `"El niño está jugando."`
* `"The girl is playing."` → `"La niña está jugando."`

Notez qu’en espagnol, on utilise "El" ou "La" selon le sujet — l’accord grammatical est géré automatiquement.

***


## Comment ça fonctionne

1. **Au build**, la CLI GT analyse les expressions encapsulées dans `derive`
2. Elle détermine toutes les valeurs de retour possibles (elles doivent pouvoir être analysées statiquement)
3. Elle crée des entrées de traduction distinctes pour chaque résultat unique
4. **À l’exécution**, `derive` est simplement une fonction identité — elle renvoie son argument tel quel

***

## Exemples

### Expressions en ligne

Vous pouvez intégrer de la logique directement dans `derive` :

```python
from gt_flask import derive, t

message = t(f"The {derive('boy' if gender == 'male' else 'girl')} is playing.")
```


### Appels de fonction

Encapsulez les appels de fonction dont les valeurs de retour possibles sont connues :

```python
from gt_flask import derive, t

def get_status_label(status: str) -> str:
    if status == "complete":
        return "completed"
    elif status == "pending":
        return "pending"
    return "unknown"

message = t(f"Task is {derive(get_status_label(status))}.")
```


### Contenu réutilisable

```python
from gt_flask import derive, t

def get_subject() -> str:
    return "boy"

translation1 = t(f"The {derive(get_subject())} is playing.")
translation2 = t(f"The {derive(get_subject())} is having fun.")
```


### Avec `declare_var`

Combinez derive avec [`declare_var`](/docs/python/api/declare-var) si vous avez besoin de contenu dynamique dans une expression statique :

```python
from gt_flask import derive, declare_var, t

def get_greeting(name: str | None) -> str:
    if name:
        return f"Hello, {declare_var(name, name='user')}"
    return "Hello, stranger"

message = t(f"{derive(get_greeting(name))}! How are you?")
```

***


## Considérations de performance

`derive` multiplie les entrées de traduction. Chaque appel avec N résultats possibles crée N entrées, et plusieurs appels à `derive` dans une même chaîne font croître ce total de façon exponentielle. À utiliser avec discernement.