2.2.进制

# 十进制 (Decimal) - 默认，无前缀)
dec_num = 100
print(dec_num)  # 输出: 100

# 二进制 (Binary) - 前缀 `0b` 或 `0B`
bin_num = 0b1100100 # 这就是十进制的 100
print(bin_num)      # 输出: 100 (Python会自动以十进制形式打印)

# 八进制 (Octal) - 前缀 `0o` 或 `0O`
oct_num = 0o144     # 这就是十进制的 100
print(oct_num)      # 输出: 100

# 十六进制 (Hexadecimal) - 前缀 `0x` 或 `0X`
hex_num = 0x64      # 这就是十进制的 100
print(hex_num)      # 输出: 100

num = 255

# 转换为不同进制的字符串
bin_str = bin(num)
oct_str = oct(num)
hex_str = hex(num)

print(f"十进制 {num}:")
print(f"二进制  {bin_str}")  # 输出: 0b11111111
print(f"八进制  {oct_str}")  # 输出: 0o377
print(f"十六进制 {hex_str}")  # 输出: 0xff

# 将二进制字符串（不带前缀也可）转换为十进制
binary_string = "11111111"
# binary_string = "0b11111111" # 带前缀也可以
decimal_from_bin = int(binary_string, 2)
print(f"二进制 {binary_string} 是十进制 {decimal_from_bin}") # 输出: 255

# 将八进制字符串转换为十进制
octal_string = "377"
decimal_from_oct = int(octal_string, 8)
print(f"八进制 {octal_string} 是十进制 {decimal_from_oct}") # 输出: 255

# 将十六进制字符串转换为十进制
hex_string = "ff" # 大小写均可
# hex_string = "0xFF" # 带前缀也可以
decimal_from_hex = int(hex_string, 16)
print(f"十六进制 {hex_string} 是十进制 {decimal_from_hex}") # 输出: 255

# 甚至可以转换自定义进制的字符串，比如三进制
ternary_string = "100110"
decimal_from_ternary = int(ternary_string, 3)
print(f"三进制 {ternary_string} 是十进制 {decimal_from_ternary}") # 输出: 255 (1*3^5 + 1*3^2 + 1*3^1 = 255)

# 一个红色值
red_hex = "#FF0000"

# 提取出RGB分量并转换为十进制
red_component = int(red_hex[1:3], 16) # 取 ‘FF’， 以16进制解析
green_component = int(red_hex[3:5], 16) # 取 ‘00’
blue_component = int(red_hex[5:7], 16) # 取 ‘00’

print(f"颜色 {red_hex} 的RGB分量为：")
print(f"  R: {red_component}")
print(f"  G: {green_component}")
print(f"  B: {blue_component}")
# 输出:
# R: 255
# G: 0
# B: 0

num = 42

# 方法1：使用字符串切片
hex_with_prefix = hex(num) # 0x2a
hex_without_prefix_1 = hex_with_prefix[2:] # 从第2个字符开始截取 2a
print(hex_without_prefix_1)#2a

# 方法2：使用格式化字符串 (f-string) - 更推荐！
# 格式： `：x` 表示十六进制， `：b` 表示二进制， `：o` 表示八进制
hex_without_prefix_2 = f"{num:x}" # 小写
hex_without_prefix_3 = f"{num:X}" # 大写
bin_without_prefix = f"{num:b}"

print(hex_without_prefix_2) # 输出： 2a
print(hex_without_prefix_3) # 输出： 2A
print(bin_without_prefix)   # 输出： 101010

# 一个数字在内存中的比特表示
num = 65
binary = bin(num)  # 0b1000001
print(f"数字 {num} 的二进制表示：{binary}")
print(f"占用 {len(binary) - 2} 个比特位")  # 减去 '0b' 前缀

