Python 与 Go：面向开发者的实用对比

关于 Python，有两件事是真的：它是世界上最受欢迎的编程语言，也是 Go 开发者最常搭配使用的语言。我们怎么知道的？来自 JetBrains 的《2026 年开发者生态系统调查》。

但我们也对这些使用这两种语言的开发者了解得更多——既有来自不同调查的定量数据，也有来自我们采访从 Python 转向 Go 的专业人士所获得的定性数据。

在本文中，我们分享这些来源中的发现，远超你通常看到的简单语法比较。我们将审视这两种语言有何不同，调查告诉了我们关于使用者的哪些信息，以及我们的采访对 Python 与 Go 之间的权衡有何说明。这样，如果你正在考虑迈出这一步，就不必盲目投入。

内容提要

• 本文从语言设计、性能、工具链、开发者画像和迁移体验等方面比较 Python 与 Go。
• Python 倾向于富有表现力的代码和快速迭代；Go 倾向于显式、标准化且易于跨团队维护的代码。
• Go 在原始性能和并发方面表现突出，并被广泛用于云基础设施。Python 在机器学习、数据科学和科学计算方面仍然更强。
• Go 开发者通常更关注基础设施，并且更资深。Go 很少是某人的第一门语言，而 Python 对初学者非常友好。
• Python 在构建 AI 模型方面领先，但 Go 开发者创建 AI 集成的比例几乎相同：46% 对 44%。
• 转向 Go 很少意味着放弃 Python。大多数团队两者并用：Go 用于服务和基础设施，Python 用于 AI 和数据工作负载。

关于数据的说明

除非另有说明，所有调查数据均来自 JetBrains 的《2026 年开发者生态系统调查》（28,945 份回复，于 2026 年 5 月至 7 月开展）。我们比较两组开发者：将 Go 列为主要语言之一的开发者（1,836 人），以及选择 Python 的开发者（11,298 人）。两组存在重叠，有 619 名受访者同时选择了两种语言。因此，下文中每一处差距都是对真实差异的保守估计。有些问题只向每组中的部分受访者展示，因此提供了样本基数供参考。定性材料来自对开发者的访谈，这些开发者将生产工作负载从 Python 迁移到了 Go。访谈在 2026 年 4 月至 5 月进行，包括七位在过去一年内开始使用 Go 的参与者。## Python 与 Go —— 语言对比

核心理念

从表面上看，Python 和 Go 似乎能和睦相处。Python 在 Python 之禅 中阐述了核心原则：简单优于复杂，可读性很重要，做一件事应该只有一种明显的方法，等等。而 Go，根据 Effective Go 的描述，“专注于简单性、可靠性和效率”，并且“专门设计用于让大规模构建软件变得容易”。

在实践中，Python 通常为编写代码的人优化，提供多种方式来表达同一件事。Go 则为两年后阅读他人代码的人（或者，如今可能是智能体）优化，因此它对大多数事情只选择一种表达方式，并要求你明确写出来。目标是让所有 Go 代码看起来都像其他 Go 代码。

我们在开头就指出这一点，因为无论这两种哲学看起来多么相似，这种方法上的差异是随后几乎所有其他语言设计差异的基础。

易用性与学习曲线

Python 可以说是生产环境中广泛使用的编程语言中最容易学习的之一。其语法类似于自然语言，核心结构集很小，初学者可以专注于编程思想而不是语言机制，从而减少挫败感并更快取得成果。调查一致显示 Python 是最受欢迎的编程语言之一（如果不是最受欢迎的）。2026 年，10% 的 Python 开发者编码时间不到一年，23% 是学生或在职学生，19% 担任初级职位，表明该语言拥有强大的早期用户基础。

Python 在早期学习者中的受欢迎程度几乎是自我延续的。最初，该语言非常适合入门课程和学习材料，很大程度上是因为它让初学者只需很少的仪式就能打印出 "Hello, world"，绕过无聊的理论，直接获得实际输出。它还额外受益于作为一种通用语言，能够处理各种用例。后来，大量的入门课程和学习材料使它成为任何想学习编程但不知从何开始的人的自然选择。

Go 的情况则不同。事实上，你很难找到通过 Go 来教授编程的课程。原因有两个。首先，Go 1.0 于 2012 年发布，远晚于 Python 已经在计算机科学课程中牢牢扎根的时间。另一个原因是 Go 解决的是初学者没有的问题。显式错误处理、静态类型和接口——我们稍后会讨论——都在由团队维护多年的大型代码库中发挥作用。Go 的实现方式也比 Python 窄得多，这使其对初学者的吸引力更小。

