Python实现数值取整方法的完全指南

def bankers_round(value, ndigits=0):
    """实现银行家舍入法"""
    # 处理整数
    if ndigits == 0:
        # 获取小数部分
        fractional = value - math.floor(value)
        
        # 整数部分
        integer_part = math.floor(value)
        
        # 判断中间值
        if fractional == 0.5:
            # 五成双：偶数向下，奇数向上
            return integer_part if integer_part % 2 == 0 else integer_part + 1
        else:
            return round(value)
    else:
        # 处理小数位
        multiplier = 10 ** ndigits
        scaled = value * multiplier
        return bankers_round(scaled) / multiplier

# 测试
print(bankers_round(2.5))  # 2
print(bankers_round(3.5))  # 4
print(bankers_round(4.5))  # 4
print(bankers_round(2.535, 2))  # 2.54

def round_to_multiple(value, base, direction='nearest'):
    """向指定基数的倍数取整"""
    if direction == 'nearest':
        return base * round(value / base)
    elif direction == 'down':
        return base * math.floor(value / base)
    elif direction == 'up':
        return base * math.ceil(value / base)
    elif direction == 'toward_zero':
        return base * math.trunc(value / base)
    else:
        raise ValueError("Invalid direction")

# 测试
print(round_to_multiple(17, 5))  # 15 (nearest)
print(round_to_multiple(17, 5, 'up'))  # 20
print(round_to_multiple(17, 5, 'down'))  # 15
print(round_to_multiple(-17, 5, 'toward_zero'))  # -15

from fractions import Fraction

def round_to_fraction(value, denominator):
    """取整到最接近的分数"""
    fraction = Fraction(value).limit_denominator(denominator)
    return float(fraction)

# 测试
print(round_to_fraction(3.14159, 100))  # 3.14 (157/50)
print(round_to_fraction(1.333, 4))  # 1.25 (5/4)

import numpy as np

# 创建数组
arr = np.array([1.23, 4.56, 7.89, 10.12])

# 四舍五入到整数
rounded = np.round(arr)  # [1., 5., 8., 10.]

# 向下取整
floored = np.floor(arr)  # [1., 4., 7., 10.]

# 向上取整
ceiled = np.ceil(arr)  # [2., 5., 8., 11.]

# 指定小数位
rounded_dec = np.round(arr, 1)  # [1.2, 4.6, 7.9, 10.1]

# 向5的倍数取整
rounded_5 = np.round(arr / 5) * 5  # [0., 5., 10., 10.]

from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN

def currency_round(value, currency='USD'):
    """货币计算取整"""
    # 不同货币的小数位
    decimals = {
        'USD': 2,
        'JPY': 0,
        'BTC': 8,
        'KRW': 0
    }
    
    # 获取小数位
    places = decimals.get(currency, 2)
    
    # 使用Decimal精确计算
    d = Decimal(str(value))
    return float(d.quantize(Decimal(f'1e-{places}'), rounding=ROUND_HALF_UP))

# 测试
print(currency_round(123.456, 'USD'))  # 123.46
print(currency_round(123.456, 'JPY'))  # 123.0
print(currency_round(0.12345678, 'BTC'))  # 0.12345678

def tax_calculation(income, tax_rate=0.2, brackets=None):
    """税 务计算（考虑税级）"""
    # 默认税级
    if brackets is None:
        brackets = [
            (10000, 0.1),
            (50000, 0.2),
            (100000, 0.3)
        ]
    
    tax = 0
    prev_bracket = 0
    
    for bracket, rate in brackets:
        if income <= prev_bracket:
            break
        
        # 计算当前税级应纳税部分
        bracket_amount = min(income, bracket) - prev_bracket
        # 税 务取整规则：向上取整到整数
        bracket_tax = math.ceil(bracket_amount * rate)
        tax += bracket_tax
        
        prev_bracket = bracket
    
    # 处理超过最高税级部分
    if income > prev_bracket:
        excess = income - prev_bracket
        # 最高税率
        max_rate = brackets[-1][1]
        tax += math.ceil(excess * max_rate)
    
    return tax

# 测试
income = 75000
tax = tax_calculation(income)
print(f"收入${income}的税额: ${tax}")  # 收入$75000的税额: $12500

def bin_data(data, bin_size, method='floor'):
    """数据分箱处理"""
    if method == 'floor':
        return [math.floor(x / bin_size) * bin_size for x in data]
    elif method == 'ceil':
        return [math.ceil(x / bin_size) * bin_size for x in data]
    elif method == 'round':
        return [round(x / bin_size) * bin_size for x in data]
    elif method == 'midpoint':
        return [math.floor(x / bin_size) * bin_size + bin_size / 2 for x in data]
    else:
        raise ValueError("Invalid binning method")

# 测试
data = [1.2, 3.7, 5.1, 7.8, 9.4]
binned = bin_data(data, 2, 'floor')  # [0.0, 2.0, 4.0, 6.0, 8.0]

import pandas as pd

