1

2

3

def calculate_discount(price, rate):

    assert 0 <= rate <= 1, "折扣率必须在0到1之间"

    return price * rate

1

2

if not <condition>:

    raise AssertionError(<message>)

1

2

3

4

5

6

7

8

9

10

def bubble_sort(arr):

    assert isinstance(arr, list), "输入必须是列表"

    assert all(isinstance(x, (int, float)) for x in arr), "列表元素必须是数字"

    n = len(arr)

    for i in range(n):

        for j in range(0, n-i-1):

            if arr[j] > arr[j+1]:

                arr[j], arr[j+1] = arr[j+1], arr[j]

    return arr

1

2

3

4

5

6

def train_model(X, y):

    # 假设X应该是标准化后的数据

    assert np.allclose(X.mean(axis=0), 0), "数据未标准化"

    assert np.allclose(X.std(axis=0), 1), "数据未标准化"

    # 训练逻辑...

1

2

3

4

5

6

7

8

9

10

11

12

13

def withdraw(account, amount):

    """从账户取款

    Args:

        account: 账户对象，必须有balance属性

        amount: 取款金额，必须为正数且不超过余额

    """

    assert hasattr(account, 'balance'), "账户对象缺少balance属性"

    assert amount > 0, "取款金额必须为正数"

    assert amount <= account.balance, "余额不足"

    account.balance -= amount

    return amount

1

2

3

4

5

6

7

8

9

10

def test_stack_operations():

    s = Stack()

    assert len(s) == 0, "新栈应为空"

    s.push(1)

    assert len(s) == 1, "压栈后长度应为1"

    assert s.peek() == 1, "栈顶元素应为1"

    s.pop()

    assert len(s) == 0, "弹栈后应为空"

1

2

3

4

5

# 错误示范

def register_user(username):

    assert isinstance(username, str), "用户名必须是字符串"

    assert len(username) >= 3, "用户名太短"

    # ...

1

2

3

4

5

# 差

assert matrix.shape[0] == matrix.shape[1]

# 好

assert matrix.shape[0] == matrix.shape[1], f"矩阵不是方阵: {matrix.shape}"

1

2

3

4

5

# 性能敏感场景

def process_large_array(arr):

    for _ in range(1000000):

        assert arr is not None  # 每次循环都检查

        # ...

1

2

3

4

5

6

# 错误示范

assert (x := calculate_value()) > 0, "值必须为正"

# 正确做法

x = calculate_value()

assert x > 0, f"值{x}必须为正"

1

2

3

4

5

6

7

8

9

10

def assert_is_sorted(iterable, key=None):

    if key is None:

        key = lambda x: x

    for i in range(len(iterable)-1):

        assert key(iterable[i]) <= key(iterable[i+1]), \

            f"序列在索引{i}处无序: {iterable[i]} > {iterable[i+1]}"

# 使用

data = [1, 2, 4, 3, 5]

assert_is_sorted(data)  # 会触发断言

1

2

3

4

5

6

7

from typing import List

def process_items(items: List[int]):

    assert isinstance(items, list), "参数必须是列表"

    assert all(isinstance(x, int) for x in items), "列表元素必须是整数"

    # 处理逻辑...

1

2

3

4

5

6

7

import asyncio

async def fetch_data(url):

    assert isinstance(url, str), "URL必须是字符串"

    assert url.startswith(('http://', 'https://')), "URL格式不正确"

    # 异步获取逻辑...

1

2

3

4

5

6

7

8

9

10

11

import logging

logging.basicConfig(level=logging.DEBUG)

def critical_operation(data):

    try:

        assert data is not None, "数据不能为空"

        assert len(data) > 0, "数据不能为空列表"

    except AssertionError as e:

        logging.critical(f"断言失败: {str(e)}", exc_info=True)

        raise  # 重新抛出或处理

1

2

3

4

5

6

7

8

9

import os

DEBUG = os.getenv('DEBUG', '1') == '1'

def critical_function(param):

    if DEBUG:

        assert param > 0, "参数必须为正"

    # 或者更灵活的方式

    assert param > 0 or not DEBUG, "参数必须为正" if DEBUG else "参数无效"

1

2

3

4

def execute_trade(account, shares, price):

    cost = shares * price

    # 缺少断言检查cost是否为正

    account.balance -= cost  # 当shares或price为负时出错

1

2

3

4

5

6

def execute_trade(account, shares, price):

    assert shares > 0, "交易股数必须为正"

    assert price > 0, "股票价格必须为正"

    cost = shares * price

    assert cost > 0, "交易成本计算异常"

    account.balance -= cost

1

2

3

4

5

def normalize_data(data):

    mean = np.mean(data)

    std = np.std(data)

    # 缺少断言检查std是否为0

    normalized = (data - mean) / std  # 当std=0时产生NaN

1

2

3

4

5

6

7

def normalize_data(data):

    mean = np.mean(data)

    std = np.std(data)

    assert std != 0, "标准差不能为零"

    normalized = (data - mean) / std

    assert not np.any(np.isnan(normalized)), "标准化结果包含NaN"

    return normalized