尽管如此，Go 的设计初衷也是易于学习，但原因不同：任何大型团队都应该能够快速让新工程师上手。许多 Go 开发者会说，如果你已经了解通用编程概念，你可以在几天或几周内用 Go 高效工作。我们交谈过的开发者表示，Go“写起来感觉和 Python 一样容易”，并且“在 Python 的简单性和 Java 的显式性之间取得了良好的平衡”。

语法与可读性

当你阅读 Python 时，即使没有编程经验，你通常也能理解，因为它读起来相对接近英语。Python 是动态类型的，因此类型声明是可选的，但在实践中，许多公司和大型代码库现在都全程使用类型提示，并由 mypy 或 Pyright 等工具检查。大多数生态系统遵循 PEP 8 中规定的格式约定，但这些约定仍然是可选的，因此一些团队会偏离它们。

相比之下，Go 是显式的且有意限制的，这促成了我们提到的跨团队可读性。它是静态类型的，这使其明显比 Python 更冗长。这是我们采访的开发者提出的主要语法抱怨。在 Go 中，格式不是偏好问题：gofmt 会将你的代码塑造成规范形式，无论你是否喜欢这些约定。

开发者们一致指出，从 Python 转向 Go 时需要做出一大调整的语法差异是错误处理。Python 允许你通过 try / except 将失败处理推到函数的边缘。经验丰富的 Go 开发者看到这种写法会大惊失色。

# Python：在方便的地方处理失败
try:
    profile = get_user(user_id)
except UserNotFound:
    return render_404()

// Go：在发生的地方处理失败
profile, err := getUser(userID)
if err != nil {
    if errors.Is(err, ErrUserNotFound) {
        return render404(w)
    }
    return fmt.Errorf("get user %s: %w", userID, err)
}

Go 版本更长，在大型处理程序中，开发者会发现自己令人作呕地编写 if err != nil 样板代码。作为回报，他们获得了没有不可见跳转的控制流：值可以走的每条路径都是显式的。两种方法都有取舍。

类型系统

Python 的动态类型在运行时检查类型。这为开发者提供了编写代码的灵活性，可以加快迭代速度，但这也意味着某些类型错误只在代码运行时才会出现。这种灵活性延伸到对象模型，它依赖于鸭子类型：代码更关心对象能做什么，而不是它是什么。我们采访的开发者说他们非常怀念鸭子类型，因为它使 Go 中的测试和模拟变得更加困难。

Go 在程序运行前检查类型。这减少了与类型相关的故障进入生产环境，并使重构更安全，但如前所述，也会导致代码冗长。

对象模型与多态

Python 是面向对象的，就像大多数开发者最初学习这个词时那样。一切都是对象，类从其他类继承（如果你坚持，可以一次继承多个）。多态有两种工作方式：沿着类层次结构向下，当子类覆盖其父类的方法时；以及通过鸭子类型横向实现，任何具有 read() 方法的对象都可以传递给期望文件对象的代码。

Go 完全没有这种层次结构。没有类，没有继承，也没有办法声明一个类型是另一个类型的子类型。相反，结构体有附加的方法，以及类型无需命名就能隐式满足的接口。

# Python：实现声明其角色
class Store(ABC):
    @abstractmethod
    def get(self, key: str) -> bytes: ...

class RedisStore(Store):
    def get(self, key: str) -> bytes:
        ...

// Go：消费者声明它需要什么；RedisStore 从未提及 Getter
type Getter interface {
    Get(key string) ([]byte, error)
}

func handleRead(g Getter, key string) ([]byte, error) {
    return g.Get(key)
}

注意依赖关系的走向。在 Python 中，RedisStore 继承自 Store，因此抽象位于实现一侧。在 Go 中，handleRead 声明了它实际调用的那一个方法，而 RedisStore 永远不知道 Getter 的存在。这就是为什么 Go 开发者说“接受接口，返回结构体”，也是为什么接口保持小巧——io.Reader 和 io.Writer 各自只有一个方法。

性能与速度

Go 遵循传统的编译模型，生成原生二进制文件。而 Python 则采用混合方法：源代码被编译为字节码，然后由解释器执行。

正如大多数编译型语言一样，Go 在原始速度方面胜出。你可以在 The Computer Language Benchmarks Game 上比较延迟、吞吐量和启动时间方面的模式。像这样的微基准测试并不能直接转化为实际工作负载，如果你不把它们当回事，我们也不会感到惊讶。我们的受访者告诉我们这种差异在他们的生产环境中意味着什么：一个团队在 Python 的 AWS Lambda 冷启动超过 10 秒后迁移到了 Go；另一个团队在将 Python 服务用 Go 重写后，测量到请求时间提高了十倍。

但原始语言速度只有在你的服务实际上是计算密集型或延迟敏感型时才重要，而许多服务两者都不是。同样重要的是，Python 解释器在其最大的用户群之一最关心的地方并不慢。在机器学习、数据工作和数值计算中，像 NumPy 和 PyTorch 这样的库将昂贵的操作卸载到优化的原生代码，使得解释器开销变得不那么重要。当我们询问迁移的开发者他们决定在哪里保留 Python 代码时，他们自信地列出了所有 AI 和 ML 工作流——LLM、聊天机器人、RAG 和模型训练。

