Comment convertir octets, ko, Mo, Go, To (et Po)
Comprenez binaire vs décimal, convertissez entre unités d'octets et évitez les pièges courants.
Pourquoi y a-t-il deux « Mo » différents ?
Achetez un disque dur de 1 To, branchez-le et votre système d'exploitation indique 931 Go. Il « manque » 69 Go au disque. Ce n'est pas un bug, une arnaque ni une erreur de format. C'est la confusion binaire/décimale ancrée dans notre façon de nommer le stockage.
Le problème central : multipliez-vous par 1 000 (décimal, la norme SI) ou par 1 024 (binaire, ce que font réellement les ordinateurs en interne) ?
- 1 ko = 1 000 octets (décimal, utilisé par les fabricants de disques, dicté par le SI)
- 1 Kio = 1 024 octets (binaire, ce que Windows appelait autrefois « ko », l'unité de la RAM)
Pour lever l'ambiguïté, la CEI a introduit de nouveaux préfixes binaires en 1998 : Kio (kibioctet, 2^10), Mio (mébioctet, 2^20), Gio (gibioctet, 2^30), Tio (tébioctet, 2^40), Pio (pébioctet, 2^50). En pratique, les anciennes étiquettes persistent partout sauf dans la documentation technique, et la plupart des systèmes d'exploitation sont incohérents : macOS utilise le décimal pour le stockage, Windows mélange, les distributions Linux varient.
Ce guide explique les mathématiques, les conventions et trois méthodes fiables de conversion.
Les formules exactes
Décimal (SI, utilisé par les fabricants de disques, vitesses réseau)
``` 1 ko = 1 000 o = 10^3 o 1 Mo = 1 000 ko = 1 000 000 o = 10^6 o 1 Go = 1 000 Mo = 1 000 000 000 o = 10^9 o 1 To = 1 000 Go = 1 000 000 000 000 o = 10^12 o 1 Po = 1 000 To = 10^15 o ```
Binaire (CEI, utilisé par la RAM, les formats de fichiers, certains SE)
``` 1 Kio = 1 024 o = 2^10 o 1 Mio = 1 024 Kio = 1 048 576 o = 2^20 o 1 Gio = 1 024 Mio = 1 073 741 824 o = 2^30 o 1 Tio = 1 024 Gio = 1 099 511 627 776 o = 2^40 o 1 Pio = 1 024 Tio = 2^50 o ```
Le rapport entre décimal et binaire croît rapidement : un disque « 1 To » marketing représente 1 000 000 000 000 octets, mais votre SE peut afficher 931 Gio d'espace utilisable après formatage et surcoût. L'écart s'élargit avec la taille — un disque « 1 Po » représente environ 0,89 Pio.
Table de référence rapide
| Octets | Décimal (SI) | Binaire (CEI) | |---------:|----------------------|--------------------------| | 1 000 | 1 ko | 0,977 Kio | | 1 024 | 1,024 ko | 1 Kio | | 1 000 000| 1 Mo | 0,954 Mio | | 1 048 576| 1,049 Mo | 1 Mio | | 10^9 | 1 Go | 0,931 Gio | | 2^30 | 1,074 Go | 1 Gio | | 10^12 | 1 To | 0,909 Tio | | 2^40 | 1,100 To | 1 Tio | | 10^15 | 1 Po | 0,888 Pio |
Méthode 1 : Utilisez le convertisseur de stockage de données de UtilBoxx (Recommandé)
La façon la plus rapide et la plus sûre de convertir entre o, ko, Mo, Go, To et Po est le Convertisseur de Stockage de UtilBoxx. Il prend en charge les modes décimal et binaire, vous laisse choisir la précision, et s'exécute entièrement dans votre navigateur — pas de téléversement, pas d'inscription, pas de journalisation de vos fichiers.
Comment l'utiliser :
- Allez sur utilboxx.com/fr/tools/unit/data
- Saisissez une valeur dans n'importe quel champ (o, ko, Mo, Go, To ou Po)
- Choisissez le mode décimal (SI) ou binaire (CEI)
- Tous les autres champs se mettent à jour instantanément
- Copiez le résultat
Pourquoi nous recommandons cette méthode :
- 100 % gratuit, sans inscription, sans e-mail, sans publicité
- Confidentialité d'abord : rien ne quitte votre navigateur
- Modes décimal et binaire avec un seul commutateur
- Conversion bidirectionnelle entre les six unités
- Haute précision — pas de surprises d'arrondi en virgule flottante
- Fonctionne sur tout appareil avec navigateur
Si vous citez souvent des tailles de fichiers, des capacités de disque ou des quantités de RAM, cet outil vous évitera de retomber dans la confusion 1024 vs 1000.
Méthode 2 : macOS Finder (et autres gestionnaires de fichiers du SE)
Si vous n'avez besoin que du nombre exact d'octets d'un fichier spécifique, le gestionnaire de fichiers de votre système d'exploitation vous donne la réponse décimale avec une précision totale.
Sur macOS Finder :
- Cliquez-droit sur n'importe quel fichier et choisissez Lire les informations (ou appuyez sur Cmd+I)
- La taille est affichée en unités décimales : ko, Mo, Go
- Cliquez sur le champ de taille pour basculer entre octets, ko, Mo et Go
- Le nombre exact d'octets est entre parenthèses
Sur Windows Explorateur de fichiers :
- Cliquez-droit sur un fichier et choisissez Propriétés
- La taille est affichée en ko, Mo ou Go (Windows utilise un mélange de binaire et décimal selon la version)
- Pour les octets exacts, divisez les ko par 1 024 uniquement si Windows rapporte des ko binaires ; Windows 10/11 moderne rapporte en fait en binaire pour certaines boîtes de dialogue et en décimal pour d'autres
Sur Linux :
- `ls -l file` affiche les octets exacts
- `ls -lh file` affiche la taille lisible par l'homme (la plupart des distros utilisent le binaire par défaut ; certaines utilisent le décimal — vérifiez votre `alias ls`)
Cette méthode est idéale pour connaître la taille d'un fichier ou dossier spécifique, mais n'aide pas pour la conversion par lots ou les calculs entre unités.
Méthode 3 : Python (ou tout langage)
Pour la conversion programmatique, quelques lignes de Python couvrent les six unités. La méthode `bit_length()` donne le nombre de bits nécessaires pour représenter un entier — utile pour dimensionner des tampons.
```python # Conversion décimale (SI) def to_bytes(value, unit): units = {"B": 1, "KB": 1e3, "MB": 1e6, "GB": 1e9, "TB": 1e12, "PB": 1e15} return value * units[unit]
# Conversion binaire (CEI) def to_bytes_binary(value, unit): units = {"B": 1, "KiB": 210, "MiB": 220, "GiB": 230, "TiB": 240, "PiB": 2*50} return value units[unit]
# bit_length d'un entier n = 123456789 print(n.bit_length()) # 27 bits ```
Pour des one-liners dans un REPL Python :
```python # Convertir 1 Gio en octets 1024 1024 1024 # 1073741824
# Convertir 1 To en Gio 1_000_000_000_000 / (2**30) # 931.3225746154785
# Convertir 5 Po en Tio 5 1e15 / (2*40) # 4547.473508864641 ```
En JavaScript, la même idée :
```js const GiB = 1024 ** 3; const TB_in_bytes = 1e12; console.log((TB_in_bytes / GiB).toFixed(3)); // 931.323 ```
Méthode 4 : CLI sous macOS/Linux
La plupart des shells ont des maths intégrées, et macOS fournit une calculatrice qui gère les grands nombres :
```bash # En bash, avec awk awk 'BEGIN { printf "1 TB in GiB = %.3f\n", 1e12 / (2^30) }' # 1 TB in GiB = 931.323
awk 'BEGIN { printf "1 GiB in bytes = %d\n", 2^30 }' # 1 GiB in bytes = 1073741824
# macOS uniquement : utilisez units units "1 TB" "GiB" # 931.32257
# Linux uniquement : numfmt fait partie de coreutils numfmt --to=iec --suffix=B 1000000000000 # 931G numfmt --to=si --suffix=B 1073741824 # 1.1G ```
L'outil `numfmt` est particulièrement utile dans les scripts shell : il accepte des nombres avec des unités optionnelles et les reformate, prend en charge les modes décimal (--si) et binaire (--iec), et gère correctement les nombres négatifs.
Questions fréquentes
Pourquoi mon disque « 1 To » affiche-t-il 931 Go ?
Les fabricants de disques utilisent le décimal : 1 To = 1 000 000 000 000 octets. Les systèmes d'exploitation affichent souvent cela en binaire, qu'ils appellent Go mais qui signifie en réalité Gio. 1 000 000 000 000 octets ÷ 1 073 741 824 octets par Gio = 931,32 Gio. L'espace « manquant » est la différence entre décimal et binaire, plus la surcharge du formatage, des tables de partition et des métadonnées du système de fichiers.
Mo est-il plus grand que Mio ?
Oui. Mo est décimal (1 000 000 octets) et Mio est binaire (1 048 576 octets). Mio est environ 4,86 % plus grand que Mo. La même logique s'applique à ko vs Kio, Go vs Gio, To vs Tio.
La RAM utilise-t-elle le binaire ou le décimal ?
La RAM est vendue et adressée en binaire. Une barrette « 16 Go » est 16 Gio (17 179 869 184 octets) et le SE la rapporte ainsi. Le « Go » marketing est techniquement incorrect selon les normes SI, mais la convention est tellement ancrée que personne n'a essayé de renommer la mémoire en « Gio ».
Qu'en est-il des vitesses réseau ?
L'équipement réseau a historiquement utilisé le décimal pour les bits par seconde (1 Mbps = 1 000 000 bits par seconde). De nombreux FAI annoncent aussi en décimal mais communiquent des vitesses en mélangeant octets par seconde et bits, menant à la confusion classique du « je paie 100 Mbps mais je n'obtiens que 12 Mo/s ». Divisez par 8 (bits vers octets) et tenez compte de la surcharge, et 100 Mbps deviennent environ 11-12 Mo/s. Le calcul est juste ; les unités prêtent à confusion.
Qu'est-ce qui est plus grand, un ko ou un Kio ?
Un Kio est plus grand. 1 Kio = 1 024 o, alors que 1 ko = 1 000 o. Le Kio (kibioctet) est 2,4 % plus grand que le ko (kilooctet). Le même schéma se vérifie : Mio > Mo, Gio > Go, Tio > To, Pio > Po.
Pourquoi l'industrie ne s'est-elle pas standardisée sur l'un ?
Dans les normes, si. La CEI utilise officiellement les préfixes binaires (Kio, Mio, Gio) depuis 1998 et la norme SI dit explicitement que « kilo » signifie 1 000. Mais les préfixes binaires n'ont pas remplacé les anciennes étiquettes dans l'usage quotidien. Apple utilise le décimal de manière cohérente pour Go et To. Microsoft utilise le binaire pour la RAM mais le décimal pour le stockage. Les outils Linux sont divisés. Le résultat est une ambiguïté permanente, et la seule parade est de savoir à quelle convention vous avez affaire dans chaque contexte.
Conclusion
Les octets, kilooctets, mégaoctets, gigaoctets, téraoctets et pétaoctets ne sont pas interchangeables, et l'écart décimal/binaire grandit à chaque marche de l'échelle. Les formules sont simples — divisez par 1 000 pour le décimal, par 1 024 pour le binaire — mais se souvenir laquelle utiliser est la partie difficile.
Pour une réponse rapide, le Convertisseur de Stockage de UtilBoxx fait le calcul dans n'importe quel mode en un clic. Pour la taille d'un fichier spécifique, le gestionnaire de fichiers de votre SE vous donne le nombre exact d'octets. Pour le travail par lots ou scripté, l'arithmétique Python ou la CLI `numfmt` sont imbattables. Et en cas de doute, cherchez le « i » final : Kio, Mio, Gio, Tio, Pio signifient toujours binaire.