说起 Python 里的 字符串拼接，哎呦，这看似简单的事儿，里面门道可不少，尤其当你从别的地方转过来，或者一开始没注意那些“潜规则”，一不小心就可能掉坑里，轻则代码看着别扭，重则性能慢到你想哭。别笑，我当年就吃过亏，看着一个几百行的小脚本跑得跟老牛拉破车似的，查来查去最后发现，嘿！全怪我可劲儿地用那个最原始的加号（+）在循环里头拼接一长串东西！所以，今天咱们就好好聊聊，在 Python 里到底有多少姿势来拼接字符串，以及啥时候该用啥姿势，避开那些不必要的麻烦。

最原始、最暴力，也最容易让人踩坑的，就是这个加号（+）了。你手里有两个字符串，比如 s1 = 'Hello'，s2 = ' World'，想连起来？简单啊，s3 = s1 + s2，结果就是 'Hello World'。这用起来顺手极了，短小精悍，对不对？对，但只对那种零敲碎打、一次性拼接几个小字符串的场景。比如：

python
name = 'Alice'
greeting = 'Hi, ' + name + '!'
print(greeting) # 输出：Hi, Alice!

看着挺好是吧？但你别看它用起来顺手，尤其是在循环里头，它就是个性能杀手，内存的无底洞！这是为啥呢？因为在 Python 里，字符串是不可变的（immutable）。意思是，你一旦建了一个字符串，就不能原地修改它。你想改？对不起，得新建一个。

所以 s = s + '新内容' 这句，表面看是修改 s，实际上 Python 在背后偷偷做了件大事：它得先申请一块新的内存空间，然后把旧 s 的内容复制进去，再把 '新内容' 也复制到紧跟着旧内容的地方，形成一个新的字符串对象，最后让 s 这个名字（变量）指向这个新生成的字符串。原来的那个旧字符串？没用了，等垃圾回收吧。

你想想，如果在循环里头，你每次都往一个大字符串后面加一点内容，比如：

python
result = ''
for i in range(10000): # 拼接1万次
result = result + str(i) # 每次都新建一个字符串

每次循环，Python 都得重新申请一块更大的内存，把之前几千几万个字符复制过去，再把当前的 str(i) 拷过去。循环几千几万次，它就得搬家几千几万次，累不累啊？内存占用也是蹭蹭地往上涨。所以，加号拼接，千万别在循环里用来累积构建大字符串，这是个大忌！

哦对，还有那个 print 里的逗号（,）。有时候你看到 print('你好', name, '!') 也能输出 '你好 Alice !' 这样的效果，是不是觉得这是另一种拼接方式？那不是真拼接哈，它就是在打印的时候给你隔开，默认加个空格。你看输出结果，中间是有空格的，而加号拼出来的默认没空格。别搞混了！它不是生成了一个新的字符串变量给你接着用，它只是 print 函数的一个特性，方便你把多个东西一起显示出来。

要说正经的多字符串合并，尤其你手里有一堆字符串在列表里、元组里啥的，那非 .join() 方法 莫属！这才是处理集合类型（比如列表、元组、集合）里字符串拼接的正确姿势，特别是当你元素数量不确定或者比较多的时候。

.join() 方法是谁的呢？它不是字符串集合的方法，而是分隔符字符串的方法！有点绕？这么理解：你得先决定，这些字符串之间你想用什么隔开？是用空字符串 ' '？是逗号 ,？还是换行符 \n？你就拿这个分隔符来调用 .join()，然后把你要拼接的那个字符串集合（比如列表 ['a', 'b', 'c']）传进去。

比如：

“`python
parts = [‘Hello’, ‘World’, ‘Python’]

用空字符串拼接

result1 = ”.join(parts) # result1 is ‘HelloWorldPython’

用空格拼接

result2 = ‘ ‘.join(parts) # result2 is ‘Hello World Python’

用破折号拼接

result3 = ‘-‘.join(parts) # result3 is ‘Hello-World-Python’

用换行符拼接

lines = [‘Line 1’, ‘Line 2’, ‘Line 3’]
report = ‘\n’.join(lines)
print(report)

输出：

Line 1

Line 2

Line 3

“`