内存管理

内存管理是性能讨论的另一个重要部分。两种语言都为你管理内存，但方式不同：Go 使用追踪垃圾回收器，而 CPython 使用引用计数加上循环垃圾回收器。这影响了开发者可以微调什么以及需要围绕什么进行设计。

Go 的 GC 与程序并发运行，旨在最小化停止世界的暂停。开发者可以调整这种行为：GOGC 和 GOMEMLIMIT 设置节奏，内存配置文件（堆和分配）告诉你服务何时分配过多。

在 CPython 中，对象通常在其最后一个引用消失时立即被释放。内存使用是可预测的，暂停很少值得测量，但成本分散在每个操作中，而且几乎没有调整的空间。

并发与并行

尽管两种语言都支持并发，但我们交谈过的开发者将更好的并发性作为他们从 Python 转向 Go 的原因。

Goroutine 是 Go 设计的核心。它们是由运行时管理的轻量级线程。创建成本低，开销小，可扩展到数千个并发操作。运行时处理调度，这使得模型比 Python 更简单——没有单独的 async/await 语法，所以函数就是函数。然而，如果你开始生成 goroutine 而不控制它们的生命周期，你最好准备好不久后处理竞态条件、泄漏和死锁。

Go 并发模型的另一半是通道——在 goroutine 之间传递值并同步它们的类型化管道。Go 可以将值传递给下一个需要它的 goroutine，而不是用锁来保护共享状态。select 语句同时等待多个通道，这是 Go 使用内置语言结构表达超时、取消和扇入的方式。这些相同的原语也会产生常见的 Go 错误：goroutine 泄漏和更多死锁。

与此同时，Python 依赖标准库、单线程事件循环和子进程来绕过解释器限制。它提供了 threading，但在 CPython 中，全局解释器锁（GIL）历来阻止线程同时运行 Python 字节码，使其对 CPU 密集型并行无效。对于 I/O 密集型并发，有 asyncio，对于真正的并行，有 multiprocessing，但这增加了内存开销，并且需要进程间通信。

值得注意的是，GIL 本身已不再是必需品——从 Python 3.13 开始，PEP 703 引入了官方支持的自由线程构建，3.14 继续了这项工作。大多数生产代码仍然在 GIL 存在的情况下运行，但随着每个新版本的发布，“Python 无法进行真正的线程化”的说法正变得越来越不准确。

# Python：async/await，以及随之而来的着色
async def fetch_all(urls):
    return await asyncio.gather(*(fetch(u) for u in urls))

// Go：普通函数并发运行
var wg sync.WaitGroup
for _, u := range urls {
    wg.Add(1)
    go func() {
        defer wg.Done()
        fetch(u)
    }()
}
wg.Wait()

并发的方法赋予了 Go 在高吞吐量服务中的大部分实际优势，在体验过两者之后，我们的受访者称赞 Go “默认异步”，更适合高并发组件，并称其具有卓越的并发模型，性能极高，对现实世界用例很有吸引力。

库、框架与 IDE

Go 的自包含生态系统

Go 从来不仅仅是被构建为一种编程语言，而是一个生态系统。正如 Go 团队所说，目标是“一个端到端的平台，围绕软件开发生命周期提供工具”（Google for Developers），格式化工具、测试框架、依赖管理和安全工具都包含在工具链中，同时还有一个足够全面的标准库，使得外部框架即使不是无关紧要，也是可选的。

开发者生态系统 2026 调查显示了 Go 团队在实现该目标方面取得了多大成功。例如，在 Gopher 中，标准 html/template 和 text/template 库包分别被 31% 和 22% 的开发者使用，而唯一其他重要的替代品——templ——的使用率为 11%。

几乎一半的 Gopher 要么不编写单元测试，要么不使用测试框架：14% 根本不编写单元测试，35% 不使用测试框架——testing 包在这方面提供了他们所需的一切。其他人也可能使用 Testify（31%）或 GoMock（25%）等工具。其余库的受欢迎程度要低得多。

对于 Web 开发，46% 的开发者使用标准 net/http 库，而 48% 使用 Gin。这证明在存在第三方框架的地方，它并不与其他许多框架竞争，而只与标准库竞争。很多时候，它输了。
Go 开发者

Go 开发者使用的库和框架
模板引擎 测试 Web 框架
用于 Go 开发的模板引擎

你在 Go 开发中使用哪些模板引擎（如果有）？
无 52%
html/template 31%
text/template 22%
templ 11%
gomponents 5%
pongo2 4%
Plush 1%
其他 2%

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：回答了 Go 部分的受访者（n = 1,529）。允许多选。
Go 中的测试框架和模拟库