# 字符与字节
char = 'A'
print(f"字符 '{char}' 的 ASCII 码：{ord(char)}")  # 65
print(f"二进制表示：{bin(ord(char))}")  # 0b1000001
print(f"占用：1 个字节（8 个比特）")

# 字符串的字节长度
text = "Hello"
bytes_data = text.encode('utf-8')
print(f"\n字符串 '{text}' 占用 {len(bytes_data)} 个字节")

# 查看每个字节
print("每个字节的值：", [byte for byte in bytes_data])
# [72, 101, 108, 108, 111] - 对应 H e l l o 的 ASCII 码

100 Mbps = 100,000,000 bits per second
100,000,000 bps ÷ 8 = 12,500,000 Bps ≈ 12.5 MB/s

def format_file_size(size_in_bytes):
    """
    将字节数格式化为人类可读的字符串 (使用二进制前缀 KiB, MiB 等)
    
    参数:
        size_in_bytes: 文件大小（字节）
    返回:
        格式化后的字符串
    """
    # 定义单位阶梯
    units = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB']
    size = float(size_in_bytes)
    index = 0

    # 循环除以1024，直到找到合适的单位
    while size >= 1024 and index < len(units) - 1:
        size /= 1024.0
        index += 1

    # 格式化输出，保留2位小数
    return f"{size:.2f} {units[index]}"

# 测试不同大小的文件
file_sizes = [
    500,                # 500 字节
    1536,               # 1.5 KiB
    1048576,            # 1 MiB
    3221225472,         # 3 GiB
    1099511627776       # 1 TiB
]

print("文件大小转换示例：")
for size in file_sizes:
    print(f"{size:>15} 字节 = {format_file_size(size)}")

# 输出：
#             500 字节 = 500.00 B
#            1536 字节 = 1.50 KiB
#         1048576 字节 = 1.00 MiB
#      3221225472 字节 = 3.00 GiB
#   1099511627776 字节 = 1.00 TiB

def mbps_to_mb_per_second(mbps_speed):
    """
    将网络速度从 Mbps (兆比特/秒) 转换为 MB/s (兆字节/秒)
    
    参数:
        mbps_speed: 网络带宽（Mbps）
    返回:
        下载速度（MB/s）
    """
    mb_per_second = mbps_speed / 8.0
    return mb_per_second

# 测试不同的宽带速度
bandwidths = [50, 100, 300, 500, 1000]  # 常见的宽带速度

print("\n网络带宽与下载速度对照表：")
print("-" * 50)
print(f"{'带宽':<10} {'理论最大下载速度':<20}")
print("-" * 50)

for bw in bandwidths:
    download_speed = mbps_to_mb_per_second(bw)
    print(f"{bw:>6} Mbps -> {download_speed:>8.2f} MB/s")

# 输出：
# 网络带宽与下载速度对照表：
# --------------------------------------------------
# 带宽         理论最大下载速度        
# --------------------------------------------------
#     50 Mbps ->     6.25 MB/s
#    100 Mbps ->    12.50 MB/s
#    300 Mbps ->    37.50 MB/s
#    500 Mbps ->    62.50 MB/s
#   1000 Mbps ->   125.00 MB/s

def calculate_download_time(file_size_mb, bandwidth_mbps):
    """
    计算文件下载所需时间
    
    参数:
        file_size_mb: 文件大小（MB）
        bandwidth_mbps: 网络带宽（Mbps）
    返回:
        下载时间（秒）
    """
    # 将文件大小转换为 Mb (兆比特)
    file_size_mb_bits = file_size_mb * 8
    
    # 计算时间（秒）
    time_seconds = file_size_mb_bits / bandwidth_mbps
    
    return time_seconds

# 测试：下载一个 2GB 的电影
file_size = 2 * 1024  # 2048 MB
bandwidths = [50, 100, 300, 1000]

print("\n下载 2GB 电影所需时间：")
print("-" * 50)