看见没？它的逻辑是：拿一个分隔符（调用 .join() 的那个字符串），去连接你给它的那些元素（传给 .join() 的那个可迭代对象里的元素）。它厉害在哪儿？它比加号聪明多了！它能预估需要的空间，一次性把活儿干完，效率高得不是一点半点。尤其是在循环里构建大字符串的那个场景，把要拼接的零碎字符串先存到一个列表里，循环结束后再用 '' .join(列表) 一次性拼接，那速度，跟用加号一个一个加简直是天壤之别！

“`python

修正上面低效的加号循环拼接

parts_list = []
for i in range(10000):
parts_list.append(str(i))

fast_result = ”.join(parts_list) # 一次性搞定，高效！
“`

这就是为什么我说 .join() 是处理大量字符串拼接的不二之选。它清晰、高效，是 Python 里的标准做法。

然后是我个人最爱、强烈推荐的—— f-string！哇塞，这玩意儿简直是 Python 3.6 之后给开发者发的大福利！写起来简洁、直观，可读性不是一般地好，而且速度也非常快，跟 .join() 有得一拼，比 % 和 .format() 那俩老兄普遍要快。

f-string，全称是 formatted string literal（格式化字符串字面值）。怎么用？就是在普通字符串前面加个小写字母 f（或大写 F，效果一样），然后想往字符串里塞变量、塞表达式？直接在字符串里用花括号 {} 伺候！

比如上面加号那个例子：

“`python
name = ‘Alice’
age = 30

想打一句 ‘你好，Alice，你今年30岁了。’

用加号：

greeting_plus = ‘你好，’ + name + ‘，你今年’ + str(age) + ‘岁了。’

用 f-string：

greeting_f = f’你好，{name}，你今年{age}岁了。’
print(greeting_f) # 输出：你好，Alice，你今年30岁了。
“`

看到了吗？直接把变量名 name 和 age 放进花括号就完事儿了！代码清爽得不是一点半点，像填空题一样，模板在那儿，变量往里一套，齐活儿！而且你注意到了吗？age 是个数字（整数），我直接放 {age} 里了，Python 自动就把它转成字符串显示了，省心！不用像用加号那样还得手动 str(age)。

f-string 的功能还远不止塞变量这么简单，它还能在花括号里直接计算表达式：

python
x = 10
y = 20
calc_string = f'{x} + {y} = {x + y}' # 直接计算 x + y
print(calc_string) # 输出：10 + 20 = 30

还能做格式化，比如控制浮点数精度，对齐文本啥的，简直是为输出美观量身定做：

“`python
pi = 3.1415926535
formatted_pi = f’圆周率保留两位小数：{pi:.2f}’ # :.2f 就是格式化规范
print(formatted_pi) # 输出：圆周率保留两位小数：3.14

data = {‘name’: ‘Bob’, ‘score’: 85}
info = f’姓名：{data[“name”]:<10}分数：{data[“score”]:>5}’ # <10左对齐占10格，>5右对齐占5格
print(info) # 输出：姓名：Bob 分数： 85
“`

f-string 兼顾了性能和可读性，在需要将变量或表达式嵌入到固定字符串模板中的场景下，它是绝对的首选！

说完了现代武器，咱们也得看看“老古董”，了解一下历史。在 f-string 出现之前，大家常用的格式化字符串的方法是 百分号（%）运算符 和 .format() 方法。

百分号（%）的方式，是从 C 语言那边学来的，很经典，但现在看起来确实有点不方便了。它用 %s 表示字符串占位符，%d 表示整数，%f 表示浮点数等等。然后把要替换的变量按顺序放到一个元组后面，用 % 连起来：

“`python
name = ‘Charlie’
age = 40

用百分号拼接/格式化

greeting_percent = ‘你好，%s，你今年%d岁了。’ % (name, age) # 变量得按顺序放元组里
print(greeting_percent) # 输出：你好，Charlie，你今年40岁了。

格式化浮点数

value = 123.45678
formatted_value = ‘Value is %.2f’ % value # %.2f 控制精度
print(formatted_value) # 输出：Value is 123.46
“`