你经常使用哪些测试框架或模拟库（如果有）？
我编写单元测试但不使用任何框架 35%
Testify 31%
GoMock 25%
我不为 Go 编写单元测试 14%
Ginkgo 7%
go-sqlmock 6%
Godog 5%
Gomega 3%
GoConvey 1%
其他 2%

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：回答了 Go 部分的受访者（n = 1,518）。允许多选。
经常使用的 Go Web 框架

你经常使用哪些 Go Web 框架（如果有）？
Gin 48%
net/http 46%
gorilla/mux 15%
go-chi/chi 15%
Echo 13%
Fiber 13%
无 12%
Beego 5%
Buffalo 2%
Revel 1%
其他 5%

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：回答了 Go 部分的受访者（n = 1,519）。允许多选。

Python 的广泛生态系统

Python 的生态系统则相反。Python 包索引（PyPI）庞大且成熟，在标准库止步的地方，往往有几个强大的替代品相互竞争。

以 Web 框架为例。一半的 Python 开发者使用 FastAPI，Django（31%）与 Flask（30%）竞争激烈。数据科学生态系统更加分散，开发者同时使用这些库：69% 使用 NumPy，68% 使用 pandas，50% 使用 PyTorch，49% 使用 Matplotlib，等等。对于 Python，通常没有明确的领导者，选择合适的框架或库是工作的一部分。
Python 开发者

Python 开发者使用的框架和包
Web 框架 数据科学
与 Python 一起使用的 Web 框架

除了 Python 之外，你还使用哪些 Web 框架 / 库？
FastAPI 50%
Django 31%
Flask 30%
无 28%
其他 3%

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：回答了 Python 部分的受访者（n = 4,276）。允许多选。
与 Python 一起使用的数据科学包

你在 Python 中使用哪些数据科学包？
NumPy 69%
pandas 68%
PyTorch 49%
Matplotlib 48%
scikit-learn 35%
OpenCV 32%
TensorFlow 30%
SciPy 29%
Seaborn 20%
Keras 15%
无 14%
XGBoost 13%
Polars 8%
其他 1% 显示更少选项

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：回答了 Python 部分的受访者（n = 4,277）。允许多选。

IDE 与编辑器

在编辑器方面，我们看到类似的模式。Go 拥有出色的语言服务器，这使得通用编辑器成为 Go 专用 IDE 的可行替代品。当被问及他们使用哪些 IDE 或编辑器进行 Go 开发时，49% 报告使用 GoLand，而 48% 报告使用 VS Code。
Go 开发者

用于 Go 开发的 IDE 和编辑器

你使用哪些 IDE 或编辑器进行 Go 开发？
GoLand 49%
Visual Studio Code 48%
Zed 14%
Cursor 14%
Neovim 10%
IntelliJ IDEA 8%
Vim 4%
Visual Studio 4%
Sublime Text 2%
Emacs 1%
Windsurf 1%
Atom <1%
其他 4%

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：回答了 Go 部分的受访者（n = 1,529）。允许多选。

一个原因是开发者可以在多大程度上访问 Go 周围生态系统，而无需自己组装。GoLand 安装时带有测试运行器、调试器、覆盖率和分析器，并接入工具链。分析在整个项目上运行，而不仅仅是打开的文件。过程间 nil 检查和处理错误检查可以捕获 Python 开发者可能只在运行时才会看到的错误。无需多言，Go 团队的 Alan Donovan 也描述过像我们这样的传统 IDE 为重构设定了“黄金标准”，因为它们在分析逻辑和用户界面之间紧密集成。
试用 GoLand
Python 开发者

用于 Python 开发的主要 IDE 或编辑器

你使用哪个 IDE 或编辑器最多用于 Python 开发？
Visual Studio Code 41%
PyCharm 22%
Cursor 10%
PyCharm Pro 8%
Jupyter Notebook 5%
Vim / Neovim 3%
IntelliJ IDEA 3%
Zed 2%
Notepad++ 2%
IDLE 1%
Datalore <1%
Windsurf <1%
Emacs <1%
其他 2%

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：回答了 Python 部分的受访者（n = 4,276）。每人一个答案。

Python 方面更加分散，有更多 Python 特有的选项，例如 Jupyter Notebook，当然还有 PyCharm。后者被 30% 的 Python 开发者使用（PyCharm – 22%，PyCharm Pro – 8%），而 VS Code 为 41%。笔记本解释了大部分分散性，因为数据工作和服务工作不一定需要相同的工具集。无论你用 Python 构建什么，PyCharm 都为你的技术栈、框架和工作流提供一流支持——无论是 Web、数据还是 ML 工作流——笔记本与调试器和类型检查器并排运行。它解析你的代码并在整个项目中解析用法、类型和依赖关系。因此，你始终清楚知道你的代码做了什么，以及如果它发生变化会破坏什么，对你和你的智能体都是如此。
试用 PyCharm

