Función Python math.exp2()

Python math 模块Módulo Python math

En el ámbito de la computación científica y la informática,las potencias de 2(powers of 2) son una de las operaciones exponenciales más básicas. Ya sea el análisis de complejidad algorítmica, la criptografía o las unidades de almacenamiento informático, todo depende del cálculo de potencias de 2.

math.exp2()Es una función introducida en Python 3.11, diseñada específicamente para calcularla potencia x de 2, es decir, 2ˣ.

Significado de la palabra： exp2Es la abreviatura de "exponential base 2", que significa "exponente de base 2".

Sintaxis básica y parámetros

math.exp2()Es una función estática del módulo math; para usarla, primero debes importar el módulo math.

Formato de sintaxis

import math

math.exp2(x)

Descripción de parámetros

  • Parámetro： x
    • Tipo: numérico (entero o flotante)
    • Descripción: exponente, indica la potencia de 2 a calcular.

Valor de retorno

  • Devuelve la potencia x de 2, es decir, 2ˣ.
  • El tipo de retorno es flotante.

Ejemplos

Dominemos completamente mediante ejemplosmath.exp2()su uso.

Ejemplo 1: Uso básico - Calcular potencias enteras de 2

Ejemplo

import math

# Calcular potencias enteras de 2
print("2 elevado a 0:", math.exp2(0))   # 1
print("2 elevado a 1:", math.exp2(1))   # 2
print("2 elevado a 2:", math.exp2(2))   # 4
print("2 elevado a 3:", math.exp2(3))   # 8
print("2 elevado a 4:", math.exp2(4))   # 16
print("2 elevado a 5:", math.exp2(5))   # 32
print("2 elevado a 10:", math.exp2(10))  # 1024

# Potencias enteras negativas
print("\nPotencias enteras negativas:")
print("2 elevado a -1:", math.exp2(-1))  # 0.5
print("2 elevado a -2:", math.exp2(-2))  # 0.25
print("2 elevado a -3:", math.exp2(-3))  # 0.125

Resultado de la ejecución:

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

Ejemplo 2: Potencias de punto flotante

math.exp2()También admite potencias de punto flotante, lo cual es muy útil en la computación científica.

Ejemplo

import math

# Calcular potencias de punto flotante de 2
print("2 elevado a 0.5:", math.exp2(0.5))    # √2 ≈ 1.414
print("2 elevado a 1.5:", math.exp2(1.5))    # 2√2 ≈ 2.828
print("2 elevado a 2.5:", math.exp2(2.5))    # 4√2 ≈ 5.657

# Verificación con funciones integradas de Python
import math
print("\n"Verificación (2^x = 2 elevado a x):")
for x in [0, 0.5, 1, 1.5, 2, 3]:
    print(f"math.exp2({x}) = {math.exp2(x)}, 2**{x} = {2**x}")

Resultado de la ejecución:

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

Ejemplo 3: Aplicación práctica - Unidades de almacenamiento informático

Las potencias de 2 se utilizan en informática para calcular la capacidad de almacenamiento.

Ejemplo

import math

# Unidades de almacenamiento informático (basadas en potencias de 2)
print("=== Unidades de almacenamiento informático ===")
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(f"1 {unit_name}: {bytes_val:.2e} bytes")
    else:
        print(f"1 {unit_name}: {int(bytes_val)} bytes")

# Dado el tamaño de un archivo, obtener la unidad correspondiente
file_size = 1073741824  # 1GB = 2^30
print(f"\n"Tamaño del archivo {file_size} bytes = {file_size / math.exp2(30):.2f} GB")

Resultado de la ejecución:

=== 计算机存储单位 ===
1 B (字节): 1 字节
1 KB (千字节): 1024 字节
1 MB (兆字节): 1048576 字节
1 GB (吉字节): 1073741824 字节
1 TB (太字节): 1099511627776 字节
1 PB (拍字节): 1.12e+15 字节

文件大小 1073741824 字节 = 1.00 GB

Ejemplo 4: Análisis de complejidad algorítmica

Las potencias de 2 son muy comunes en el análisis de algoritmos y se utilizan para describir el crecimiento exponencial.

Ejemplo

import math

# Mostrar crecimiento exponencial
print("=== Crecimiento exponencial (2^n) ===")
for n in range(1, 11):
    result = math.exp2(n)
    # Visualizar el crecimiento con *
    stars = "*" * min(int(result / math.exp2(4)), 50)
    print(f"n={n:2d}: {int(result):6d} {stars}")

# Complejidad logarítmica: log2(n)
print("\n"=== Complejidad logarítmica (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}")

Resultado de la ejecución:

=== 指数级增长 (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
密码学应用

Ejemplo 5: Criptografía y seguridad de redes

En criptografía, las potencias de 2 se utilizan para calcular el tamaño del espacio de claves.

Ejemplo

import math

# Tamaño del espacio de claves
print("=== Tamaño del espacio de claves ===")
key_lengths = [64, 128, 256, 512]

for bits in key_lengths:
    key_space = math.exp2(bits)
    print(f"Clave de {bits} bits: {key_space:.2e} posibilidades")

# Comparación de fortaleza de seguridad
print("\n"=== Comparación de fortaleza de seguridad ===")
# Supongamos que se pueden intentar 10^18 veces por segundo (10^18)
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"Clave de {bits} bits: se necesitan {years_to_crack:.2e} años para descifrarla")

Resultado de la ejecución: Otras extensiones