麻烦吧？格式化符号（%s, %d, %.2f 等）得对上，变量得按顺序传个元组过去。要是占位符多一点，或者后面跟的变量顺序搞错了，那就等着报错或者结果不对吧。写长了眼都花了，可读性真不咋地。

.format() 方法 是在 % 之后出现的，算是向前迈了一大步，解决了顺序问题。它用花括号 {} 作为占位符，然后调用字符串的 .format() 方法，把要替换的值传进去。传值可以按顺序，也可以用名字：

“`python
name = ‘David’
age = 50

用 .format() 按顺序传值

greeting_format_order = ‘你好，{}，你今年{}岁了。’.format(name, age)

用 .format() 按名字传值 (更清晰)

greeting_format_named = ‘你好，{n}，你今年{a}岁了。’.format(n=name, a=age)

print(greeting_format_order) # 输出：你好，David，你今年50岁了。
print(greeting_format_named) # 输出：你好，David，你今年50岁了。
“`

.format() 比 % 好点，至少能用名字占位符了，不用死记顺序。也能进行各种格式化操作，功能上跟 f-string 类似，但在语法上 f-string 更简洁，直接在字符串里写变量/表达式，不用跳出去调用 .format() 方法。所以 .format() 算是过渡方案吧。

但说实话，有了 f-string 之后，百分号和 .format() 这两货我基本就只在看别人老代码时才用了。新代码？除非有特别的原因（比如要在非常老的 Python 版本上运行，虽然现在 Python 3 普及度已经很高了），不然真没啥必要学了，直接拥抱 f-string 吧！

总结一下，Python 字符串拼接的几种主要方式各有山头：

1. 加号（+）：最直观，适合少量、短小字符串的简单拼接。严禁在循环中用于累积构建大字符串，效率极低，内存消耗大。
2. 逗号（,）在 print 中：不是真正的拼接，只是 print 函数为了方便打印多个值而提供的分隔功能，默认用空格分隔。
3. .join() 方法：处理列表、元组等可迭代对象中大量字符串拼接的 首选，效率高，尤其在需要循环累积字符串的场景下，先存列表再 .join() 是标准做法。分隔符自由控制。
4. f-string (f'')：Python 3.6+ 推荐 的方式，用于将变量、表达式直接嵌入到字符串模板中。语法简洁，可读性极高，性能优秀。适合需要将动态内容和静态文本结合的场景，还能方便地进行格式化控制。
5. 百分号（%）：老式方法，可读性差，不推荐新代码使用。
6. .format() 方法：比 % 进步，但比 f-string 繁琐，可作为老代码维护或 f-string 不可用时的备选。

到底用哪个拼接方法，真不是拍脑袋的事儿，得看场景。少量字符串、一次性的，加号图个快，没毛病。处理大量、来自列表/迭代器的， .join() 是不二之选，高效得没话说。需要在字符串里嵌入变量、表达式啥的，f-string 简直是神，写起来心情都愉悦很多！

我记得刚开始学 Python 那会儿，就一股脑儿地用加号，写个日志生成器，每次往日志文件里追加一行，就是 log_line += '...' + var + '...' 这么写。数据量一上来，程序就卡得不行，CPU 占用也高。后来查资料才知道，哦，原来加号在背后搞了这么多小动作，一直在搬家。换成先收集所有日志行到一个列表，最后 log_content = '\n'.join(log_lines) 一次性写入文件，那速度，咻！一下就好了，对比太鲜明了。那个“卧槽，原来是这样！”的顿悟感，现在还记忆犹新。

所以啊，别小看这字符串拼接，里头藏着效率的门道。选对方法，代码不仅跑得快，看着也舒服，以后自己或者同事维护起来都省事儿。用顺手了，写代码也能少烦心很多。希望这些经验之谈，能帮你彻底理清 python怎么拼接字符串 这团看似简单实则暗藏玄机的“乱麻”吧！