如果你同时使用 Go 和 Python——正如四分之一的 Gopher 那样——值得注意的是 GoLand 和 PyCharm 构建在同一个平台上，因此键位映射、快捷键和设置可以在它们之间同步。GoLand 还通过 Python Community Edition 插件 支持 Python 功能。## Python vs Go——更广阔的图景

语言本身只是一方面，但在决定使用哪种语言工作时，还有许多其他因素需要考虑。开发者会考虑这些语言用于什么、谁在使用它们，以及它们如何维护。在本节中，我们将深入探讨塑造 Python 和 Go 更广阔图景的因素。

Go 开发者更资深

在《2026 开发者生态系统调查》中所有关于年龄、经验和资历的问题上，Go 开发者（Gopher）往往比 Python 开发者的职业发展阶段更靠前。

在总体专业编码经验方面（不仅仅是其主要编程语言的经验），20% 的 Go 开发者报告有 16 年或以上经验，而 Python 开发者中这一比例为 12%。另一端，9% 的 Go 开发者有 1–2 年经验，而 Python 开发者中这一比例为 20%。

大多数 Go 专业人士担任高级职位，比例为 60%，只有 2% 是培训生，10% 是初级。与此同时，42% 的 Python 专业人士是高级；培训生（6%）和初级（19%）占该群体的四分之一。

72% 的 Go 开发者从事全职工作，而 Python 开发者中这一比例为 51%。学生和半工半读学生在 Go 开发者中占 8%，而在 Python 群体中占 23%。

最后，按年龄划分，Go 开发者中最大的群体是 30–34 岁（23%），而 Python 最大的群体是 21–24 岁（22%）。

这些差异与我们之前提出的观点一致：Python 是学习者非常流行的第一门语言，而 Go 几乎从不被选为第一门语言，而是由更有经验的开发者在职业生涯后期开始使用。

在阅读以下关于开发者人口统计的章节时，务必记住这一点，因为其中许多数字看起来像是两种语言之间的差异，但实际上，它们只是资深群体与普通群体之间的差异，无论你比较哪个生态系统都会看到。

Go 与 Python 开发者

经验与资历：经验 | 职位 | 就业 | 年龄

专业编码经验

你有多少年专业编码经验？

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 1,836，Python n = 11,298。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。* 表示统计学显著差异（p < 0.05，已校正）。

职位级别

你当前职位的级别是什么？

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 1,531，Python n = 6,891。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。* 表示统计学显著差异（p < 0.05，已校正）。

就业状况

以下哪项最能描述你的就业和参与软件开发的情况？

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 1,836，Python n = 11,298。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。* 表示统计学显著差异（p < 0.05，已校正）。

年龄

你的年龄段是什么？

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 1,836，Python n = 11,298。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。* 表示统计学显著差异（p < 0.05，已校正）。

薪资随资历变化

薪资区间清楚地显示了经验如何影响其他人口统计数据。Go 开发者在最高区间中占比更高：9% 报告年收入超过 180,000 美元，而 Python 程序员中这一比例为 6%。与此同时，Python 用户更多地集中在最低区间。

Go 与 Python 开发者

年收入（美元）

薪资区间以美元计，由当地货币换算。

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 1,115，Python n = 5,004。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。* 表示统计学显著差异（p < 0.05，已校正）。

不过，如果我们只看全职开发者，差异就不再具有统计学显著性。这种溢价与资历和就业状况有关，而不是主要语言。换句话说，学习 Go 本身并不能保证更高的薪资，但需要 Go 的职位通常薪酬更好。

他们构建什么

开发者生态系统调查还询问人们其代码实现了哪些功能。

Go 开发者更常报告：

• 69%——提供 API 和服务（Python——41%）
• 63%——集成 API 和服务（Python——47%）
• 51%——应用逻辑和工作流（Python——37%）
• 47%——用户界面（Python——41%）
• 35%——库和框架（Python——26%）

与此同时，Python 开发者报告以下比例更高：

• 38%——数据处理和分析（Go——30%）
• 36%——人工智能和机器学习（Go——20%）
• 32%——数据科学和数据分析（Go——15%）

关于代码在何处执行的问题提供了更多背景：绝大多数 Go 开发者面向服务器、基础设施或云环境（74%，而 Python 开发者中为 57%）。另一方面，66% 的 Python 开发者面向桌面端（Go——47%）。

Python 显然是一种通用语言，在 AI、ML 和数据工作方面占据优势，这些工作更倾向于本地执行，而 Go 则严重偏向网络服务和基础设施。