def feature_rounding(df, config):
    """特征工程取整处理"""
    df_rounded = df.copy()
    
    for col, method in config.items():
        if method == 'int':
            df_rounded[col] = df[col].astype(int)
        elif method == 'floor':
            df_rounded[col] = np.floor(df[col])
        elif method == 'ceil':
            df_rounded[col] = np.ceil(df[col])
        elif method == 'round':
            df_rounded[col] = np.round(df[col])
        elif method == 'bankers':
            df_rounded[col] = df[col].apply(bankers_round)
        elif isinstance(method, int):
            df_rounded[col] = np.round(df[col], method)
        elif isinstance(method, tuple) and method[0] == 'multiple':
            base = method[1]
            df_rounded[col] = base * np.round(df[col] / base)
    
    return df_rounded

# 使用示例
data = {
    'price': [19.99, 29.50, 45.75, 99.99],
    'quantity': [1.5, 2.0, 1.75, 3.0],
    'rating': [4.2, 3.8, 4.5, 4.0]
}
df = pd.DataFrame(data)

config = {
    'price': 'int',         # 截断取整
    'quantity': 'ceil',      # 向上取整
    'rating': 1             # 四舍五入到1位小数
}

rounded_df = feature_rounding(df, config)
"""
   price  quantity  rating
0     19       2.0     4.2
1     29       2.0     3.8
2     45       2.0     4.5
3     99       3.0     4.0
"""

class SensorDataProcessor:
    """传感器数据处理系统"""
    def __init__(self, precision=0.01, rounding='round'):
        self.precision = precision
        self.rounding = rounding
        self.calibration_factor = 1.0
    
    def calibrate(self, reference_value, readings):
        """校准传感器"""
        avg_reading = sum(readings) / len(readings)
        self.calibration_factor = reference_value / avg_reading
    
    def process_reading(self, raw_value):
        """处理原始读数"""
        # 应用校准
        calibrated = raw_value * self.calibration_factor
        
        # 根据配置取整
        if self.rounding == 'round':
            return round(calibrated / self.precision) * self.precision
        elif self.rounding == 'floor':
            return math.floor(calibrated / self.precision) * self.precision
        elif self.rounding == 'ceil':
            return math.ceil(calibrated / self.precision) * self.precision
        else:
            return calibrated
    
    def batch_process(self, raw_values):
        """批量处理读数"""
        return [self.process_reading(v) for v in raw_values]

# 使用示例
sensor = SensorDataProcessor(precision=0.1, rounding='round')
sensor.calibrate(100.0, [98.5, 99.2, 101.3])  # 校准因子≈1.005

readings = [99.0, 100.5, 102.3]
processed = sensor.batch_process(readings)  # [99.5, 101.0, 102.8]

def engineering_round(value, significant_digits=3):
    """工程取整（保留有效数字）"""
    if value == 0:
        return 0.0
    
    # 计算数量级
    magnitude = math.floor(math.log10(abs(value)))
    
    # 计算缩放因子
    scale = 10 ** (magnitude - significant_digits + 1)
    
    # 取整并缩放
    return round(value / scale) * scale

# 测试
print(engineering_round(123456, 3))  # 123000
print(engineering_round(0.00123456, 3))  # 0.00123
print(engineering_round(12.3456, 3))  # 12.3

import timeit
import math

# 测试数据
values = [x * 0.1 for x in range(1000000)]

# 测试函数
def test_round():
    return [round(x) for x in values]

def test_math_floor():
    return [math.floor(x) for x in values]

def test_int():
    return [int(x) for x in values]

def test_numpy_round():
    arr = np.array(values)
    return np.round(arr)

# 性能测试
methods = {
    "round": test_round,
    "math.floor": test_math_floor,
    "int": test_int,
    "numpy.round": test_numpy_round
}

results = {}
for name, func in methods.items():
    time = timeit.timeit(func, number=1)
    results[name] = time

print("100万次操作耗时:")
for name, time in sorted(results.items(), key=lambda x: x[1]):
    print(f"{name}: {time:.4f}秒")

# 使用Decimal进行精确金融计算
from decimal import Decimal, ROUND_HALF_EVEN
amount = Decimal('123.456').quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN)

# 使用Pandas/NumPy进行向量化操作
df['rounded'] = np.round(df['values'], 2)

# 保留有效数字
def engineering_round(value, sig_digits=3):
    if value == 0: return 0
    scale = 10 ** (math.floor(math.log10(abs(value))) - sig_digits + 1)
    return round(value / scale) * scale

# 避免循环内重复取整
# 错误做法
for value in large_list:
    result = round(value, 2)

# 正确做法
rounded_list = [round(v, 2) for v in large_list]

# 处理NaN和Inf
def safe_round(value, digits=0):
    if math.isnan(value) or math.isinf(value):
        return value
    return round(value, digits)

class TestRounding(unittest.TestCase):
    def test_bankers_round(self):
        self.assertEqual(bankers_round(2.5), 2)
        self.assertEqual(bankers_round(3.5), 4)
    
    def test_currency_round(self):
        self.assertEqual(currency_round(123.456, 'USD'), 123.46)
        self.assertEqual(currency_round(123.456, 'JPY'), 123)

# 浮点数精度问题
print(round(2.675, 2))  # 2.67 不是2.68