# int() 的截?cái)嘈袨?
print(int(3.7))   # 輸出: 3
print(int(3.2))   # 輸出: 3
print(int(-3.7))  # 輸出: -3 (不是-4！)
print(int(-3.2))  # 輸出: -3

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

# 時(shí)間處理錯(cuò)誤
total_seconds = 125.7
minutes = int(total_seconds / 60)  # 期望2分鐘
seconds = total_seconds % 60
print(f"時(shí)間: {minutes}分 {seconds:.1f}秒")  # 輸出: 2分 5.7秒 — 但分鐘計(jì)算正確嗎？
# 實(shí)際: 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

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

import math

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

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

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

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

# 錯(cuò)誤實(shí)現(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"錯(cuò)誤價(jià)格: ${final_price:.2f}, 正確價(jià)格: ${correct_final:.2f}")
# 輸出: 錯(cuò)誤價(jià)格: $170.99, 正確價(jià)格: $169.99

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

# 錯(cuò)誤：直接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è)計(jì)使用ceil
health_after_critical = current_health - math.ceil(damage)  # 100 - 26 = 74

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

import time

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

# 提取整數(shù)秒部分（向零截?cái)啵?
seconds = int(timestamp)
# 提取毫秒部分
milliseconds = int((timestamp - seconds) * 1000)

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

# 但注意：負(fù)時(shí)間戳處理
negative_ts = -1.7
print(int(negative_ts))      # -1 (截?cái)?
print(math.floor(negative_ts)) # -2 (正確向下取整)

def round_half_up(n, decimals=0):
    """實(shí)現(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

# 金融級(jí)精確計(jì)算
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"小費(fèi): {rounded_tip}, 總計(jì): {total}")
# 輸出: 小費(fèi): 15.00, 總計(jì): 114.99

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

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

print("0.1 的二進(jìn)制:", float_to_binary(0.1)[-10:])
print("0.2 的二進(jìn)制:", float_to_binary(0.2)[-10:])
print("0.3 的二進(jìn)制:", 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：浮點(diǎn)轉(zhuǎn)整數(shù)時(shí)的微小誤差
value = 0.3 / 0.1  # 期望3.0，實(shí)際≈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 (精度丟失)

# 用分計(jì)算避免浮點(diǎn)誤差
price_cents = 199  # 1.99元
tax_rate = 15      # 15%
total_cents = price_cents * (100 + tax_rate) // 100
print(f"總計(jì): {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

# 但注意：浮點(diǎn)精度問(wèn)題可能導(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):
    """將浮點(diǎn)數(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)回浮點(diǎ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:]}...")  # 顯示部分二進(jìn)制

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

import timeit

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

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

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

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

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

import sys

small_int = 10
small_float = float(small_int)
print(f"小整數(shù)內(nèi)存: {sys.getsizeof(small_int)}字節(jié)")
print(f"小浮點(diǎn)數(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"大浮點(diǎn)數(shù)內(nèi)存: {sys.getsizeof(huge_float)}字節(jié)")
# 輸出:
# 小整數(shù)內(nèi)存: 28字節(jié)
# 小浮點(diǎn)數(shù)內(nèi)存: 24字節(jié)
# 大整數(shù)內(nèi)存: 84字節(jié)
# 大浮點(diǎn)數(shù)內(nèi)存: 24字節(jié)

# 原始低效實(shí)現(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 (危險(xiǎn)代碼!)
def create_product(request):
    price_str = request.POST['price']
    price_float = float(price_str)  # 轉(zhuǎn)浮點(diǎn)
    # 直接使用浮點(diǎn)計(jì)算折扣
    discounted = price_float * 0.9
    # 存儲(chǔ)到數(shù)據(jù)庫(kù)（假設(shè)字段為FloatField）
    Product.objects.create(price=discounted)

from decimal import Decimal

def create_product(request):
    price_str = request.POST['price']
    # 直接轉(zhuǎn)Decimal（避免浮點(diǎn)中間表示）
    price_dec = Decimal(price_str)
    
    # 精確計(jì)算折扣（保留2位小數(shù)）
    discounted = price_dec * Decimal('0.9')
    discounted = discounted.quantize(Decimal('0.01'))
    
    # 存儲(chǔ)到DecimalField
    Product.objects.create(price=discounted)
    
    # 需要整數(shù)分時(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')
# 危險(xiǎn)：直接使用浮點(diǎn)轉(zhuǎn)換
df['temperature_f'] = df['temperature_c'] * 9/5 + 32

# 按整數(shù)華氏度分組
df['group'] = df['temperature_f'].apply(int)  # 截?cái)嘈?shù)
print(df)

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

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

# 安全分組（避免浮點(diǎn)誤差）
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()  # 浮點(diǎn)溫度

# 直接轉(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()
        # 添加容差處理浮點(diǎn)誤差
        temp_rounded = round(temp + 1e-5)  # 避免22.999...顯示為22
        display.show(int(temp_rounded))
    except OSError as e:
        # 錯(cuò)誤處理（傳感器故障）
        display.show(-1)  # 錯(cuò)誤代碼

# 直接計(jì)算整數(shù)部分（無(wú)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} (類(lèi)型: {type(value).__name__})")
    result = int(value)  # 或其他轉(zhuǎn)換
    print(f"轉(zhuǎn)換后: {result} (類(lèi)型: {type(result).__name__})")
    # 檢查精度損失
    if isinstance(value, float):
        print(f"原始浮點(diǎn): {value:.20f}")
    return result

debug_convert(3.7)   # 顯示截?cái)?
debug_convert(-2.5)  # 顯示向零截?cái)?

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

import math

def test_float_conversion():
    # 測(cè)試0.1+0.2=0.3場(chǎng)景
    assert math.isclose(0.1 + 0.2, 0.3), "浮點(diǎn)加法錯(cuò)誤"
    
    # 測(cè)試轉(zhuǎn)換邊界
    assert int(2.999999999999999) == 2, "截?cái)嘈袨殄e(cuò)誤"
    assert round(2.5) == 2, "舍入行為錯(cuò)誤"  # 注意銀行家舍入

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):
        # 測(cè)試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會(huì)驗(yàn)證輸入是否為float

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

pylint --enable=unsubscriptable-object your_script.py

# 向下取整確保資源充足（非截?cái)啵。?
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