madamasterclass.com
Découvrir la représentation des entiers naturels
Dans ce cours, nous allons explorer les différentes façons de représenter les entiers naturels en informatique. Nous verrons les systèmes binaire, octal et hexadécimal, ainsi que les méthodes de conversion entre ces bases. Nous aborderons également les fonctions Python utiles pour manipuler ces représentations.
En informatique, les nombres entiers peuvent être représentés selon différentes bases numériques. Chaque base a ses avantages spécifiques selon le contexte d'utilisation.
# Représentation binaire en Python nombre_binaire = 0b1010 # équivalent à 10 en décimal print(nombre_binaire) # Affiche: 10 print(bin(10)) # Affiche: '0b1010'
# Représentation octale en Python nombre_octal = 0o12 # équivalent à 10 en décimal print(nombre_octal) # Affiche: 10 print(oct(10)) # Affiche: '0o12'
# Représentation hexadécimale en Python nombre_hex = 0xA # équivalent à 10 en décimal print(nombre_hex) # Affiche: 10 print(hex(10)) # Affiche: '0xa'
| Conversion | Fonction Python |
|---|---|
| Décimal → Binaire | bin(nombre) |
| Décimal → Octal | oct(nombre) |
| Décimal → Hexadécimal | hex(nombre) |
| Base quelconque → Décimal | int('nombre', base) |
Éducation
# Conversion depuis différentes bases
print(int('1010', 2)) # Convertit '1010' binaire en décimal → 10
print(int('12', 8)) # Convertit '12' octal en décimal → 10
print(int('A', 16)) # Convertit 'A' hexadécimal en décimal → 10
# Formatage avec f-strings
nombre = 255
print(f"Binaire: {nombre:b}") # Affiche: Binaire: 11111111
print(f"Octal: {nombre:o}") # Affiche: Octal: 377
print(f"Hexadécimal: {nombre:x}") # Affiche: Hexadécimal: ff
La maîtrise des différentes représentations des nombres entiers est essentielle en programmation. Le système binaire est fondamental pour comprendre le fonctionnement interne des ordinateurs, tandis que les systèmes octal et hexadécimal offrent des représentations plus compactes souvent utilisées dans les systèmes informatiques. Python fournit toutes les fonctions nécessaires pour convertir facilement entre ces différentes bases.
1. Créez une fonction `decimal_vers_binaire(n)` qui convertit un nombre décimal en binaire
2. Créez la fonction inverse `binaire_vers_decimal(b)`
3. Testez avec 10, 25 et 255
def decimal_vers_binaire(n):
if n == 0: return "0"
bits = []
while n > 0:
bits.append(str(n % 2))
n = n // 2
return ''.join(reversed(bits))
def binaire_vers_decimal(b):
return sum(int(bit) * 2**i for i, bit in enumerate(reversed(b)))
# Tests
print(decimal_vers_binaire(10)) # 1010
print(binaire_vers_decimal("1010")) # 10
print(decimal_vers_binaire(255)) # 11111111
1. Créez une fonction `decimal_vers_hexa(n)` sans utiliser hex()
2. Créez la fonction inverse `hexa_vers_decimal(h)`
3. Gérer les lettres A-F en majuscules
def decimal_vers_hexa(n):
if n == 0: return "0"
chiffres = []
hex_chars = "0123456789ABCDEF"
while n > 0:
chiffres.append(hex_chars[n % 16])
n = n // 16
return ''.join(reversed(chiffres))
def hexa_vers_decimal(h):
h = h.upper()
hex_chars = "0123456789ABCDEF"
return sum(hex_chars.index(c) * 16**i
for i, c in enumerate(reversed(h)))
# Tests
print(decimal_vers_hexa(255)) # FF
print(hexa_vers_decimal("FF")) # 255
1. Créez une fonction `convertir(n, base)` qui convertit n dans une base (2-16)
2. Créez la fonction inverse `vers_decimal(s, base)`
3. Testez avec différentes bases
def convertir(n, base):
if base < 2 or base > 16:
raise ValueError("Base doit être entre 2 et 16")
if n == 0: return "0"
chiffres = "0123456789ABCDEF"
result = []
while n > 0:
result.append(chiffres[n % base])
n = n // base
return ''.join(reversed(result))
def vers_decimal(s, base):
s = s.upper()
chiffres = "0123456789ABCDEF"
return sum(chiffres.index(c) * base**i
for i, c in enumerate(reversed(s)))
# Tests
print(convertir(42, 2)) # 101010
print(convertir(42, 8)) # 52
print(vers_decimal("101010", 2)) # 42
1. Créez une fonction qui vérifie si une chaîne est un nombre binaire valide
2. Faites de même pour l'hexadécimal
3. Créez une fonction qui détecte automatiquement la base
def est_binaire(s):
return all(c in '01' for c in s)
def est_hexadecimal(s):
return all(c.upper() in '0123456789ABCDEF' for c in s)
def detecter_base(s):
if s.startswith('0b'): return 2
if s.startswith('0x'): return 16
if est_binaire(s): return 2
if est_hexadecimal(s): return 16
return 10 # par défaut
# Tests
print(est_binaire("10101")) # True
print(est_hexadecimal("FF2A")) # True
print(detecter_base("0b1010")) # 2
1. Créez une calculatrice qui peut:
- Additionner deux nombres dans une base donnée
- Convertir le résultat dans d'autres bases
2. Implémentez une interface simple
def calculatrice():
print("Calculatrice multi-base")
a = input("Premier nombre: ")
b = input("Deuxième nombre: ")
base = int(input("Base (2-16): "))
# Conversion en décimal
dec_a = vers_decimal(a, base)
dec_b = vers_decimal(b, base)
# Calcul
result_dec = dec_a + dec_b
# Affichage
print(f"\nRésultats:")
print(f"Binaire: {convertir(result_dec, 2)}")
print(f"Octal: {convertir(result_dec, 8)}")
print(f"Décimal: {result_dec}")
print(f"Hexadécimal: {convertir(result_dec, 16)}")
# Exemple d'utilisation
calculatrice()
Dans le cadre d'un projet sur les systèmes de numération, vous devez développer une fonction pour convertir des nombres binaires en octaux. Cela aidera à interpréter les valeurs des capteurs qui fournissent des données en binaire.
1. Créez une fonction `binaire_vers_octale(b)` qui convertit un nombre binaire en octal.
2. Créez la fonction inverse `octale_vers_binaire(o)`.
3. Testez avec "1010", "11111111" et "1001".
def binaire_vers_octale(b):
dec = int(b, 2)
return oct(dec)[2:]
def octale_vers_binaire(o):
dec = int(o, 8)
return bin(dec)[2:]
# Tests
print(binaire_vers_octale("1010")) # 12
print(octale_vers_binaire("12")) # 1010
Dans un système de gestion de fichiers, il est nécessaire de convertir des identifiants de fichiers octaux en hexadécimaux pour assurer une compatibilité avec d'autres systèmes. Développez des fonctions pour effectuer cette conversion.
1. Créez une fonction `octale_vers_hexadecimale(o)` qui convertit un nombre octal en hexadécimal.
2. Créez la fonction inverse `hexadecimale_vers_octale(h)`.
3. Testez avec "17", "77" et "10".
def octale_vers_hexadecimale(o):
dec = int(o, 8)
return hex(dec)[2:].upper()
def hexadecimale_vers_octale(h):
dec = int(h, 16)
return oct(dec)[2:]
# Tests
print(octale_vers_hexadecimale("17")) # F
print(hexadecimale_vers_octale("F")) # 17
Lors d'un projet de développement logiciel, vous devez permettre la représentation de nombres dans différentes bases pour répondre aux besoins des utilisateurs. Créez une fonction qui convertit des nombres décimaux en n'importe quelle base de 2 à 16.
1. Créez une fonction `decimal_vers_base(n, base)` qui convertit un nombre décimal vers une base N (2-16).
2. Créez la fonction inverse `base_vers_decimal(s, base)`.
3. Testez avec 42 dans les bases 2, 8 et 16.
def decimal_vers_base(n, base):
if base < 2 or base > 16:
raise ValueError("Base doit être entre 2 et 16")
chiffres = "0123456789ABCDEF"
result = []
while n > 0:
result.append(chiffres[n % base])
n //= base
return ''.join(reversed(result))
def base_vers_decimal(s, base):
s = s.upper()
chiffres = "0123456789ABCDEF"
return sum(chiffres.index(c) * (base ** i) for i, c in enumerate(reversed(s)))
# Tests
print(decimal_vers_base(42, 2)) # 101010
print(decimal_vers_base(42, 8)) # 52
print(decimal_vers_base(42, 16)) # 2A
Dans le cadre d'une application de sécurité, il est essentiel de valider les entrées des utilisateurs pour s'assurer qu'elles respectent les formats de nombre attendus. Développez des fonctions pour vérifier si une chaîne est un nombre valide en base décimale ou hexadécimale.
1. Créez une fonction `est_hexadecimal(s)` qui vérifie si une chaîne est un nombre hexadécimal valide.
2. Créez une fonction `est_decimal(s)` qui vérifie si une chaîne est un nombre décimal valide.
3. Testez avec des valeurs valides et invalides.
def est_hexadecimal(s):
return all(c.upper() in '0123456789ABCDEF' for c in s)
def est_decimal(s):
return s.isdigit()
# Tests
print(est_hexadecimal("1A3F")) # True
print(est_decimal("12345")) # True
print(est_hexadecimal("G12")) # False
print(est_decimal("12.34")) # False
Pour un projet d'application de calculatrice, vous devez créer une fonction qui permet aux utilisateurs d'additionner des nombres dans plusieurs bases et d'afficher le résultat dans différentes bases. Cela améliorera l'expérience utilisateur en simplifiant les conversions.
1. Créez une calculatrice qui peut:
- Additionner deux nombres dans une base donnée (2-16)
- Afficher le résultat dans d'autres bases.
2. Implémentez une interface simple.
3. Testez avec des entrées dans différentes bases.
def calculatrice_multi_base():
print("Calculatrice Multi-Base")
a = input("Premier nombre: ")
b = input("Deuxième nombre: ")
base = int(input("Base (2-16): "))
# Conversion en décimal
dec_a = base_vers_decimal(a, base)
dec_b = base_vers_decimal(b, base)
# Calcul
result_dec = dec_a + dec_b
# Affichage
print(f"\nRésultats:")
for b in [2, 8, 10, 16]:
print(f"Base {b}: {decimal_vers_base(result_dec, b)}")
# Exemple d'utilisation
calculatrice_multi_base()
Considérons la suite définie par \( u_n = \frac{n}{n + 1} \) pour \( n \in \mathbb{N} \).
1. Déterminez le sens de variation de la suite \( (u_n) \).
2. Calculez la limite de la suite \( (u_n) \) lorsque \( n \) tend vers l'infini.
Soit la suite définie par \( v_n = \frac{1}{n} + \frac{(-1)^n}{n} \) pour \( n \in \mathbb{N}^* \).
1. Étudiez le sens de variation de la suite \( (v_n) \).
2. Calculez la limite de la suite \( (v_n) \) lorsque \( n \) tend vers l'infini.
Considérons la suite définie par \( w_n = n^2 - 3n + 2 \).
1. Déterminez le sens de variation de la suite \( (w_n) \).
2. Calculez la limite de la suite \( (w_n) \) lorsque \( n \) tend vers l'infini.
Soit la suite définie par \( z_n = \frac{3^n}{n!} \).
1. Étudiez le sens de variation de la suite \( (z_n) \).
2. Calculez la limite de la suite \( (z_n) \) lorsque \( n \) tend vers l'infini.
Considérons la suite définie par \( a_n = \ln(n+1) - \ln(n) \).
1. Étudiez le sens de variation de la suite \( (a_n) \).
2. Calculez la limite de la suite \( (a_n) \) lorsque \( n \) tend vers l'infini.
Un investisseur place 1000€ dans un compte d'épargne qui rapporte 5% d'intérêt par an. La valeur de l'investissement après \( n \) années est donnée par \( V_n = 1000 \times (1 + 0.05)^n \).
1. Déterminez le sens de variation de la suite \( (V_n) \).
2. Calculez la limite de la valeur de l'investissement lorsque \( n \) tend vers l'infini.
Une population de bactéries double chaque heure. Si la population initiale est de 100 bactéries, la population après \( n \) heures est donnée par \( P_n = 100 \times 2^n \).
1. Étudiez le sens de variation de la suite \( (P_n) \).
2. Calculez la limite de la population lorsque \( n \) tend vers l'infini.
Un coureur parcourt une distance de 10 km. Il commence par courir 1 km le premier jour, puis augmente sa distance de 0.5 km chaque jour. La distance parcourue le \( n \)-ième jour est donnée par \( D_n = 1 + 0.5(n - 1) \).
1. Déterminez le sens de variation de la suite \( (D_n) \).
2. Calculez la limite de la distance parcourue lorsque \( n \) tend vers l'infini.
Un architecte prévoit de construire un gratte-ciel. Chaque étage mesure 3 mètres de hauteur. La hauteur totale après \( n \) étages est donnée par \( H_n = 3n \).
1. Étudiez le sens de variation de la suite \( (H_n) \).
2. Calculez la limite de la hauteur lorsque \( n \) tend vers l'infini.
Une personne commence à économiser 100€ le premier mois et augmente son épargne de 10€ chaque mois. La somme totale après \( n \) mois est donnée par \( S_n = 100n + 10\frac{n(n-1)}{2} \).
1. Déterminez le sens de variation de la suite \( (S_n) \).
2. Calculez la limite de la somme totale lorsque \( n \) tend vers l'infini.