for bw in bandwidths:
    time_sec = calculate_download_time(file_size, bw)
    time_min = time_sec / 60
    
    if time_min < 1:
        print(f"{bw:>4} Mbps: {time_sec:.1f} 秒")
    else:
        print(f"{bw:>4} Mbps: {time_min:.1f} 分钟 ({time_sec:.0f} 秒)")

# 输出示例：
#  50 Mbps: 5.5 分钟 (327 秒)
# 100 Mbps: 2.7 分钟 (164 秒)
# 300 Mbps: 54.6 秒
# 1000 Mbps: 16.4 秒

# 查看一个数字的比特表示
def show_bits(number, byte_count=1):
    """显示数字的比特表示"""
    # 转换为二进制字符串（去掉 0b 前缀）
    binary = bin(number)[2:]
    
    # 填充到指定字节数
    total_bits = byte_count * 8
    binary = binary.zfill(total_bits)
    
    # 格式化输出（每8位一组）
    formatted = ' '.join([binary[i:i+8] for i in range(0, len(binary), 8)])
    
    print(f"数字 {number} 的比特表示：")
    print(f"  二进制: {formatted}")
    print(f"  占用: {byte_count} 字节 ({total_bits} 比特)")

# 测试
show_bits(65, 1)   # 字符 'A'
print()
show_bits(255, 1)  # 最大的单字节数
print()
show_bits(1024, 2) # 需要2个字节

# 输出：
# 数字 65 的比特表示：
#   二进制: 01000001
#   占用: 1 字节 (8 比特)
# 
# 数字 255 的比特表示：
#   二进制: 11111111
#   占用: 1 字节 (8 比特)
# 
# 数字 1024 的比特表示：
#   二进制: 00000100 00000000
#   占用: 2 字节 (16 比特)

# 为什么 1TB 硬盘实际只有 931GB？
advertised_tb = 1  # 厂商标称 1TB
advertised_bytes = advertised_tb * 1000 * 1000 * 1000 * 1000  # 厂商用1000进制

# 转换为系统显示的容量（1024进制）
actual_gib = advertised_bytes / (1024 ** 3)

print(f"厂商标称: {advertised_tb} TB")
print(f"实际容量: {advertised_bytes:,} 字节")
print(f"系统显示: {actual_gib:.2f} GiB")

# 输出：
# 厂商标称: 1 TB
# 实际容量: 1,000,000,000,000 字节
# 系统显示: 931.32 GiB

# 小心大小写！
print("Byte (B，大写) = 字节，用于存储容量")
print("bit (b，小写) = 比特，用于传输速度")
print()
print("100 MB = 100 兆字节 = 800 兆比特 = 800 Mb")
print("100 Mb = 100 兆比特 = 12.5 兆字节 = 12.5 MB")

class StorageConverter:
    """存储单位转换工具类"""
    
    @staticmethod
    def bytes_to_human(bytes_count, binary=True):
        """将字节转换为人类可读格式"""
        if binary:
            units = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB']
            base = 1024
        else:
            units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
            base = 1000
        
        size = float(bytes_count)
        for unit in units[:-1]:
            if abs(size) < base:
                return f"{size:.2f} {unit}"
            size /= base
        return f"{size:.2f} {units[-1]}"
    
    @staticmethod
    def mbps_to_mbytes(mbps):
        """将 Mbps 转换为 MB/s"""
        return mbps / 8
    
    @staticmethod
    def mbytes_to_mbps(mbytes):
        """将 MB/s 转换为 Mbps"""
        return mbytes * 8

# 使用示例
converter = StorageConverter()

# 转换文件大小
print(converter.bytes_to_human(1536000000))  # 1.43 GiB
print(converter.bytes_to_human(1536000000, binary=False))  # 1.54 GB

# 转换网速
print(f"100 Mbps = {converter.mbps_to_mbytes(100):.2f} MB/s")
print(f"12.5 MB/s = {converter.mbytes_to_mbps(12.5):.0f} Mbps")