# 基礎(chǔ)整數(shù)轉(zhuǎn)浮點數(shù)
int_value = 42
float_value = float(int_value)
print(f"原始整數(shù): {int_value}, 類型: {type(int_value)}")
print(f"轉(zhuǎn)換后浮點數(shù): {float_value}, 類型: {type(float_value)}")
# 輸出:
# 原始整數(shù): 42, 類型: <class 'int'>
# 轉(zhuǎn)換后浮點數(shù): 42.0, 類型: <class 'float'>

# 場景1: 用戶輸入處理
user_input = "100"
int_input = int(user_input)  # 先轉(zhuǎn)整數(shù)
float_input = float(int_input)  # 再轉(zhuǎn)浮點數(shù)
print(f"用戶輸入的浮點數(shù): {float_input}")

# 場景2: 數(shù)學(xué)運算中的隱式轉(zhuǎn)換
result = 10 / 3  # 整數(shù)除法自動返回浮點數(shù)
print(f"10 / 3 = {result} (類型: {type(result)})")  # 輸出: 3.3333333333333335

# 場景3: 顯式轉(zhuǎn)換確保精度
count = 5
total = 100
average = float(total) / count  # 避免整數(shù)除法截斷
print(f"平均值: {average}")  # 輸出: 20.0 而非 20

# 大整數(shù)轉(zhuǎn)換
large_int = 10**18  # 1后面18個0
large_float = float(large_int)
print(f"大整數(shù)轉(zhuǎn)浮點: {large_float}")  # 輸出: 1e+18，仍精確

# 極大整數(shù)可能損失精度
huge_int = 10**30
huge_float = float(huge_int)
# 檢查是否精確
print(f"10**30 == float(10**30)? {huge_int == int(huge_float)}")  # 輸出: True (在合理范圍內(nèi))

# 但超過浮點數(shù)表示范圍會出錯
try:
    too_huge = float(10**309)  # 超出雙精度浮點范圍
except OverflowError as e:
    print(f"錯誤: {e}")  # 輸出: float too large to convert

# 精度丟失示例
n = 2**53 + 1
f = float(n)
print(f"{n} == float({n})? {n == int(f)}")  # 輸出: False!
print(f"原始值: {n}, 浮點表示: {f}, 轉(zhuǎn)回整數(shù): {int(f)}") 
# 輸出: 原始值: 9007199254740993, 浮點表示: 9.007199254740992e+15, 轉(zhuǎn)回整數(shù): 9007199254740992

# 錯誤做法：可能返回整數(shù)（在Python 2中）
avg_bad = 7 / 2  # Python 3中為3.5，但代碼可讀性差

# 正確做法：顯式轉(zhuǎn)換
avg_good = float(7) / 2  # 始終返回3.5

import math

angle_deg = 90  # 整數(shù)角度
angle_rad = float(angle_deg) * math.pi / 180  # 必須轉(zhuǎn)浮點
print(f"sin(90°) = {math.sin(angle_rad)}")  # 輸出: 1.0

price = 199  # 整數(shù)價格（分）
print(f"價格: {float(price)/100:.2f} 元")  # 輸出: 1.99 元

# int() 的截斷行為
print(int(3.7))   # 輸出: 3
print(int(3.2))   # 輸出: 3
print(int(-3.7))  # 輸出: -3 (不是-4！)
print(int(-3.2))  # 輸出: -3

# 金融計算陷阱
account_balance = 99.99  # 賬戶余額（美元）
withdrawal = int(account_balance)  # 用戶想取整數(shù)部分
print(f"可提取: ${withdrawal}")  # 輸出: $99 — 損失了0.99美元！

# 時間處理錯誤
total_seconds = 125.7
minutes = int(total_seconds / 60)  # 期望2分鐘
seconds = total_seconds % 60
print(f"時間: {minutes}分 {seconds:.1f}秒")  # 輸出: 2分 5.7秒 — 但分鐘計算正確嗎？
# 實際: 125.7 / 60 = 2.095 → int(2.095)=2，正確

# round() 基本用法
print(round(3.7))  # 輸出: 4
print(round(3.2))  # 輸出: 3
print(round(2.5))  # 輸出: 2 (注意：Python 3采用"銀行家舍入法")
print(round(3.5))  # 輸出: 4

# 處理負數(shù)
print(round(-2.5))  # 輸出: -2
print(round(-3.5))  # 輸出: -4

import math

# math.floor()：向下取整（朝向負無窮）
print(math.floor(3.7))  # 輸出: 3
print(math.floor(-3.7)) # 輸出: -4

# math.ceil()：向上取整（朝向正無窮）
print(math.ceil(3.2))   # 輸出: 4
print(math.ceil(-3.2))  # 輸出: -3

