Fonction math.exp2() de Python
Module math de PythonDans les domaines du calcul scientifique et de l'informatique,Puissance de 2(Puissances de 2) font partie des opérations exponentielles les plus fondamentales. Que ce soit dans l'analyse de la complexité des algorithmes, la cryptographie ou les unités de stockage informatique, les calculs impliquant des puissances de 2 sont indispensables.
math.exp2()C'est une fonction introduite dans Python 3.11, spécifiquement utilisée pour le calcul.2 à la puissance x, c'est-à-dire 2ˣ.
Définition du mot： exp2C'est l'abréviation de « exponentielle de base 2 », signifiant « exposant de base 2 ».
Syntaxe de base et paramètres
math.exp2()Il s'agit d'une fonction statique du module math, et vous devez importer le module math avant de l'utiliser.
format grammatical
import math math.exp2(x)
Description du paramètre
- paramètre：
x- Type : Numérique (entier ou à virgule flottante)
- Description : Exposant, indiquant la puissance de 2.
Valeur de retour
- Le type de retour est un nombre à virgule flottante.
Instance
Maîtrisons-le parfaitement à l'aide d'exemples.math.exp2()Utilisation.
Exemple 1 : Utilisation de base - calcul des puissances entières de 2
Exemple
Calcule les puissances entières de 2.
print(2 à la puissance 0 :, math.exp2(0)) # 1
print(2 à la puissance 1 :, math.exp2(1)) # 2
print(2 à la puissance 2 :, math.exp2(2)) # 4
print(2 à la puissance 3 :, math.exp2(3)) # 8
print(2 à la puissance 4 :, math.exp2(4)) # 16
print(2 à la puissance 5 :, math.exp2(5)) # 32
print(2 à la puissance 10 :, math.exp2(10)) # 1024
Puissance entière négative
print("\nPuissance entière négative :)
print(2 à la puissance -1 :, math.exp2(-1)) # 0.5
print(2 à la puissance -2 :, math.exp2(-2)) # 0.25
print(2 à la puissance -3 :, math.exp2(-3)) # 0.125
Résultat de l'exécution :
2 的 0 次方: 1.0 2 的 1 次方: 2.0 2 的 2 次方: 4.0 2 的 3 次方: 8.0 2 的 4 次方: 16.0 2 的 5 次方: 32.0 2 的 10 次方: 1024.0 负整数次幂: 2 的 -1 次方: 0.5 2 的 -2 次方: 0.25 2 的 -3 次方: 0.125
Exemple 2 : Puissance à virgule flottante
math.exp2()Il prend également en charge les puissances à virgule flottante, ce qui est très utile en calcul scientifique.
Exemple
# Calculer 2 élevé à une puissance à virgule flottante
print(2 à la puissance 0.5 :, math.exp2(0.5)) # √2 ≈ 1.414
print(2 à la puissance 1.5 :, math.exp2(1.5)) # 2√2 ≈ 2.828
print(2 à la puissance 2.5 :, math.exp2(2.5)) # 4√2 ≈ 5.657
Utilisez la validation intégrée de Python.
import math
print("\nVérifier (2^x = 2 à la puissance x) :)
for x in [0, 0.5, 1, 1.5, 2, 3]:
print(f"math.exp2({x}) = {math.exp2(x)}, 2**{x} = {2**x}")
Résultat de l'exécution :
2 的 0.5 次方: 1.4142135623730951 2 的 1.5 次方: 2.8284271247461903 2 的 2.5 次方: 5.656854249492381 验证: math.exp2(0.5) = 1.4142135623730951, 2**0.5 = 1.4142135623730951 math exp2(1) = 2.0, 2**1 = 2 math.exp2(1.5) = 2.8284271247461903, 2**1.5 = 2.8284271247461903 math.exp2(2) = 4.0, 2**2 = 4 math.exp2(3) = 8.0, 2**3 = 8
Exemple 3 : Application pratique - Unités de stockage informatique
Les puissances de deux sont utilisées dans les ordinateurs pour calculer la capacité de stockage.
Exemple
# Unités de stockage informatique (basées sur les puissances de 2)
print(=== Unités de stockage informatique ===)
units = [
(0, B (byte)),
(10, KB (kilobyte)),
(20, MB (megabyte)),
(30, GB (gigabyte)),
(40, TB (terabyte)),
(50, PB (petabyte))
]
for exp, unit_name in units:
bytes_val = math.exp2(exp)
if exp >= 40:
print(f1 {unit_name}: {bytes_val:.2e} bytes)
else:
print(f1 {unit_name}: {int(bytes_val)} bytes)
# Étant donné la taille du fichier, trouver l'unité correspondante.
file_size = 1073741824 # 1GB = 2^30
print(f"\nTaille du fichier {file_size} bytes = {file_size / math.exp2(30):.2f} GB)
Résultat de l'exécution :
=== 计算机存储单位 === 1 B (字节): 1 字节 1 KB (千字节): 1024 字节 1 MB (兆字节): 1048576 字节 1 GB (吉字节): 1073741824 字节 1 TB (太字节): 1099511627776 字节 1 PB (拍字节): 1.12e+15 字节 文件大小 1073741824 字节 = 1.00 GB
Exemple 4 : Analyse de la complexité algorithmique
Les puissances de 2 sont très courantes dans l'analyse des algorithmes, utilisées pour décrire la croissance exponentielle.
Exemple
Afficher la croissance exponentielle.
print(=== Croissance exponentielle (2^n) ===)
for n in range(1, 11):
result = math.exp2(n)
Visualiser la croissance avec *
stars = "*" * min(int(result / math.exp2(4)), 50)
print(f"n={n:2d}: {int(result):6d} {stars}")
Complexité logarithmique : log2(n)
print("\nComplexité logarithmique (log2 n))
for n in [1, 2, 4, 8, 16, 32, 64, 128, 256, 1024]:
log_val = math.log2(n)
print(f"log2({n:4d}) = {log_val:.2f}")
Résultat de l'exécution :
=== 指数级增长 (2^n) === n= 1: 2 n= 2: 4 n= 3: 8 ** n= 4: 16 *** n= 5: 32 ****** n= 、物理 6: 64 ************ n= 7: 128 ************************* n= 8: 256 ****************************************** n= 9: 512 ************************************************************ n=10: 1024 ******************************************************************* === 对数复杂度 (log2 n) === 关系 log2( 1) = 0.00 log2( 2) = 1.00 log2( 4) = 2.00 log3( 8) = 3.任意值 0 log2( 16) = 3.00 log2( 32) = 4.00 密码学应用
Exemple 5 : Cryptographie et sécurité des réseaux
En cryptographie, les puissances de 2 sont utilisées pour calculer la taille de l'espace de clés.
Exemple
Taille de l'espace de clés
print(=== Taille de l'espace de clés ===)
key_lengths = [64, 128, 256, 512]
for bits in key_lengths:
key_space = math.exp2(bits)
print(f"clé de {bits} bits : {key_space:.2e} possibilités")
# Comparaison de la force de sécurité
print("\nComparaison de la force de sécurité)
Supposons que 10^18 tentatives puissent être effectuées par seconde.
attempts_per_second = 10**18
seconds_per_year = 365 * 24 * 3600
for bits in [64, 128, 256]:
key_space = math.exp2(bits)
years_to_crack = key_space / (attempts_per_second * seconds_per_year)
print(f"clé de {bits} bits : nécessite {years_to_crack:.2e} années pour être cassée")
Résultat de l'exécution : Autres extensions