不过，这组数据中有一个特别有趣的项目：AI 集成。虽然 AI 开发本身是 Python 的领域，但集成不是。46% 的 Go 开发者报告实现了 AI 集成，而 Python 为 44%，数量几乎相等。当被问及工作中从事的开发类型时，51% 的 Python 开发者报告使用 AI 和 AI 工具，而 Go 为 48%。Go 工程师可能不训练模型，但他们构建 AI 驱动产品的比例与 Python 开发者大致相同。

Go 与 Python 开发者

Go 和 Python 开发者构建什么
功能 | 平台 | 开发类型

他们的代码实现什么

你的代码实现了哪些具体功能？

收起选项

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 1,836，Python n = 11,298。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。允许多选。* 表示统计学显著差异（p < 0.05，已校正）。

他们的代码在哪里运行

你的代码在哪些平台上执行？

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 1,836，Python n = 11,298。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。允许多选。* 表示统计学显著差异（p < 0.05，已校正）。

工作中从事的开发类型

你在工作中参与哪些类型的开发？

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 1,595，Python n = 7,427。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。允许多选。* 表示统计学显著差异（p < 0.05，已校正）。

DevOps：同样的工作，不同的工具箱

Python 和 Go 开发者之间另一个值得单独成节的共同点是 DevOps。两个群体都参与该领域，尽管 Python 开发者（31%）略低于 Go 开发者（45%）。两个群体也倾向于使用不同的工具。

• 对于编排，Go 开发者总体上更可能使用工具，尤其是 Kubernetes。只有 8% 的 Go 开发者不使用容器编排工具（Python 为 17%）；58% 使用 Kubernetes（Python 为 39%）。我们采访的工程师提到，Go 与 Kubernetes 的深度集成是他们将整个服务从 Python 迁移到 Go 的原因之一。
• 对于配置管理，Terraform 在两个群体中都领先。然而，Python 开发者更倾向于云原生 IaC 工具（Python 为 29%，Go 为 23%），或者什么都不用（Python 为 21%，Go 为 15%），而 Go 开发者更常选择 GitOps（Go 为 27%，Python 为 21%）。
• 在 DevOps 实践方面，Go 开发者总体上报告使用得更多，只有一个例外：AI 驱动的运维（Go 开发者 12%，Python 开发者 18%）。Python 开发者也更可能完全不用任何 DevOps 实践（Python 为 6%，Go 为 2%）。

因此，即使你在同一类职位中从 Python 转向 Go，工具集的变化可能与语言变化本身一样大。

Go 与 Python 开发者

DevOps 工具和实践
编排 | 配置管理 | 实践

容器编排工具

你使用哪些容器编排工具或服务？

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 1,435，Python n = 7,242。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。允许多选。* 表示统计学显著差异（p < 0.05，已校正）。

配置管理和 IaC 工具

你使用哪些配置管理或 IaC 工具？

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 930，Python n = 3,109。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。允许多选。* 表示统计学显著差异（p < 0.05，已校正）。

正在使用的 DevOps 实践

你或你的团队目前使用以下哪些 DevOps 实践？

来源：JetBrains《2026 开发者生态系统调查》，加权数据。基数：Go n = 930，Python n = 3,110。Go 和 Python 开发者是指在其主要语言中选择了该语言的受访者；同时选择两者的人被计入两个群体。允许多选。* 表示统计学显著差异（p < 0.05，已校正）。### 操作系统

当我们询问开发者用于其开发环境的操作系统时，出现了一个有趣的差异。Go 开发者在 macOS（70%）和 Linux（57%）上工作的比例显著高于 Windows（44%）。与此同时，Python 开发者首先使用 Windows（66%），然后在 macOS（54%）和 Linux（52%）之间几乎平分。

对于计划迁移到 Go 的开发者来说，继续使用 Windows 并不一定会让部署变得复杂，即使目标是 Linux 服务器。对于纯 Go 而言，从这三种操作系统中的任何一种构建 Linux 二进制文件，最多只需要两个环境变量；而 Python 部署无论最终运行在哪里，仍然必须找到匹配的解释器和原生包。

Go 与 Python 开发者

开发环境所用的操作系统

你在哪些操作系统上使用开发环境？

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：Go n = 1,836，Python n = 11,298。Go 和 Python 开发者是指在主要语言中选择了该语言的受访者；同时选择两者的人被计入两组。允许多选。* 表示差异具有统计学显著性（p < 0.05，经校正）。

使用 AI 的两种不同方式

我们已经讨论过使用 Python 和 Go 进行 AI 开发，但用 AI 来辅助 Go 和 Python 开发又如何呢？两个群体在工作中都大量使用 AI，但在使用方式和用途上存在差异。