# 通過字符串格式化實現(xiàn)四舍五入轉(zhuǎn)整數(shù)
value = 3.746
rounded_int = int(f"{value:.0f}")  # 格式化為0位小數(shù)再轉(zhuǎn)整
print(rounded_int)  # 輸出: 4

# 但注意：這依賴于浮點數(shù)的字符串表示
value = 2.5
print(int(f"{value:.0f}"))  # 輸出: 2 — 與round()行為一致

# 錯誤實現(xiàn)：使用int()導(dǎo)致用戶損失折扣
original_price = 199.99
discount_rate = 0.15
discount_amount = original_price * discount_rate  # 29.9985
final_price = original_price - int(discount_amount)  # 199.99 - 29 = 170.99

# 正確做法：使用round()確保合理舍入
correct_discount = round(discount_amount, 2)  # 30.00
correct_final = original_price - correct_discount  # 169.99
print(f"錯誤價格: ${final_price:.2f}, 正確價格: ${correct_final:.2f}")
# 輸出: 錯誤價格: $170.99, 正確價格: $169.99

# 游戲中角色受傷
current_health = 100.0
damage = 25.7

# 錯誤：直接int()導(dǎo)致傷害不足
health_after_bad = current_health - int(damage)  # 100 - 25 = 75

# 正確：使用floor確保傷害不低估
health_after_good = current_health - math.floor(damage)  # 100 - 25 = 75
# 或根據(jù)游戲設(shè)計使用ceil
health_after_critical = current_health - math.ceil(damage)  # 100 - 26 = 74

print(f"錯誤剩余生命: {health_after_bad}, 正確剩余生命: {health_after_good}")

import time

# 獲取當(dāng)前時間戳（浮點秒）
timestamp = time.time()  # 例如 1717020845.123456

# 提取整數(shù)秒部分（向零截斷）
seconds = int(timestamp)
# 提取毫秒部分
milliseconds = int((timestamp - seconds) * 1000)

print(f"時間: {seconds}秒 + {milliseconds}毫秒")

# 但注意：負時間戳處理
negative_ts = -1.7
print(int(negative_ts))      # -1 (截斷)
print(math.floor(negative_ts)) # -2 (正確向下取整)

def round_half_up(n, decimals=0):
    """實現(xiàn)傳統(tǒng)的四舍五入（非銀行家舍入）"""
    multiplier = 10 ** decimals
    return math.floor(n * multiplier + 0.5) / multiplier

print(round_half_up(2.5))  # 輸出: 3.0
print(round_half_up(3.5))  # 輸出: 4.0

# 用于轉(zhuǎn)整數(shù)
print(int(round_half_up(2.5)))  # 輸出: 3

from decimal import Decimal, ROUND_HALF_UP

# 金融級精確計算
amount = Decimal('99.99')
tip = amount * Decimal('0.15')
# 四舍五入到分
rounded_tip = tip.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
total = amount + rounded_tip

print(f"小費: {rounded_tip}, 總計: {total}")
# 輸出: 小費: 15.00, 總計: 114.99

print(0.1 + 0.2 == 0.3)  # 輸出: False!
print(0.1 + 0.2)         # 輸出: 0.30000000000000004

def float_to_binary(f):
    """展示浮點數(shù)的二進制表示（簡化版）"""
    import struct
    [d] = struct.unpack(">Q", struct.pack(">d", f))
    return f"{d:064b}"

print("0.1 的二進制:", float_to_binary(0.1)[-10:])
print("0.2 的二進制:", float_to_binary(0.2)[-10:])
print("0.3 的二進制:", float_to_binary(0.3)[-10:])
# 輸出顯示尾部位不匹配

