> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-dependabot-submodules-dot-claude-85784ca.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Table
export const GitHubLink = ({url}) =>
Source GitHub
;
## classe wandb.Table
```python theme={null}
columns: 'list[ColumnKey] | None' = None,
data: 'list[InputRow] | np.ndarray | pd.DataFrame | None' = None,
rows: 'list[InputRow] | None' = None,
dataframe: 'pd.DataFrame | None' = None,
dtype: 'Any' = None,
optional: 'bool | list[bool]' = True,
allow_mixed_types: 'bool' = False,
log_mode: 'LogMode | None' = 'IMMUTABLE'
```
La classe Table permet d’afficher et d’analyser des données tabulaires.
Contrairement aux feuilles de calcul traditionnelles, les Tables prennent en charge de nombreux types de données :
des valeurs scalaires, des chaînes de caractères, des tableaux NumPy et la plupart des sous-classes de `wandb.data_types.Media`.
Cela signifie que vous pouvez intégrer `Images`, `Video`, `Audio` et d’autres types de médias enrichis et annotés
directement dans les Tables, aux côtés d’autres valeurs scalaires plus classiques.
Cette classe est la classe principale utilisée pour générer des W\&B Tables
[https://docs.wandb.ai/models/tables](https://docs.wandb.ai/models/tables)
## Arguments
* `columns`: Noms des colonnes du tableau. Valeurs par défaut : \["Input", "Output", "Expected"].
* `data`: Tableau 2D de valeurs orienté par lignes, tableau NumPy ou DataFrame pandas.
* `rows`: Tableau 2D de valeurs orienté par lignes.
* `dataframe`: Objet DataFrame utilisé pour créer le tableau. Lorsqu'il est défini, les arguments `data` et `columns` sont ignorés.
* `dtype`: Type attendu pour les valeurs des colonnes, utilisé pour valider les
données. S'il n'est pas défini, les types sont déduits à partir des données. Il peut s'agir de :
* un type unique
* un type intégré Python tel que `int`, `str`, `bool`, list, dict ou
datetime.
* un type W\&B Media comme `wandb.Image` déclaré dans wandb.data\_types
* une valeur constante
* une liste de l'un des éléments ci-dessus pour attribuer un type différent à chaque
colonne (doit avoir la même longueur que `columns`)
* `optional`: Détermine si les valeurs `None` sont autorisées. Valeur par défaut : True.
* S'il s'agit d'une valeur booléenne unique, le caractère facultatif est appliqué à toutes les
colonnes spécifiées lors de la création
* S'il s'agit d'une liste de valeurs booléennes, le caractère facultatif est appliqué à chaque
colonne ; la liste doit avoir la même longueur que `columns`
s'applique à toutes les colonnes. Une liste de valeurs booléennes s'applique à chaque colonne correspondante.
* `allow_mixed_types`: Détermine si les colonnes peuvent contenir des types mixtes (désactive la validation de type). Valeur par défaut : False
* `log_mode`: Contrôle la façon dont la Table est enregistrée lorsque des modifications surviennent.
Options :
* "IMMUTABLE" (par défaut) : la Table ne peut être enregistrée qu'une seule fois ; les tentatives d'enregistrement suivantes après modification du tableau seront sans effet.
* "MUTABLE" : la Table peut être enregistrée à nouveau après des modifications, créant une nouvelle version d'artifact à chaque enregistrement.
* "INCREMENTAL" : les données de la Table sont enregistrées de façon incrémentielle, chaque enregistrement créant une nouvelle entrée d'artifact contenant les nouvelles données depuis le dernier enregistrement.
## Méthodes
### méthode Table.add\_column()
```python theme={null}
self,
name: 'str',
data: 'list[Any] | np.ndarray',
optional: 'bool' = False
```
Ajoute une colonne de données au tableau.
##### Arguments
* `name`: Le nom unique de la colonne.
* `data`: Une colonne de données homogènes.
* `optional`: Si les valeurs nulles sont autorisées.
### méthode Table.add\_computed\_columns()
```python theme={null}
self,
fn: 'Callable[[int, dict[ColumnKey, Any]], dict[str, Any]]'
```
Ajoute une ou plusieurs colonnes calculées à partir des données existantes.
##### Arguments
* `fn`: fonction qui accepte un index et le dictionnaire d’une ligne, et qui renvoie un dictionnaire représentant les nouvelles colonnes de cette ligne, avec pour clés les noms des nouvelles colonnes.
##### Exemples
Dans le callback :
* `ndx` est un entier qui représente l’indice de la ligne.
* `row` est un dictionnaire dont les clés correspondent aux colonnes existantes.
```python theme={null}
import wandb
table = wandb.Table(columns=["x", "y"], data=[[3, 1], [4, 6]])
table.add_computed_columns(lambda ndx, row: {"diff": row["x"] - row["y"]})
```
### méthode Table.add\_data()
```python theme={null}
self, *data: 'Any'
```
Ajoute une nouvelle ligne de données au tableau.
Le nombre maximal de lignes d’un tableau est déterminé par
`wandb.Table.MAX_ARTIFACT_ROWS`.
Le nombre d’éléments des données doit correspondre au nombre de colonnes du tableau.
* `row`:
### méthode Table.cast()
```python theme={null}
self,
col_name: 'ColumnKey',
dtype: 'Any',
optional: 'bool' = False
```
Convertit une colonne vers un type de données spécifique.
Il peut s'agir d'une classe Python standard, d'un type interne de W\&B
ou d'un objet d'exemple, comme une instance de wandb.Image ou de
wandb.Classes.
##### Arguments
* `col_name`: Le nom de la colonne à convertir.
* `dtype`: Le type cible.
* `optional`: Indique si la colonne doit accepter des valeurs None.
### méthode Table.get\_column()
```python theme={null}
self,
name: 'ColumnKey',
convert_to: "Literal['numpy'] | None" = None
```
Récupère une colonne du tableau et, éventuellement, la convertit en objet NumPy.
##### Arguments
* `name`: Le nom de la colonne.
* `convert_to`: « numpy » convertit les données sous-jacentes en un objet NumPy.
### méthode Table.get\_dataframe()
```python theme={null}
self
```
Renvoie un `pandas.DataFrame` contenant le tableau.
### méthode Table.get\_index()
```python theme={null}
(self)
```
Renvoie un tableau d’indices de lignes à utiliser dans d’autres tableaux afin de créer des liens.