Go 开发者表示，他们每天使用 AI 完成诸如跨多个文件编辑代码（60% 对 52%）、以智能体方式开发功能或程序（51% 对 41%）、生成提交信息（51% 对 36%）和测试（47% 对 34%），或执行代码审查（39% 对 34%）等任务。

与此同时，Python 开发者在一项任务上领先：学习编码和软件开发的新知识（Python 开发者 38%，Go 开发者 31%），这与早先的数据一致，即 Python 开发者中处于职业生涯早期的人群更多。

然而，有一长串任务两个群体几乎没有区别：重构、调试、检查代码潜在问题、询问一般性问题，或生成样板代码——尽管考虑到 Go 语言的冗长，你可能会以为 Go 开发者会更热衷于最后一项。

Go 与 Python 开发者

他们每天使用 AI 工具完成的任务

你在工作中使用 AI 工具完成以下各项任务的频率如何？回答“每天”的比例。

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：对这些任务进行评分的受访者（Go n = 993，Python n = 5,056）；各任务基数略有不同。Go 和 Python 开发者是指在主要语言中选择了该语言的受访者；同时选择两者的人被计入两组。* 表示差异具有统计学显著性（p < 0.05，经校正）。

因此，AI 辅助编码在两个生态系统中都很常见。Go 开发者只是将其接入了维护繁重的代码库的生产杂务中：提交、测试、审查和多文件编辑。

这两个群体也倾向于使用不同的工具。Go 开发者更可能使用终端和智能体工具，如 Claude Code（45% 对 40%）、OpenAI Codex（24% 对 17%）、Cursor（17% 对 12%）和 OpenCode（12% 对 6%）。反之，Python 开发者更多使用通用助手以及 Google 或 Microsoft 的产品界面，如 ChatGPT（20% 对 16%）、Google Antigravity（9% 对 5%）和 Microsoft 365 Copilot（4% 对 1%）。

Go 与 Python 开发者

工作中用于编码的 AI 工具

你在工作中使用以下哪些 AI 工具来完成编码和其他开发相关任务？

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：Go n = 1,482，Python n = 6,747。Go 和 Python 开发者是指在主要语言中选择了该语言的受访者；同时选择两者的人被计入两组。允许多选。* 表示差异具有统计学显著性（p < 0.05，经校正）。

一个必须改变的数字

软件开发仍然是一个男性占主导地位的领域，而这一差距在 Go 中尤为明显；由于 Go 通常是人们的第二语言，它继承了人才管道所提供的一切，并进一步加剧了这一差距。在我们的样本中，只有 1.8% 的 Go 开发者认同自己为女性，而 Python 开发者为 5.8%。

Go 与 Python 开发者

性别

你的性别是？

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：Go n = 1,833，Python n = 11,284。Go 和 Python 开发者是指在主要语言中选择了该语言的受访者；同时选择两者的人被计入两组。* 表示差异具有统计学显著性（p < 0.05，经校正）。

从 Python 转向 Go

一条被充分走过的单向路径

你可能会问，为什么我们关注从 Python 转向 Go，而不是反过来。数据让开发者正在走的路径几乎没有疑问。Python 已经是 Go 开发者中最常见的第二语言——35% 的 Gopher 将其声明为另一门主要语言。但大多数 Go 开发者（70%）表示，他们在未来 12 个月内没有打算采用另一门语言；如果有，他们提到的是 Rust（16%），而不是 Python（2%）。另一方面，10% 的 Python 开发者（按绝对数量计算是一个大得多的群体）计划学习 Go，大约是 Go 开发者计划学习 Python 的比例的 5.5 倍。

Go 与 Python 开发者

他们计划在未来 12 个月内采用的语言

你是否计划在未来 12 个月内采用或迁移到其他语言？如果是，是哪些？

来源：JetBrains 开发者生态系统调查 2026，加权数据。基数：Go n = 1,836，Python n = 11,295。Go 和 Python 开发者是指在主要语言中选择了该语言的受访者；同时选择两者的人被计入两组。允许多选。n/a：受访者已将该语言作为主要语言使用。* 表示差异具有统计学显著性（p < 0.05，经校正）。

为什么要从 Python 转向 Go？

尽管我们的受访开发者从事不同的角色、开发不同的产品，但他们给出了从 Python 转向 Go 的一致理由。这些理由是：

• 更好的性能与速度，包括冷启动、延迟和运营成本。
• 更简单、更有效的并发模型。
• 类型安全，可在编译时捕获原本会进入生产环境的故障。
• 贴近平台，因为 Kubernetes 和大部分云原生工具链都是用 Go 编写的，所以从事该基础设施工作的团队已经每天与 Go 打交道。

他们得到了什么，又失去了什么

感知到的潜在收益是一回事，但 Go 真的兑现了吗？根据我们采访的开发者，它在上述领域确实做到了。但他们还发现了意想不到的好处：可预测的格式化和 linting 有助于实现“整洁代码”，开箱即用的工具链，以及与 Python 相当的简洁性。

