写函数不难。难的是写出让人愿意看的函数。

为什么你的函数总被嫌弃？

说个扎心的：大部分程序员写的函数，根本配不上"函数"这个名字，顶多是一坨能跑的代码。

你肯定写过这种东西：

def process_data(data):

    # 先处理一下

    result = []

    for i in data:

        # 做一些操作

        if i > 0:

            # 这里有个逻辑

            temp = i * 2

            # 再处理一下

            if temp < 100:

                result.append(temp)

            else:

                # 特殊情况

                result.append(100)

        else:

            # 负数处理

            result.append(0)

    # 返回结果

    return result

什么感觉？累。

注释全是废话，逻辑嵌套得像俄罗斯套娃，变量名随意得像抽卡。这种函数，三个月后你自己都看不懂——不要不信。

好函数的三个硬标准

一个函数只做一件事

别贪心。函数名应该明确告诉别人它干了一件什么事情。

# ❗️ 一个函数干了五件事

def process_user_data(user):

    # 验证

    # 格式化

    # 计算

    # 存储

    # 发送通知

    pass

# ✅ 拆成五个函数

def validate_user(user): ...

def format_user_data(user): ...

def calculate_user_score(user): ...

def save_user(user): ...

def send_welcome_email(user): ...

拆完之后，每个函数一眼就能看懂。主流程清爽得像刚用过了海飞丝。

参数别超过三个

超过三个参数，说明你这个函数管得太宽。

# ❗️ 参数多到记不住

def create_report(title, content, author, date, format, 

                  include_images, include_comments, share_url):

    pass

# ✅ 用对象收拢

def create_report(report_config):

    pass

# 或者用数据类

@dataclass

class ReportConfig:

    title: str

    content: str

    author: str

    date: str

    format: str = "markdown"

    include_images: bool = True

    include_comments: bool = False

    share_url: str = ""

参数少，调用时心不慌、手不抖。

命名要说人话

process、handle、do_something 这种名字，等于没说。

# ❌ 看了等于没看

def process(data):

    handle(result)

    do_something(temp)

# ✅ 一眼就知道在干嘛

def calculate_total_price(items):

    apply_discount(subtotal)

    add_tax(final_amount)

函数名应该让别人不看函数的具体实现就能知道在干什么。做不到？说明函数命名有问题。

高阶玩法

默认参数是朋友，但别乱用

# ❌ 可变默认参数是坑

def add_item(item, items=[]):  # 这个列表会累积！

    items.append(item)

    return items

# ✅ 用 None 当哨兵

def add_item(item, items=None):

    if items is None:

        items = []

    items.append(item)

    return items

这个坑，踩过一次就忘不了。我当年就被坑过，debug 花了两个小时。

返回类型要一致

不要一会儿返回列表，一会儿返回 None。调用的人会疯。

# ❌ 返回类型看心情

def find_user(user_id):

    if found:

        return user

    return None

# ✅ 保持一致，或者用 Optional

from typing import Optional

def find_user(user_id) -> Optional[User]:

    if found:

        return user

    return None

类型提示不是装饰，是契约。

早返回，少嵌套

# ❌ 嵌套地狱

def process_order(order):

    if order:

        if order.is_valid:

            if order.has_items:

                if order.payment_ok:

                    return ship_order(order)

                else:

                    return "Payment failed"

            else:

                return "No items"

        else:

            return "Invalid order"

    else:

        return "No order"

# ✅ 守卫条件，早返回

def process_order(order):

    if not order:

        return "No order"

    if not order.is_valid:

        return "Invalid order"

    if not order.has_items:

        return "No items"

    if not order.payment_ok:

        return "Payment failed"

    return ship_order(order)

逻辑一马平川，读起来不累。这在之前的Python条件判断：if 写得好，下班下得早中也提到过。

实战：重构一个混乱函数

真实场景。你要写个函数计算购物车总价：

# 重构前

def calc(items, tax, discount, shipping):

    total = 0

    for i in items:

        if i.price > 0:

            total += i.price * i.qty

    if discount:

        total = total - discount

    if total < 0:

        total = 0

    total = total + tax

    if shipping and total < 100:

        total += 10

    return total

问题一堆：参数乱、逻辑散、魔法数字、边界条件随意。

# 重构后

from typing import List

from dataclasses import dataclass

@dataclass

class CartItem:

    price: float

    quantity: int

@dataclass

class OrderConfig:

    tax_rate: float = 0.08

    discount: float = 0.0

    free_shipping_threshold: float = 100.0

    shipping_fee: float = 10.0

def calculate_cart_total(items: List[CartItem], config: OrderConfig) -> float:

    subtotal = sum(item.price * item.quantity for item in items if item.price > 0)

    after_discount = max(0, subtotal - config.discount)

    after_tax = after_discount * (1 + config.tax_rate)

    if after_tax < config.free_shipping_threshold:

        after_tax += config.shipping_fee

    return round(after_tax, 2)

仔细看一下重构后的函数，认真体会下。与之前的函数实现区别很明显：参数有结构了，每一步目的明确，魔法数字变成了配置，结果四舍五入避免浮点坑。

读起来一气呵成。

最后多说两句

写函数跟写文章一个道理：

函数名要准确，不搞标题党

逻辑块要清晰，不一坨到底

变量名要精准，不含糊其辞

函数长度要克制，超过 50 行就应该想想能不能拆分

好的函数，别人拿来就能用，不用猜、不用试、不用调。