def is_close(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

print(is_close(0.1 + 0.2, 0.3))  # 輸出: True

import math
print(math.isclose(0.1 + 0.2, 0.3))  # 輸出: True

# 陷阱1：浮點轉(zhuǎn)整數(shù)時的微小誤差
value = 0.3 / 0.1  # 期望3.0，實際≈2.9999999999999996
print(int(value))  # 輸出: 2 (而非3！)

# 安全做法：添加容差
safe_int = int(value + 1e-10)
print(safe_int)  # 輸出: 3

# 陷阱2：大數(shù)轉(zhuǎn)換
n = 10000000000000001
f = float(n)
print(n == int(f))  # 輸出: False (精度丟失)

# 用分計算避免浮點誤差
price_cents = 199  # 1.99元
tax_rate = 15      # 15%
total_cents = price_cents * (100 + tax_rate) // 100
print(f"總計: {total_cents/100:.2f}元")  # 安全輸出

# 提取特定小數(shù)位作為整數(shù)
value = 3.14159
# 取兩位小數(shù)轉(zhuǎn)整數(shù)（314）
integer_part = int(str(value).replace('.', '')[:3])
print(integer_part)  # 輸出: 314

# 但注意：浮點精度問題可能導(dǎo)致意外
value = 0.1 + 0.2
print(str(value))  # '0.30000000000000004' — 影響字符串轉(zhuǎn)換

def extract_decimal_digits(f, digits=2):
    """提取指定小數(shù)位作為整數(shù)（安全版）"""
    scaled = f * (10 ** digits)
    return int(round(scaled))  # 先四舍五入再轉(zhuǎn)整

print(extract_decimal_digits(3.14159, 2))  # 輸出: 14
print(extract_decimal_digits(0.1 + 0.2, 1))  # 輸出: 3

import struct

def float_to_int_bits(f):
    """將浮點數(shù)轉(zhuǎn)為64位整數(shù)表示（IEEE 754）"""
    return struct.unpack('>Q', struct.pack('>d', f))[0]

def int_bits_to_float(i):
    """將64位整數(shù)轉(zhuǎn)回浮點數(shù)"""
    return struct.unpack('>d', struct.pack('>Q', i))[0]

pi = 3.1415926535
bits = float_to_int_bits(pi)
print(f"Pi的位表示: {bin(bits)[-32:]}...")  # 顯示部分二進制

# 修改位模式（實驗性）
modified_bits = bits | (1 << 52)  # 設(shè)置某一位
modified_pi = int_bits_to_float(modified_bits)
print(f"修改后的Pi: {modified_pi}")

import timeit

# 設(shè)置測試參數(shù)
N = 10_000_000  # 一千萬次操作

# 測試int()轉(zhuǎn)換
int_time = timeit.timeit(
    'int(3.14)', 
    number=N
)
print(f"int(3.14) 耗時: {int_time:.4f}秒")

# 測試round()轉(zhuǎn)換
round_time = timeit.timeit(
    'round(3.14)', 
    number=N
)
print(f"round(3.14) 耗時: {round_time:.4f}秒")

# 測試math.floor
import math
floor_time = timeit.timeit(
    'math.floor(3.14)', 
    globals=globals(),
    number=N
)
print(f"math.floor(3.14) 耗時: {floor_time:.4f}秒")

# 結(jié)果示例（實際值因機器而異）:
# int(3.14) 耗時: 0.8521秒
# round(3.14) 耗時: 1.9843秒
# math.floor(3.14) 耗時: 1.2037秒

import sys

small_int = 10
small_float = float(small_int)
print(f"小整數(shù)內(nèi)存: {sys.getsizeof(small_int)}字節(jié)")
print(f"小浮點數(shù)內(nèi)存: {sys.getsizeof(small_float)}字節(jié)")

huge_int = 10**100
huge_float = float(huge_int)  # 可能損失精度
print(f"大整數(shù)內(nèi)存: {sys.getsizeof(huge_int)}字節(jié)")
print(f"大浮點數(shù)內(nèi)存: {sys.getsizeof(huge_float)}字節(jié)")
# 輸出:
# 小整數(shù)內(nèi)存: 28字節(jié)
# 小浮點數(shù)內(nèi)存: 24字節(jié)
# 大整數(shù)內(nèi)存: 84字節(jié)
# 大浮點數(shù)內(nèi)存: 24字節(jié)

# 原始低效實現(xiàn)
pixels_float = [0.5, 0.25, 0.75]
pixels_int = [int(p * 255) for p in pixels_float]

# 優(yōu)化1：避免列表推導(dǎo)中的重復(fù)乘法
SCALE = 255
pixels_int = [int(p * SCALE) for p in pixels_float]

# 優(yōu)化2：使用map()（微幅提升）
pixels_int = list(map(lambda p: int(p * SCALE), pixels_float))

# 優(yōu)化3：NumPy向量化（顯著提升）
import numpy as np
pixels_array = np.array(pixels_float)
pixels_int_np = (pixels_array * SCALE).astype(int)

# views.py (危險代碼!)
def create_product(request):
    price_str = request.POST['price']
    price_float = float(price_str)  # 轉(zhuǎn)浮點
    # 直接使用浮點計算折扣
    discounted = price_float * 0.9
    # 存儲到數(shù)據(jù)庫（假設(shè)字段為FloatField）
    Product.objects.create(price=discounted)

from decimal import Decimal

def create_product(request):
    price_str = request.POST['price']
    # 直接轉(zhuǎn)Decimal（避免浮點中間表示）
    price_dec = Decimal(price_str)
    
    # 精確計算折扣（保留2位小數(shù)）
    discounted = price_dec * Decimal('0.9')
    discounted = discounted.quantize(Decimal('0.01'))
    
    # 存儲到DecimalField
    Product.objects.create(price=discounted)
    
    # 需要整數(shù)分時
    price_in_cents = int(discounted * 100)

city,temperature_c
New York,22.5
London,18.3
Tokyo,26.7

import pandas as pd

df = pd.read_csv('temperatures.csv')
# 危險：直接使用浮點轉(zhuǎn)換
df['temperature_f'] = df['temperature_c'] * 9/5 + 32

# 按整數(shù)華氏度分組
df['group'] = df['temperature_f'].apply(int)  # 截斷小數(shù)
print(df)

# 正確轉(zhuǎn)換與分組
def c_to_f(c):
    """攝氏轉(zhuǎn)華氏（精確計算）"""
    return round(c * 9/5 + 32)  # 四舍五入到整數(shù)

df['temperature_f'] = df['temperature_c'].apply(c_to_f)

# 安全分組（避免浮點誤差）
df['group'] = (df['temperature_f'] // 10).astype(int) * 10
# 例如 73 → 70, 85 → 80

print(df)

# 更高效的方式
df['temperature_f'] = (df['temperature_c'] * 1.8 + 32).round().astype(int)

# sensor.py
import dht
import machine

sensor = dht.DHT22(machine.Pin(4))
sensor.measure()
temp = sensor.temperature()  # 浮點溫度

# 直接轉(zhuǎn)整顯示
display.show(int(temp))  # 可能顯示22.9°C為22°C（應(yīng)為23°C）

def safe_display_temp():
    try:
        sensor.measure()
        temp = sensor.temperature()
        # 添加容差處理浮點誤差
        temp_rounded = round(temp + 1e-5)  # 避免22.999...顯示為22
        display.show(int(temp_rounded))
    except OSError as e:
        # 錯誤處理（傳感器故障）
        display.show(-1)  # 錯誤代碼

# 直接計算整數(shù)部分（無round函數(shù)調(diào)用）
temp_int = int(temp + 0.5) if temp >= 0 else int(temp - 0.5)
display.show(temp_int)

def debug_convert(value):
    print(f"輸入: {value} (類型: {type(value).__name__})")
    result = int(value)  # 或其他轉(zhuǎn)換
    print(f"轉(zhuǎn)換后: {result} (類型: {type(result).__name__})")
    # 檢查精度損失
    if isinstance(value, float):
        print(f"原始浮點: {value:.20f}")
    return result

debug_convert(3.7)   # 顯示截斷
debug_convert(-2.5)  # 顯示向零截斷

def calculate_discount(price, rate):
    # 確保輸入是Decimal或整數(shù)分
    assert isinstance(price, (int, Decimal)), "價格必須為整數(shù)或Decimal"
    assert 0 <= rate <= 1, "折扣率必須在0-1之間"
    
    discount = price * rate
    # 確保折扣是精確值
    assert discount == round(discount, 2), "折扣計算不精確"
    return discount

import math

def test_float_conversion():
    # 測試0.1+0.2=0.3場景
    assert math.isclose(0.1 + 0.2, 0.3), "浮點加法錯誤"
    
    # 測試轉(zhuǎn)換邊界
    assert int(2.999999999999999) == 2, "截斷行為錯誤"
    assert round(2.5) == 2, "舍入行為錯誤"  # 注意銀行家舍入

test_float_conversion()

import unittest
import math

class TestConversions(unittest.TestCase):
    
    def test_int_to_float(self):
        self.assertEqual(float(42), 42.0)
        self.assertEqual(type(float(42)), float)
    
    def test_float_to_int_truncation(self):
        self.assertEqual(int(3.9), 3)
        self.assertEqual(int(-3.9), -3)
    
    def test_rounding_methods(self):
        self.assertEqual(round(2.5), 2)  # 銀行家舍入
        self.assertEqual(math.floor(2.9), 2)
        self.assertEqual(math.ceil(2.1), 3)
    
    def test_precision_boundary(self):
        # 測試2^53邊界
        n = 2**53
        self.assertEqual(int(float(n)), n)
        self.assertNotEqual(int(float(n + 1)), n + 1)
    
    def test_float_comparison(self):
        # 安全比較
        self.assertTrue(math.isclose(0.1 + 0.2, 0.3))

if __name__ == '__main__':
    unittest.main()

def calculate(x: float) -> int:
    return int(x)  # mypy會驗證輸入是否為float

calculate(10)  # 錯誤：參數(shù)應(yīng)為float

pylint --enable=unsubscriptable-object your_script.py

# 向下取整確保資源充足（非截斷?。?
required_servers = math.floor(total_users / users_per_server)

def to_cents(dollars: float) -> int:
    """安全轉(zhuǎn)分（四舍五入）"""
    return int(round(dollars * 100))

CENTS_PER_DOLLAR = 100
PERCENTAGE_SCALE = 100