但 Go 也有一些从 Python 转过来的开发者一眼就能看出的缺陷。正如采用 Go 的理由一致，抱怨也同样一致：

• 显式的错误处理与 Python 根本不同，不够直观，而且更重复。
• 整体上冗长且固执己见，表达相同行为需要更多行代码，表达方式也更少。
• 对象模型使测试和 mock 明显更加困难。
• 库缺口，尤其是在测试方面。

他们真的离开了吗？

“迁移”“转型”和“切换”听起来都像是要彻底离开 Python 的最终决定，但事实并非如此。我们采访的开发者中，没有一个人将 Python 完全从技术栈中移除。他们将其保留用于人工智能和机器学习、数据科学，以及仅支持 Python 的平台上的流水线；也仅仅是因为他们所在的更大团队已经了解 Python 并能用它高效工作。

“转向 Go”的现实结果并不是变成单一语言使用者，而是拥有一个多语言代码库，让每种语言都用在其最适合的地方。

结论

那么，你应该选择哪种语言？是否值得为了 Go 而放弃 Python？我们希望到现在答案已经清楚——问题不在于哪种语言更好，而在于哪种语言更合适。根据我们的数据和开发者证言，以下是我们的发现。

Go 可能更合适，如果：

• 性能对你的应用至关重要：延迟、吞吐量或冷启动是你实际拥有且可以测量的问题。
• 工作负载是并发的，尤其是 I/O 密集型。
• 服务长期存在，并由团队而非个人维护。
• 系统已经严重依赖 Kubernetes 和其余云原生工具链。

Python 可能更合适，如果：

• 工作是机器学习、数据科学或数值计算。
• 你的平台只接受 Python，正如托管 ETL 和 notebook 环境经常做的那样。
• 迭代速度比运行时速度更重要，这在内部工具和原型中经常如此。
• 你依赖的库没有 Go 等价物；对于许多科学计算栈来说，并不存在这样的等价物。

仅凭语言特性很少能决定最佳选择。在决定用什么来构建时，团队会权衡他们已经运行的工具体系、同事已经了解或愿意学习的语言，以及他们愿意改变现有系统的程度。这些因素比任何基准测试都更有分量，也正是我们交谈过的开发者最终同时使用两种语言，而不是二选一的原因。## 常见问题解答

Go 能完全取代 Python 吗？

对于大量后端工作来说，理论上可以。但实际上并没有。我们采访的开发者中，没有人完全从技术栈中移除 Python。他们保留 Python 用于机器学习和数据科学，用于只接受 Python 的平台上的数据管道，以及因为他们周围的团队已经熟悉它。在 2026 年开发者生态系统调查中，约四分之一的 Go 开发者报告在同一个项目中使用 Python。

Go 适合数据工程吗？

这取决于你指的是管道哪一端。Go 非常适合数据的移动，包括数据摄取服务、流处理、API 集成和 CLI 工具，30% 的 Go 开发者报告从事数据处理和分析，而 Python 开发者这一比例为 38%。分析端则是另一回事：只有 15% 的 Gopher 从事数据科学和数据分析，而 Python 开发者有 32%，库生态系统也反映了这一点。

Python 开发者需要多长时间才能学会 Go？

就语言本身而言，需要几天到几周。语法很小，gofmt 解决了格式争论，我们交谈过的开发者说 Go “感觉和 Python 一样容易编写”。更耗时的是周围的一切：系统概念，如指针、接口、goroutine 和通道，以及 Go 要求你改变的习惯，从显式错误处理到设计测试接缝而不是在运行时打补丁。

更大的调整可能根本不是语言本身。Go 的工作往往更接近 Kubernetes、Terraform 和 GitOps，所以如果你从 Python 团队转到 Go 团队，要预算与学习语法一样多的时间来学习工具链。

Go 适合机器学习吗？

对于训练模型来说，可能不适合。20% 的 Go 开发者从事人工智能和机器学习，而 Python 开发者有 36%，我们采访的开发者直言不讳地说明了原因：Python 有库，而 Go 缺乏等效的库。

当涉及围绕模型构建产品时，情况就不同了。46% 的 Go 开发者实现 AI 集成，而 Python 为 44%——差异可以忽略不计。Gopher 通常不训练模型，但他们确实在为模型提供服务。

Go 和 Python 可以在同一个项目中使用吗？

它们不仅可以一起使用，而且经常一起使用。27% 的 Go 开发者报告在同一个项目中同时使用 Python 和 Go，仅次于 TypeScript (43%)，略高于 JavaScript (24%)。我们从采访中得知，通常的分工遵循每种语言的优势：Go 用于网络服务和基础设施，Python 用于数据工作、机器学习以及任何依赖科学计算库栈的事情。